js006-面向对象的程序设计

var person = new Object();

person.name = "meimei";

person.age = 18;

person.job = "software enginer";

person.sayName = function(){

       alert(this.name);

};

创建了一个名为person的对象，添加三个属性并对其赋值，和一个方法sayName用于显示this.name

[[Configurable]]

表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性。默认值为：true

[[Enumerable]]

表示能否通过for-in循环返回属性。默认值为：true

[[Writable]]

表示能否修改属性的值。默认值为：true

[[Value]]

包含这个属性的数据值，读取属性值的时候，从这个位置读；写入属性值的时候，把新值保存到这个位置，这个特性的默认值为Undefined

getter函数

读取访问器属性时调用，返回有效值

setter函数

写入访问器属性是调用，传入新值

[[Configurable]]

表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性。默认值为：true

[[Enumerable]]

表示能否通过for-in循环返回属性。默认值为：true

[[Get]]

读取访问器属性时调用的函数，默认值为：Undefined

[[Set]]

写入访问器属性是调用的函数，默认值为：Undefined

var book = {

       _year: 2015,

       _edition:1

};

Object.defineProperty(book, "year", {

       get:function(){

              if (newValue > 2015) {

                            this.year = newValue;

                            this.edition += newValue - 2015;

                     }

       }

});

book.year = 2016;

alert(book.edition); //2

创建了一个book对象，并定义了连个默认属性，

_（添加下划线）表示只能通过对象访问的属性。

var book ={};

Object.defineProperties(book,{

       _year:{

              writable:true,

              value:2015

       },

       edition:{

              value:1

       },

       year:{

              get.function(){

                     return this._year;

              },

              set:function(newValue){

                     if (newValue > 2015) {

                            this.year = newValue;

                            this.edition += newValue - 2015;

                     }

              }

       }

});

定义了个book独享的两个数据属性_year和edition和一个访问器属性(year).最终的对象与上一节中定义的对昂相同，唯一的区别是这里的属性都是在同一时间创建的。

var book ={};

Object.defineProperties(book,{

       _year:{

              value:2015;

       },

       edition:{

              value:1

       },

       year:{

              get:function(newValue){

                     if (newValue > 2015) {

                            this._year = newValue;

                            this.edition += newValue - 2015;

                     }

              }

       }

});

var descriptor = Object.getOwnPropertyDescriptor(book, "_year");

alert(descriptor.value);  //2015

alert(descriptor.configurable);  //false

使用Object.getOwnPropertyDescriptor()方法，可以取得给定属性的描述符，该方法接收两个参数：属性所在的对象和要读取其描述符的属性的名称。返回值是一个对象，如果是访问器属性，这个对象的属性有：Configurable、Enumerable、Get、Set

如果是数据属性，这个对象的属性有：Configurable、Enumerable、Writable、Value

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("meimei", 18, "teacher");

var person2 = createPerson("lal-Alice", 18, "software enginer");

可以多次调用createPerson()函数

在控制台运行并测试：

console.log(person2);

Object {name: "lal- Alice", age: 18, job: "software enginer"}

但是工程模式没有解决对象识别的问题（怎样知道一个对象的类型）

function Person(name, age, job){

       this.name = name;

       this.age = age;

       this.job = job;

       o.sayName = function(){

              alert(this.name);

       };

}

var person1 = new Person("meimei", 18, "teacher");

var person2 = new Person("lal", 18, "software enginer");

Person()取代了createPerson()函数。相对来说不同的是：Person()中

1、没有显式地创建对象；

2、直接将属性和方法赋给了this对象；

3、没有return语句。

创建一个新对象

将构造函数的作用域赋给新对象

执行构造函数中的代码（添加新属性）

返回新对象

当做构造函数使用

var person2 = new Person("lal-Alice", 18, "software enginer");

person.sayName();//"lal-Alice"

作为普通函数调用

person("lal-Alice" , 18, "software enginer");

window.sayName();//"lal-Alice"

在另一个对象的作用域中调用

var o = new Object();

Person.call(o, "lal-Alice", 18, "software enginer");

o.sayName();//"lal-Alice"

function Person(name, age, job){

       this.name = name;

       this.age = age;

       this.job = job;

       this.fiiends = ["shelby", "Court"];

}

Person.prototype = {

       constructor:person;

       sayName:function(){

              alert(this.name);

       }

}

var person1 = new Person("meimei", 18, "teacher");

var person2 = new Person("lal", 18, "software enginer");

person1.fiiends.push("van");

alert(person1.fiiends);  //"shelby，Court，van"

alert(person2.fiiends);  //"shelby，Court"

alert(person1.fiiends == person2.fiiends);  //false

alert(person1.sayName == person2.sayName);  //true

实例属性是在构造函数中定义的，而由所有实例共享的属性constructor和方法sayName()则是在原型中定义的。而修改了person1.fiiends，并不会影响到person2.fiiends

function Person(name, age, job){

       //属性

       this.name = name;

       this.age = age;

       this.job = job;

       //方法

       if (typeof this.sayName != "function") {

              Person.prototype.sayName = function(){

                     alert(this.name);

              }

       };

}

var friend = new Person("lal-Alice" , 18, "software enginer");

friend.sayName();

加粗代码只有在sayName()方法不存在的情况下，才会添加到原型中，这段代码只有在初次构造函数时才会调用。

//原型链

function SupperType(){

       this.property = true;

       SupperType.property.getSuperValue = function(){

              return this.property;

       };

}

function SubType(){

       this.subproperty = false;

}

//继承了SuperType

SubType.propertype = new SupperType();

SubType.propertype.getSuperValue = function() {

       return this.subproperty;

};

var instance = new SupperType();

alert(instance.getSuperValue());  //true

定义了两个类型：SuperType  SubType。每个类型分别有一个属性和一个方法。