面向对象01 理解对象和创建对象

理解对象和创建对象

1.理解对象

• 创建一个Object的实例，然为其添加属性和方法(早期创建对象的模式)

var person = new Object();
person.name = "Nicholas";
person.age = 29;
person.job = "Software Engineer";

person.sayName = function(){
    alert(this.name);

}

• 用对象字面量语法重写上述过程：

var person = {
    name: "Nicholas";
    age: 29;
    job: "Software Engineer";
    
    sayName: function(){
        alert(this.name);
    }
}

1.1 属性类型

ECMAScript中有两种 属性(property) :数据属性和访问器属性，用 特性(attribute) 来描述属性的各种特征。

数据属性：

数据属性包含一个数据值的位置，在这个位置可以读取和写入值。

数据属性有四个描述其行为的特性：

• [[Enumerable]]:表示能否通过 for-in循环返回属性，默认值为true。
• 要修改属性默认的特性，必须使用ECMAScript的Object.defineProperty()方法

访问器属性

访问器属性不包含数据值，它们包含一对getter和setter函数(不是必须的)。在读取访问器属性时，会调用getter函数，在写入访问器属性时，会调用setter函数并传入新值。访问器属性有以下四个特性：

• [[Enumerable]]:表示能否通过 for-in循环返回属性，默认值为true。
• 访问器属性不能直接定义，必须使用Object.defineProperty()方法来定义

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; //对访问器属性year进行写入，因此调用setter函数
alert(book.edition); //2

2 创建对象

Object构造函数和对象字面量

前面提到了早期创建对象的两种方法：Object构造函数和对象字面量，但是这些方式有明显的缺点：使用同一个接口创建很多对象，会产生大量的重复代码。

工厂模式：

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 = create("Nicholas", 29, "Software Engineer");

缺点：

• 工厂模式虽然解决了创建多个相似对象会有大量重复代码的问题，但是却没有解决 对象识别 的问题(因为返回的都是Object类型)

构造函数模式

ECMAScript中的构造函数可以用来创建特定类型的对象。

function Person(name, age, job){
    this.name=name;
    this.age=age;
    this.job=job;
    this.sayName=function(){
        alert(this.name);
    }
}
// 注意将Person当做构造函数，需要使用new操作符来创建新对象
var person1 = new Person("xin",22,"Software Engineer");
var person2 = new Person("wu",22,"Software Engineer");

在上面的例子中，person1和person2分别保存着一个不同的实例，但是这两个对象都有一个constructor(构造函数)属性，该属性执行Person。

检测对象类型：

• 利用constructor属性：

alert(person1.constructor == Person); //true

• 利用instanceof操作符：

alert(person1 instanceof Object); //true
alert(person1 instanceof Person); //true

创建自定义的构造函数意味着将来可以将它的事例标识为一种特定的类型

缺点：

• 每个方法都要在每个实例上重新创建一遍。上例中，person1和person2中都有一个sayName的方法，但是两个实例中的方法不是同一个Function的实例。因此不同实例上的同名函数是不相等的。
• 解决方法：把函数定义转移到构造函数外部。

function Person(name, age, job){
    this.name=name;
    this.age=age;
    this.job=job;
    this.sayName=sayName;//sayName属性设置为全局的sayName函数
}
function sayName(){
        alert(this.name);
}
var person1 = new Person("xin",22,"Software Engineer");
var person2 = new Person("wu",22,"Software Engineer");

• 修改后，person1和person2对象共享了在全局作用域中定义的同一个sayName()函数。但是出现了新的问题：

  • 在全局作用域中定义的函数(sayName)实际上只能被某个对象(person1 person2)调用，让全局作用域“名不副实”；

  • 如果对象需要定义很多方法，则需要在全局作用域中定义很多全局函数，是得这个 自定义的引用类型(自定义的构造函数) 无封装性可言。

  • 解决方法：原型模式

原型模式

每个函数都有一个prototype(原型) 属性，这个属性是一个指针，指向一个对象，而这个对象的用途是 包含可以由特定类型的所有实例共享的属性和方法 。

function Person(){
}
Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.ptototype.sayName = function(){
    alert(this.name);
}
var person1 = new Person();
person1.sayName(); //"Nicholas"

var person2 = new Person();
person2.sayName();//"Nicholas"
//person1和person2的属性和方法是所有实例共享的
alert(person1.sayName == person2.sayName); //true

理解原型对象

image

原型属性[[Prototype]]的访问

• 确定对象之间的关系 isPrototypeOf

alert(Person.prototype.isPrototypeOf(person1));//true

• 获取原型对象 Object.getPrototypeOf()

