프로토타입과 상속

const user = {
    name: "김민준",
    age: 28
};

// user 객체의 프로토타입을 확인합니다.
// 브라우저 환경에서는 일반적으로 Object.prototype이 출력됩니다.
console.log(user.__proto__);
// 또는 더 표준적인 방법: Object.getPrototypeOf(user)
console.log(Object.getPrototypeOf(user));

// user는 Object.prototype의 toString 메서드를 상속받아 사용합니다.
console.log(user.toString()); // 결과: [object Object]
// user 객체 자체에는 toString 메서드가 없지만, 프로토타입 체인을 통해 Object.prototype.toString을 찾아서 사용합니다.

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

// Person 함수의 prototype 객체에 sayHello 메서드를 추가합니다.
Person.prototype.sayHello = function() {
    console.log(`안녕하세요, 제 이름은 ${this.name}입니다.`);
};

const person1 = new Person("이수민", 25);
const person2 = new Person("박지훈", 30);

// person1과 person2는 Person의 인스턴스이며,
// 이들의 [[Prototype]]은 Person.prototype을 가리킵니다.
console.log(person1.__proto__ === Person.prototype); // 결과: true
console.log(person2.__proto__ === Person.prototype); // 결과: true

// 인스턴스들은 자신에게 sayHello 메서드가 없지만, 프로토타입 체인을 통해 접근합니다.
person1.sayHello(); // 결과: 안녕하세요, 제 이름은 이수민입니다.
person2.sayHello(); // 결과: 안녕하세요, 제 이름은 박지훈입니다.

// 각 인스턴스는 sayHello 메서드를 복사한 것이 아니라,
// 프로토타입 객체의 동일한 메서드를 참조합니다.
console.log(person1.sayHello === person2.sayHello); // 결과: true

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

console.log(Animal.prototype.constructor === Animal); // 결과: true

const dog = new Animal("바둑이");
console.log(dog.constructor === Animal); // 결과: true

const parent = {
    parentProp: "Parent Value",
    parentMethod: function() {
        console.log("Parent Method Called!");
    }
};

const child = {
    childProp: "Child Value"
};

// child의 프로토타입을 parent로 설정합니다.
// Object.setPrototypeOf()는 객체의 [[Prototype]]을 설정하는 표준적인 방법입니다.
Object.setPrototypeOf(child, parent);

console.log(child.childProp);   // 결과: Child Value (child 객체 자신의 속성)
console.log(child.parentProp);  // 결과: Parent Value (프로토타입 체인을 통해 parent에서 찾음)
child.parentMethod();           // 결과: Parent Method Called! (프로토타입 체인을 통해 parent에서 찾음)

console.log(child.nonExistent); // 결과: undefined (체인 끝까지 찾았으나 없음)

// 부모 생성자 함수
function Animal(name) {
    this.name = name;
    this.species = "동물";
}

Animal.prototype.sound = function() {
    console.log("동물 소리!");
};

// 자식 생성자 함수
function Dog(name, breed) {
    // Animal 생성자를 호출하여 name과 species를 상속받습니다.
    // call() 메서드를 사용하여 this를 Dog의 인스턴스로 바인딩합니다.
    Animal.call(this, name); // 상위 생성자의 속성 상속
    this.breed = breed;
}

// Dog.prototype을 Animal.prototype의 새로운 객체로 설정하여 프로토타입 체인을 연결합니다.
// Object.create()는 지정된 프로토타입을 가진 새로운 객체를 만듭니다.
Dog.prototype = Object.create(Animal.prototype);
// constructor 참조를 Dog로 되돌립니다. 프로토타입 상속 자체에 필수인 단계는 아닙니다.
Dog.prototype.constructor = Dog;

// Dog.prototype에 Dog만의 메서드를 추가합니다.
Dog.prototype.bark = function() {
    console.log("멍멍!");
};

const myDog = new Dog("댕댕이", "시바견");

console.log(myDog.name);     // 결과: 댕댕이 (Animal에서 상속받은 속성)
console.log(myDog.species);  // 결과: 동물 (Animal에서 상속받은 속성)
console.log(myDog.breed);    // 결과: 시바견 (Dog 자신의 속성)

myDog.sound(); // 결과: 동물 소리! (Animal.prototype에서 상속받은 메서드)
myDog.bark();  // 결과: 멍멍! (Dog.prototype 자신의 메서드)

console.log(myDog.__proto__ === Dog.prototype);             // true
console.log(Dog.prototype.__proto__ === Animal.prototype);  // true
console.log(Animal.prototype.__proto__ === Object.prototype); // true
console.log(Object.prototype.__proto__ === null);          // true (체인의 끝)

// 부모 클래스
class Animal {
    constructor(name) {
        this.name = name;
        this.species = "동물";
    }

    sound() { // 이 메서드는 Animal.prototype에 추가됩니다.
        console.log("동물 소리!");
    }
}

// 자식 클래스 (extends 키워드를 사용하여 상속)
class Dog extends Animal {
    constructor(name, breed) {
        super(name); // 부모 클래스의 constructor를 호출합니다. (필수)
        this.breed = breed;
    }

    bark() { // 이 메서드는 Dog.prototype에 추가됩니다.
        console.log("멍멍!");
    }

    // 부모 메서드 오버라이딩 (재정의)
    sound() {
        console.log(`${this.name}는 멍멍 짖습니다!`);
    }
}

const myCat = new Animal("나비");
myCat.sound(); // 결과: 동물 소리!

const myNewDog = new Dog("초코", "푸들");
console.log(myNewDog.name);     // 결과: 초코
console.log(myNewDog.species);  // 결과: 동물
console.log(myNewDog.breed);    // 결과: 푸들

myNewDog.sound(); // 결과: 초코는 멍멍 짖습니다! (오버라이딩된 메서드)
myNewDog.bark();  // 결과: 멍멍!

// 내부적으로 여전히 프로토타입 체인으로 연결되어 있습니다.
console.log(myNewDog.__proto__ === Dog.prototype);        // true
console.log(Dog.prototype.__proto__ === Animal.prototype); // true
console.log(Animal.prototype.__proto__ === Object.prototype); // true

const parentForLookup = { score: 10 };
const childForLookup = Object.create(parentForLookup);
console.log(childForLookup.score, Object.hasOwn(childForLookup, "score"));
childForLookup.score = 20;
console.log(childForLookup.score, parentForLookup.score);
delete childForLookup.score;
console.log(childForLookup.score);