js如何检测原型链的终点

function findPrototypeChainEnd(obj) {
    let currentProto = obj;
    let chain = [];
    while (currentProto !== null) {
        chain.push(currentProto);
        currentProto = Object.getPrototypeOf(currentProto);
    }
    // 链的最后一个元素会是 Object.prototype (如果不是 null),
    // 它的原型是 null，所以循环会在 null 处停止。
    // 实际的终点是 null 本身，但它不会被 push 进 chain。
    // 如果需要明确指出终点是 null，可以在循环结束后说明。
    console.log("原型链追溯到终点：", chain);
    return null; // 终点就是 null
}

let myObject = {};
findPrototypeChainEnd(myObject); // 输出：[{}, Object]

function MyConstructor() {}
let instance = new MyConstructor();
findPrototypeChainEnd(instance); // 输出：[MyConstructor {}, MyConstructor.prototype, Object]

class MyClass {}
let classInstance = new MyClass();
findPrototypeChainEnd(classInstance); // 输出：[MyClass {}, MyClass.prototype, Object]

// 甚至对于 Object.prototype 本身
findPrototypeChainEnd(Object.prototype); // 输出：[Object]

// 简单字面量对象
console.log("--- 简单字面量对象 ---");
let simpleObj = {};
let proto = simpleObj;
let i = 0;
while (proto) { // 循环直到 proto 为 null
    console.log(`第 ${i++} 层原型:`, proto);
    proto = Object.getPrototypeOf(proto);
}
// 预期输出：
// 第 0 层原型: {}
// 第 1 层原型: [Object: null prototype] {} (即 Object.prototype)

// 使用构造函数创建的对象
console.log("\n--- 构造函数创建的对象 ---");
function Animal(name) {
    this.name = name;
}
Animal.prototype.sayName = function() { console.log(this.name); };
let dog = new Animal("Buddy");
proto = dog;
i = 0;
while (proto) {
    console.log(`第 ${i++} 层原型:`, proto);
    proto = Object.getPrototypeOf(proto);
}
// 预期输出：
// 第 0 层原型: Animal { name: 'Buddy' }
// 第 1 层原型: Animal { sayName: [Function (anonymous)] } (即 Animal.prototype)
// 第 2 层原型: [Object: null prototype] {} (即 Object.prototype)

// 使用 ES6 Class 创建的对象
console.log("\n--- ES6 Class 创建的对象 ---");
class Vehicle {
    constructor(type) { this.type = type; }
    drive() { console.log("Driving a", this.type); }
}
class Car extends Vehicle {
    constructor(make) { super("car"); this.make = make; }
}
let myCar = new Car("Tesla");
proto = myCar;
i = 0;
while (proto) {
    console.log(`第 ${i++} 层原型:`, proto);
    proto = Object.getPrototypeOf(proto);
}
// 预期输出：
// 第 0 层原型: Car { type: 'car', make: 'Tesla' }
// 第 1 层原型: Car {} (即 Car.prototype)
// 第 2 层原型: Vehicle {} (即 Vehicle.prototype)
// 第 3 层原型: [Object: null prototype] {} (即 Object.prototype)

// 特殊情况：Object.create(null) 创建的对象
console.log("\n--- Object.create(null) 创建的对象 ---");
let nullProtoObj = Object.create(null);
nullProtoObj.value = 10;
proto = nullProtoObj;
i = 0;
while (proto) {
    console.log(`第 ${i++} 层原型:`, proto);
    proto = Object.getPrototypeOf(proto);
}
// 预期输出：
// 第 0 层原型: [Object: null prototype] { value: 10 }
// (这里循环就结束了，因为它的原型直接就是 null)