数组迭代方法

array.forEach(callback(element, index, array), thisArg);

const arr = [1, 2, 3, 4, 5];

// 基本遍历
arr.forEach((item, index) => {
  console.log(`索引 ${index}: ${item}`);
});
// 输出: 索引 0: 1, 索引 1: 2, ...

// 使用 thisArg
const obj = { multiplier: 2 };
arr.forEach(function(item) {
  console.log(item * this.multiplier);
}, obj);
// 输出: 2, 4, 6, 8, 10

const users = [
  { name: 'Alice', score: 85 },
  { name: 'Bob', score: 92 },
  { name: 'Charlie', score: 78 },
];

// 计算总分
let total = 0;
users.forEach((user) => {
  total += user.score;
});
console.log(`平均分: ${(total / users.length).toFixed(1)}`); // 平均分: 85.0

// 批量修改对象属性
users.forEach((user) => {
  user.grade = user.score >= 90 ? 'A' : user.score >= 80 ? 'B' : 'C';
});
// users 现在包含 grade 属性

// 使用 array 参数
arr.forEach((item, index, array) => {
  console.log(`当前元素: ${item}, 数组长度: ${array.length}`);
});

// ❌ 不推荐：在 forEach 中进行大量计算
arr.forEach((item) => {
  // 复杂计算...
});

// ✅ 推荐：大数据量使用 for 循环
for (let i = 0; i < arr.length; i++) {
  // 复杂计算...
}

const newArray = array.map(callback(element, index, array), thisArg);

const numbers = [1, 2, 3, 4, 5];

// 数值转换
const doubled = numbers.map((num) => num * 2);
console.log(doubled); // [2, 4, 6, 8, 10]

// 提取对象属性
const users = [
  { name: 'Alice', age: 25 },
  { name: 'Bob', age: 30 },
];
const names = users.map((user) => user.name);
console.log(names); // ['Alice', 'Bob']

// 格式化数据
const prices = [100, 200, 300];
const formatted = prices.map((price) => `¥${price.toFixed(2)}`);
console.log(formatted); // ['¥100.00', '¥200.00', '¥300.00']

// 对象数组转换
const products = [
  { id: 1, name: 'Apple', price: 5 },
  { id: 2, name: 'Banana', price: 3 },
];

const formatted = products.map(({ id, name, price }) => ({
  key: id,
  label: name,
  value: price,
}));
console.log(formatted);

  // ... 中间省略 ...

// 重建对象（React 常用）
const items = ['Apple', 'Banana', 'Orange'];
const itemObjects = items.map((item, index) => ({
  id: index,
  text: item,
}));

// ❌ 不推荐：map 中有副作用
let sum = 0;
const result = numbers.map((n) => {
  sum += n; // 副作用
  return n * 2;
});

// ✅ 推荐：map 只做转换
const result = numbers.map((n) => n * 2);
const sum = numbers.reduce((acc, n) => acc + n, 0);

// ❌ 不推荐：map 返回值不使用
numbers.map((n) => console.log(n)); // 应该用 forEach

// ✅ 推荐：使用正确的方法
numbers.forEach((n) => console.log(n));

const newArray = array.filter(callback(element, index, array), thisArg);

const numbers = [1, 2, 3, 4, 5, 6];

// 过滤偶数
const evens = numbers.filter((num) => num % 2 === 0);
console.log(evens); // [2, 4, 6]

// 过滤对象数组
const products = [
  { name: 'Apple', price: 5, inStock: true },
  { name: 'Banana', price: 3, inStock: false },
  { name: 'Orange', price: 4, inStock: true },
];
const available = products.filter((p) => p.inStock && p.price < 5);
console.log(available); // [{ name: 'Orange', price: 4, inStock: true }]

// 去除假值
const mixed = [0, 1, false, 2, '', 3, null, undefined, NaN];
const truthy = mixed.filter(Boolean);
console.log(truthy); // [1, 2, 3]

// 多条件过滤
const data = [
  { name: 'Alice', age: 25, department: 'Engineering' },
  { name: 'Bob', age: 30, department: 'Marketing' },
  { name: 'Charlie', age: 28, department: 'Engineering' },
];

