犀牛笔记--函数

1.函数作为参数传给其他函数：
    data.sort(function(a,b){return a-b})
    //关于数组的sort函数，其回调函数返回负值，a在b之前
    //正值，b在a之前

2.函数定义好后立即调用
    var temp=(function(x){return x*x})(10);

    function foo(){};//函数声明，可以提前
    var foo=function(){};//表达式定义函数，不能提前

3.JAVASCRIPT的函数可以嵌套在其他函数里面
    function hy(a,b){
        function square(x){return x*x;}
        return Math.sqrt(square(a)+square(b));
    }

4.函数声明语句并非真正的语句，他们可以出现在全局代码里，或者内嵌在其他函数内，
但是它们并不能出现在循环，条件判断或者try/catch语句中。
但函数定义表达式可以出现在javascript的任何地方

5.jquery的方法链式调用原理
    $(":header").map(function(){return this.id;}).get().set();
    当方法不需要返回值时，建议将其返回值定为return this;
    这样就可以实现方法的链式调用。

6.嵌套函数中this的指向问题
 var o={
           m:function(){
               var This=this;
               f();

               function f(){
                   console.log(this);
                   console.log(This);
               }
           }
        };
    o.m();
以上示例中，对象o内定义了函数m()，在函数m()内定义函数f()并调用
在f内的this并不指向调用外层函数的上下文，而是指向全局对象
其返回值：

            Window Html001.html//严格模式下返回undefined
            Object { m=function()}

7.构造函数的调用
如果在函数或者方法调用前带有关键字new，就形成了构造函数调用
var o=new Object();
var o=new Object;//没有形参时可以省略掉Object后面的括号
一旦使用了new关键字调用构造函数，构造函数内的this就会指向new出来的新对象
        var o={
           m:function(){
               var This=this;
               f();

               function f(){
                   //console.log(this);
                   console.log(This===o);
               }
           }
        };
        new o.m();//函数内部this不指向上下文，也就是不指向o

8.间接调用，call()与aplly()
允许函数显示的指定函数运行的域，也就是规定this的指向
foo.call(obj1,args1...)；
foo.apply(obj2,arg[...]);

9.函数调用的形参与实参
function foo(arg1,arg2,arg3....){}

foo(arg1); 
如果函数调用时传入的实参比函数定义时的形参数要少，则多的形参被定义为undefined
这个特性可用来实现类似函数重载的功能

function getPropertyName(o,/*可选参数，数组a*/arr) {
    // body...
    var arr=arr||[];//undefined在逻辑运算中返回false，若调用时a不存在，则将arr赋予新的空数组[]
    for(var p in o) arr.push(p);
        return arr;
}
getPropertyName(o);
getPropertyName(o,myArray);

设计原则：
    当使用这种可选参数来创建函数时，满足原则1.可选参数放在参数列表最后。2./**/用注释说明可选参数
        3.调用函数时，可选参数位置最好显式的传入null作为占位符。

function foo(arg1,arg2,arg3....){}

foo(arg1); 
再回到这个函数调用例子，当实参列表超过形参列表时，函数内部无法显式获得超过部分的引用
此时可用arguments类数组来调用，事实上arguments[]数组内存储着传进来的所有实参
arguments也包含着length属性；

实参对象的应用实例：
        (function (x,y,z){
            if(arguments.length!=3){
                throw new Error(
                        "该函数必须传入3个参数"
                );
            }
            console.log(x+y+z);
        }(1,2));
        运行结果：Error: 该函数必须传入3个参数
    用于验证实参列表个数，只有在实参数目为3时，才执行函数。
/**
复习：类数组对象
    js的数组有四大特性：
        1.有新元素加入数组时，自动更新length
        2.设置length为一个较小值时将截断数组
        3.从Array.prototype继承一些方法
        4.其类属性为“Array”

    这四个特性让数组与类数组对象区分开来
    而像arguments这样的类数组对象，可以理解为其属性名刚好为从0开始的非负整数序列
    且有个length属性记录它的属性长度

    而区别在于length没有数组的特性1，2.
    且没有从Array.prototype继承方法

    但是可以利用call临时继承调用
    var a={"0":"a","1":"b","2":"c"};

    Array.prototype.join.call(a,"+") //"a+b+c"
    
    Array.map(function(x){return x*x}) //ecma5，不修改原数组，返回一个数组副本，其中的每一项都是
                                        参数内函数的返回值。

*/
细说实参对象arguments://该对象的可枚举属性仅有实参
    属性callee与caller
            callee:指代当前正在执行的函数
            caller：调用当前正在执行的函数的函数//！--暂时无法理解这句话--！

            callee可用在匿名函数中实现递归
            function (x) {
                // body...
                if(x<1)return 1;
                return x*arguments.callee(x-1);//此处的arguments.callee()就是在调用函数本身
            }

