（九）JavaScript之【JS函数（定义、参数、调用、【闭包】、call(),apply()）】[较深，胆小勿进]

一】、定义：

 /**
  * 函数表达式
  *
  * Function() 构造函数
  *
  * 函数提升（Hoisting）
  * JavaScript默认将当前作用域提升到前面去
  * Hoisting应用在变量的声明和函数的声明
  * 【使用表达式定义函数时无法提升】
  *
  * 自调用函数
  *
  * 函数是对象*/

 //函数表达式储存在变量中
 var x = function () { return 'message'; };

 console.log(x());

 /**
  以上函数实际上是一个 匿名函数 (函数没有名称)。
  函数存储在变量中，不需要函数名称，通常通过变量名来调用。
  上述函数以分号结尾，因为它是一个执行语句。
  */

 //不建议。在 JavaScript 中，很多时候，你需要避免使用 new 关键字。
 var myFunction = new Function('a', 'b', 'return a*b');
 console.log(myFunction(3, 4));

 //函数提升
 //在函数声明之前调用
 myFunction();

 function myFunction() {
     console.log(233);
 }

 //自调用函数，是一个表达式，有括号把表达式括起来
 (function () {
     console.log('Hello'); //我将调用我自己
 })();

 //函数是对象，函数有属性和方法
 console.log(typeof(function add() {})); //function

 //arguments.length 属性返回函数调用过程接收到的参数个数
 //arguments是JavaScript的内置对象
 function myFunction(a, b){
     console.log(arguments.length);
 }

 myFunction(1, 2); //
 myFunction(); //
 myFunction('test'); //

 //总结：
 //函数定义作为对象的属性，称之为对象方法。
 //函数如果用于创建新的对象，称之为对象的构造函数。

二】、参数

 /**
  * 函数参数
  *
  * arguments 对象
  * arguments对象包含了函数调用的参数数组
  * */

 /**
  * 如果函数在调用时缺少参数，参数会默认设置为： undefined
  有时这是可以接受的，但是建议最好为参数设置一个默认值*/

function add(x, y){
    if(y === undefined) {
        y = 0;
    }
    //或者：
    //y = y || 0;
    //如果y已经定义 ， y || 返回 y, 因为 y 是 true, 否则返回 0, 因为 undefined 为 false。
    console.log( x + y);
}

add(2);
console.log(Boolean(undefined)); //false

 //查找最后一个参数的值
 function findMax() {
     var maxNum = 0;

     for(var i = 0;i < arguments.length;i++) {
         if(arguments[i] > maxNum) {
             maxNum = arguments[i];
         }
     }
     console.log(maxNum);
 }
 findMax(4,5,6); //

 function sumAll() {
     var sum = 0;

     for(var i = 0;i < arguments.length;i++) {
         sum += arguments[i];
     }
     console.log(sum);
 }
 sumAll(4,5,6); //

三】、调用

 /**
  * 函数的调用：
  *
  * 1.作为一个函数调用
  *
  * 2.作为对象的方法调用
  *
  * 3.构造函数new调用函数
  *
  * 4.call()、apply()调用函数
  * call([thisObj[,arg1[, arg2[,   [,.argN]]]]])
  * call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。
  如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。 */

 var myObject = {
     myName: 'lqc',
     myPets: ['HuaDou', 'ErBao'],
     fullInformation: function () {
         return this.myName + ' have ' + this.myPets[1];
     }
 };

 console.log(myObject.fullInformation());

 function multiply(a, b) {
     return a*b;
 }

 console.log(multiply.call(myObject, 5, 6));
 console.log(multiply.apply(myObject, [5, 6]));

四】、闭包

闭包：
私有变量可以用到闭包

 // 计数菌
 var add = (function (){
     var counter = 0;

     return function () {
         return counter++;
     };

 })();

 console.log(add());
 console.log(add());
 console.log(add());

 //定义多个嵌套函数
 function counter() {
     var counter = 0;

     return {
         count: function () {
             return counter++;
         },
         reset: function () {
             return counter = 0;
         }
     };
 }

 var c1 = counter();
 var c2 = counter();

 console.log(c1.count());
 console.log(c1.count());
 console.log(c1.count());

 console.log(c2.count());
 console.log(c2.count());
 console.log(c2.reset());

五】、call()方法和apply()方法

参考：http://www.cnblogs.com/lqcdsns/p/5349496.html