귀하의 질문에서 보여준 코드 샘플은 모두 프로토 타입 상속을 사용합니다. 사실 JavaScript로 작성하는 모든 객체 지향 코드는 프로토 타입 상속의 패러다임입니다. 자바 스크립트에는 단순히 고전적인 상속이 없습니다. 이것은 상황을 약간 정리할 것입니다.

                                   Inheritance
                                        |
                         +-----------------------------+
                         |                             |
                         v                             v
                    Prototypal                     Classical
                         |
         +------------------------------+
         |                              |
         v                              v
Prototypal Pattern             Constructor Pattern

보시다시피 프로토 타입 상속과 고전적 상속은 상속의 두 가지 다른 패러다임입니다. Self, Lua 및 JavaScript와 같은 일부 언어는 프로토 타입 상속을 지원합니다. 그러나 C ++, Java 및 C #과 같은 대부분의 언어는 고전적 상속을 지원합니다.

객체 지향 프로그래밍의 빠른 개요

프로토 타입 상속과 고전적 상속은 모두 객체 지향 프로그래밍 패러다임입니다 (즉, 객체를 다룹니다). 객체는 단순히 실제 개체의 속성을 캡슐화하는 추상화입니다 (예 : 프로그램에서 실제 단어를 나타냄). 이것을 추상화라고합니다.

추출: 컴퓨터 프로그램에서 실제 사물의 표현.

이론적으로 추상화는 “특정 예에서 공통 특징을 추출하여 형성된 일반적인 개념”으로 정의됩니다. 그러나이 설명을 위해 앞서 언급 한 정의를 대신 사용할 것입니다.

이제 일부 개체에는 많은 공통점이 있습니다. 예를 들어 진흙 자전거와 할리 데이비슨은 공통점이 많습니다.

진흙 자전거 :

할리 데이비슨 :

진흙 자전거와 Harley Davidson은 모두 자전거입니다. 따라서 자전거는 진흙 자전거와 할리 데이비슨의 일반화입니다.

                   Bike
                     |
    +---------------------------------+
    |                                 |
    v                                 v
Mud Bike                       Harley Davidson

위의 예에서 자전거, 진흙 자전거 및 Harley Davidson은 모두 추상화입니다. 그러나 자전거는 진흙 자전거와 Harley Davidson의보다 일반적인 추상화입니다 (즉, 진흙 자전거와 Harley Davidson은 모두 특정 유형의 자전거입니다).

일반화 : 보다 구체적인 추상화의 추상화입니다.

객체 지향 프로그래밍에서 우리는 객체 (실제 엔티티의 추상화)를 만들고 클래스 나 프로토 타입을 사용하여 이러한 객체의 일반화를 만듭니다. 일반화는 상속을 통해 생성됩니다. 자전거는 진흙 자전거의 일반화입니다. 따라서 진흙 자전거는 자전거에서 물려받습니다.

고전적인 객체 지향 프로그래밍

고전적인 객체 지향 프로그래밍에는 클래스와 객체라는 두 가지 유형의 추상화가 있습니다. 앞에서 언급했듯이 객체는 실제 개체의 추상화입니다. 반면에 클래스는 객체 또는 다른 클래스의 추상화입니다 (예 : 일반화). 예를 들어 다음을 고려하십시오.

+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity |                Comments               |
+----------------------+----------------+---------------------------------------+
| 0                    | John Doe       | Real World Entity.                    |
| 1                    | johnDoe        | Variable holding object.              |
| 2                    | Man            | Class of object johnDoe.              |
| 3                    | Human          | Superclass of class Man.              |
+----------------------+----------------+---------------------------------------+

고전적인 객체 지향 프로그래밍 언어에서 볼 수 있듯이 객체는 추상화 일뿐 (즉 모든 객체의 추상화 수준이 1)이고 클래스는 일반 화일뿐입니다 (즉, 모든 클래스의 추상화 수준이 1보다 큼).

클래식 객체 지향 프로그래밍 언어의 객체는 클래스를 인스턴스화해야만 만들 수 있습니다.

class Human {
    // ...
}

class Man extends Human {
    // ...
}

Man johnDoe = new Man();

고전적인 객체 지향 프로그래밍 언어의 요약에서 객체는 실제 엔티티의 추상화이고 클래스는 일반화 (즉, 객체 또는 다른 클래스의 추상화)입니다.

따라서 추상화 수준이 증가함에 따라 개체가 더 일반적이되고 추상화 수준이 감소함에 따라 개체가 더 구체적이됩니다. 이러한 의미에서 추상화 수준은보다 구체적인 개체에서보다 일반적인 개체에 이르는 범위와 유사합니다.

프로토 타입 객체 지향 프로그래밍

프로토 타입 객체 지향 프로그래밍 언어는 전통적인 객체 지향 프로그래밍 언어보다 훨씬 간단합니다. 프로토 타입 객체 지향 프로그래밍에서는 한 가지 유형의 추상화 (즉, 객체) 만 있기 때문입니다. 예를 들어 다음을 고려하십시오.