10.将对象属性用作实参，减少记忆参数列表顺序，在参数列表巨大的情况下
    function arrayCopy(a,a_start,b,b_start,length) {//该函数将a数组从a_start处复制length个元素至b数组中起始位置b_start位置
                    // 要记忆这些形参的顺序实在不容易
                }

    function easyCopy(argument) {
                    // body...
                    arrayCopy(arguments.from,
                            arguments.from_start||0,
                            arguments.to,
                            arguments.to_start||0,
                            arguments.length
                        )
                }
    //在调用easyCopy时，只需传入一个匿名对象就可以了
    a=[1,2,3,4];
    b=[];
    easyCopy(
        {from:a,to:b,length:4}//传入匿名对象
        );

11.作为值的函数
    在js中，函数也可以作为--实参，传入别的函数参数列表；
    看如下一个函数的定义
        function square(x) {return x*x}
    这个定义创建一个新的函数对象，并将其值赋给square；
    var s=square;//现在s和square指代同一个函数

    类似数组的sort()方法，接受一个函数
    写法Array.sort(function (a,b) {return a-b;
        // body...
    })
    或者Array.sort(bj);//bj指代一个函数

12.自定义函数属性
    js中函数是对象，所以可以定义函数的属性，用于计数之类的工作
    比如要计算一个函数的调用次数，又不想定义一个全局变量
    则可以：
    foo.times=0;
    function foo(argument) {
        // body...
        foo.times++;
    }//还有更多用途，

    //定义缓存
    foo.times=0;//判断if语句执行次数的标记
        function foo(x){
            if(x<1&&x!=Math.round(x)) throw new Error("foo（）函数参数为大于1的正整数");
            if( !(x in foo)){
                foo.times++;
                console.log(foo.times);
                foo[x]=x*foo(x-1);//将已经计算出来的值存储进foo[]类数组之中
            }
            return foo[x];
        }
        foo[1]=1;

        foo(11);
        foo(10);//从返回结果可以看到，此处并没进入if判断中，减少了很多次运算
        foo(12);
        foo(0.6);//验证数值输入的正确性

            代码运行返回结果：
                    1
                    Html001.html (第 23 行)
                    2
                    Html001.html (第 23 行)
                    3
                    Html001.html (第 23 行)
                    4
                    Html001.html (第 23 行)
                    5
                    Html001.html (第 23 行)
                    6
                    Html001.html (第 23 行)
                    7
                    Html001.html (第 23 行)
                    8
                    Html001.html (第 23 行)
                    9
                    Html001.html (第 23 行)
                    10
                    Html001.html (第 23 行)
                    11
                    Html001.html (第 23 行)
                    Error: foo（）函数参数为大于1的正整数

13.作为命名空间的函数
    类似jquery这样的库的做法
    a.(function (argument) {
        // body...
    }())
    b.(function (argument) {
        // body...
    })();
    定义一个匿名函数并立即调用，在匿名函数内的变量就不会污染全局命名空间
    对于包裹function的圆括号的解释：
        function前面没有圆括号时，js会将function解释为函数声明语句，这样就无法立即执行
        而加上圆括号，或是其他运算符，则会被解释为函数定义表达式。

