javascript 对象基础--读书笔记

一：对象废除（dereference）
      ECMScript 有 无用存储单元收集程序，意味着不必要专门销毁对象来释放内存。当再没有对对象的引用时，称该对象被废除（dereference）了。运行 无用存储单元收集程序时，所有废除的对象都被销毁。每当函数执行完它的代码， 无用存储单元收集程序都会运行，释放所有的局部变量，还有在其他一些不可预知的情况下，无用存储单元收集程序也会运行。
     把对象的所有引用都设置为null，可以强制性的废除对象。例如：

var _object = new Object;
_object = null;

     当变量_object设置为null后，对第一个创建的对象的引用就不存在了，这意味着下次运行无用存储单元收集程序时，该对象将被销毁。

注：废除对象的引用时要当心。如果一个对象有两个或者更多引用，则要正确废除该对象，必须将其所有引用都设置为NULL。

二：内置对象

         1、encodeURI与encodeURIComponent区别：

                encodeURI（）方法不对URI中的特殊字符进行编码，如冒号、前斜杠、问号和英镑符号，而encodeURIComponent（）则对它发现哦所有非标准字符串进行编码。

三：静态作用域并非静态的

function sayHi(){
     alert("hi");
}
sayHi.allternate = function(){
      alert("hola");
}
sayHi(); //output "hi"
sayHi.allternate();    //output "hola"

四：定义类或对象

1、工厂方式

工厂函数（factory function）

function createCar(){
     var oTempCar = new Object;
     oTempCar.color = "red";
     oTempCar.doors = 4;

     oTempCar.mpg = 23;
     oTempCar.showColor = function(){ 
         alert(this.color); 
     } 
     return oTempCar;
}
var oCar1 = createCar();
var oCar2 = createCar();

2、构造函数方式

function Car(sColor, iDoors, iMpg){
    this.color = sColor;
    this.doors = iDoors;
    this.mpg = iMpg;
    this.showColor = function(){
        alert(this.color);
    };
}
var onCar1 = new Car("red", 4, 23);
var onCar2 = new Car("blue", 4, 25);

以上两种存在的问题，使用这两种方法必须创建对象的方法，每个对象都有自己的showColor版本，事实上，每个对象都共享了同一个函数。

3、原型方式

function Car(){
 
}

Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.mpg = 23;
Car.prototype.showColor = function(){
    alert(this.color);
};

var onCar1 = new Car();
var onCar2 = new Car();

4：混合的构造函数/原型方式

联合使用构造函数和原型方式，就可像用其他程序设计语言一样创建对象。这种概念非常简单，即用构造函数定义对象的所有非函数属性，用原型方式定义对象的函数属性（方法）。结果所有函数都只创建一次，而每个对象具有自己的对象属性实例。

function Car(sColor, iDoors, iMpg){
    this.color = sColor;
    this.doors = iDoors;
    this.mpg = iMpg;
    this.dirvers = new Array("Mike", "Sue");
    
}
Car.prototype.showColor = function(){
    alert(this.color);
};
var onCar1 = new Car("red", 4, 23);
var onCar2 = new Car("blue", 4, 25);

5：动态原型方法

function Car(sColor, iDoors, iMpg){
    this.color = sColor;
    this.doors = iDoors;
    this.mpg = iMpg;
    this.dirvers = new Array("Mike", "Sue");
    if(typeof Car._initialied == "undefined"){ //判断是否已创建了此方法
        Car.prototype.showColor = function(){
            alert(this.color);
        };
        Car._initialied = true;
    }
}

五：修改对象

1、重定义已有方法

Function.prototype.toString = function(){
    return "Function code hidden";
}

以上即是覆盖已经有的定义的方法。不过toString指向的原始函数被无用存储单元回收程序回收，因为它被完全废弃了。没有能够恢复原始函数的方法，所以在覆盖原始方法之前，比较安全的做法是存储它的指针，以便以后的使用。有时你甚至可能在新方法中调用原始的方法。

Function.prototype.originalToString = Function.prototype.toString;

Function.prototype.toString = function(){
    if(this.originalToString().length > 100){
        return "Function too long to display.";
    }else{
        return this.originalToString();
    }
}

2、极晚绑定

从技术上来讲，根本不存在极晚绑定。（表示能够在对象实例化后再定义它的方法。）

var o  = new Object;

Object.prototype.sayHi = function(){
    alert("Hi");
}
o.sayHi();

不建议使用极晚绑定，因为很难对其跟踪和记录。不过，还是应该了解这种可能。

六：继承

1：对象冒充

function ClassA(sColor){
    this.color = sColor;
    this.sayColor = function(){
        alert(this.color);
    }
}

function ClassB(sColor, sName){
    this.newMethod = ClassA;
    this.newMethod(sColor);
    delete this.newMethod;
    
    this.name = sName;
    this.sayName = function(){
        alert(this.name);
    };
}

注:所有的新属性和新方法都必须在删除了新方法的代码行后定义。否则，可能会覆盖超类的相关属性和方法。

2：call()方法

function ClassB(sColor){
    ClassA.call(this, sColor);
    this.name = SName;
    this.sayName = function(){
        alert(this.name);
    };
}

3：apply()方法

function ClassB(sColor){
    ClassA.apply(this, [sColor]);
    this.name = SName;
    this.sayName = function(){
        alert(this.name);
    };
}

call 与apply区别就是，apply参数以数组的方式传过去。

4：原型连

function ClassA(){
    
}
ClassA.prototype.color = "red";
ClassA.prototype.sayColor = function() {
    alert(this.color);
};

function ClassB(){
    
}

ClassB.prototype = new ClassA();

ClassB.prototype.name = "";

ClassB.prototype.sayName = function(){
    alert(this.name);
}

原型链的神奇之处就是红色代码行。这里，把ClassB的prototype属性设置成ClassA实例。这很有意义，因为想要ClassA的所有属性和方法，但是有不想逐个将他们赋予ClassB的prototype属性。

注：调用ClassA的构造函数时，没有给它传递函数。这在原型链中是标准做法。要确保构造函数没有任何参数。

5: 其他继承方式

zInherit

xbObject