笔记-javascript创建对象

1. 工厂模式创建对象

//在函数内创建一个对象，给对象赋予属性及方法再将对象返回
function person (name, age) {
    var obj = new Object();
    obj.name = name;
    obj.age = age;
    obj.sayName = function () {
        alert(this.name);
    };
    return obj;
}
var per = person("zhangsan", 21);
per.sayName();//zhangsan
//工厂模式无从识别对象的类型，全部都是Object
alert(typeof per); //object

缺点：没有new，重复调用方法，资源浪费。

2.构造方法创建对象

//没有显示的创建对象,直接将属性和方法赋值给了this对象,没有return语句
function Person (name, age) {
    this.name = name;
    this.age = age;
    //相当于this.sayName = new Function ("alert(this.name)");
    this.sayName = function () {
        alert(this.name);
    };
}
//使用new创建对象,
var person = new Person("zhangsan", 21);
var person2 = new Person("lisi", 21);
person.sayName();//zhangsan
//能够识别对象（这正是构造函数模式胜于工厂模式的地方）
//使用构造函数的最大的问题在于每次创建实例的时候都要重新创建一次方法（理论上每次创建对象的时候对象的属性均不同，而对象的方法是相同的）
alert(person instanceof Person);//true
alert(person instanceof Object);//true
alert(person.sayName == person2.sayName);//false

解决了没有new，但是函数还是重复调用，浪费资源

3.原型模式创建对象

原型类似css里面的class选择器·，一次给一组元素加样式

// 我们创建的每个函数都有prototype（原型）属性，这个属性是一个指针，指向一个对象，
　　而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。使用原型对象的好处就是可以让所有对象实例共享它所包含的属性及方法。
function Person () {}
Person.prototype.name = "Tom";
Person.prototype.age = 21;
Person.prototype.friends = ["Lee", "Jack"];
Person.prototype.sayName = function () {
    alert(this.name);
};

var p1 = new Person();
p1.sayName();  //Tom
alert(p1.friends);
var p2 = new Person();
p2.sayName();    //Tom
alert(p2.friends);
alert(p1.sayName == p2.sayName);    //true
//一个实例修改了引用，另一个也随之更改了引用
p1.friends.push("john");
alert(p1.friends);  //Lee,Jack,john
alert(p2.friends);  //Lee,Jack,john

解决了没有new，同时也解决了函数重复调用，但是成员属性都一样

4.混合模式创建对象（组合使用构造函数和原型模式）

//混合模式中构造函数模式用于定义实例属性，而原型模式用于定义方法和共享属性
function Person (name, age) {
    this.name = name;
    this.age = age;
    this.friends = ["Lee", "Jack"];
    if (typeof this.sayName != "function") {
        Person.prototype.sayName = function () {
            alert(this.name);
        };
    }
}

var p1 = new Person("Tom", 23);
var p2 = new Person("Bob", 21);
p1.sayName();
alert(p1.friends);
p2.sayName();
alert(p2.friends);
//一个实例修改了引用，另一个不会更改引用
p1.friends.push("john");
alert(p1.friends);
alert(p2.friends);

5.原型对象概念

// 我们创建的每个函数都有prototype（原型）属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。
　　使用原型对象的好处就是可以让所有对象实例共享它所包含的属性及方法。
function Person () {}
Person.prototype.name = "Tom";
Person.prototype.age = 21;
Person.prototype.sayName = function () {
    alert(this.name);
};

var p1 = new Person();
var p2 = new Person();
alert(p1.constructor == Person);    //true
alert(p1.constructor == Object);    //false
//检测属性是实例属性还是原型属性
// alert(p1.hasOwnProperty("name"));    //false
// alert("name" in p1);    //true
// alert(Person.prototype.hasOwnProperty("name"));    //true
// //检测指示对象是否存在于另一个对象的原型链中
// alert(Person.prototype.isPrototypeOf(p1));    //true
// alert(Person.prototype.isPrototypeOf(p2));    //true
// //返回的对象(Person.prototype)是这个对象(p1)的原型
// alert(Object.getPrototypeOf(p1) == Person.prototype);    //true
// alert(p1.sayName == p2.sayName);    //true
p1.name = "john";
alert(hasPrototypeProperty(p1, "name"));
//检测属性是否属于原型
function hasPrototypeProperty (object, name) {
    return !object.hasOwnProperty(name) && (name in object);
}

6.寄生构造函数模式

function Person (name, age) {
    var obj = new Object();
    obj.name = name;
    obj.age = age;
    obj.sayName = function () {
        alert(this.name);
    };
    return obj;
}
var p1 = new Person("Tom", 21);
p1.sayName();
//返回的对象与构造函数和构造函数的原型没有关系，相当于在构造函数外部创建对象
alert(p1 instanceof Person);    //false
alert(Person.prototype.isPrototypeOf(p1));    //false

7.原型链

function Parent () {
    this.property = true;
    this.colors = ["red", "green", "blue"];
}
Parent.prototype.getParentValue = function () {
    return this.property;
};

function Child () {
    this.childproperty = false;
}
//继承Parent
Child.prototype = new Parent();
Child.prototype.getChildValue = function () {
    return this.childproperty;
};

var instance = new Child();
var instance2 = new Child();
// alert(instance.getParentValue());    //true

//instance相当于Child,Parent,Object任何一个类型的实例
// alert(instance instanceof Child);    //true
// alert(instance instanceof Parent);    //true
// alert(instance instanceof Object);    //true

//Object.prototype,Parent.prototype,Child.prototype任何一个相当于instance的原型
// alert(Object.prototype.isPrototypeOf(instance));        //true
// alert(Parent.prototype.isPrototypeOf(instance));        //true
// alert(Child.prototype.isPrototypeOf(instance));        //true

alert(instance.colors);    //ren, green, blue
instance.colors.push("yellow");
//因为引用类型的原型属性会被所有的实例共享,所以改变一个实例的引用类型的值时，另外一个实例的引用类型值也会改变
alert(instance.colors);        //ren, green, blue, yellow
alert(instance2.colors);    //ren, green, blue, yellow