6.1.1 属性类型
1ECMA有两种属性：数据属性和访问器属性
1.数据属性
这都是处理对象的吗
要修改属性默认的特性，必须使用object.defineProperty()方法。这个方法接收三个参数：属性所在的对象，属性的名字和一个描述符对象。描述符对象的属性必须是:configurable. enumerable.writable和value。设置其中的一或多个值，可以修改对应的特性值如
var person={};
Object.definePropetyName(person,"name",{
writable:false;
value:"nicola";//只读的 赋值操作会被忽略，在严格模式下，赋值操作将会导致抛出错误。
}};
alert(person.name);//nicola
他妈的这例子真的有反应它的作用嘛？？？？
把configurable设置为false，表示不能从对象中删除属性。如果对这个属性调用delete，则在非严格模式下什么也不会发生，严格模式抛错。
默认值都是false
2.访问器属性
不包含数据值，包含一对儿函数：getter和setter。
var book={
_year:2004,
edition:1
};
Object.defineProperty(book, "year",{
get:function(){
return this._year;
},
set:function(newValue){
if(newValue>2004){
this._year=newValue;
this.edition+=newValue-2004;
}
}
});
book.year=2005;
alert(book.edition); //2
_year中的下划线是一种常用的记号，用于表示只能通过对象方法访问的属性。而访问器属性则包含一个getter函数和一个setter函数。这是使用访问器属性的常见方法，即设置一个属性的值会导致其它属性发生变化。
不一定要同时制定getter和setter，只指定getter意味着只读。
6.1.2 定义多个属性
Object.defineProperties()方法：由于为对象定义多个属性的可能性很大，使用该方法可以通过描述符一次定义多个属性。接收两个对象参数：第一个对象是要添加和修改其属性的对象，第二个对象的属性与第一个对象中药添加或修改的属性一一相应。如：
var book={};
Object.defineProperties(book,{
_year:{
value:2004
},
edition:{
value:1
},
year:{
get:function(){
return this._year;
},
set:function(newValue){//自动获取newValue吗
if(newValue>2004){
this._year=newValue;
this.edition+=newValue-2004;
}
}
}
});
以上代码对外上定义了两个数据属性（_year和edition）和一个访问器属性（year）
6.1.3 读取属性的特性
Object.getOwnPropertyDescriptor()方法，可以取得给定属性的描述符。接收两个参数：属性所在的对象和要读取器描述符的属性名称。返回值是一个对象，如果是访问器属性，这个对象的属性有configurable, enumerable, writable和value。例如：
var book={};
Object.defineProperties(book,{
_year:{
value:2004
},
edition:{
value:1
},
year:{
get:function(){
return this._year;
},
set:function(newValue){
if(newValue>2004){
this._year=newValue;
this.edition+=newValue-2004;
}
}
}
});
var descriptor = Object.getOwnPropertyDescriptor(book,"_year");
alert(descriptor.value); //2004
alert(descriptor.configurable);//false（能否delete）
alert(typeof descriptor.get);//undefined
var descriptor = Object.getOwnPropertyDescriptor(book, "year");
alert(descriptor.value);//undefined pourquoi?
alert(descriptor.enumerable);//false
alert(typeof descriptor.get);//funtion
//对于数据属性_year，value等于最初的值，configurable是false，而get等于undefined。对于访问器属性year，value等于undefined，enumerable是false，而get是一个指向getter函数的指针。
6.2 创建对象
6.2.1 工厂模式
用函数来封装以特定接口创建对象的细节，如
function createPerson（name,age,job）{
var o=new Object();
o.name=name;
o.age=age;
o.job=job;
o.sayName=function(){
alert(this.name);
};
return o;
}
var person1=createPerson("nicolas",29,"software engineer");
var person2=createPerson("greg",27,"doctor");
6.2.2 构造函数模式
构造函数可用来创建特定类型的对象。
像Object和array这样的原生构造函数，在运行时会自动出现在执行环境中。此外，也可以创建自定义的构造函数，从而定义自定义对象类型的属性和方法。例如
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
this.sayName=function(){
alert(this.name);
};
}
var person1=new Person("nico",29,"software engineer");
var person2=new Person("greg",27,"doctor");
//没有显式地创建对象
//直接将属性和方法赋给了this对象
//没有return语句
//按照惯例，构造函数始终都应该以一个大写字母开头，而非构造函数应该以一个小写字母开头。
要创建Person的实例，必须使用new操作符。以这种方式调用构造函数实际上会经历以下4个步骤：
（1）创建一个新对象；
（2）将构造函数的作用域赋给新对象（因此this就指向了这个新对象）
（3）执行构造函数中的代码（为这个新对象添加属性）
（4）添加新对象
对象的constructor属性最初是用来标识对象类型的，但是，检测对象类型，还是instanceof 操作符更可靠一些。
1.将构造函数当做函数
构造函数与其它函数的唯一区别就在于它们的调用方式。构造函数不存在定义的特殊语法。任何函数，只用通过new操作符来调用，那么它就可以作为构造函数。
看例子
//当作构造函数使用
var person=new Person("nico",29,"software engineer");
person.sayName();//nico
//作为普通函数
Person("greg",27,"doctor");//添加到window
window.sayName(); //greg
//在另一个对象的作用域中调用
var o=new Object();
Person.call(o,"kris",25,"nurse");
o.sayName();//kris
2.构造函数的问题
就是构造函数中的每个方法都要在每个实例上重新创建一遍。（函数也是对象，因此每定义一个函数，就是实例化了一个对象）不同实例上的同名函数是不相等的。
不如把函数定义转移到构造函数外部，如
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
this.sayName=sayName;//把它变成一个指针
}
function sayName(){//全局函数
alert(this.name);//但是此处的this？
}
//但是此种方法没有封装性了
var person1=new Person("nico",29,"engineer");
var person2=new Person("greg",27,"doctor");
6.2.3 原型模式
创建的每个函数都有一个prototype属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。prototype就是通过调用构造函数而创建的那个 对象实例的原型对象（您说了跟没说似的）。换句话说，不必在构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象中。如
function Person(){
//构造函数变成空函数
}
Person.prototype.name="nico";
Person.prototype.age=29;
Person.prototype.job="engineer";
Person.prototype.sayName=function(){
alert(this.name);
};
var person1=new Person();
person1.sayName();//"nico"
var person2=new Person();
person2.sayName();//"nico"
alert(person1.sayName==person2.sayName);//true 两个函数的指针
1.理解原型对象
无论什么时候，只要创建了一个新函数，就会根据一组特定的规则为该函数创建一个prototype属性，这个属性指向函数的原型对象。在默认情况下，所有原型对象都会获得一个构造函数属性，这个属性包含一个指向prototype属性所在函数的指针。就拿前面的例子来说，person.prototype.constructor指向person。
创建了自定义的构造函数之后，其原型对象默认只会获得constructor属性，其它方法都是从object继承而来的。当调用构造函数创建一个新实例时，该实例的内部将包含一个指针（内部属性），指向构造函数的原型对象。
Person.prototype指向了原型对象，而Person.prototype.constructor又指回了Person。Person的每个实例——person1和person2都包含一个内部属性，属性仅仅指向了Person.prototype，它们与构造函数没有直接的关系。
alert(Person.prototype.isPrototypeOf(person1)); //true
使用Object.getPrototypeOf()可以方便取得一个对象的原型，而这在利用原型实现继承的情况下是非常重要的。
每当代码读取某个对象的某个属性时，都会执行一次搜索，目标是具有给定名字的属性。搜索首先从对象实例本身开始。如果在实例中没找到就继续搜索指针指向的原型对象。
原型最初只包含constructor属性，而该属性也是共享的，因此可以通过对象实例访问。
原型中的值只能被覆盖（屏蔽），不能被重写。
function Person(){
}
Person.prototype.name="nico";
Person.prototype.age=29;
Person.prototype.job="engineer";
Person.prototype.sayName=function(){
alert(this.name);
};
var person1=new Person();
var person2=new Person();
person1.name="greg";
alert(person1.name); //greg
alert(person2.name); //nico
delete person1.name;//delete的用法
alert(person1.name); //nico
使用hasOwnProperty()方法可以检测一个属性是存在于实例中，还是在原型中。如
function Person(){
}
Person.prototype.name="nico";
Person.prototype.age=29;
Person.prototype.job="engineer";
Person.prototype.sayName=function(){
alert(this.name);
};
var person1=new Person();
var person2=new Person();
alert(person1.hasOwnProperty("name")); //false
person1.name="greg";
alert(person1.name);
alert(person1.hasOwnProperty(name)); //true
-
原型与in操作符
有两种方式使用in操作符：单独使用和在for-in循环中使用。在单独使用时，in操作符会在通过对象能够访问给定属性时返回true，无论该属性存在于实例中还是原型中。同时使用hasOwnProperty()方法和in操作符，就可以确定该属性到底是存在于对象中，还是在原型中。
function hasPrototypeProperty(object, name){
return !object.hasOwnProperty(name)&&(name in object);
}
要取得对象上所有可枚举的实例属性，可以使用ECMA的Object.keys()方法。这个方法接收一个对象作为参数，返回一个包含所有可枚举属性的字符串数组。看例子
function Person(){
}
Person.prototype.name="nico";
Person.prototype.age=29;
Person.prototype.job="engineer";
Person.prototype.sayName=function(){
alert(this.name);
}//所以相当于这个函数返回的是指向该函数的指针吧
var keys=Object.keys(Person.prototype);
alert(keys); //name age job sayName
var p1=new Person();
p1.name="rob";
p1.age=31;
var p1keys=Object.keys(p1);
alert(p1keys); //name age
3.更简单的原型语法
function Person(){
}
//对象字面量
Person.prototype={
//如果constructor的值真的很重要可以写成
//constructor：Person,
name:"nico";
age:29;
job:"engineer";
say : function(){
alert(this.name);
}
}
但是constructor属性不再指向Person了。此处的语法本质上完全重写了默认的prototype对象，因此constructor属性也就变成了新对象的constructor属性。（指向object构造函数），不再指向Person函数。
注意（以下都看不懂）：以这种方式（添加了constructor属性）重设constructor属性会导致它的enumerable特性被设置为true。默认情况下，原生的constructor属性是不可枚举的。
4.原型的动态性
实例中的指针仅指向原型，而不指向构造函数。看例子：
function Person(){
}
var friend =new Person();
Person.prototype={
constructor:Person,
name:"nico",
age:29,
job:"doc",
sayName:function(){
alert(this.name);
}
};
friend.sayName(); //error
因为是先创建了对象，而后又重写了原型。而把原型修改为另外一个对象就等于切断了构造函数与最初原型之间的联系。
（重写原型对象切断了现有原型与任何之前已经存在的对象实例之间的联系；它们引用的仍然是最初的原型）
5.原生对象的原型
原型模式的重要性不仅体现在创建自定义类型方面，就连所有原生的引用类型，都是采用这种模式创建的。
所有原生引用类型（object，array，string）都在其构造函数的原型上定义了方法。
通过原生对象的原型，不仅可以取得所有默认方法的引用，而且也可以定义新方法。可以像修改自定义对象的原型一样修改原生对象的原型，因此可以随时添加方法。下面的代码就给基本包装类型String添加了一个名为startsWith()的方法。
String.prototype.startsWith=function(text){
return this.indexOf(text)==0;
};
var msg="hello world";
alert(msg.starsWith("hello")); //true
//在传入的文本位于一个字符串开始时返回true
原型对象的问题：1.省略了为构造函数传递初始化参数这一环节。结果所有实例在默认情况下都将取得相同的属性值。2.最大问题是由其共享的本性所导致的。看例子
function Person(){
}
Person.prototype={
constructor:Person,
name:"nico",
age:29,
job:"engineer",
friends:["shelby","court"],
sayName:function(){
alert(this.name);
}
};
var person1=new Person();
var person2=new Person();
person1.friends.push("van");//此时这个数组还是指向原型中的，所以共享了？！
alert(person1.friends); //shelby court van
alert(person2.friends); //shelby court van
alert(person1.friends==person2.friends); //true
所以很少有人单独使用原型模式。
6.2.4 组合使用构造函数模式和原型模式
构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。结果，每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用个，最大限度地节省了内存，而且这种方式还支持向构造函数传递参数。如：
function Person(name, age, job){
this.name=name;
this.age=age;
this.job=job;
this.friends=["shelby","court"];
}
Person.prototype={
constructor:Person,
sayName:function(){
alert(this.name);
}
};
//其实这也相当于把属性和方法分开了吧
var person1=new Person("nico",29,"engineer");
var person2=new Person("greg",27,"doctor");
person1.friends.push("van");//此时这个数组还是指向原型中的，所以共享了？！
alert(person1.friends); //shelby court van
alert(person2.friends); //shelby court
alert(person1.friends===person2.friends); //false
alert(person1.sayName===person2.sayName); //true
6.2.5 动态原型模式
动态原型模式把所有信息封装在了构造函数中，而通过在构造函数中初始化原型（仅在必要的情况下），又保持了同时使用构造函数和原型的优点。换句话说（作者口头禅），可以通过检查某个应该存在的方法是否有效，来决定是否需要初始化原型。看例子
function Person(name,age,job){
//属性
this.name=name;
this.age=age;
this.job=job;
//方法
//只有sayName()方法不存在的情况下，才会把它添加到原型中。
//这段代码只有在初次调用构造函数时才会执行。
//这里对原型所做的修改，能够立即在所有实例中得到反映。
if(typeof this.sayName!="function"){
Person.prototype.sayName=function(){
alert(this.name);
};
}
}
var friend = new Person("nico",29,"engineer");
friend.sayName();
在使用动态模型时，不能使用对象字面量重写原型。如果在已经创建了实例的情况下重写原型，那么就会切断现有实例与新原型之间的联系。
6.2.6 寄生构造函数模式
通常，在前述的几种模式都不适用的情况下，可以使用寄生parasite构造函数模式。基本思想：创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象；但从表面上看，这个函数又很像是典型的构造函数。看例子
function Person(){
var o=new Object();
o.name=name;
o.age=age;
o.job=job;
o.sayName=function(){
alert(this.name);
};
return o;
}
var friend =new Person("nico",29,"engineer");
friend.sayName();//nico
//这个方法很眼熟了
再看个例子
function SpecialArray(){
var values=new Array();//
//添加值
values.push.apply(values,arguments);
//添加方法
values.toPipedString=function(){
return this.join("|");
};
//返回数组
return values;
}
var colors=new SpecialArray("red","blues","green");
alert(color.toPipedString());
关于寄生构造函数模式的说明：返回的对象与构造函数或者与构造函数的原型属性之间没有关系；也就是说，构造函数返回的对象与在构造函数外部创建的对象没有什么不同。（看不懂）
6.2.7 稳妥构造函数模式
稳妥对象：没有公共属性，而且其方法也不引用this的对象。最适合在一些安全的环境中，或者在防止数据被其它应用程序改动时使用。直接看例子吧
function Person(name,age){
var o=new Object();
//可以在此处定义私有变量和函数
//添加方法
o.sayName=function(){
alert(name);
};
return o;
}
6.3 继承
ECMA只支持实现继承。因为函数没有签名，故无法实现接口继承。（签名是啥，我也不懂）
6.3.1 原型链
利用原型让每一个引用类型继承另一个引用类型的属性和方法。
“假如让原型对象等于另一个类型的实例，此时的原型对象将包含一个指向另一个原型的指针。相应地，另一个原型中也包含着指向另一个构造函数的指针”如此层层递进，就构成了实例与原型的链条。
一种基本模式，如：
function SuperType(){
this.property=true;
}
//原型对象中定义的方法
SuperType.prototype.getSuperValue=function(){
return this.property;
};
function SubType(){
this.subproperty=false;
}
//继承了SuperType
SubType.prototype=new SuperType();
//↑原型对象指向另一个实例（父对象）？ 而这个实例又指向的是其对应的原型对象 这样相当于把两个原型对象联系起来了吧
//它其中还是有getSuperValue的吧...
SubType.prototype.getSubValue=function(){
return this.subproperty;
};
var instance=new SubType();
alert(instance.getSuperValue()); //true
没有使用SubType默认提供的原型，而是给它换了一个新原型。
调用instance.getSuperValue()会经历三个搜索步骤：1）搜索实例，2）搜索SubType.prototype。3）搜索SuperType.prototype(找到）
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
