js如何判断属性是否在原型上

in

Object.prototype.hasOwnProperty.call()

prop in obj

obj.hasOwnProperty(prop)

in

hasOwnProperty

in

hasOwnProperty

!(obj.hasOwnProperty(prop)) && (prop in obj)

function Person(name) {
    this.name = name; // 实例属性
}

Person.prototype.greet = function() { // 原型属性
    console.log(`Hello, my name is ${this.name}`);
};

const person1 = new Person('Alice');
person1.age = 30; // 实例属性

// 检查 'name' 属性
console.log('--- 检查 name (实例属性) ---');
console.log(`'name' in person1: ${'name' in person1}`); // true
console.log(`person1.hasOwnProperty('name'): ${person1.hasOwnProperty('name')}`); // true
console.log(`'name' 在原型上吗？ ${!person1.hasOwnProperty('name') && ('name' in person1)}`); // false

// 检查 'greet' 属性
console.log('\n--- 检查 greet (原型属性) ---');
console.log(`'greet' in person1: ${'greet' in person1}`); // true
console.log(`person1.hasOwnProperty('greet'): ${person1.hasOwnProperty('greet')}`); // false
console.log(`'greet' 在原型上吗？ ${!person1.hasOwnProperty('greet') && ('greet' in person1)}`); // true

// 检查 'toString' 属性 (更深的原型链，来自 Object.prototype)
console.log('\n--- 检查 toString (更深的原型属性) ---');
console.log(`'toString' in person1: ${'toString' in person1}`); // true
console.log(`person1.hasOwnProperty('toString'): ${person1.hasOwnProperty('toString')}`); // false
console.log(`'toString' 在原型上吗？ ${!person1.hasOwnProperty('toString') && ('toString' in person1)}`); // true

// 检查 'age' 属性 (实例属性)
console.log('\n--- 检查 age (实例属性) ---');
console.log(`'age' in person1: ${'age' in person1}`); // true
console.log(`person1.hasOwnProperty('age'): ${person1.hasOwnProperty('age')}`); // true
console.log(`'age' 在原型上吗？ ${!person1.hasOwnProperty('age') && ('age' in person1)}`); // false

// 检查一个不存在的属性
console.log('\n--- 检查 nonexistent (不存在的属性) ---');
console.log(`'nonexistent' in person1: ${'nonexistent' in person1}`); // false
console.log(`person1.hasOwnProperty('nonexistent'): ${person1.hasOwnProperty('nonexistent')}`); // false
console.log(`'nonexistent' 在原型上吗？ ${!person1.hasOwnProperty('nonexistent') && ('nonexistent' in person1)}`); // false

hasOwnProperty

Object.prototype.hasOwnProperty.call(obj, prop)

const objWithOverriddenHasOwnProperty = {
    myProp: 1,
    hasOwnProperty: function() {
        return false; // 故意返回 false
    }
};

console.log('\n--- 使用 Object.prototype.hasOwnProperty.call() ---');
console.log(`objWithOverriddenHasOwnProperty.hasOwnProperty('myProp'): ${objWithOverriddenHasOwnProperty.hasOwnProperty('myProp')}`); // false (被覆盖了)
console.log(`Object.prototype.hasOwnProperty.call(objWithOverriddenHasOwnProperty, 'myProp'): ${Object.prototype.hasOwnProperty.call(objWithOverriddenHasOwnProperty, 'myProp')}`); // true (正确判断)

// 所以判断原型属性，更严谨的写法是：
const isPrototypeProperty = (obj, prop) => !Object.prototype.hasOwnProperty.call(obj, prop) && (prop in obj);

console.log(`'myProp' 在 objWithOverriddenHasOwnProperty 的原型上吗？ ${isPrototypeProperty(objWithOverriddenHasOwnProperty, 'myProp')}`); // false (因为它是实例属性)

hasOwnProperty

in

in

Object.prototype

toString

valueOf

{}

'toString' in {}

true

Object.prototype.toString

const myObj = {};
console.log(`'toString' in myObj: ${'toString' in myObj}`); // true
console.log(`myObj.hasOwnProperty('toString'): ${myObj.hasOwnProperty('toString')}`); // false

in

hasOwnProperty

myObj

toString

in

Object.getPrototypeOf()

[[Prototype]]

Object.getOwnPropertyDescriptor()

function Vehicle() {}
Vehicle.prototype.wheels = 4;

function Car() {}
Car.prototype = Object.create(Vehicle.prototype); // Car 继承自 Vehicle
Car.prototype.constructor = Car;
Car.prototype.engine = 'V6';

const myCar = new Car();
myCar.color = 'red';

let currentProto = Object.getPrototypeOf(myCar); // 获取 myCar 的直接原型 (Car.prototype)
const propName = 'wheels';

let foundOnPrototype = false;
while (currentProto) {
    if (Object.prototype.hasOwnProperty.call(currentProto, propName)) {
        console.log(`${propName} 在 ${currentProto.constructor.name}.prototype 上找到。`);
        foundOnPrototype = true;
        break;
    }
    currentProto = Object.getPrototypeOf(currentProto); // 继续向上查找原型链
}
console.log(`'${propName}' 是原型属性吗？${foundOnPrototype}`); // true

// 检查一个实例属性
currentProto = Object.getPrototypeOf(myCar);
const instancePropName = 'color';
foundOnPrototype = false;
while (currentProto) {
    if (Object.prototype.hasOwnProperty.call(currentProto, instancePropName)) {
        foundOnPrototype = true;
        break;
    }
    currentProto = Object.getPrototypeOf(currentProto);
}
console.log(`'${instancePropName}' 是原型属性吗？${foundOnPrototype}`); // false

hasOwnProperty

Object.getOwnPropertyDescriptor(obj, propName)

value

writable

enumerable

configurable

Object.getOwnPropertyDescriptor(obj, propName)

undefined

Object.getOwnPropertyDescriptor

JSON.stringify()

for...in

for...in

hasOwnProperty

// 错误的深拷贝尝试 (会把原型属性也拷贝过去)
function badDeepClone(obj) {
    const newObj = {};
    for (const key in obj) {
        // 缺少 hasOwnProperty 检查
        if (typeof obj[key] === 'object' && obj[key] !== null) {
            newObj[key] = badDeepClone(obj[key]);
        } else {
            newObj[key] = obj[key];
        }
    }
    return newObj;
}

// 正确的深拷贝，只拷贝实例属性
function goodDeepClone(obj) {
    if (typeof obj !== 'object' || obj === null) {
        return obj;
    }
    const newObj = Array.isArray(obj) ? [] : {};
    for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) { // 关键：只处理自身属性
            if (typeof obj[key] === 'object' && obj[key] !== null) {
                newObj[key] = goodDeepClone(obj[key]);
            } else {
                newObj[key] = obj[key];
            }
        }
    }
    return newObj;
}