JavaScript创建对象与对象的继承

面向对象的语言都有一个标志，那就是它们都有类这个东西，但是，js没有类这个概念，即使是现在的ES6规定了class关键字，但正如阮大神说的，这些都是语法糖，ES6 class能做到的，ES5大部分都能做到。所以，理解ES5的面向对象还是有意义的，虽然原型链啥的指来指去的脑壳痛。基于这些，我整理了一些对象的创建方法和继承，权当一个个人笔记，免得经常不用忘了。

一、创建对象

最普通的创建对象就是字面量了，简单清晰，可读性贼高，像这样：

let obj = {
	name: 'xiaom',
	age: 24,
	consoleName: function () {
		console.log(this.name)
	}
}

这样的可读性我觉得可能仅次于 【person[‘姓名’] = ‘小明’】，但是这样的方法，存在着一些问题，当我们用同一个接口去创建对象的时候，重复代码很多很多，看起来很乱，于是就有了工厂模式。

1.工厂模式
说白了工程模式就是用一个函数return的方法返回对象

function createObj (name,age) {
	let o = new Object()
	o.name = name
	o.age = age
	o.consoleName = function () {
		console.log(this.name)
	}
	return o
}
let obj1 = createObj('xiaom', 25)

这样的只要是用这样一个接口去创建，就不用重复写了。但是，因为不能知道一个对象识别问题，所以其实这种方式单独去用的不多。

2.构造函数模式
构造函数很经典的，为什么经典我也不知道，反正就是经典。
就再拿上面的例子来写吧。

function Obj (name, age) {
	this.name = name
	this.age = age
	this.consoleName = function () {
		console.log(this.name)
	}
}
let obj1 = new Obj('xiaom', 25)

定义构造函数时，构造函数名首字母请大写，这样一看就知道这是一个构造函数；
构造函数如果不用new 操作符就直接使用，如 【 Obj() 】，那这就是一个普通函数，this就指向window啦，这样是不对的；
new 操作符的作用是创建一个新对象，将构造函数的作用域赋给新对象（也就是让this指向新对象），执行构造函数的代码，返回对象。
但是，追求完美的人是不满足的，由于方法在构造函数中，每new一次，都要重新创建一遍，提出构造函数拿到全局，又会污染全局环境，就很不好

 function consoleName  () {
	console.log(this.name)
} 
	
function Obj (name, age) {
	this.name = name
	this.age = age
	this.consoleName = consoleName  
}
// 污染了全局环境
let obj1 = new Obj('xiaom', 25)

3.原型模式
我们知道，每个对象都有一个prototype的属性，这个属性就是一个指针，指向一个对象，而且这个对象所存在的方法或者属性，是所有实例共有的。

function Obj () {}
Obj.prototype.name = 'xiaom'
Obj.prototype.age = 24
Obj.prototype.consoleName =  function consoleName  () {
	console.log(this.name)
} 
let obj = new Obj()

一个新对象，最开始的prototype只有一个属性，就是constructor，指向的就是对象本身,同时在不太严谨的情况下，每个实例有一个 __proto__ 的方法,指向对象的原型。(现在ES6有一个Object.getPrototypeOf()方法了，其作用和__proto__一样)

Obj.prototype.constructor === Obj // true
Obj.prototype === obj.__proto__ // true
Obj.prototype === Object.getPrototypeOf(obj) // true

原型模式省略了参数初始化的这一个环节，结果就是，所有的实例在默认情况下，值都是一样的，简单的说，就是没办法传参了，于是就有了组合模式。

4.组合使用构造函数模式和原型模式
这种方面也是现在最常见的方法，发挥构造函数和原型的优点，二者相辅相成，各司其职。构造函数用来定义实例的属性，原型用来定义方法和共享属性，很大程度的节省了内存，而且，这种模式还支持传参。

function Obj (name,age) {
	this.name = name
	this.age = age
}
Obj.prototype = {
	constructor: Obj
	consoleName: function consoleName  () {
		console.log(this.name)
	} 
}

当然还有一些创建的方法我就不写了，大致也就是这些几种的组合，主要还是因为懒。

二、继承

1.原型链
原型链实现继承的主要思想，就利用原型让一个对象继承另外一个对象的属性和方法，像这样：

function A () {
	this.children= ['A', 'B', 'C']
}
function B () {
	this.sex = 'M'
}
// B继承A的属性
B.prototype = new A()

但这样的继承是有问题的

let bb1 = new B()
let bb2 = new B()
bb1.children.push('D')
bb2.children // ['A', 'B', 'C', 'D']

就像这样，改变了实例bb1中的children值，会影响其他实例，这是行不通的。

2.使用构造函数
这种方式很简单，只需要在子类中调用父类的构造函数就OK啦

function A (name) {
	this.children= ['A', 'B', 'C']
	this.name = name
}
function B () {
	A.call(this, 'xiaom') // call或者apply都可以，而且还能传参
	this.sex = 'M'
}

但是，单单用这个，也是有问题的，就是父元素的方法必须要在构造函数中，如果方法在原型上，则无法继承，这怎么能嘛，所以很少用的。

3.原型 + 构造函数组合继承
跟创建一下，一个人搞不定，就大家一起来，这样就是集合了以上的长处，且看实例

function A (name) {
	this.children= ['A', 'B', 'C']
	this.name = name
}
A.prototype.console = function () {
	console.log(this.name)
}
function B () {
// 用来继承构造函数中的属性
	A.call(this, 'xiaom')
	this.sex = 'M'
}
// 继承方法
B.prototype = new A()
B.prototype.constructor = B

这种方式最常用，也很好用，看着就逻辑清楚，跟创建对象时候的组合模式一样的思路。

4.寄生组合式继承
另外的两种，原型式继承和寄生式继承，都是由一个叫克罗克福德推而广之的，但是多多少少有些问题，具体的我就不记下来了，因为懒。但是这种模式必须要写，因为这种继承号称是最理想的继承思路。
首先我们创建两个函数

// 就是对传入其中的对象进行浅复制
function object (o) {
	function F () {}
	F.prototype = o
	return new F()	
}
// 封装的继承原型的函数
function inheritPrototype (ChildObj, ParentObj) {
	let pro = object(ParentObj.prototype)
	pro.constructor = ChildObj
	ChildObj.prototype = pro
}

然后的继承就和组合继承差不多了

function A (name) {
	this.children= ['A', 'B', 'C']
	this.name = name
}
A.prototype.console = function () {
	console.log(this.name)
}
function B () {
// 用来继承构造函数中的属性
	A.call(this, 'xiaom')
	this.sex = 'M'
}
inheritPrototype (B, A)

差不多就这些了，关于ES6的class和它实现继承的extend，可以参考阮一峰的ES6入门