// 父对象：动物，有一个共享属性 eats
const animal = { eats: true };

// 子对象：兔子，有自己的属性 jumps
const rabbit = { jumps: true };

// 把 rabbit 的原型设为 animal（让兔子继承动物的属性）
Object.setPrototypeOf(rabbit, animal);

// 现在兔子能访问动物的 eats 属性了
console.log(rabbit.eats); // true（从原型链上找到的）

// 1. 定义构造函数（用来创建“人”实例）
function Person(name) {
  // 实例独有的属性：每个实例的 name 都不同
  this.name = name;
}

// 2. 在构造函数的 prototype 上定义共享方法（所有实例共用）
Person.prototype.sayHello = function () {
  console.log(`你好，我是${this.name}`);
};

// 3. 用 new 创建实例
const alice = new Person('Alice');

// 验证原型关系
console.log(Object.getPrototypeOf(alice) === Person.prototype); // true（实例的原型是构造函数的 prototype）
console.log(Person.prototype.constructor === Person); // true（原型的构造函数指向原函数）

function myNew(constructor, ...args) {
  // 1. 创建空对象，并把它的原型设为构造函数的 prototype
  const obj = Object.create(constructor.prototype);

  // 2. 执行构造函数，this 指向新对象
  const result = constructor.apply(obj, args);

  // 3. 返回结果：如果构造函数返回了对象，就用它；否则用新对象
  return result instanceof Object ? result : obj;
}

// 用自定义的 myNew 创建实例，和原生 new 效果一样
const bob = myNew(Person, 'Bob');
bob.sayHello(); // 你好，我是Bob

// 1. 定义构造函数 Animal
function Animal(name) {
  this.name = name; // 实例独有的属性
}

// 2. 在 Animal.prototype 上定义共享方法
Animal.prototype.eat = function () {
  console.log(`${this.name} 在吃东西`);
};

// 3. 创建实例 cat
const cat = new Animal('喵星人');

// 4. 调用 cat.eat()，查找流程：
// ① 检查 cat 自身：没有 eat 方法 → ② 查 cat 的原型（Animal.prototype）→ 找到 eat 方法，执行
cat.eat(); // 喵星人 在吃东西

const cat = new Animal('喵星人');

// 顺着原型链往上找：
console.log(Object.getPrototypeOf(cat)); // Animal.prototype（第一层）
console.log(Object.getPrototypeOf(Animal.prototype)); // Object.prototype（第二层）
console.log(Object.getPrototypeOf(Object.prototype)); // null（第三层，终点）
console.log(Object.getPrototypeOf(null)); // 报错（null 没有原型）

function Dog() {}
// 创建实例 dog1（此时 Dog.prototype 上还没有 bark 方法）
const dog1 = new Dog();

// 后续给 Dog.prototype 添加 bark 方法
Dog.prototype.bark = function () {
  console.log('汪汪！');
};

// dog1 能调用到新添加的 bark 方法
dog1.bark(); // 汪汪！

function Cat() {}
// 旧实例：创建于原型重写前
const cat1 = new Cat();

// 完全重写 Cat.prototype（新对象）
Cat.prototype = {
  meow() {
    console.log('喵喵~');
  },
};

// 新实例：创建于原型重写后
const cat2 = new Cat();

cat1.meow(); // 报错（cat1 的原型还是原来的空对象，没有 meow 方法）
cat2.meow(); // 喵喵~（cat2 的原型是新对象，有 meow 方法）

// 写法1：ES6 Class
class Animal {
  // 构造函数：对应原来的构造函数
  constructor(name) {
    this.name = name;
  }

  // 实例方法：会被添加到 Animal.prototype 上
  eat() {
    console.log(`${this.name} 在吃东西`);
  }
}

// 写法2：ES5 原型继承（和上面完全等价）
function Animal(name) {
  this.name = name;
}

Animal.prototype.eat = function () {
  console.log(`${this.name} 在吃东西`);
};

