// 使用字面量進(jìn)行創(chuàng)建
// 通過字面量創(chuàng)建的對(duì)象，都會(huì)有原型開銷，并且他們的原型都是指向Object.prototype
var Sheep = {
  name: "小羊",
  school: "青青草原",
  age: 18
}

// 驗(yàn)證原型鏈
const sheepPrototype = Object.getPrototypeOf(Sheep)
console.log(sheepPrototype === Object.prototype) // 輸出: true

// 深入理解字面量對(duì)象的原型
const myObj = { a: 1 }
console.log(myObj.__proto__ === Object.prototype) // true
console.log(myObj.hasOwnProperty('a')) // true - 來自O(shè)bject.prototype
console.log(myObj.toString()) // "[object Object]" - 來自O(shè)bject.prototype

// 使用工廠模式創(chuàng)建對(duì)象 - 避免了new關(guān)鍵字，并且具有封裝性
function Sheep(name, age) {
  if (name === '喜羊羊') {
    return { 
      name, 
      age, 
      feature: ['聰明'],
      eat: function() {
        console.log(`${this.name}在吃青草`)
      }
    }
  } else {
    return { 
      name, 
      age, 
      feature: ['貪吃鬼'],
      eat: function() {
        console.log(`${this.name}在吃零食`)
      }
    }
  }
}

const sheep1 = Sheep('喜羊羊', 3)
const sheep2 = Sheep('懶羊羊', 4)

// 類型檢測(cè)問題
console.log(sheep1 instanceof Object); // true (所有對(duì)象都是Object的實(shí)例)
console.log(sheep1 instanceof Sheep);  // false! 無法識(shí)別具體類型

function createSheep(name) {
  return {
    name: name,
    eat: function() { // 每次調(diào)用都創(chuàng)建新函數(shù)
      console.log('吃草')
    }
  }
}

const s1 = createSheep('羊1')
const s2 = createSheep('羊2')
console.log(s1.eat === s2.eat) // false - 方法沒有復(fù)用！

// 使用構(gòu)造函數(shù)創(chuàng)建對(duì)象 - 使用new的好處是模板化、高效率、類型識(shí)別和封裝
// 在構(gòu)造函數(shù)中創(chuàng)建的方法在每次創(chuàng)建對(duì)象的時(shí)候，都會(huì)重新創(chuàng)建一次方法
function Sheep(name, age) {
  this.name = name;
  this.age = age;
  this.eat = function() {
    console.log(`${age}歲的${name}在吃草`)
  }
}

const sheep1 = new Sheep('喜羊羊', 3)
const sheep2 = new Sheep('沸羊羊', 4)

// 類型識(shí)別成功
console.log(sheep1 instanceof Sheep) // true
console.log(sheep1.constructor === Sheep) // true

// 但方法依然沒有復(fù)用
console.log(sheep1.eat === sheep2.eat) // false - 每個(gè)實(shí)例都有獨(dú)立的eat方法

// new操作符的模擬實(shí)現(xiàn)
function myNew(Constructor, ...args) {
  // 1. 創(chuàng)建一個(gè)新對(duì)象
  const obj = {}
  
  // 2. 將新對(duì)象的原型指向構(gòu)造函數(shù)的prototype
  obj.__proto__ = Constructor.prototype
  
  // 3. 將構(gòu)造函數(shù)的this綁定到新對(duì)象上并執(zhí)行
  const result = Constructor.apply(obj, args)
  
  // 4. 如果構(gòu)造函數(shù)返回對(duì)象，則返回該對(duì)象；否則返回新創(chuàng)建的對(duì)象
  return result instanceof Object ? result : obj
}

// 使用示例
const mySheep = myNew(Sheep, '美羊羊', 3)
console.log(mySheep instanceof Sheep) // true

// 解決辦法：將方法綁定到構(gòu)造函數(shù)的原型上
function Sheep(name, age) {
  this.name = name;
  this.age = age;
}

Sheep.prototype.eat = function() {
  console.log(`${this.age}歲的${this.name}在吃草`)
}

const sheep1 = new Sheep('喜羊羊', 3)
const sheep2 = new Sheep('沸羊羊', 4)
console.log(sheep1.eat === sheep2.eat) // true - 方法復(fù)用成功！

// 原型模式 - 所有屬性和方法都定義在原型上
function Sheep() {}