const filtered = data.filter(
  (item) => item.age >= 25 && item.age <= 28 && item.department === 'Engineering'
);
console.log(filtered); // [{ name: 'Charlie', ... }]


  // ... 中间省略 ...

  { status: 'success', data: { value: 2 } },
];
const validData = responses
  .filter((r) => r.status === 'success')
  .filter((r) => r.data !== null);
console.log(validData.length); // 2

// 链式过滤（更易读）
const result = data
  .filter((item) => item.active)
  .filter((item) => item.score > 60)
  .filter((item) => item.age >= 18);

// 动态条件过滤
const conditions = {
  minPrice: 10,
  maxPrice: 50,
  category: 'fruit',
};

const filtered = products.filter((p) => {
  return (
    p.price >= conditions.minPrice &&
    p.price <= conditions.maxPrice &&
    p.category === conditions.category
  );
});

// 使用解构
const filtered = users.filter(({ age, status }) => age >= 18 && status === 'active');

const result = array.reduce(callback(accumulator, currentValue, index, array), initialValue);

const numbers = [1, 2, 3, 4, 5];

// 求和
const sum = numbers.reduce((acc, cur) => acc + cur, 0);
console.log(sum); // 15

// 求乘积
const product = numbers.reduce((acc, cur) => acc * cur, 1);
console.log(product); // 120

// 找最大值
const max = numbers.reduce((acc, cur) => (acc > cur ? acc : cur), numbers[0]);
console.log(max); // 5

// 找最小值
const min = numbers.reduce((acc, cur) => (acc < cur ? acc : cur), numbers[0]);
console.log(min); // 1

// 数组转对象
const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
];
const userMap = users.reduce((acc, user) => {
  acc[user.id] = user.name;
  return acc;
}, {});
console.log(userMap); // { 1: 'Alice', 2: 'Bob' }

// 统计元素出现次数

  // ... 中间省略 ...

const double = (x) => x * 2;
const addOne = (x) => x + 1;
const square = (x) => x * x;

const calculate = pipe(double, addOne, square);
console.log(calculate(3)); // ((3 * 2) + 1)² = 49

const arr = [];

// ❌ 不提供初始值，空数组会报错
arr.reduce((acc, cur) => acc + cur); // TypeError: Reduce of empty array with no initial value

// ✅ 提供初始值则安全
arr.reduce((acc, cur) => acc + cur, 0); // 0

// ⚠️ 无初始值时的问题
const nums = [1, 2, 3];
// 无初始值：acc 第一次是 1，cur 第一次是 2
const sum1 = nums.reduce((acc, cur) => acc + cur);
// 有初始值：acc 第一次是 0，cur 第一次是 1
const sum2 = nums.reduce((acc, cur) => acc + cur, 0);
console.log(sum1 === sum2); // true（结果相同，但过程不同）

const result = array.reduceRight(callback(accumulator, currentValue, index, array), initialValue);

const arr = [1, 2, 3, 4, 5];

// 从右向左累加
const sum = arr.reduceRight((acc, cur) => acc + cur, 0);
console.log(sum); // 15（结果相同）

// 从右向左拼接
const strs = ['a', 'b', 'c'];
const result = strs.reduceRight((acc, cur) => acc + cur, '');
console.log(result); // 'cba'

// 实现compose函数
const compose =
  (...fns) =>
  (x) =>
    fns.reduceRight((v, fn) => fn(v), x);

const double = (x) => x * 2;
const addOne = (x) => x + 1;

const calculate = compose(double, addOne);
console.log(calculate(3)); // (3 + 1) * 2 = 8

const element = array.find(callback(element, index, array), thisArg);
const index = array.findIndex(callback(element, index, array), thisArg);

const users = [
  { id: 1, name: 'Alice', age: 25 },
  { id: 2, name: 'Bob', age: 30 },
  { id: 3, name: 'Charlie', age: 28 },
];

// find() - 查找元素
const user = users.find((u) => u.id === 2);
console.log(user); // { id: 2, name: 'Bob', age: 30 }

