계승 복습

1. 원형 체인 - 부모 클래스를 만드는 실례를 계승합니다.본질 상장 다시 쓰기 원형 대상

function SuperType(){
    this.property = true;
}
SuperType.prototype.getSuperValue = function(){
    return this.property;
}
function SubType(){
    this.subproperty = false;
}
// SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function(){
    return this.subproperty;
}

var instance = new SubType();
alert(instance.getSubValue());

글꼴을 추가하는 새로운 방법을 사용하면 한 줄을 계승하는 코드가 무효가 됩니다.constructor 지향이 바뀌었습니다.

 SubType.prototype = new SuperType();
 SubType.prototype = {
    getSubValue：function(){},
    getName:function(){}
 }

2. 차용 구조 함수 - 즉 하위 유형 구조 함수 내부에서 초유형 구조 함수를 호출한다

function SuperType(){
    this.colors = ["red","blue","green"];
}
function SubType(){
    // SuperType
    SuperType.call(this);
}
var instance = new SubType();
instance.colors.push("black");
alert(instance.colors);//"red,blue,green,black"
var instance2 = new SubType();
alert(instance2.colors);//"red,blue,green"

원형 체인에 비해 장점은 하위 유형 구조 함수에서 초유형 구조 함수에 매개 변수call() 사용 문제를 전달할 수 있다는 것이다. 방법은 모두 구조 함수에 정의되어 있다.
3. 조합 계승 - 원형 체인과 구조 함수 기술을 한데 조합

function SuperType(name){
    this.name = name;
    this.colors = ["red","blue","green"];
}
SuperType.prototype.sayName = function (){
    return this.name;
}
function SubType(name,age){
    // 
    SuperType.call(this,name);
    this.age = age;
}

// 
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
    return this.age;
}
var instance1 = new SubType("Nicholas",20);
instance1.colors.push("black");
alert(instance1.colors);//"red,blue,green,black"
instance1.sayName();//"Nicholas"
instance1.sayAge();//20

var instance2 = new SubType("Jemmy",30);
alert(instance2.colors);//"red,blue,green"
instance2.sayName();//"Jemmy"
instance2.sayAge();//30
// 。

4. 원형 계승 - 원형을 빌려 기존의 대상을 바탕으로 새로운 대상을 만들 수 있다

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

object 함수 내부에 임시 구조 함수를 만들고 전송된 대상을 이 구조 함수의 원형으로 하고 마지막으로 이 임시 형식의 새로운 실례를 되돌려줍니다.본질적으로 말하자면, object () 는 그 대상에 대해 얕은 복사를 실행했다

var person = {
    name:"Nicholas",
    fridens:["Shelby","Court","Van"]
};

var anotherPerson = object(person);
anotherPerson.name = "Greg";
anotherPerson.fridens.push("Rob");

var yetAnotherPerson = object(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.fridens.push("Barbie");
alert(person.fridens);//""Shelby,Court,Van,Rob,Barbie"

ECMAScript5는 희증 개체를 통과합니다.create () 방법은 원형식 계승과 위의object () 행위를 규범화합니다.

var person = {
    name:"Nicholas",
    fridens:["Shelby","Court","Van"]
};
var anotherPerson = Object.create(person);
anotherPerson.name = "Greg";
anotherPerson.fridens.push("Rob");

var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.fridens.push("Barbie");
alert(person.fridens);//""Shelby,Court,Van,Rob,Barbie"

5. 기생식 상속 - 상속 프로세스를 봉인하는 데 사용되는 함수를 생성합니다.이 함수 내부는 어떤 방식으로 대상을 강화하고, 마지막에는 정말로 모든 일을 한 것처럼 대상을 되돌려준다.

function createAnother(original){
    var clone = create(original);
    clone.sayHi = function(){
        alert("HI");
    };
    return clone;
}

var person = {
    name:"Nicholas",
    fridens:["Shelby","Court","Van"]
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi();//"HI"
//create() ， 。

6. 기생 조합식 계승 - 조합식 계승 문제는 어떤 상황에서도 두 번의 초유형 구조 함수를 호출하는 것이다.한 번은 하위 유형의 원형을 만들 때입니다.또 다른 하위 유형 내부 기생 조합식 계승은 구조 함수를 빌려 속성을 계승하고 원형 체인 혼합 형식을 통해 계승하는 방법이다. 본질: 하위 유형의 원형을 지정하기 위해 초유형의 구조 함수를 호출할 필요가 없다.

function inheritProrotype(SubType,SuperType){
    var prototype = create(SuperType.prototype);
    prototype.constructor = SubType;
    SubType.prototype = prototype;
}