// 所有屬性和方法都定義在原型上
Sheep.prototype.name = '陽光中學(xué)';
Sheep.prototype.age = 3;
Sheep.prototype.feature = ['聰明'] // 引用類型屬性
Sheep.prototype.eat = function() {
  console.log('我正在吃青春蛋糕~');
};

const sheep1 = new Sheep()
const sheep2 = new Sheep()

// 方法共享成功
console.log(sheep1.eat === sheep2.eat) // true

// 但引用類型屬性共享帶來了問題
sheep1.feature.push('玩游戲')
console.log(sheep2.feature) // ['聰明', '玩游戲'] - 意外修改了所有實(shí)例！

// 深入理解原型鏈查找
const s = new Sheep()

// 屬性查找順序演示
console.log(s.hasOwnProperty('name')) // false - name不是實(shí)例自有屬性
console.log('name' in s) // true - 但能通過原型鏈找到

// 原型鏈：s -> Sheep.prototype -> Object.prototype -> null
console.log(s.__proto__ === Sheep.prototype) // true
console.log(Sheep.prototype.__proto__ === Object.prototype) // true
console.log(Object.prototype.__proto__ === null) // true

// 組合模式(構(gòu)造函數(shù)+原型) - ES6 class出現(xiàn)之前的最佳實(shí)踐
// 獨(dú)立屬性+通用方法
function Sheep(name, age) {
  // 實(shí)例屬性 - 每個(gè)實(shí)例獨(dú)有
  this.name = name;
  this.age = age;
  this.friends = []; // 引用類型也是獨(dú)有的
}

// 共享方法 - 定義在原型上
Sheep.prototype.eat = function() {
  console.log(`${this.age}歲的${this.name}在吃草`)
}

Sheep.prototype.addFriend = function(friendName) {
  this.friends.push(friendName)
}

const sheep1 = new Sheep('喜羊羊', 3)
const sheep2 = new Sheep('沸羊羊', 4)

// 驗(yàn)證方法共享
console.log(sheep1.eat === sheep2.eat) // true

// 驗(yàn)證屬性獨(dú)立
sheep1.addFriend('美羊羊')
console.log(sheep1.friends) // ['美羊羊']
console.log(sheep2.friends) // [] - 不受影響

// 組合模式的靈活性展示
function Animal(type) {
  this.type = type;
  this.energy = 100;
}

// 可以動(dòng)態(tài)添加原型方法
Animal.prototype.sleep = function() {
  this.energy += 20;
  console.log(`${this.type}睡覺后，能量恢復(fù)到${this.energy}`)
}

// 可以覆蓋原型方法
Animal.prototype.toString = function() {
  return `[Animal: ${this.type}]`
}

const cat = new Animal('貓')
console.log(cat.toString()) // [Animal: 貓]

// Object.create() - 可以顯式指定原型對(duì)象

// 示例1：顯式指定原型
const Sheep = {
  name: '喜羊羊',
  eat: function() {
    console.log('我愛吃飯')
  }
}

const sheep = Object.create(Sheep)
sheep.name = '懶羊羊' // 覆蓋原型上的name
console.log(sheep.name) // 懶羊羊
console.log(Object.getPrototypeOf(sheep) === Sheep); // true

// 示例2：創(chuàng)建無原型對(duì)象 - Object.prototype也不繼承
const sheep1 = Object.create(null);
const sheep2 = {};

// 檢查原型
console.log(Object.getPrototypeOf(sheep1)); // null
console.log(Object.getPrototypeOf(sheep2)); // [Object: null prototype] {} (即Object.prototype)

// 嘗試調(diào)用基礎(chǔ)方法
console.log(typeof sheep1.toString); // "undefined"
console.log(typeof sheep2.toString); // "function"

// 示例3：實(shí)現(xiàn)對(duì)象的淺克隆，保持原型鏈不變
function shallowClone(original) {
  const clone = Object.create(Object.getPrototypeOf(original));
  Object.assign(clone, original);
  return clone;
}

// 克隆無原型對(duì)象
const sheep1 = Object.create(null);
sheep1.name = '喜羊羊';

const clonedSheep1 = shallowClone(sheep1);
console.log(clonedSheep1.name); // 喜羊羊
console.log(clonedSheep1 === sheep1); // false
console.log(Object.getPrototypeOf(clonedSheep1)); // null
console.log(typeof clonedSheep1.toString); // undefined