const notFound = users.find((u) => u.id === 99);
console.log(notFound); // undefined

// findIndex() - 查找索引
const index = users.findIndex((u) => u.name === 'Bob');
console.log(index); // 1

const notFoundIndex = users.findIndex((u) => u.id === 99);
console.log(notFoundIndex); // -1

// 查找复合条件
const result = users.find((u) => u.age > 25 && u.name.startsWith('B'));
console.log(result); // { id: 2, name: 'Bob', age: 30 }

// 查找并修改
const found = users.find((u) => u.id === 2);
if (found) {
  found.age = 31; // 注意：这会修改原数组
}

// 查找后删除
const idx = users.findIndex((u) => u.id === 2);
if (idx !== -1) {
  users.splice(idx, 1);
}

// 查找后替换
const idx = users.findIndex((u) => u.id === 2);
if (idx !== -1) {
  users[idx] = { ...users[idx], name: 'Robert' };
}

const element = array.findLast(callback(element, index, array), thisArg);
const index = array.findLastIndex(callback(element, index, array), thisArg);

const arr = [1, 2, 3, 4, 5, 3];

// findLast() - 从末尾查找
const lastEven = arr.findLast((n) => n % 2 !== 0);
console.log(lastEven); // 3（最后一个奇数）

// findLastIndex() - 从末尾查找索引
const lastEvenIndex = arr.findLastIndex((n) => n === 3);
console.log(lastEvenIndex); // 5（最后一个3的索引）

// 对比 find 和 findLast
const firstMatch = arr.find((n) => n === 3);
const lastMatch = arr.findLast((n) => n === 3);
console.log(firstMatch, lastMatch); // 3, 3（值相同但位置不同）

const firstIndex = arr.findIndex((n) => n === 3);
const lastIndex = arr.findLastIndex((n) => n === 3);
console.log(firstIndex, lastIndex); // 2, 5

const result = array.some(callback(element, index, array), thisArg);
const result = array.every(callback(element, index, array), thisArg);

const numbers = [1, 2, 3, 4, 5];

// some() - 是否存在
const hasLarge = numbers.some((num) => num > 3);
console.log(hasLarge); // true

const hasNegative = numbers.some((num) => num < 0);
console.log(hasNegative); // false

// every() - 是否全部
const allPositive = numbers.every((num) => num > 0);
console.log(allPositive); // true

  // ... 中间省略 ...


// 数据验证
const formData = { name: 'Alice', email: 'alice@example.com', age: 25 };
const requiredFields = ['name', 'email'];
const hasAllFields = requiredFields.every((field) => formData[field]);
console.log(hasAllFields); // true

// some 找到第一个 true 就停止
let someCount = 0;
[1, 2, 3, 4, 5].some((num) => {
  someCount++;
  return num === 3;
});
console.log(someCount); // 3（只遍历到第三个）

// every 找到第一个 false 就停止
let everyCount = 0;
[1, 2, 3, 4, 5].every((num) => {
  everyCount++;
  return num < 3;
});
console.log(everyCount); // 3（只遍历到第三个）

// some 空数组返回 false（不存在满足条件的元素）
[].some((x) => true); // false

// every 空数组返回 true（所有元素都满足条件，空集的"所有"为真）
[].every((x) => false); // true ⚠️ 注意这个特殊行为

// 权限检查
const permissions = ['read', 'write'];
const canDelete = permissions.some((p) => p === 'delete');
console.log(canDelete); // false

// 表单验证
const fields = ['email', 'password', 'confirmPassword'];
const allValid = fields.every((field) => {
  const input = document.querySelector(`#${field}`);
  return input.checkValidity();
});

// 数组比较
const arr1 = [1, 2, 3];
const arr2 = [1, 2, 3, 4];
const hasSameElements = arr1.every((n) => arr2.includes(n));

const iterator = array.entries(); // [index, value] 对
const iterator = array.keys();    // 索引
const iterator = array.values();  // 值

const arr = ['a', 'b', 'c'];

