属性的可枚举性和所有权

2. 访问器属性（Getter/Setter）

const user = {
    firstName: "John",
    lastName: "Doe",

    // 定义访问器属性
    get fullName() {
        return `${this.firstName} ${this.lastName}`;
    },

    set fullName(value) {
        const parts = value.split(" ");
        this.firstName = parts[0];
        this.lastName = parts[1] || "";
    },

    // 计算属性
    get age() {
        return new Date().getFullYear() - this.birthYear;
    },
};

user.birthYear = 1990;
console.log(user.fullName); // John Doe
console.log(user.age); // 计算出的年龄

user.fullName = "Jane Smith";
console.log(user.firstName); // Jane
console.log(user.lastName); // Smith

3. 属性描述符的继承性

class Animal {
    constructor(name) {
        this.name = name;
    }

    // 类方法是不可枚举的
    speak() {
        console.log(`${this.name} makes a noise.`);
    }
}

class Dog extends Animal {
    constructor(name) {
        super(name);
    }

    // 重写的方法也是不可枚举的
    speak() {
        console.log(`${this.name} barks.`);
    }
}

const dog = new Dog("Rex");

// 检查属性描述符
console.log(Object.getOwnPropertyDescriptor(dog, "name"));
// { value: 'Rex', writable: true, enumerable: true, configurable: true }

console.log(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(dog), "speak"));
// { value: [Function: speak], writable: true, enumerable: false, configurable: true }

实践应用场景

1. 实现真正的私有属性

function createPrivateObject() {
    const privateData = new WeakMap();

    class PrivateObject {
        constructor() {
            // 存储私有数据
            privateData.set(this, {
                secret: Math.random(),
                count: 0,
            });

            // 定义不可枚举的访问器
            Object.defineProperty(this, "_internal", {
                enumerable: false,
                configurable: false,
                get() {
                    return privateData.get(this);
                },
            });
        }

        // 公有方法
        increment() {
            const data = privateData.get(this);
            data.count++;
            return data.count;
        }

        getSecret() {
            const data = privateData.get(this);
            return data.secret;
        }
    }

    return PrivateObject;
}

const PrivateObject = createPrivateObject();
const obj = new PrivateObject();

console.log(Object.keys(obj)); // []
console.log(obj.increment()); // 1
console.log(obj.getSecret()); // 随机数

2. 不可变配置对象

function createConfig(options = {}) {
    const config = {
        ...options,
        // 默认配置
        apiUrl: "https://api.example.com",
        timeout: 30000,
        retryCount: 3,
    };

    // 冻结所有属性
    Object.keys(config).forEach(key => {
        Object.defineProperty(config, key, {
            value: config[key],
            writable: false,
            enumerable: true,
            configurable: false,
        });
    });

    // 防止添加新属性
    Object.preventExtensions(config);

    return config;
}

const config = createConfig({ timeout: 5000 });

config.timeout = 10000; // 静默失败
config.newProp = "test"; // 静默失败
delete config.apiUrl; // false

console.log(Object.keys(config)); // ['apiUrl', 'timeout', 'retryCount']

3. JSON 序列化控制

class User {
    constructor(name, email, password) {
        this.name = name;
        this.email = email;

        // 密码设为不可枚举，不会被 JSON.stringify 包含
        Object.defineProperty(this, "password", {
            value: password,
            enumerable: false,
            writable: false,
            configurable: false,
        });

        // 内部状态设为不可枚举
        Object.defineProperty(this, "_metadata", {
            value: {
                created: new Date(),
                version: 1,
            },
            enumerable: false,
        });
    }

    toJSON() {
        // 自定义序列化
        return {
            name: this.name,
            email: this.email,
            // 不包含 password 和 _metadata
            metadata: this._metadata, // 需要时手动添加
        };
    }
}

const user = new User("John", "john@example.com", "secret123");

console.log("JSON.stringify:", JSON.stringify(user));
// {"name":"John","email":"john@example.com","metadata":{"created":"2024-01-01T00:00:00.000Z","version":1}}

console.log("Object.keys:", Object.keys(user)); // ['name', 'email']

4. 属性验证和监听

function createValidatedObject(schema) {
    const obj = {};

    for (const [key, validator] of Object.entries(schema)) {
        let value;

        Object.defineProperty(obj, key, {
            enumerable: true,
            configurable: false,

            get() {
                return value;
            },

            set(newValue) {
                // 验证
                if (!validator(newValue)) {
                    throw new Error(`Invalid value for ${key}: ${newValue}`);
                }

                // 通知变化
                if (obj._listeners && obj._listeners[key]) {
                    obj._listeners[key].forEach(callback => {
                        callback(newValue, value);
                    });
                }

                value = newValue;
            },
        });

        // 添加监听方法
        obj.onChange = function (prop, callback) {
            if (!this._listeners) {
                Object.defineProperty(this, "_listeners", {
                    value: {},
                    enumerable: false,
                });
            }

            if (!this._listeners[prop]) {
                this._listeners[prop] = [];
            }

            this._listeners[prop].push(callback);
        };
    }

    return obj;
}

