深浅拷贝与数组方法

// 值类型：互不影响
let a = 1;
let b = a;
b = 2;
console.log(a); // 1

// 引用类型：共享同一块内存
let obj1 = { name: 'Alice' };
let obj2 = obj1;
obj2.name = 'Bob';
console.log(obj1.name); // 'Bob' —— obj1 也被改了

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

copy.a = 99;
console.log(original.a); // 1 —— 值类型，互不影响

copy.b.c = 99;
console.log(original.b.c); // 99 —— 嵌套对象还是同一个引用

const original = { a: 1, b: { c: 2 } };
const copy = { ...original };

const arr = [1, [2, 3], { x: 4 }];

const copy1 = [...arr];
const copy2 = Array.from(arr);
const copy3 = arr.slice();
const copy4 = arr.concat();

const original = { a: 1, b: { c: 2 }, d: [3, 4] };
const copy = JSON.parse(JSON.stringify(original));

copy.b.c = 99;
console.log(original.b.c); // 2 —— 完全独立

const problematic = {
  fn: function() {},       // 函数 → 丢失
  undef: undefined,        // undefined → 丢失
  sym: Symbol('id'),       // Symbol → 丢失
  date: new Date(),        // Date → 变成字符串
  regex: /abc/g,           // RegExp → 变成空对象 {}
  map: new Map(),          // Map → 变成空对象 {}
  set: new Set(),          // Set → 变成空对象 {}
  nan: NaN,                // NaN → 变成 null
  infinity: Infinity,      // Infinity → 变成 null
};

const copy = JSON.parse(JSON.stringify(problematic));
// 函数、undefined、Symbol 直接消失
// Date 变成 "2026-05-13T..." 字符串
// RegExp、Map、Set 变成 {}

const obj = { a: 1 };
obj.self = obj;
JSON.parse(JSON.stringify(obj)); // TypeError: Converting circular structure to JSON

const original = {
  date: new Date(),
  regex: /abc/g,
  map: new Map([['key', 'value']]),
  set: new Set([1, 2, 3]),
  nested: { deep: { value: 42 } },
};

const copy = structuredClone(original);
copy.nested.deep.value = 0;
console.log(original.nested.deep.value); // 42

const obj = { a: 1 };
obj.self = obj;
const copy = structuredClone(obj); // 正常工作，不会报错
console.log(copy.self === copy); // true —— 循环引用关系被保留

function deepClone(source, cache = new WeakMap()) {
  // 值类型和 null 直接返回
  if (source === null || typeof source !== 'object') {
    return source;
  }

  // 命中缓存，说明存在循环引用，直接返回之前的拷贝
  if (cache.has(source)) {
    return cache.get(source);
  }

  // 处理特殊内置类型
  if (source instanceof Date) return new Date(source);
  if (source instanceof RegExp) return new RegExp(source.source, source.flags);
  if (source instanceof Map) {
    const mapCopy = new Map();
    cache.set(source, mapCopy);
    source.forEach((value, key) => {
      mapCopy.set(deepClone(key, cache), deepClone(value, cache));
    });
    return mapCopy;
  }
  if (source instanceof Set) {
    const setCopy = new Set();
    cache.set(source, setCopy);
    source.forEach((value) => {
      setCopy.add(deepClone(value, cache));
    });
    return setCopy;
  }

  // 创建新对象或数组，保留原型链
  const target = Array.isArray(source) ? [] : Object.create(Object.getPrototypeOf(source));

  // 先存入缓存，再递归（防止循环引用时无限递归）
  cache.set(source, target);

  // 拷贝所有自有属性（包括 Symbol 键）
  const keys = [...Object.keys(source), ...Object.getOwnPropertySymbols(source)];
  for (const key of keys) {
    target[key] = deepClone(source[key], cache);
  }

  return target;
}

const obj = {
  name: 'test',
  nested: { value: 42 },
  arr: [1, 2, [3]],
  date: new Date(),
  regex: /abc/gi,
  map: new Map([['a', 1]]),
};
obj.self = obj; // 循环引用

const cloned = deepClone(obj);
console.log(cloned.self === cloned);         // true
console.log(cloned.nested === obj.nested);   // false
console.log(cloned.date.getTime() === obj.date.getTime()); // true

const numbers = [1, 2, 3, 4];
const doubled = numbers.map(num => num * 2);
// [2, 4, 6, 8]