14.闭包
    js中，函数的执行依赖于变量作用域，这个作用域是在函数定义时创建的，而不是在函数执行时。
    例子1：
        var scope="global scope";
        function checkscope() {
            // body...
            var scope="local scope";
            function f() {
                // body...
                return scope;
            }
            return f();//f在checkscope内部执行时很容易理解，它寻找f的作用域，在checkscope函数内找到scope就返回了
        }
        checkscope();
    例子2：
        var scope="global scope";
        function checkscope() {
            // body...
            var scope="local scope";
            function f() {
                // body...
                return scope;
            }
            return f;
        }
        checkscope()();    //在全局执行chechscope内部的函数f；因为闭包的存在，f()也是在其作用域链内寻找scope
                        //这个作用域链在函数定义之初就开始存在

    例子3：                    
    foo.times=0;
    function foo(argument) {
        // body...
        foo.times++;
    }//这是12小结的一个例子，foo.times来记录函数foo的调用次数
    下面用闭包来改写它。
        var times=(function () {
                var count=0;
                return function(){
                    return count++;
                }
        }())//当外层作为命名空间的函数返回之后，除了timer(),任何函数或语句都访问不到其内部的count
            //而又因为times在外部使用其作用域链上的count，所以count会作为一个变量一直存在内存
            //times()每次调用都访问的是内存中已经存在的count；故可以充当计数器
        function foo(argument) {
        // body...
            times();
        }


    例子4：
    function counter(){
        var count=0;
        return {
            count:function(){return ++count;},
            reset:function(){return count=0;}
        }//返回一个包含两个方法的匿名对象
    }

    var obj1=counter();
    var obj2=counter();//obj1和obj2接受到的是不同的Object。所以他们的count互不干涉
     console.log(obj1.count());
     console.log(obj1.count());
     console.log(obj1.count());

     例子5：//ECMA5中的变体
     function counter(n){
         return {
             get count(){
                 return ++n;
             },
             set count(m){
                 if (m<=n) {throw Error("您设置的n太小了")}
                 return n=m;
             }
         }
     }
     var obj=counter(100);
     console.log(obj.count);
     console.log(obj.count);
     console.log(obj.count);
     console.log(obj.count=200);
     console.log(obj.count);
     console.log(obj.count);
         利用setter和getter来定义计数器count，给予计数器设置初值和临时更改的方法
         而count则是obj的私有属性，且通过赋值修改必须遵循get方法设置的条件

     例子6：//闭包实现私有属性的经典做法
          function addPrivateProperty(o,name,predicate) {
            // body...
            var value;
            o["get"+name]=function () {
                return value;
            };
            o["set"+name]=function(v){
                if (predicate&&!predicate(v)) {throw new Error("数据未通过predicate函数合法性验证")}
                value=v;
            }
        }

        var o={};
        addPrivateProperty(o,"Name",function(v){return typeof v=="string";});
        addPrivateProperty(o,"Age");//未进行合法性验证

        o.setName("wangjue");
        o.setAge(18);
        console.log(o.getName());
        console.log(o.getAge());
        为何能够不断添加属性，是因为每个属性的set和get方法组--存在于不同的作用域链，
        可以利用如下例子进行例证：
        function constfunc(v){
            var value;
            return function(){
                value=v;
                return value;};

        }
        var fun1=constfunc("arr1");
        var fun2=constfunc();//发现只要传递的参数不一样，就会创建新的闭包

        console.log(fun1());//=>arr1
        console.log(fun2());//=>undefine    value并未共享


     例子7：
         function constfunc(v) {
             // body...
             return function(){return v;};
         }//一个总是返回v的函数
         for(var i=0;i<10;i++) fun[i]=constfunc(i);
         fun[5]();//=》返回值为5

         上述代码循环创建了很多闭包

     总结性语言：多个嵌套函数并不会将作用域链上的私有成员复制一份，他们是共享的。

     例子8：
         嵌套函数内，也就是闭包，无法访问外部函数的arguments和this
         function foo(arg1,arg2) {
             // body...
             var self=this;
             var outArguments=arguments;

             return function () {
                 return self+outArguments.toString(" ");
             }
         }
         前文已经提过，嵌套函数内部使用this，指代的是全局环境window,或者undefined
         //闭包  end

15.函数的属性，方法和构造方法
    在js中，函数是特殊的对象，故其也有对象的一些性质
        所以其也拥有属性和方法，能够用Function()构造函数创建。

    （1）length：函数对象也拥有一个length属性，其值为函数声明时的形参列表的表长。
                //一个检测实参与形参是否数量相等的函数
                function check(argument) {
                    // body...
                    if(argument.length!=argument.callee.length) throw new Error("传入参数数量不对")
                }

                function test(arg1,arg2) {
                    // body...
                    check(arguments);
                    return arg1+arg2;
                }

                test(1,2);

    (2)prototype每一个函数都有一个原型属性
    (3)call(),与aplly()方法

    (4)bind(); //ECMA5中新增的方法，f.bind(obj);将函数f绑定至obj上
        兼容性解决：
            function bind(f,o) {
                // body...
                if(f.bind) return f.bind(o);
                else{
                    return f.apply(o,arguments);
                }
            }//这里的自定义bind()函数就是将f绑定至o下，且立即执行

        function f(argument) {
            // body...
        }
        f.bind(o,agr1,arg2);//bind除第一个参数外，后面的几个参数都将传入f，参与函数调用

    (5)toString()//返回函数的完整源码

    (6)Function()构造函数；


16.函数式编程
    类似数组的reduce(),map()之类的方法就是函数式编程的例子


17.高阶函数，所谓高阶函数就是操作函数的函数，其传入函数作为参数，返回值也是函数

18.记忆函数
    //闭包的实例
        function memorize(foo){
            var cache={};
            return function () {
                // body...
                var key=arguments.length+Array.prototype.join.call(arguments,",");//作为缓存的键
                if(key in cache)  return cache[key];//若在cache中找到了key，则直接返回内存中的值
                else {
                    cache[key]=foo.apply(this,arguments);//内存中没有，则赋值。
                    return counter[key];//
                }
            }
        }

        //当我们使用一个递归函数时，往往要使用记忆功能
        var factorial=memorize(function (n) {
            // body...
            return n<=1?1:n*factorial(n-1);
        })
        factorial(5);