JavaScript原型及原型链

 1.JS 中对象的属性查找机制及实现属性查找机制的伪代码

        在 JavaScript 中，当访问一个对象的属性时，会先在对象自身查找，如果没有找到，则会沿着原型链逐级向上查找，直到找到该属性或到达原型链的顶端（即 null）。

伪代码实现如下：

function findProperty(obj, property) {
    // 在对象自身查找属性
    if (obj.hasOwnProperty(property)) {
        return obj[property];
    }
    // 获取对象的原型
    var proto = Object.getPrototypeOf(obj);
    // 沿着原型链逐级查找
    while (proto) {
        if (proto.hasOwnProperty(property)) {
            return proto[property];
        }
        proto = Object.getPrototypeOf(proto);
    }
    // 未找到属性
    return undefined;
}

2.实现一个ES5 的 Object.create() 函数。

   Object.create() 方法创建一个新对象，使用现有的对象来提供新创建的对象的 __proto__。

function myObjectCreate(proto) {
    function F() {} // 创建一个临时的构造函数
    F.prototype = proto; // 将构造函数的原型指向传入的对象
    return new F(); // 返回一个新对象，其原型指向传入的对象
}

// 使用示例
const parent = { name: 'parent' };
const child = myObjectCreate(parent);
console.log(child.name); // 输出 'parent'

3. 使用原型链实现继承，本质通过改变对象的什么，来实现继承？

        通过改变对象的 __proto__ 属性（即对象的原型）来实现继承。具体地，通过将一个对象的 __proto__ 指向另一个对象，从而使前者可以访问后者的属性和方法。

4. 当我们使用 new 关键字，其背后干了哪些事？

        使用 new 关键字时，JavaScript 会执行以下步骤：

1. 创建一个新对象。
2. 将新对象的 __proto__ 设置为构造函数的 prototype 属性。
3. 执行构造函数，并将 this 绑定到新创建的对象上。
4. 如果构造函数返回一个对象，则返回该对象；否则，返回新创建的对象。

   function myNew(constructor, ...args) {
       // 创建一个新对象
       const obj = {};
       // 设置新对象的原型
       obj.__proto__ = constructor.prototype;
       // 执行构造函数
       const result = constructor.apply(obj, args);
       // 返回新创建的对象或构造函数返回的对象
       return result instanceof Object ? result : obj;
   }
   

5. 假定代码中需要4个类，分别是 Animal，Dog，Cat，Human。Animal 有方法 eat,sleep;Dog,Cat有方法bark；Human有方法speak；用js中的继承实现。

   // 定义Animal类
   function Animal(){}
   Animal.prototype.eat = function(){
       console.log("Eating...");
   };
   Animal.prototype.sleep = function(){
       console.log("sleeping...");
   };
   
   // 定义Dog类
   function Dog(){}
   Dog.prototype = Object.create(Animal.prototype);
   Dog.prototype.constructor = Dog;
   Dog.prototype.break = function(){
       console.log("Breaking...");
   };
   
   // 定义Cat类
   function Cat(){
       Cat.prototype = Object.create(Animal.prototype);
       Cat.prototype.constructor = Cat;
       Cat.prototype.meow = function(){
           console.log("Meowing...");
       }
   };
   
   // 定义Human类
   function Human(){}
   Human.prototype = Object.create(Animal.prototype)
   Human.prototype.constructor = Human;
   Human.prototype.speak = function(){
       console.log("speaking...");
   };
   
   // 测试继承
   const dog = new Dog();
   dog.eat(); // Eating...
   dog.sleep(); // Sleeping...
   dog.bark(); // Barking...
   
   const cat = new Cat();
   cat.eat(); // Eating...
   cat.sleep(); // Sleeping...
   cat.meow(); // Meowing...
   
   const human = new Human();
   human.eat(); // Eating...
   human.sleep(); // Sleeping...
   human.speak(); // Speaking...