const users = [
  { name: 'Alice', age: 25 },
  { name: 'Bob', age: 30 },
];

const names = users.map(user => user.name);
// ['Alice', 'Bob']

[1, 2, 3].map(num => {
  if (num > 1) return num * 2;
  // num === 1 时没有 return，结果是 undefined
});
// [undefined, 4, 6]

const numbers = [1, 2, 3, 4, 5, 6];
const evenNumbers = numbers.filter(num => num % 2 === 0);
// [2, 4, 6]

const users = [
  { name: 'Alice', active: true, age: 25 },
  { name: 'Bob', active: false, age: 30 },
  { name: 'Charlie', active: true, age: 35 },
];

// 先筛选活跃用户，再提取名字
const activeNames = users
  .filter(user => user.active)
  .map(user => user.name);
// ['Alice', 'Charlie']

const numbers = [1, 2, 3, 4];
const sum = numbers.reduce((acc, num) => acc + num, 0);
// 10

const people = [
  { name: 'Alice', department: 'Engineering' },
  { name: 'Bob', department: 'Marketing' },
  { name: 'Charlie', department: 'Engineering' },
  { name: 'Diana', department: 'Marketing' },
];

const grouped = people.reduce((groups, person) => {
  const dept = person.department;
  if (!groups[dept]) {
    groups[dept] = [];
  }
  groups[dept].push(person);
  return groups;
}, {});

// {
//   Engineering: [{ name: 'Alice', ... }, { name: 'Charlie', ... }],
//   Marketing: [{ name: 'Bob', ... }, { name: 'Diana', ... }]
// }

const pipe = (...fns) => (initialValue) =>
  fns.reduce((acc, fn) => fn(acc), initialValue);

const add10 = x => x + 10;
const multiply2 = x => x * 2;
const toString = x => `Result: ${x}`;

const transform = pipe(add10, multiply2, toString);
console.log(transform(5)); // "Result: 30"

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

const unique = numbers.reduce((acc, num) => {
  if (!acc.includes(num)) {
    acc.push(num);
  }
  return acc;
}, []);
// [1, 2, 3, 4]

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
];

const bob = users.find(user => user.name === 'Bob');
// { id: 2, name: 'Bob' }

const hasAdmin = users.some(user => user.role === 'admin');

const allActive = users.every(user => user.active);

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

nested.flat();    // [1, 2, 3, 4, [5, 6]]
nested.flat(2);   // [1, 2, 3, 4, 5, 6]
nested.flat(Infinity); // [1, 2, 3, 4, 5, 6] —— 无论多深都拍平

const sentences = ['Hello World', 'Goodbye Moon'];

const words = sentences.flatMap(sentence => sentence.split(' '));
// ['Hello', 'World', 'Goodbye', 'Moon']

// 等价于：
// sentences.map(s => s.split(' ')).flat()
// [['Hello', 'World'], ['Goodbye', 'Moon']].flat()

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

// 只保留偶数并翻倍
const result = numbers.flatMap(num =>
  num % 2 === 0 ? [num * 2] : []
);
// [4, 8, 12]

const unique = [...new Set([1, 2, 2, 3, 3, 4])];
// [1, 2, 3, 4]

const unique = arr.filter((item, index) => arr.indexOf(item) === index);

const unique = arr.reduce((acc, item) => {
  return acc.includes(item) ? acc : [...acc, item];
}, []);

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 1, name: 'Alice (duplicate)' },
];

// 方式一：Map
const uniqueUsers = [...new Map(users.map(user => [user.id, user])).values()];

// 方式二：reduce
const uniqueUsers2 = users.reduce((acc, user) => {
  if (!acc.some(existing => existing.id === user.id)) {
    acc.push(user);
  }
  return acc;
}, []);

[10, 9, 2, 1, 100].sort();
// [1, 10, 100, 2, 9] —— 不是你想要的

// 升序
[10, 9, 2, 1, 100].sort((a, b) => a - b);
// [1, 2, 9, 10, 100]

// 降序
[10, 9, 2, 1, 100].sort((a, b) => b - a);

const sorted = [...original].sort((a, b) => a - b);

const sorted = original.toSorted((a, b) => a - b);

const results = await Promise.all(
  urls.map(async (url) => {
    const response = await fetch(url);
    return response.json();
  })
);