对象枚举与迭代

对象枚举与迭代的基本概念

JavaScript中对象属性的枚举与迭代是处理对象数据的关键操作。枚举指的是列出对象的所有可访问属性，而迭代则是按顺序访问这些属性或它们的值。这两种操作在日常开发中频繁出现，比如数据处理、对象转换等场景。

对象属性的可枚举性(enumerable)是一个重要特性，它决定了属性是否会在某些枚举操作中出现。通过Object.defineProperty()定义的属性默认不可枚举，而直接赋值的属性默认是可枚举的。

const obj = {
  name: 'John',
  age: 30
};

Object.defineProperty(obj, 'id', {
  value: '123',
  enumerable: false
});

for (const key in obj) {
  console.log(key); // 只输出 'name' 和 'age'
}

常见的枚举方法

for...in 循环

for...in语句是最基本的对象枚举方法，它会遍历对象及其原型链上的所有可枚举属性。使用时通常需要配合hasOwnProperty()检查来过滤掉继承的属性。

const person = {
  name: 'Alice',
  age: 25,
  job: 'Developer'
};

for (const key in person) {
  if (person.hasOwnProperty(key)) {
    console.log(`${key}: ${person[key]}`);
  }
}

Object.keys()

Object.keys()方法返回一个包含对象自身可枚举属性名称的数组，不包含原型链上的属性。这个方法在只需要对象自身属性时特别有用。

const car = {
  make: 'Toyota',
  model: 'Camry',
  year: 2020
};

const keys = Object.keys(car);
console.log(keys); // ['make', 'model', 'year']

Object.getOwnPropertyNames()

与Object.keys()类似，但Object.getOwnPropertyNames()会返回对象自身的所有属性(包括不可枚举的)，但不包括Symbol属性和原型链上的属性。

const obj = {};
Object.defineProperty(obj, 'hidden', {
  value: 'secret',
  enumerable: false
});

console.log(Object.keys(obj)); // []
console.log(Object.getOwnPropertyNames(obj)); // ['hidden']

现代迭代方法

Object.values() 和 Object.entries()

ES2017引入了Object.values()和Object.entries()方法，分别返回对象自身可枚举属性的值数组和键值对数组。

const user = {
  username: 'jsmith',
  email: 'jsmith@example.com',
  isAdmin: false
};

console.log(Object.values(user));
// ['jsmith', 'jsmith@example.com', false]

console.log(Object.entries(user));
// [['username', 'jsmith'], ['email', 'jsmith@example.com'], ['isAdmin', false]]

Object.fromEntries()

Object.fromEntries()是Object.entries()的逆操作，将键值对数组转换回对象。这在处理Map结构或表单数据时特别有用。

const entries = [
  ['name', 'Bob'],
  ['age', 35],
  ['city', 'New York']
];

const person = Object.fromEntries(entries);
console.log(person);
// { name: 'Bob', age: 35, city: 'New York' }

Symbol属性的处理

ES6引入的Symbol类型属性不会被常规枚举方法包含。要访问这些属性，需要使用Object.getOwnPropertySymbols()。

const id = Symbol('id');
const user = {
  [id]: '12345',
  name: 'John'
};

console.log(Object.keys(user)); // ['name']
console.log(Object.getOwnPropertySymbols(user)); // [Symbol(id)]

性能考虑与最佳实践

不同枚举方法在性能上有差异。for...in通常最慢，因为它需要检查原型链；Object.keys()和类似方法更快。在大型对象或性能敏感场景中，选择合适的枚举方法很重要。

// 性能较差的写法
for (const key in obj) {
  if (obj.hasOwnProperty(key)) {
    // 处理属性
  }
}

// 性能更好的写法
const keys = Object.keys(obj);
for (const key of keys) {
  // 处理属性
}

自定义迭代行为

通过实现[Symbol.iterator]方法，可以使对象可迭代，从而支持for...of循环和展开运算符等操作。

const range = {
  start: 1,
  end: 5,
  [Symbol.iterator]() {
    let current = this.start;
    const end = this.end;
    return {
      next() {
        if (current <= end) {
          return { value: current++, done: false };
        }
        return { done: true };
      }
    };
  }
};

for (const num of range) {
  console.log(num); // 1, 2, 3, 4, 5
}

枚举与不可变对象

在处理不可变对象时，枚举方法的选择尤为重要。某些方法会返回新数组，而有些则直接操作原对象。

const frozenObj = Object.freeze({
  prop1: 'value1',
  prop2: 'value2'
});

// 这些方法是安全的
Object.keys(frozenObj);
Object.values(frozenObj);

// 这些操作会抛出错误
frozenObj.prop3 = 'value3'; // TypeError

实际应用场景

深度拷贝对象

结合枚举方法可以实现对象的深度拷贝，这在状态管理库中很常见。

function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  
  const clone = Array.isArray(obj) ? [] : {};
  
  Object.entries(obj).forEach(([key, value]) => {
    clone[key] = deepClone(value);
  });
  
  return clone;
}

const original = { a: 1, b: { c: 2 } };
const copy = deepClone(original);

属性过滤与转换

枚举方法可以方便地实现对象属性的过滤和转换。

function pick(obj, keys) {
  return Object.fromEntries(
    Object.entries(obj).filter(([key]) => keys.includes(key))
  );
}

const user = {
  name: 'Jane',
  age: 28,
  email: 'jane@example.com',
  password: 'secret'
};

const publicProfile = pick(user, ['name', 'age', 'email']);
console.log(publicProfile);
// { name: 'Jane', age: 28, email: 'jane@example.com' }

枚举与原型链

理解枚举方法如何处理原型链很重要。某些方法会包含原型链属性，而有些则不会。

function Person(name) {
  this.name = name;
}

Person.prototype.sayHello = function() {
  console.log(`Hello, I'm ${this.name}`);
};

const person = new Person('Mike');

// for...in 包含原型链方法
for (const key in person) {
  console.log(key); // 'name', 'sayHello'
}

// Object.keys() 不包含原型链方法
console.log(Object.keys(person)); // ['name']

枚举顺序的确定性

ES6规范明确了对象自有属性的枚举顺序，这在实际开发中有时会被依赖。

1. 数字键按升序排列
2. 字符串键按创建顺序排列
3. Symbol键按创建顺序排列

const obj = {
  '2': 'two',
  '3': 'three',
  '1': 'one',
  'b': 'b',
  'a': 'a'
};

console.log(Object.keys(obj)); // ['1', '2', '3', 'b', 'a']