JS 精粹( 函数)

    函数是对象，它与其它对象唯一的不同是它可以调用。函数可实现：代码复用、信息隐藏、代码组合调用。

    建立函数时会建立：上下文、调用函数的代码。每个函数（除Function.prototype）都会有一个原型对象。

   function foo ( ) {
     //code
}
 
  foo.prototype = {constructor:this};   

    它必有一个foo.prototype对象，而且这是显含的。

    函数字面量属于字面量，也就属于表达式的范畴。从而可以使用表达式的地方就可以使用函数字面量。

    JS函数的参数是按值传递的。它不会检查传入实参的类型、个数；若实参少于形参实参函数调用时的形参值为undefined.每个函数会this,this在函数执行时才会确定，与函数的调用方式相关（与动态作用域有某种相似）。调用方式分为：方法调用、函数调用、构造器调用、apply调用。

   

    方法调用：也就是说一个函数为某个对象的属性值。那么函数调用时的this到底是哪个？

          我要再次强调，对象会有自己默认的原型链，同时我们可以设置对象的prototype属性，但这个属性与内部的原型链相比很弱，对象的"继承"或更确切的说是委托是基于内部原型链的。

   var a = {};
   var b = {"name":"name"};
    a.prototype = b;
   console.log(a.name)    //undefined


    Object.setPrototypeOf(a,b);
     console.log(a.name)   //"name"

   开始，我直接设置prototype属性，然后以为通过对象的继承可以访问到对象b中的name;事实是：此时a与b的原型链链接到了Object.prototype。

   接着，我真正修改了原型链，故可以访问到name属性。

 

   那么,这个表面的prototype有何用？

        前文提到函数（除Function.prototype）总会有一个对象与之对应。若我建立一个用函数建立一个对象的话，就会有用。新建的对象的原型链中的上一环为构造函数的prototype对象。

 function foo () {}
//那么一定有一个foo.prototype对象。
var  b = new foo();
该对象的原型链中就会有 b 的存在
  foo.prototype.isPrototypeOf(b) //true

     其三，一般函数的原型链中不含prototype对象。但Function.prototype为function(){},且位于Function的原型链中。

              Function.prototype.isPrototypeOf(Function)        //true.

 

      回到刚才的问题，方法调用函数时，对应的this为何值。我直接给出结论，我认为是：可以直接查找到方法的那个对象。直接上代码。

     

   var a = {"a":"a"};
        var b = {"b":"b"};
        var c = {"c":"c",
                 "show":function(){
                     return this;
                 }
             };
         Object.setPrototypeOf(b,c);
         Object.setPrototypeOf(a,b);   
     //现在原型链从a开始到b到c到Object.prototype.
 
          a.show();         //对象a
          b.show();        //对象b
    

   //Function的例子
    
     Function.prototype.method = function (name,func) {
            this.prototype[name] = func;
              return this; 
};
        //  this与调用方式有关

       干脆更加明白一些。

   Function.prototype  //    function () {}
   Function.protoype.demo = function () {
                console.log(this); 
};

  //可以通过Function这个函数访问到demo方法，
    
      Function.demo()        // function    Function() { [native code] }
      
       Function.prototype.demo()    //  function () {}

                  所以，不是方法在那个对象中this就是哪个。

 

    函数调用的时候的this值。

            直接调用函数是this是全局对象而非该函数的外围的this值，ES6中有语法糖来处理这个问题。

    构造函数模式的this

          new + 构造函数会形成一个对象，这里忽略其他细节；只讲this值，这时的this是新建立的那个对象。还是举个栗子。

   function foo (name) {
                  this.name = name;
}
 
   var obj = new foo ();
   
//也就是说foo执行时的this是obj,从而才有给obj添加name属性的可能
 

      构造函数与一般函数没有区别，但是若一个函数建立的目的是用于建立对象，应当把其首字母大写；否则直接调用可能会给全局对象添加属性。

     apply调用模式

            函数是对象，所以可以有方法，apply/call就是方法。伪代码：function.apply(this,argumnets)，function.call(this,p1,p1,p1)。

记忆

     记忆这种优化手段真是让人兴奋，它可以大大减少计算的工作量，例如在阶乘、裴波那契数列的计算中，若不采用优化，那浏览器甚至算不出来。采用优化后秒算出结果。下面是通用的记忆器。

 function memoizer (memo,formula) {
        var recur = function (n) {
                 var result = memo[n];
                if ( typeof result !== "number") {
 
                     result = formula();
                memo[n] = result;
           }
            return result;   

        }
    return recur;
}

      JS的函数化很强大，这种方法在一个个函数的基础上差异化继承，也可以增强；也是建立部件的基础。实现对象与它的功能模块的扩充。建立对象与方法之间的松散耦合。

    var o = {name:"demo"};
    var enhance = function (o) {
                var that = o;
                 if ( !o.name) {
                         o.name = "initial"; 
          } 
                 if ( !o.get_name) {
                          o.get_name = function () {
                                 return o.name;    
                                   };              
         }
           return that;
};
    var  b =  enhance(o);