const obj = { a: 1, b: 2, c: 3 };

// 方法1: Object.keys()
for (const key of Object.keys(obj)) {
  console.log(key); // 'a', 'b', 'c'
  console.log(obj[key]); // 1, 2, 3
}

// 方法2: 使用數(shù)組的解構(gòu)和循環(huán)
for (const key of Object.keys(obj)) {
  const value = obj[key];
  console.log(key, value);
}

const obj = { a: 1, b: 2, c: 3 };

for (const value of Object.values(obj)) {
  console.log(value); // 1, 2, 3
}

const obj = { a: 1, b: 2, c: 3 };

// 方法1: 使用數(shù)組解構(gòu)
for (const [key, value] of Object.entries(obj)) {
  console.log(key, value); // 'a' 1, 'b' 2, 'c' 3
}

// 方法2: 不使用解構(gòu)
for (const entry of Object.entries(obj)) {
  const key = entry[0];
  const value = entry[1];
  console.log(key, value);
}

const obj = {
  name: 'John',
  age: 30,
  city: 'New York',
  
  // 添加 Symbol.iterator 方法
  [Symbol.iterator]: function* () {
    // 遍歷自身屬性
    for (const key of Object.keys(this)) {
      yield [key, this[key]];
    }
  }
};

// 現(xiàn)在可以用 for...of 直接遍歷
for (const [key, value] of obj) {
  console.log(`${key}: ${value}`);
}
// 輸出:
// name: John
// age: 30
// city: New York

const obj = {
  a: 1,
  b: 2,
  c: 3,
  [Symbol.iterator]: function* () {
    for (const key of Object.keys(this)) {
      yield this[key];
    }
  }
};

for (const value of obj) {
  console.log(value); // 1, 2, 3
}

const user = {
  firstName: 'John',
  lastName: 'Doe',
  age: 30,
  email: 'john@example.com',
  
  [Symbol.iterator]: function* () {
    // 自定義迭代順序
    yield ['姓名', `${this.firstName} ${this.lastName}`];
    yield ['年齡', this.age];
    yield ['郵箱', this.email];
  }
};

for (const [label, value] of user) {
  console.log(`${label}: ${value}`);
}
// 輸出:
// 姓名: John Doe
// 年齡: 30
// 郵箱: john@example.com

const product = {
  id: 1,
  name: 'Laptop',
  price: 999.99,
  category: 'Electronics',
  inStock: true,
  
  [Symbol.iterator]: function* () {
    // 只迭代非布爾值的屬性
    const keys = Object.keys(this);
    for (const key of keys) {
      if (typeof this[key] !== 'boolean') {
        yield [key, this[key]];
      }
    }
  }
};

for (const [key, value] of product) {
  console.log(`${key}: ${value}`);
}
// 輸出:
// id: 1
// name: Laptop
// price: 999.99
// category: Electronics

class UserCollection {
  constructor() {
    this.users = [];
  }
  
  add(user) {
    this.users.push(user);
  }
  
  // 使實(shí)例可迭代
  *[Symbol.iterator]() {
    for (const user of this.users) {
      yield user;
    }
  }
  
  // 或者返回鍵值對(duì)
  *entries() {
    for (let i = 0; i < this.users.length; i++) {
      yield [i, this.users[i]];
    }
  }
}

const collection = new UserCollection();
collection.add({ name: 'Alice', age: 25 });
collection.add({ name: 'Bob', age: 30 });

// 遍歷用戶
for (const user of collection) {
  console.log(user.name, user.age);
}

// 遍歷帶索引的用戶
for (const [index, user] of collection.entries()) {
  console.log(index, user.name);
}

function* objectEntries(obj) {
  for (const key of Object.keys(obj)) {
    yield [key, obj[key]];
  }
}

const obj = { x: 10, y: 20, z: 30 };

for (const [key, value] of objectEntries(obj)) {
  console.log(key, value);
}

const config = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  retries: 3,
  debug: false
};

// 配置迭代器
config[Symbol.iterator] = function* () {
  const keys = Object.keys(this).sort(); // 按字母排序
  for (const key of keys) {
    yield { key, value: this[key] };
  }
};

for (const { key, value } of config) {
  if (typeof value !== 'boolean') { // 過濾布爾值
    console.log(`配置 ${key} = ${value}`);
  }
}

const company = {
  name: 'TechCorp',
  departments: {
    engineering: { employees: 50, budget: 1000000 },
    sales: { employees: 20, budget: 500000 },
    marketing: { employees: 15, budget: 300000 }
  }
};

// 扁平化迭代器
company[Symbol.iterator] = function* () {
  yield ['公司名稱', this.name];
  for (const [dept, info] of Object.entries(this.departments)) {
    yield [`${dept}部門人數(shù)`, info.employees];
    yield [`${dept}部門預(yù)算`, info.budget];
  }
};

for (const [label, value] of company) {
  console.log(`${label}: ${value}`);
}

const obj = {};
// 創(chuàng)建一個(gè)大對(duì)象
for (let i = 0; i < 1000000; i++) {
  obj[`key${i}`] = i;
}

// 測(cè)試不同方法的性能
console.time('Object.keys + for...of');
for (const key of Object.keys(obj)) {
  const value = obj[key];
}
console.timeEnd('Object.keys + for...of');

console.time('Object.entries + for...of');
for (const [key, value] of Object.entries(obj)) {
  // 直接有值
}
console.timeEnd('Object.entries + for...of');

console.time('for...in');
for (const key in obj) {
  if (obj.hasOwnProperty(key)) {
    const value = obj[key];
  }
}
console.timeEnd('for...in');

// 創(chuàng)建可迭代對(duì)象的工具函數(shù)
function makeIterable(obj, options = {}) {
  const {
    exclude = [],      // 排除的屬性
    includeOnly = null, // 只包含的屬性
    sortKeys = false,  // 是否按鍵排序
    valueOnly = false  // 只返回值
  } = options;
  
  const iterable = { ...obj };
  
  iterable[Symbol.iterator] = function* () {
    let keys = Object.keys(this);
    
    // 過濾
    if (exclude.length) {
      keys = keys.filter(key => !exclude.includes(key));
    }
    
    if (includeOnly) {
      keys = keys.filter(key => includeOnly.includes(key));
    }
    
    // 排序
    if (sortKeys) {
      keys.sort();
    }
    
    // 迭代
    for (const key of keys) {
      if (valueOnly) {
        yield this[key];
      } else {
        yield [key, this[key]];
      }
    }
  };
  
  return iterable;
}

// 使用示例
const data = { a: 1, b: 2, c: 3, d: 4, e: 5 };
const iterableData = makeIterable(data, {
  exclude: ['e'],
  sortKeys: true
});

for (const [key, value] of iterableData) {
  console.log(key, value); // a 1, b 2, c 3, d 4
}

// 推薦的最佳實(shí)踐
const obj = { a: 1, b: 2, c: 3 };

// 1. 只需要鍵或值
for (const key of Object.keys(obj)) { }
for (const value of Object.values(obj)) { }

// 2. 需要鍵值對(duì)
for (const [key, value] of Object.entries(obj)) { }

// 3. 需要直接迭代對(duì)象（添加迭代器）
obj[Symbol.iterator] = function* () {
  for (const [key, value] of Object.entries(this)) {
    yield { key, value };
  }
};