// 使用示例
const schema = {
    age: value => Number.isInteger(value) && value >= 0,
    email: value => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
    name: value => typeof value === "string" && value.length > 0,
};

const user = createValidatedObject(schema);

user.onChange("age", (newAge, oldAge) => {
    console.log(`Age changed from ${oldAge} to ${newAge}`);
});

user.age = 25; // OK
user.age = -5; // Error: Invalid value for age: -5

性能考虑

1. 枚举操作性能对比

const obj = {};
// 创建大量属性
for (let i = 0; i < 10000; i++) {
    obj[`prop${i}`] = i;
    // 每10个属性设一个不可枚举
    if (i % 10 === 0) {
        Object.defineProperty(obj, `hidden${i}`, {
            value: `hidden${i}`,
            enumerable: false,
        });
    }
}

// 性能测试
console.time("for...in");
for (let key in obj) {
}
console.timeEnd("for...in");

console.time("Object.keys");
Object.keys(obj);
console.timeEnd("Object.keys");

console.time("getOwnPropertyNames");
Object.getOwnPropertyNames(obj);
console.timeEnd("getOwnPropertyNames");

2. 属性访问优化

// 缓存可枚举属性列表
function getEnumerableKeys(obj) {
    if (!obj.__enumerableKeys) {
        Object.defineProperty(obj, "__enumerableKeys", {
            value: Object.keys(obj),
            enumerable: false,
            writable: true,
            configurable: true,
        });
    }
    return obj.__enumerableKeys;
}

// 当对象改变时更新缓存
function defineEnumerableProperty(obj, key, value) {
    Object.defineProperty(obj, key, {
        value,
        enumerable: true,
        writable: true,
        configurable: true,
    });

    // 更新缓存
    if (obj.__enumerableKeys) {
        if (!obj.__enumerableKeys.includes(key)) {
            obj.__enumerableKeys.push(key);
        }
    }
}

特殊情况和陷阱

1. 数组的特殊性

const arr = [1, 2, 3];

// 数组索引是可枚举的
console.log(Object.keys(arr)); // ['0', '1', '2']

// 添加不可枚举属性
Object.defineProperty(arr, "custom", {
    value: "hidden",
    enumerable: false,
});

// for...in 会包含索引
for (let key in arr) {
    console.log(key); // 0, 1, 2 (没有 custom)
}

// 但 length 是不可枚举的
console.log(Object.getOwnPropertyDescriptor(arr, "length"));
// { value: 3, writable: true, enumerable: false, configurable: false }

2. Class 的默认行为

class MyClass {
    instanceProp = "instance"; // 实例属性，可枚举

    constructor() {
        this.constructorProp = "constructor"; // 也是可枚举的
    }

    // 原型方法，不可枚举
    method() {}

    // 静态属性，可枚举
    static staticProp = "static";
}

const instance = new MyClass();

console.log(Object.keys(instance));
// ['instanceProp', 'constructorProp']

console.log(Object.getOwnPropertyNames(instance));
// ['instanceProp', 'constructorProp']

3. Symbol 属性的枚举

const obj = {
    regular: "regular",
    [Symbol("sym1")]: "symbol1",
    [Symbol("sym2")]: "symbol2",
};

// 定义不可枚举的Symbol
const sym3 = Symbol("sym3");
Object.defineProperty(obj, sym3, {
    value: "symbol3",
    enumerable: false,
});

console.log("Object.keys:", Object.keys(obj)); // ['regular']
console.log("for...in:"); // 只有 'regular'
console.log("getOwnPropertySymbols:", Object.getOwnPropertySymbols(obj)); // [Symbol(sym1), Symbol(sym2), Symbol(sym3)]
console.log("Reflect.ownKeys:", Reflect.ownKeys(obj)); // ['regular', Symbol(sym1), Symbol(sym2), Symbol(sym3)]

最佳实践

1. 明确属性意图：

• 公共 API：可枚举
• 内部实现：不可枚举
• 常量配置：writable: false

2. 谨慎使用不可枚举属性：

• 避免过度使用，会增加复杂性
• 文档化不可枚举属性的存在

3. 性能优化：

• 频繁遍历的对象，保持属性可枚举
• 大型对象，考虑缓存键列表

4. 安全考虑：

• 敏感数据设为不可枚举
• 使用 Object.freeze() 或 Object.seal() 增强安全性

5. 框架/库开发：

• 原型方法设为不可枚举
• 内部状态设为不可枚举
• 提供明确的 API 访问方式

6. 调试友好：

• 开发环境下，可考虑让调试属性可枚举
• 生产环境下，隐藏内部实现细节