// 子类 Rabbit 继承父类 Animal
class Rabbit extends Animal {
  constructor(name, speed) {
    // super()：调用父类的 constructor，相当于 Animal.call(this, name)
    super(name);
    // 子类独有的属性
    this.speed = speed;
  }

  // 子类独有的方法（添加到 Rabbit.prototype 上）
  jump() {
    console.log(`${this.name} 跳得很快，速度${this.speed}`);
  }
}

// 创建子类实例
const bunny = new Rabbit('小兔', 10);

// 验证继承关系
console.log(bunny instanceof Rabbit); // true（是 Rabbit 的实例）
console.log(bunny instanceof Animal); // true（也是 Animal 的实例，因为继承）
console.log(bunny instanceof Object); // true（最终继承自 Object）

// 调用继承的方法和自己的方法
bunny.eat(); // 小兔 在吃东西（继承自 Animal）
bunny.jump(); // 小兔 跳得很快，速度10（自己的方法）

function User(name) {
  this.name = name; // 每个实例独有的属性
}

// 所有 User 实例共享 sayHi 方法
User.prototype.sayHi = function () {
  console.log(`你好，${this.name}`);
};

const user1 = new User('Alice');
const user2 = new User('Bob');

// 验证：两个实例的 sayHi 是同一个函数
console.log(user1.sayHi === user2.sayHi); // true

// 父类：图形
function Shape(color) {
  this.color = color;
}

// 父类的共享方法
Shape.prototype.getColor = function () {
  return this.color;
};

// 子类：圆形
function Circle(radius, color) {
  // 1. 调用父类构造函数，继承父类的属性（color）
  Shape.call(this, color);
  // 2. 子类独有的属性
  this.radius = radius;
}

// 3. 搭建原型链：让 Circle.prototype 继承 Shape.prototype
Circle.prototype = Object.create(Shape.prototype);
// 4. 修复 constructor 指向（因为上面一步把 Circle.prototype 换成了新对象，constructor 会指向 Shape）
Circle.prototype.constructor = Circle;

// 5. 子类的共享方法
Circle.prototype.getArea = function () {
  return Math.PI * this.radius ** 2;
};

// 使用子类
const redCircle = new Circle(5, 'red');
console.log(redCircle.getColor()); // red（继承自 Shape）
console.log(redCircle.getArea()); // 78.539...（自己的方法）

// 给 Array.prototype 加 sum 方法，所有数组都能调用
Array.prototype.sum = function () {
  return this.reduce((total, num) => total + num, 0);
};

const numbers = [1, 2, 3, 4];
console.log(numbers.sum()); // 10

// 不小心给 Object.prototype 加了一个 hack 方法
Object.prototype.hack = function () {
  console.log('所有对象都会有这个方法！');
};

// 即使是新建的空对象，也会有 hack 方法
const emptyObj = {};
emptyObj.hack(); // 所有对象都会有这个方法！

const pureObj = Object.create(null);
console.log(pureObj.hack); // undefined（不受原型污染影响）

function Person() {}
// 原型上的 name 属性
Person.prototype.name = '原型默认名';

// 实例上的 name 属性（和原型同名）
const person = new Person();
person.name = '实例自定义名';

// 访问时会优先用实例的属性
console.log(person.name); // 实例自定义名
// 要访问原型的属性，需要手动找原型
console.log(Object.getPrototypeOf(person).name); // 原型默认名

function A() {}
function B() {}

// A 的原型指向 B 的实例
A.prototype = new B();
// B 的原型指向 A 的实例 → 循环引用！
B.prototype = new A();

// 尝试创建实例：会触发无限递归，栈溢出
try {
  const a = new A();
} catch (e) {
  console.error(e.message); // Maximum call stack size exceeded
}

function Foo() {}
const f1 = new Foo();

console.log(f1 instanceof Object);
console.log(Foo.prototype instanceof Object);
console.log(Object.getPrototypeOf(f1) === Foo.prototype);