// entries() - 返回 [index, value] 对
for (const [index, value] of arr.entries()) {
  console.log(`${index}: ${value}`);
}
// 0: a, 1: b, 2: c

// keys() - 只返回索引
for (const key of arr.keys()) {
  console.log(key);
}
// 0, 1, 2

// values() - 只返回值
for (const value of arr.values()) {
  console.log(value);
}
// a, b, c

// 转换为数组
const entries = [...arr.entries()];
console.log(entries); // [[0, 'a'], [1, 'b'], [2, 'c']]

const keys = [...arr.keys()];
console.log(keys); // [0, 1, 2]

const values = [...arr.values()];
console.log(values); // ['a', 'b', 'c']

const newArray = array.flat(depth);     // depth 默认为 1
const newArray = array.flatMap(callback(element, index, array));

// flat() - 扁平化数组
const nested = [1, [2, 3], [4, [5, 6]]];
console.log(nested.flat());   // [1, 2, 3, 4, [5, 6]]（深度 1）
console.log(nested.flat(2));  // [1, 2, 3, 4, 5, 6]（深度 2）
console.log(nested.flat(Infinity)); // [1, 2, 3, 4, 5, 6]（完全扁平）

// 移除空位
const sparse = [1, , 3, , 5];
console.log(sparse.flat()); // [1, 3, 5]

// flatMap() - map + flat（深度 1）
const sentences = ['Hello World', 'Good Morning'];
const words = sentences.flatMap((s) => s.split(' '));
console.log(words); // ['Hello', 'World', 'Good', 'Morning']

// 复杂示例：映射并扁平化
const data = [
  { name: 'Alice', hobbies: ['reading', 'gaming'] },
  { name: 'Bob', hobbies: ['music'] },
];
const allHobbies = data.flatMap((user) => user.hobbies);
console.log(allHobbies); // ['reading', 'gaming', 'music']

// 过滤并映射
const numbers = [1, 2, 3, 4, 5];
const result = numbers.flatMap((n) => (n % 2 === 0 ? [n, n * 2] : []));
console.log(result); // [2, 4, 4, 8]

需要什么结果？
├─ 无需返回值，只需遍历 → forEach()
├─ 新数组（相同长度） → map()
├─ 新数组（可能更短） → filter()
├─ 单个值（聚合） → reduce()
├─ 单个元素 → find()
├─ 索引位置 → findIndex()
├─ 布尔值（存在性） → some()
├─ 布尔值（全部性） → every()
└─ 扁平化数组 → flat() / flatMap()

// ❌ 性能差：filter 后取第一个
const user = users.filter((u) => u.id === 1)[0];

// ✅ 性能好：使用 find
const user = users.find((u) => u.id === 1);

// ❌ 性能差：map 后 filter
const result = arr.map(transform).filter(Boolean);

// ✅ 性能好：先 filter 后 map（减少 map 操作次数）
const result = arr.filter(shouldProcess).map(transform);

// ❌ 多次遍历
const sum = arr.reduce((a, b) => a + b, 0);
const max = Math.max(...arr);
const min = Math.min(...arr);

// ✅ 单次遍历（大数据量时）
const { sum, max, min } = arr.reduce(
  (acc, cur) => ({
    sum: acc.sum + cur,
    max: Math.max(acc.max, cur),
    min: Math.min(acc.min, cur),
  }),
  { sum: 0, max: -Infinity, min: Infinity }
);

// ❌ 内存占用大：链式调用创建多个中间数组
const result = largeArray
  .filter(condition1)
  .map(transform1)
  .filter(condition2)
  .map(transform2);

// ✅ 内存优化：使用 reduce 单次处理
const result = largeArray.reduce((acc, item) => {
  if (!condition1(item)) return acc;
  const transformed = transform1(item);
  if (!condition2(transformed)) return acc;
  acc.push(transform2(transformed));
  return acc;
}, []);

// ✅ 或者使用 for...of（性能最优）
const result = [];
for (const item of largeArray) {
  if (!condition1(item)) continue;
  const transformed = transform1(item);
  if (!condition2(transformed)) continue;
  result.push(transform2(transformed));
}

