1.建立对象

1.字面量对象
2.组织函数
3.Object.create

//1.字面量
var obj={
    name: '字面量',
    show: function(){
        console.log(this.name)
    }
}
//2.组织函数
function fun (name) {
    this.name=name
}
var obj=new fun('obj')
//3.Object.create
var obj={name: 'obj'}
var obj=Object.create(obj)

2.JavaScript继续

1.原型链继续

function Parent(name){
    this.name=name
    this.sleep=function(){
        console.log(this.name + '在睡觉')
    }
}
Parent.prototype.eat=function(food){
    console.log(this.name + '正在吃' + food)
}
function Child(){}
Child.prototype=new Parent('Child')
Child.prototype.constructor=Child
var child=new Child()

Child.prototype=new Parent('Child')就是把Parent实例赋值给Child.prototype，也就是说new Child().__proto__===new Parent('Child')。

能够经由过程Child.prototype在原型对象上增添新的属性或要领，也能够经由过程，child.__proto__在原型对象上增加新的要领和属性。

瑕玷：
1.原型对象上的属性和要领是一切实例都可接见的，而且一个实例改变了原型上的要领和属性都邑影响到其他实例。
2.建立子类实例时，没法向父类组织函数传参。

2.组织函数继续

function Parent(name){
    this.name=name
    this.sleep=function(){    
        console.log(this.name + '在睡觉')
    }
}
Parent.prototype.eat=function(food){
    console.log(this.name + '正在吃' + food)
}

function Child(){
    Parent.call(this,'child')
}
Child.prototype.eyes=function(){console.log('eyes')}
var child=new Child()

组织函数继续能够经由过程call或apply要领完成继续。这类要领不能继续原型对象中的属性和要领，只能继续实例属性和实例要领，然则能够向父类传参。

3.组合继续

function Parent(name){
    this.name=name
    this.sleep=function(){    
        console.log(this.name + '正在睡觉')
    }
}
Parent.prototype.eat=function(food){
    console.log(this.name + '正在吃' + food)
}
function Child(){
    Parent.call(this,'child')
}
Child.prototype.eyes=function(){console.log('eyes')}

Child.prototype=new Parent()
Child.prototype.constructor=Child 
var child=new Child()

组合继续是比较好的继续, 他是原型链继续和组织函数继续的连系, 合理的利用了这两种组合的特性，既是子类的实例，也是父类的实例, 但有一个瑕玷就是挪用了两次组织函数。

4.组合继续优化

function Parent(name){
    this.name=name
    this.sleep=function(){    
        console.log(this.name + '正在睡觉')
    }
}
Parent.prototype.eat=function(food){
    console.log(this.name + '正在吃' + food)
}
function Child(){
    Parent.call(this,'child')
}
Child.prototype = Object.create(Parent.prototype)
Child.prototype.constructor=Child 
var child=new Child()

5.寄生组合继续

function Parent(name){
    this.name=name
    this.sleep=function(){    
        console.log(this.name + '正在睡觉')
    }
}
Parent.prototype.eat=function(food){
    console.log(this.name + '正在吃' + food)
}
function Child(){
    Parent.call(this,'child')
}
function f(){}
f.prototype=Parent.prototype
Child.prototype=new f()
Child.prototype.constructor=Child 
var child=new Child()

只挪用一次父类的组织函数，避免了在子类原型上建立不必要的，过剩的属性。