Prototype

// 생성자 함수를 통한 프로토타입 상속
function Animal(name) {
    this.name = name;
}

// prototype에 메서드 추가 (모든 인스턴스가 공유)
Animal.prototype.speak = function() {
    console.log(`${this.name}가 소리를 냅니다.`);
};

Animal.prototype.sleep = function() {
    console.log(`${this.name}가 잠을 잡니다.`);
};

// 자식 생성자 함수
function Dog(name, breed) {
    // 부모 생성자 호출 (super 역할)
    Animal.call(this, name);
    this.breed = breed;
}

// 프로토타입 체인 설정 (상속)
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

// Dog만의 메서드 추가
Dog.prototype.bark = function() {
    console.log(`${this.name}가 멍멍 짖습니다!`);
};

// 메서드 오버라이딩
Dog.prototype.speak = function() {
    console.log(`${this.name}(${this.breed})가 왈왈!`);
};

// 인스턴스 생성 및 테스트
const myDog = new Dog('바둑이', '진돗개');

myDog.speak();  // 바둑이(진돗개)가 왈왈!
myDog.sleep();  // 바둑이가 잠을 잡니다. (상속받은 메서드)
myDog.bark();   // 바둑이가 멍멍 짖습니다!

// 프로토타입 체인 확인
console.log(myDog instanceof Dog);    // true
console.log(myDog instanceof Animal); // true
console.log(Dog.prototype.isPrototypeOf(myDog)); // true

// Object.create()를 사용한 프로토타입 상속
// 더 명시적이고 유연한 상속 방식

const personProto = {
    greet() {
        console.log(`안녕하세요, ${this.name}입니다.`);
    },
    introduce() {
        console.log(`저는 ${this.age}살이고, ${this.job}입니다.`);
    }
};

// Object.create로 프로토타입 설정
const developer = Object.create(personProto, {
    // 프로퍼티 디스크립터로 세밀한 제어 가능
    name: {
        value: '김개발',
        writable: true,
        enumerable: true
    },
    age: {
        value: 28,
        writable: true,
        enumerable: true
    },
    job: {
        value: '프론트엔드 개발자',
        writable: true,
        enumerable: true
    }
});

// 개발자만의 메서드 추가
developer.code = function(language) {
    console.log(`${this.name}가 ${language}로 코딩합니다.`);
};

developer.greet();     // 안녕하세요, 김개발입니다.
developer.introduce(); // 저는 28살이고, 프론트엔드 개발자입니다.
developer.code('JavaScript'); // 김개발가 JavaScript로 코딩합니다.

// 프로토타입 확인
console.log(Object.getPrototypeOf(developer) === personProto); // true

// null 프로토타입으로 순수 딕셔너리 객체 생성
const pureDict = Object.create(null);
pureDict.key = 'value';
console.log(pureDict.hasOwnProperty); // undefined (상속 없음)

// __proto__ vs prototype 이해하기

function Person(name) {
    this.name = name;
}

Person.prototype.sayHello = function() {
    console.log(`Hello, I'm ${this.name}`);
};

const john = new Person('John');

// prototype: 함수 객체의 프로퍼티
// 이 함수로 생성될 인스턴스의 [[Prototype]]이 될 객체
console.log(Person.prototype);
// { sayHello: [Function], constructor: Person }

// __proto__: 모든 객체의 [[Prototype]] 접근자
// 해당 객체가 실제로 상속받는 프로토타입 객체
console.log(john.__proto__);
// { sayHello: [Function], constructor: Person }

// 핵심: 둘은 같은 객체를 참조!
console.log(john.__proto__ === Person.prototype); // true

// 권장: __proto__ 대신 Object.getPrototypeOf() 사용
console.log(Object.getPrototypeOf(john) === Person.prototype); // true

// 프로토타입 체인 시각화
console.log(john.__proto__);                      // Person.prototype
console.log(john.__proto__.__proto__);             // Object.prototype
console.log(john.__proto__.__proto__.__proto__);    // null (체인의 끝)

// 프로퍼티 검색 과정
// 1. john.name -> john 객체에서 발견 -> "John"
// 2. john.sayHello -> john에 없음 -> Person.prototype에서 발견
// 3. john.toString -> Person.prototype에 없음 -> Object.prototype에서 발견