const products = [
  { name: 'Apple', price: 5, category: 'fruit', inStock: true },
  { name: 'Carrot', price: 2, category: 'vegetable', inStock: true },
  { name: 'Banana', price: 3, category: 'fruit', inStock: false },
  { name: 'Broccoli', price: 4, category: 'vegetable', inStock: true },
];

// 链式调用：过滤库存 -> 选择水果 -> 价格调整 -> 提取信息
const result = products
  .filter((p) => p.inStock)
  .filter((p) => p.category === 'fruit')
  .map((p) => ({
    name: p.name,
    price: p.price * 1.1, // 加价 10%
    originalPrice: p.price,
  }))
  .sort((a, b) => a.price - b.price);

console.log(result);
// [{ name: 'Apple', price: 5.5, originalPrice: 5 }]

const orders = [
  { id: 1, product: 'Apple', quantity: 2, price: 5, date: '2024-01-01' },
  { id: 2, product: 'Banana', quantity: 3, price: 3, date: '2024-01-01' },
  { id: 3, product: 'Apple', quantity: 1, price: 5, date: '2024-01-02' },
  { id: 4, product: 'Orange', quantity: 2, price: 4, date: '2024-01-02' },
  { id: 5, product: 'Banana', quantity: 1, price: 3, date: '2024-01-03' },
];

