JavaScript语言精粹读书笔记

【经典用法】：

 

//①定义新方法

Function .prototype.method=function(name, func){

              this.prototype[name]=func;

              return this;

}

 

//②给Object增加一个create方法，这个方法创建一个使用原对象作为其原型的新对象

Object.create=function(o){

       var F=function(){};

       F.prototype=o;

       return new F();

}

 

//③继承

Function.method(‘inherits’, function(Parent){

       this.prototype=new Parent();

       return this;

});

 

  

 

【对象】

1）JS中的对象是name/value对的集合并拥有一个连到原型对象的隐藏连接。

2）对象字面量产生的对象连接到Object.prototype；

3）引用：对象通过引用来传递，他们永远不会被复制。

4）函数就是对象。

5）函数对象连接到Function.prototype（该原型的对象本身连接到Object.prototype）。

6）函数在创建的时候会附加2个隐藏属性：函数的上下文（包括函数实参、函数形参、内嵌函数、内部变量等）和实现函数行为的代码

Object

1.                               __proto__: Object

1.                                                       __defineGetter__: function __defineGetter__() { [native code] }

2.                                                       __defineSetter__: function __defineSetter__() { [native code] }

3.                                                       __lookupGetter__: function __lookupGetter__() { [native code] }

4.                                                       __lookupSetter__: function __lookupSetter__() { [native code] }

5.                                                       constructor: function Object() { [native code] }

6.                                                       hasOwnProperty: function hasOwnProperty() { [native code] }

7.                                                       isPrototypeOf: function isPrototypeOf() { [native code] }

8.                                                       propertyIsEnumerable: function propertyIsEnumerable() { [native code] }

9.                                                       toLocaleString: function toLocaleString() { [native code] }

10.                                                    toString: function toString() { [native code] }

11.                                                    valueOf: function valueOf() { [native code] }

 

 

new大致过程：

var instance=new func(setting);

 

 èvar func=new Function();

 èfunc.prototype={construction:func; __prototype__:object}; //相当于字面量

   func.__prototype__=Function.prototype;

   func.上下文：

   func.调用方法()：

   func.代码：

  func.[[scope]]:在函数创建的时候保存起来的，静态不变。是一个包含了所有层变量对象的分层链

 

 

èvar instance={};

  func.apply(instance, setting); èinstance.T=func; instance.T(setting); delete instance.T; 

instance.__prototype__=func.prototype;

 

func

1.                          name: "asdf"

2.                               __proto__: func

1.                                                       constructor: function func(){this.name="asdf"}

2.                                                       __proto__: Object

 

当前上下文activeExecutionContext={

                         VO:{.....},  //或者AO

                         this: thisValue,

                         Scope:[]     // scope= withObject|catchObject+VO|AO+[[scoper]]

                  }

 

【函数】

1）除了声明时定义的形式参数，每个函数还接收2个附加的参数：this和arguments

2）一个函数总会返回一个值，如果没有指定返回值，则返回undefined。如果函数调用时在前面加上了new前缀，且返回值不是一个对象，则返回this。

 

【this】

this在JS中有4中调用模式：

①方法调用模式：当一个函数被保存为对象的一个属性时，就称它是一个方法。当一个方法被调用时，this被绑定到该对象。

②函数调用模式：当一个函数并非一个对象的属性时，它就是被当做一个函数来调用。这个模式下的this被绑定到全局对象window，函数实际是window的属性。

③构造器调用模式：如果在一个函数前面带上new来调用，则背地里会创建一个连到该函数prototytpe成员的新对象，同时this会被绑定到那个新对象上。

④apply调用模式：允许选择this的值，apply第一个参数绑定给this的值，第2个参数是传给调用函数的参数数组。

 

【异常】

JS提供了一套异常处理机制。异常是干扰程序的正常流程的不寻常的事故。当发现这样的事故时，你的程序就应该抛出一个异常：

var add=function(a, b){

       if(typeof a !==’number’ || typeof b!==’number’)

       throw {name:’TypeError’, message:’add nedds numbers’};

return a+b;

}

var try_it=function(){

       try{add(“seven”);       }

       catch(e){document.writeln(e.name+”:”+e.message);}

}

 

【模块】

String.method(‘deentityify’, function(){

       var entity={quot:’”’,lt:’<’,gt:’>’};

       return function(){

       return this.replace(/&([^&;]+);/g, function(a,b){

var r=entity[b];return typeof r===’string’?r:a});

};

});

模式模式利用函数作用域和闭包来创建被绑定对象与私有成员的关联。模块模式的一般形式是：一个定义了私有变量和函数的函数；利用闭包创建可以访问私有变量和函数的特权函数；最后返回这个特权函数，或者把它们保存到一个可访问到的地方。使用模块模式就可以摒弃全局变量的使用，促进信息隐藏和其他优秀的设计实践。

 

【柯里化】

函数也是值。柯里化：局部套用，把多参数函数转换为一系列单参数函数并进行调用的技术。柯里化允许我们把函数与传递给它的参数相结合，产生出一个新的函数。

var add1=add.curry(1);

document.writeln(add1(6));  //7

 

Function.method(‘curry’, function(){

       var slice=Array.prototype.slice,

          args=slice.apply(arguments),

       that=this;

       return function(){

              return that.apply(null, args.concat(slice.apply(arguments)));

};

});

 

 

 

 另外参考好文：《深入学习Javascript》 http://blog.goddyzhao.me/JavaScript-Internal