js创建对象模式与继承方式小结

创建js对象必须知道的4种方法#

---

欢迎指正！

1. 工厂模式

   简单说明：通过函数中创建新的对象，赋予属性后，再返回该对象。该方法一般不适用

    function sayName() {
    	console.log(this.name);
    }
   
    function Person1 (name, age) {
    	var obj = new Object();
    	obj.name = name;
    	obj.age = age;
    	obj.sayName = sayName;
   
    	return obj;
    }
   
    var person1 = Person1('susan', 21);
    person1.sayName();	
   

2. 构造函数模式

   简单说明：无需在函数中创建对象而使用this指代，且无需返回

    function Person2 (name, age) {
    		this.name = name;
    		this.age = age;
    		this.sayName = sayName;
    	}
   
    var person2 = new Person2('susan', 21);
    person2.sayName();
   

3. 原型模式

   在函数中不对属性进行定义，而是使用prototype属性进行定义

    function Person3 () {}
   
    Person3.prototype.name = 'susan';
    Person3.prototype.age = 21;
    Person3.prototype.sayName = sayName;
   
    var person3 = new Person3();
    person3.sayName();
   

4. 混合构造函数模式与原型模式（推荐）

   该方法集合了两种模式的优点，既可以做到对象拥有私有属性，又可以公用其中的一些方法

    function Person4 (name, age) {
    	this.name = name;
    	this.age = age;
    }
   
    Person4.prototype.sayName = sayName;
   
    var person4 = new Person4('susan', 21);
    person4.sayName();
   

js继承必须知道的4种方法

---

1. 原型链继承。

   简单说明：子类的原型对象为基类的实例函数

    (function () {
    	function SuperType() {
    		this.property = true;
    		this.exist = 'yes';
    	}
   
    	SuperType.prototype.getSuperValue = function () {
    		return this.property;
    	}
   
    	function SubType() {
    		this.subproperty = false;
    	}
   
    	//继承SuperType
    	SubType.prototype = new SuperType();
    	//避免使用字面量方法设置
    	SuperType.prototype.getSubValue = function () {
    		return this.subproperty;
    	}
   
    	var instance = new SubType();
    	console.log(instance.getSuperValue());  //true
    }());
   

2. 构造函数继承

   在子类中使用call/apply调用父类

    (function () {
    	function SuperType() {
    		this.colors = ['red', 'blue', 'pink'];
    	}
   
    	function SubType() {
    		SuperType.call(this);
    	}
   
    	var instance1 = new SubType();
    	instance1.colors.push('black');
    	console.log(instance1.colors); //["red", "blue", "pink", "black"]
   
    	var instance2 = new SubType();
    	console.log(instance2.colors);	//["red", "blue", "pink"]
    }());
   

3. 原型式继承

   使用Object.create()，返回的新对象以括号内的对象为原型，其中可以对私有属性进行更改，而方法也得到了公用。不足点在于当数据为数组时，会共享这个数组。

    var sub = Object.create(person);
    sub.name = 'jack';
    sub.colors.push('white');
    console.log(sub.name);	//jack	
    var subs = Object.create(person);
    subs.name = 'jan';
    subs.colors.push('pink');
    console.log(subs.name);	//jan
    console.log(subs.colors); //["red", "black", "white", "pink"]
   

4. 拷贝继承

   拷贝一个对象的所有属性和方法,缺点是无法获取基类不能枚举的属性

    function Animal () {
    	this.name = 'susan';
    	this.age = 21;
    	this.sayName = function () {
    		console.log(this.name);
    	}
    }
   
    Animal.prototype.sayAge = function () {
    	console.log(this.age);
    }
   
    function Cat () {
    	var animal = new Animal();
   
    	for (var p in animal) {
    		Cat.prototype[p] = animal[p];
    	}
    }
   
    Cat.prototype.sayHi = function () {
    	console.log('hi');
    }
   
    var cat = new Cat();
    cat.sayAge();	//21
    cat.sayName();	//susan
    cat.sayHi();	//hi