面向对象的JavaScript-008-Function介绍

1.

 // 函数
     /* Declare the function 'myFunc' */
     function myFunc(theObject) {
        theObject.brand = "Toyota";
      }

      /*
       * Declare variable 'mycar';
       * create and initialize a new Object;
       * assign reference to it to 'mycar'
       */
      var mycar = {
        brand: "Honda",
        model: "Accord",
        year: 1998
      };

      /* Logs 'Honda' */
      console.log(mycar.brand);

      /* Pass object reference to the function */
      myFunc(mycar);

      /*
       * Logs 'Toyota' as the value of the 'brand' property
       * of the object, as changed to by the function.
       */
      console.log(mycar.brand);

      //var y = function x() {};
      //alert(x); // throws an error
     //var foo = new Function("alert(anonymous);");
     //foo();    //Uncaught ReferenceError: anonymous is not defined
     foo(); // alerts FOO!
     function foo() {
        alert('FOO!');
     }
     var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))();
     foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.

     var x = 0;               // source element
     if (x == 0) {            // source element
        x = 10;               // not a source element
        function boo() {}     // not a source element
     }
     function foo() {         // source element
        var y = 20;           // source element
        function bar() {}     // source element
        while (y == 10) {     // source element
           function blah() {} // not a source element
           y++;               // not a source element
        }
     }

     // function declaration
     function foo() {}

     // function expression
     (function bar() {})

     // function expression
     x = function hello() {}

     if (x) {
        // function expression
        function world() {}
     }

     // function declaration
     function a() {
        // function declaration
        function b() {}
        if (0) {
           // function expression
           function c() {}
        }
     }

     // This function returns a string padded with leading zeros
     function padZeros(num, totalLen) {
        var numStr = num.toString();             // Initialize return value as string
        var numZeros = totalLen - numStr.length; // Calculate no. of zeros
        for (var i = 1; i <= numZeros; i++) {
           numStr = "0" + numStr;
        }
        return numStr;
     }
     var result;
     result = padZeros(42,4); // returns "0042"
     console.log(result);
     result = padZeros(42,2); // returns "42"
     console.log(result);
     result = padZeros(5,4);  // returns "0005"
     console.log(result);

     // 菲波那其数
     var factorial = function fac(n) { return n<2 ? 1 : n*fac(n-1) };
     console.log(factorial(3));

     function map(f,a) {
       var result = [], // Create a new Array
           i;
       for (i = 0; i != a.length; i++)
         result[i] = f(a[i]);
       return result;
     }
     console.log(map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]));    // returns [0, 1, 8, 125, 1000].

     // 阶乘
     function factorial(n){
       if ((n === 0) || (n === 1))
         return 1;
       else
         return (n * factorial(n - 1));
     }
     var a, b, c, d, e;
     a = factorial(1); // a gets the value 1
     b = factorial(2); // b gets the value 2
     c = factorial(3); // c gets the value 6
     d = factorial(4); // d gets the value 24
     e = factorial(5); // e gets the value 120
     console.log(a);
     console.log(b);
     console.log(c);
     console.log(d);
     console.log(e);

     // Function scope
     // The following variables are defined in the global scope
     var num1 = 20,
         num2 = 3,
         name = "Chamahk";

     // This function is defined in the global scope
     function multiply() {
       return num1 * num2;
     }

     multiply(); // Returns 60

     // A nested function example
     function getScore () {
       var num1 = 2,
           num2 = 3;

       function add() {
         return name + " scored " + (num1 + num2);
       }

       return add();
     }

     console.log(getScore()); // Returns "Chamahk scored 5"

     var x = 0;
     while (x < 10) { // "x < 10" is the loop condition
        // do stuff
        x++;
     }

     // can be converted into a recursive function and a call to that function:
     function loop(x) {
       if (x >= 10) // "x >= 10" is the exit condition (equivalent to "!(x < 10)")
         return;
       // do stuff
       loop(x + 1); // the recursive call
     }
     loop(0);

     // However, some algorithms cannot be simple iterative loops. For example, getting all the nodes of a tree structure (e.g. the DOM) is more easily done using recursion:
     function walkTree(node) {
       if (node == null) //
         return;
       // do something with node
       for (var i = 0; i < node.childNodes.length; i++) {
         walkTree(node.childNodes[i]);
       }
     }

     // function foo(i) {
     //   if (i < 0)
     //     return;
     //   console.log('begin:' + i);
     //   foo(i - 1);
     //   console.log('end:' + i);
     // }
     //foo(3);
     // Output:

     // begin:3
     // begin:2
     // begin:1
     // begin:0
     // end:0
     // end:1
     // end:2
     // end:3

     // Nested functions and closures
     function addSquares(a,b) {
       function square(x) {
         return x * x;
       }
       return square(a) + square(b);
     }
     a = addSquares(2,3); // returns 13
     b = addSquares(3,4); // returns 25
     c = addSquares(4,5); // returns 41

     // Since the inner function forms a closure, you can call the outer function and specify arguments for both the outer and inner function:

     function outside(x) {
       function inside(y) {
         return x + y;
       }
       return inside;
     }
     fn_inside = outside(3); // Think of it like: give me a function that adds 3 to whatever you give it
     result = fn_inside(5); // returns 8

     result1 = outside(3)(5); // returns 8

     // Multiply-nested functions
     function A(x) {
       function B(y) {
         function C(z) {
           console.log(x + y + z);
         }
         C(3);
       }
       B(2);
     }
     A(1); // logs 6 (1 + 2 + 3)

     // Name conflicts
     function outside() {
       var x = 10;
       function inside(x) {
         return x;
       }
       return inside;
     }
     result = outside()(20); // returns 20 instead of 10

     // Closures
     var pet = function(name) {   // The outer function defines a variable called "name"
       var getName = function() {
         return name;             // The inner function has access to the "name" variable of the outer function
       }
       return getName;            // Return the inner function, thereby exposing it to outer scopes
     },
     myPet = pet("Vivie");

     myPet();                     // Returns "Vivie"

     var createPet = function(name) {
       var sex;

       return {
         setName: function(newName) {
           name = newName;
         },

         getName: function() {
           return name;
         },

         getSex: function() {
           return sex;
         },

         setSex: function(newSex) {
           if(typeof newSex === "string" && (newSex.toLowerCase() === "male" || newSex.toLowerCase() === "female")) {
             sex = newSex;
           }
         }
       }
     }

     var pet = createPet("Vivie");
     pet.getName();                  // Vivie

     pet.setName("Oliver");
     pet.setSex("male");
     pet.getSex();                   // male
     pet.getName();                  // Oliver

     var getCode = (function(){
       var secureCode = "0]Eal(eh&2";    // A code we do not want outsiders to be able to modify...

       return function () {
         return secureCode;
       };
     })();

     getCode();    // Returns the secureCode

     var createPet = function(name) {  // Outer function defines a variable called "name"
       return {
         setName: function(name) {    // Enclosed function also defines a variable called "name"
           name = name;               // ??? How do we access the "name" defined by the outer function ???
         }
       }
     }

     // Using the arguments object
     function myConcat(separator) {
        var result = "", // initialize list
            i;
        // iterate through arguments
        for (i = 1; i < arguments.length; i++) {
           result += arguments[i] + separator;
        }
        return result;
     }

     // returns "red, orange, blue, "
     myConcat(", ", "red", "orange", "blue");

     // returns "elephant; giraffe; lion; cheetah; "
     myConcat("; ", "elephant", "giraffe", "lion", "cheetah");

     // returns "sage. basil. oregano. pepper. parsley. "
     myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");

     // Default parameters
     function multiply(a, b) {
       b = typeof b !== 'undefined' ?  b : 1;

       return a*b;
     }

     multiply(5); //

     // function multiply2(a, b = 1) {
     //   return a*b;
     // }

     // multiply2(5); // 5

     // Rest parameters
     // function multiply(multiplier, ...theArgs) {
     //   return theArgs.map(x => multiplier * x);
     // }

     // var arr = multiply(2, 1, 2, 3);
     // console.log(arr); // [2, 4, 6]

     // Arrow functions
     var a = [
       "Hydrogen",
       "Helium",
       "Lithium",
       "Beryl­lium"
     ];

     var a2 = a.map(function(s){ return s.length });

     // var a3 = a.map( s => s.length );

     // Lexical this

     function Person() {
       // The Person() constructor defines `this` as itself.
       this.age = 0;

       setInterval(function growUp() {
         // In nonstrict mode, the growUp() function defines `this`
         // as the global object, which is different from the `this`
         // defined by the Person() constructor.
         this.age++;
       }, 1000);
     }

     var p = new Person();

     function Person() {
       var self = this; // Some choose `that` instead of `self`.
                        // Choose one and be consistent.
       self.age = 0;

       setInterval(function growUp() {
         // The callback refers to the `self` variable of which
         // the value is the expected object.
         self.age++;
       }, 1000);
     }

     // function Person(){
     //   this.age = 0;

     //   setInterval(() => {
     //     this.age++; // |this| properly refers to the person object
     //   }, 1000);
     // }

     // var p = new Person();