[Day5] ES5 (higher order function, anonymous function, scope, closure)

Date: February 4

1. Higher order function

What is a Function: a Function is a data type [Function] Function that can be defined by an expression

Higher order function: since a function is of a type and can be used as a parameter or return value of another function, the function is called a higher-order function (simply a function calling function)


        // The declarative myFunction02 of the function indicates that the name of the function indicates the function itself 
        function myFunction02() {

        console.log(myFunction02);  // Print function itself
        myFunction02()  // Function call execution


        function fn() {
            console.log("I'm a function and I want to be an argument to another function");

         *  a Common parameters 
         *  cb function
         * fn02 Is a higher-order function with another function as its parameter
        function fn02(a,cb) {
           // console.log(cb);


        fn02(1,fn)  // 1


        // Function can be used as the return value of another function
          Find 10 + 100
             10 + 1000
             10+ 10000

        function getSum(a) {
            // The latter function is the return value of the previous getSum function
            return function(b) {
               return a + b;

        var callback = getSum(10)  

        callback =  function(b) {
               return  10 + b;

        var r1 =  callback(100)
        var r2 =  callback(1000)
        console.log(r1);  // 110
        console.log(r2);  // 1010

2. Anonymous function

      1. Anonymous function: anonymous function [execute function immediately]: a function without a name

      2. Features: it can only be used once, and [execute now] needs to be called immediately


        // Anonymous function with no parameters and no return value
         (function() {
         // Anonymous function with parameters and no return value 

         (function(a,b) {

         // Anonymous function with parameter and return value
         var result =  (function(a,b) {
             return a + b


3. Scope, closure

        1. Scope: the scope within which a variable can work

        2. Global variable: a variable that can be accessed anywhere

        3. Local variable: a variable that can be accessed only within a fixed code fragment

        4. Scope:

Block level scope: es5 has no block level scope, {}; if() {} ; for() {} ; while() {}

Function scope: the only scope in es5. Because there is a function scope in es5, the variables in the function are local variables

        5. Scope chain: a chain structure inside a function that points outside the function. When the internal scope accesses the external scope, the scope chain will be generated [this access method is called closure]

        6. Closure: the internal scope accesses the external scope, and the law of accessing variables: the proximity principle

        7. Function of closure: protect the current variable from global pollution, which can extend the scope of local variables [reflected in the high-order function whose return value is a function]


        function myFunc() {
            // The current variable b can only be used in the current function, so it cannot be accessed outside the function
            // var means that local variables in a function are defined
            var b = 20;
            // If var is removed, then this variable is a global variable
            c = 100;
            console.log(b);  // 10 the printed value can access the variable b in the current function

        function func01() {
              var  a = 10;
             function func02() {
                 // The internal scope has this variable, and the external scope also has the proximity principle that this variable has priority to access the internal scope
                 var a = 20;
                 console.log(a);  // Internal scope accessed external scope


Case: (closure)

        1. Traversal 1-4  
        2. All values are + 5 and printed 


        function fn() {
            for(var i = 1;i<=4;i++) {
                (function(a) {

            // p(i) using ordinary function calls
            // function p(a) {
            //     a+=5
            //          console.log(a);
            // }



4. Characteristics of variables in scope

        1. Variable

1.1 the first common variable is var a = 10

1.2 the second {function a() {}

        2. Characteristics of variables in action:

2.1 the function can be automatically promoted to the front of the current scope

2.2 the variable name of a common variable can be automatically promoted to the front of the current scope, but the value cannot be changed


    // Interview questions

       var a = 10;

       function fn() {
       // var a;
           var a = 20;

       fn(); //undefined

       function fn2(a) {
        var a = 20;


Keywords: SQL linq p2p

Added by jwer78 on Fri, 04 Feb 2022 06:59:02 +0200