// 克隆標(biāo)準(zhǔn)對(duì)象
const sheep2 = {};
sheep2.name = '懶羊羊';

const clonedSheep2 = shallowClone(sheep2);
console.log(clonedSheep2.name); // 懶羊羊
console.log(clonedSheep2 === sheep2); // false - 是一個(gè)全新的、獨(dú)立的對(duì)象
console.log(Object.getPrototypeOf(clonedSheep2) === Object.prototype); // true
console.log(typeof clonedSheep2.toString); // function

// 使用第二個(gè)參數(shù)定義屬性描述符
const sheepPrototype = { eat: function() { console.log('吃草') } }
const animal = Object.create(sheepPrototype, {
  age: {
    value: 3,
    writable: true,
    enumerable: true,
    configurable: true
  },
  id: {
    value: Math.random(),
    writable: false, // 只讀屬性
    enumerable: false // 不可枚舉
  }
})

console.log(animal.age) // 3
animal.age = 4 // 可以修改
console.log(animal.age) // 4

animal.id = 999 // 嘗試修改只讀屬性
console.log(animal.id) // 仍然是原來的隨機(jī)數(shù)

// 枚舉測(cè)試
for(let key in animal) {
  console.log(key) // 只會(huì)打印age和原型上的屬性，不會(huì)打印id
}

// ES6 Class - class中定義的方法，不是綁定到構(gòu)造函數(shù)本身，
// 而是被自動(dòng)添加到了構(gòu)造函數(shù)的prototype(原型)對(duì)象上
class Sheep {
  constructor(name, age) {
    // 實(shí)例屬性
    this.name = name;
    this.age = age;
    this.friends = [];
  }
  
  // 實(shí)例方法 - 自動(dòng)添加到prototype
  sayHello() {
    console.log(`Hello, my name is ${this.name}`);
  }
  
  eat() {
    console.log(`${this.name}在吃草`);
  }
  
  addFriend(friend) {
    this.friends.push(friend);
  }
  
  // 靜態(tài)方法
  static compare(sheep1, sheep2) {
    return sheep1.age - sheep2.age;
  }
  
  // getter
  get info() {
    return `${this.name} (${this.age}歲)`;
  }
  
  // setter
  set info(value) {
    [this.name, this.age] = value.split(',');
  }
}

// 使用
const sheep1 = new Sheep('喜羊羊', 3);
const sheep2 = new Sheep('美羊羊', 2);

// 驗(yàn)證方法共享
console.log(sheep1.sayHello === sheep2.sayHello); // true

// 使用靜態(tài)方法
console.log(Sheep.compare(sheep1, sheep2)); // 1

// 使用getter/setter
console.log(sheep1.info); // 喜羊羊 (3歲)
sheep1.info = '懶羊羊,5';
console.log(sheep1.name); // 懶羊羊
console.log(sheep1.age); // "5"

// Class本質(zhì)上還是函數(shù)
console.log(typeof Sheep) // "function"

// Class定義的方法在prototype上
console.log(Sheep.prototype.sayHello) // [Function: sayHello]

// 用傳統(tǒng)方式實(shí)現(xiàn)同樣的效果
function TraditionalSheep(name, age) {
  this.name = name;
  this.age = age;
}

TraditionalSheep.prototype.sayHello = function() {
  console.log(`Hello, my name is ${this.name}`);
};

// 驗(yàn)證：方法不屬于實(shí)例的自有屬性，而是在prototype上
const sheep = new Sheep("喜羊羊", 2)
console.log(sheep.hasOwnProperty('sayHello')); // false
console.log(sheep.__proto__.hasOwnProperty('sayHello')); // true

// 繼承
class SmartSheep extends Sheep {
  constructor(name, age, iq) {
    super(name, age); // 調(diào)用父類構(gòu)造函數(shù)
    this.iq = iq;
  }
  
  // 方法重寫
  eat() {
    super.eat(); // 調(diào)用父類方法
    console.log('...一邊吃一邊思考');
  }
  
  // 新方法
  solve() {
    console.log(`${this.name}解決了問題！`);
  }
}

const smartSheep = new SmartSheep('喜羊羊', 3, 150);
smartSheep.eat(); 
// 喜羊羊在吃草
// ...一邊吃一邊思考