+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity |                Comments               |
+----------------------+----------------+---------------------------------------+
| 0                    | John Doe       | Real World Entity.                    |
| 1                    | johnDoe        | Variable holding object.              |
| 2                    | man            | Prototype of object johnDoe.          |
| 3                    | human          | Prototype of object man.              |
+----------------------+----------------+---------------------------------------+

프로토 타입 객체 지향 프로그래밍 언어에서 볼 수 있듯이 객체는 실제 엔티티 (이 경우 단순히 객체라고 함) 또는 다른 객체 (이 경우 추상화하는 객체의 프로토 타입이라고 함)의 추상화입니다. 따라서 프로토 타입은 일반화입니다.

프로토 타입 객체 지향 프로그래밍 언어의 객체는 전일로 (즉, 무에서) 또는 다른 객체 (새로 생성 된 객체의 프로토 타입이 됨)에서 생성 될 수 있습니다.

var human = {};
var man = Object.create(human);
var johnDoe = Object.create(man);

저의 겸손한 의견으로는 프로토 타입 객체 지향 프로그래밍 언어는 다음과 같은 이유로 고전적인 객체 지향 프로그래밍 언어보다 더 강력합니다.

1. 추상화 유형은 한 가지뿐입니다.
2. 일반화는 단순히 객체입니다.

지금 쯤이면 고전적 상속과 프로토 타입 상속의 차이를 깨달았을 것입니다. 클래식 상속은 다른 클래스에서 상속 된 클래스로 제한됩니다. 그러나 프로토 타입 상속에는 다른 프로토 타입에서 상속 된 프로토 타입뿐만 아니라 프로토 타입에서 상속 된 객체도 포함됩니다.

프로토 타입 클래스 동형

프로토 타입과 클래스가 매우 유사하다는 것을 알고 계실 것입니다. 사실입니다. 그들은. 사실 그들은 매우 유사해서 실제로 프로토 타입을 사용하여 클래스를 모델링 할 수 있습니다.

function CLASS(base, body) {
    if (arguments.length < 2) body = base, base = Object.prototype;
    var prototype = Object.create(base, {new: {value: create}});
    return body.call(prototype, base), prototype;

    function create() {
        var self = Object.create(prototype);
        return prototype.hasOwnProperty("constructor") &&
            prototype.constructor.apply(self, arguments), self;
    }
}

위의 CLASS함수를 사용하여 클래스처럼 보이는 프로토 타입을 만들 수 있습니다.

var Human = CLASS(function () {
    var milliseconds = 1
      , seconds      = 1000 * milliseconds
      , minutes      = 60 * seconds
      , hours        = 60 * minutes
      , days         = 24 * hours
      , years        = 365.2425 * days;

    this.constructor = function (name, sex, dob) {
        this.name = name;
        this.sex = sex;
        this.dob = dob;
    };

    this.age = function () {
        return Math.floor((new Date - this.dob) / years);
    };
});

var Man = CLASS(Human, function (Human) {
    this.constructor = function (name, dob) {
        Human.constructor.call(this, name, "male", dob);
        if (this.age() < 18) throw new Error(name + " is a boy, not a man!");
    };
});

var johnDoe = Man.new("John Doe", new Date(1970, 0, 1));

그러나 그 반대는 사실이 아닙니다 (즉, 프로토 타입을 모델링하기 위해 클래스를 사용할 수 없습니다). 프로토 타입은 객체이지만 클래스는 객체가 아니기 때문입니다. 그것들은 완전히 다른 유형의 추상화입니다.

결론

요약하면 추상화는 “특정 예제에서 공통 기능을 추출하여 형성된 일반적인 개념” 이고 일반화는 “더 구체적인 추상화의 추상화”라는 것을 배웠습니다 . 우리는 또한 프로토 타입과 고전적 상속의 차이점과 둘 다 같은 동전의 두 얼굴 인 방법에 대해서도 배웠습니다.

이별 노트에서 프로토 타입 상속에는 프로토 타입 패턴과 생성자 패턴의 두 가지 패턴이 있음을 언급하고 싶습니다. 프로토 타입 패턴은 프로토 타입 상속의 표준 패턴 인 반면 생성자 패턴은 프로토 타입 상속이 클래식 상속처럼 보이도록 만드는 데 사용됩니다. 개인적으로 저는 프로토 타입 패턴을 선호합니다.

추신 : 나는 블로그 게시물 ” 왜 프로토 타입 상속이 중요한가 “를 작성하고 ” 클래식보다 프로토 타입 상속의 이점? ” 이라는 질문에 답한 사람 입니다. 내 대답은 받아 들여진 대답입니다.

답변

class Person {
  fn() {...}
} // or constructor function say, function Person() {}

// create instance
let person = new Person();

// base object
let Person = { fn(){...} }

// instance
let person = Object.create(Person);

let animal = {hasChlorophyl: false};

let dog = Object.create(animal);
Object.assign(dog, {
  speak() {
    console.log("Woof!");
  }
});

let suzanna = Object.create(dog);
Object.assign(suzanna, {
  name: "Suzanna"
});

suzanna.speak();