// 按产品分组统计
const summary = orders.reduce((acc, order) => {
  const key = order.product;
  if (!acc[key]) {

  // ... 中间省略 ...

  return acc;
}, {});

// 计算总金额
const total = orders.reduce((acc, order) => acc + order.quantity * order.price, 0);
console.log(`总金额: ¥${total}`); // 总金额: ¥35

const formData = {
  username: 'alice',
  email: 'alice@example.com',
  age: 25,
  password: 'abc123',
  confirmPassword: 'abc123',
};

const validationRules = {
  username: {
    validate: (v) => v.length >= 3,
    message: '用户名至少3个字符',

  // ... 中间省略 ...


// 批量验证结果
const isValid = Object.keys(validationRules).every((field) =>
  validationRules[field].validate(formData[field])
);
console.log(isValid); // true/false

const salesData = [
  { month: 'Jan', sales: 100, cost: 80 },
  { month: 'Feb', sales: 120, cost: 90 },
  { month: 'Mar', sales: 150, cost: 100 },
  { month: 'Apr', sales: 130, cost: 95 },
  { month: 'May', sales: 180, cost: 120 },
];

// 计算利润
const withProfit = salesData.map((item) => ({
  ...item,
  profit: item.sales - item.cost,

  // ... 中间省略 ...

// 找出最佳月份
const bestMonth = salesData.reduce((best, current) =>
  current.sales > best.sales ? current : best
);

console.log(`最佳月份: ${bestMonth.month}, 销售额: ${bestMonth.sales}`);

// forEach - 执行操作
[1, 2, 3].forEach((n) => console.log(n)); // 打印，返回 undefined

// map - 转换数据
const doubled = [1, 2, 3].map((n) => n * 2); // 返回 [2, 4, 6]

// 可以省略（但不推荐）
[1, 2, 3].reduce((a, b) => a + b); // 6

// 必须提供初始值
[].reduce((a, b) => a + b, 0); // 0（空数组必须提供）
[1, 2, 3].reduce((a, b) => a.concat(b), []); // 初始值类型不同

// 方案1：使用 some/every 的短路特性
const found = arr.some((item) => {
  if (item === target) {
    // 处理逻辑
    return true; // 中断
  }
});

// 方案2：使用 for...of
for (const item of arr) {
  if (item === target) break; // 可以中断
}

// 方案3：抛出异常（不推荐）
try {
  arr.forEach((item) => {
    if (item === target) throw new Error('found');
  });
} catch (e) {
  if (e.message !== 'found') throw e;
}

// filter - 遍历全部
const result = arr.filter(item => item.id === 1)[0];

// find - 找到即停（更快）
const result = arr.find(item => item.id === 1);

// 简单值去重
const unique = [...new Set([1, 2, 2, 3])]; // [1, 2, 3]

// 对象数组去重（基于 JSON）
const arr = [{ id: 1 }, { id: 1 }, { id: 2 }];
const unique = arr.filter(
  (item, index) => arr.findIndex((i) => JSON.stringify(i) === JSON.stringify(item)) === index
);

// 对象数组去重（基于属性）
const uniqueById = arr.filter(
  (item, index, self) => self.findIndex((i) => i.id === item.id) === index
);

// 使用 reduce
const unique = arr.reduce((acc, cur) => {
  const exists = acc.some((item) => item.id === cur.id);
  return exists ? acc : [...acc, cur];
}, []);

[].every((x) => x > 100); // true
[].every((x) => x < 0);   // true
// 逻辑：不存在不满足条件的元素，因此"所有元素都满足"

// 性能测试（100万元素）
// map: ~55ms
// forEach: ~50ms
// 差异约 10%，可忽略

// find polyfill
if (!Array.prototype.find) {
  Array.prototype.find = function (callback, thisArg) {
    for (let i = 0; i < this.length; i++) {
      if (callback.call(thisArg, this[i], i, this)) {
        return this[i];
      }
    }
    return undefined;
  };
}

// flat polyfill
if (!Array.prototype.flat) {
  Array.prototype.flat = function (depth = 1) {
    return this.reduce((acc, cur) => {
      if (Array.isArray(cur) && depth > 0) {
        acc.push(...cur.flat(depth - 1));
      } else {
        acc.push(cur);
      }
      return acc;
    }, []);
  };
}

// ✅ 根据目的选择方法
const data = [1, 2, 3, 4, 5];

// 只需遍历
data.forEach((n) => console.log(n));

// 需要转换后的数组
const doubled = data.map((n) => n * 2);

// 需要筛选
const evens = data.filter((n) => n % 2 === 0);

// 需要聚合结果
const sum = data.reduce((acc, n) => acc + n, 0);

// 需要查找
const found = data.find((n) => n > 3);

// 需要判断
const hasEven = data.some((n) => n % 2 === 0);
const allPositive = data.every((n) => n > 0);

// ❌ 在迭代中修改数组长度
arr.forEach((item, index) => {
  if (condition) arr.splice(index, 1); // 危险！
});

// ✅ 使用 filter
const filtered = arr.filter((item) => !condition);

// ❌ map 不返回值
arr.map((item) => console.log(item));

// ✅ 使用 forEach
arr.forEach((item) => console.log(item));

// ❌ reduce 不提供初始值
arr.reduce((acc, cur) => acc + cur); // 空数组报错

// ✅ 始终提供初始值
arr.reduce((acc, cur) => acc + cur, 0);

// ❌ 创建多个中间数组
const result = arr
  .filter(condition1)
  .map(transform1)
  .filter(condition2)
  .map(transform2);

// ✅ 合并操作
const result = arr
  .filter((item) => condition1(item) && condition2(transform1(item)))
  .map((item) => transform2(transform1(item)));

// ✅ 或使用 reduce（大数据量）
const result = arr.reduce((acc, item) => {
  if (!condition1(item)) return acc;
  const transformed = transform1(item);
  if (!condition2(transformed)) return acc;
  acc.push(transform2(transformed));
  return acc;
}, []);

// Iterator Helpers 链式操作
function* naturals() {
  let i = 0
  while (true) yield i++
}

const result = naturals()
  .take(5)          // 取前 5 个: [0, 1, 2, 3, 4]
  .filter(x => x % 2 === 0)  // 过滤偶数: [0, 2, 4]
  .map(x => x * x)  // 平方: [0, 4, 16]

console.log([...result]) // [0, 4, 16]

  // ... 中间省略 ...

const pairs = [1, 2, 3].values().flatMap(x => [x, x * 2])
console.log([...pairs]) // [1, 2, 2, 4, 3, 6]

// drop() - 跳过前 N 个
const dropped = naturals().drop(3).take(3)
console.log([...dropped]) // [3, 4, 5]