alert(Object.getPrototypeOf(person1) == Person.prototype); //true
alert(Object.getPrototypeOf(person1).name);//Nicholas

• 每当代码读取某个对象的某个属性时，都会执行一次搜索，目标是具有给定名字的属性。搜索 首先从对象实例本身开始 。如果在实例中找到了具有给定名字的属性，则返回该属性的值。如果没有找到，则继续搜索指针指向的原型对象，在原型对象中查找具有给定名字的属性。如果在原型对象中找到了额这个属性，则返回该属性的值。
• 虽然可以通过对象实例访问保存在原型中的值，但却不能通过对象重写原型中的值。如果在实例中添加了一个属性，且该属性与实例原型中的一个属性同名，则该属性会屏蔽原型中的那个属性。
• 可以使用hasOwnProperty()方法来检测一个属性是存在与实例中，还是存在与原型中。

person1.hasOwnProperty("name"); //false

• 原型与in操作符：单独使用in操作符时，in操作符会在通过原型能够访问给定属性时返回true，无论该属性存在与实例中还是存在原型中。同时使用hasOwnProperty()方法和in操作符，就可以确定该属性到底是存在与对象中，还是存在与原型中。

alert( !person1.hasOwnProperty(name) && name in person1); //true

更简单的原型语法：

前面的例子中每添加一个属性和方法就要敲一遍Person.prototype。为了减少不必要的输入，更常见的方法是 用一个包含所有属性和方法的对象字面量来重写整个原型对象

function Person(){
}
Person.prototype = {
    name: "Nicholas",
    age: 29,
    job: "Software Engineer",
    sayName: function(){
        alert(this.name);
    }
}

注意：
这里使用的语法，本质上完全重写了默认的prototype对象，因此constructor属性也就变成了新对象的constructor属性(指向Object构造函数)，不再指向Person函数。使用instanceof操作符还能返回正确的结果，但是通过constructor已经无法确定对象的类型了。

var friend = new Person();
alert(friend.instanceof Person);//true
alert(friend.constructor == Person);//false

如果constructor属性很重要，可以将其设为适当的值

//方法一，但是会使constructor属性的[[Enumerable]]特性变为true
function Person(){
}
Person.prototype = {
    constructor:Person,
    name:"Nicholas",
    age:29,
    job:"Software Engineer",
    sayName:function(){
        alert(this.name);
    }
}

function Person(){
}
Person.prototype = {
    name:"Nicholas",
    job:"Software Engineer",
    age:29,
    sayName:function(){
        alert(this.name);
    }
}
Object.defindProperty(Person.prototype, "constructor",{ 
    enumerable: false,
    value: Person
});

原生对象的原型：

所有原生类型(Object,Array,String,等等)都在其构造函数的原型上定义了方法。

原型对象的问题：

• 省略了为构造函数传递参数，导致了所有实例在默认情况下都取得相同的属性值。
• 原型对象的最大问题是由其共享属性 的本质所导致的：

function Person(){
}
Person.prototype = {
    constructor: Person,
    name: "Nicholas",
    age: 29,
    job: "Software Engineer",
    friends: ["Sheldon","Court"],
    sayName: function(){
        alert(this.name);
    }
};
var person1 = new Person();
var person2 = new Person();

person1.friends.push("van");
alert(person1.friends); //sheldon，court，van
alert(person2.friends); //sheldon，court，van
alert(person1.friends === person2.friends);//true

出现上述问题的原因在于：person1和person2的friends属性共享一个数组。

组合使用构造函数模式和原型模式

构造函数模式用来定义实例属性，原型模式用来定义方法和共享属性。结果每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用，最大限度的节省了内存。

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["sheldon","mary"];
}
Person.prototype = {
    constructor: Person,
    sayName: function(){
        alert(this.name);
    }
}

稳妥构造函数模式

• 特点：1.新创建对象的实例方法不引用this；2.不使用new 操作符调用构造函数

function Person(name,age,job){
    var o = new Object();
    o.sayName = function(){
        alert(name);
    }
    return o;
}

• 以这种方式创建的对象中，除了使用sayName()方法之外，没有其他办法访问name的值。

var friend = Person("Nicholas",29,"Software Engineer");
friend.sayName();

即使有其他代码会给这个对象添加方法或数据成员，但也不可能有别的方法访问传入到构造函数中的原始数据(name,job,age)。稳妥构造函数模式提供的这种安全性，使得它非常适合在某些安全环境中执行。

使用稳妥构造函数模式创建的对象与构造函数之间没什么关系，因此instanceof操作符对这种对象没有什么意义