ES6+ 新特性详解：从 ES2015 到 ES2024

// 块级作用域示例
{
  var a = 1;  // 函数/全局作用域
  let b = 2;  // 块级作用域
  const c = 3; // 块级作用域，不可重新赋值
}
console.log(a); // 1
// console.log(b); // ReferenceError: b is not defined
// console.log(c); // ReferenceError: c is not defined

// 暂时性死区（Temporal Dead Zone, TDZ）
console.log(typeof x); // undefined（var 提升）
// console.log(typeof y); // ReferenceError（TDZ）
let y = 10;

// const 必须初始化，且不能重新赋值
const PI = 3.14159;
// PI = 3; // TypeError: Assignment to constant variable

// 但 const 对象属性可变
const obj = { name: 'Alice' };
obj.name = 'Bob'; // 允许
// obj = {}; // 错误

// let 在循环中产生正确闭包
for (let i = 0; i < 5; i++) {
  setTimeout(() => console.log(i), 0); // 0, 1, 2, 3, 4
}

// var 在循环中产生错误闭包
for (var j = 0; j < 5; j++) {
  setTimeout(() => console.log(j), 0); // 5, 5, 5, 5, 5
}

// 无参数
const f1 = () => 'hello';

// 单个参数（可省略括号）
const f2 = x => x * 2;

// 多个参数
const f3 = (a, b) => a + b;

// 多行函数体需用花括号 + return
const f4 = (a, b) => {
  const sum = a + b;
  return sum * 2;
};

// 返回对象字面量需加括号
const f5 = () => ({ id: 1, name: 'test' });

function Timer() {
  this.seconds = 0;

  // 传统函数：this 指向调用者（setTimeout 的全局对象）
  setInterval(function() {
    this.seconds++; // 错误：this 指向 window/global
  }, 1000);

  // 箭头函数：this 继承自 Timer 实例
  setInterval(() => {
    this.seconds++; // 正确
  }, 1000);
}

// 不适用于对象方法
const obj = {
  name: 'Alice',
  greet: () => `Hello, ${this.name}`, // this 指向外部，不是 obj
  greetOk() {
    return `Hello, ${this.name}`; // 正确
  }
};

// 没有 arguments
const sum = () => {
  // console.log(arguments); // ReferenceError
};

// 不能作为构造函数
// const p = new (() => {}); // TypeError

const name = 'World';
const greeting = `Hello, ${name}!`; // Hello, World!

// 多行字符串
const multiLine = `
  <div>
    <p>Hello</p>
  </div>
`;

// 表达式插值
const a = 5, b = 10;
console.log(`${a} + ${b} = ${a + b}`); // 5 + 10 = 15

// 三元表达式
const score = 85;
const grade = `成绩: ${score >= 60 ? '及格' : '不及格'}`;

// 函数调用
const formatPrice = p => `¥${p.toFixed(2)}`;
console.log(formatPrice(19.9)); // ¥19.90

function highlight(strings, ...values) {
  return strings.reduce((result, str, i) => {
    const value = values[i] ? `<strong>${values[i]}</strong>` : '';
    return result + str + value;
  }, '');
}

const user = 'Alice';
const action = 'login';
const result = highlight`用户 ${user} 执行了 ${action} 操作`;
console.log(result); // 用户 <strong>Alice</strong> 执行了 <strong>login</strong> 操作

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

// 基本解构
const [first, second] = arr;
console.log(first, second); // 1 2

// 跳过元素
const [a, , c] = arr;
console.log(a, c); // 1 3

// 剩余模式
const [head, ...tail] = arr;
console.log(head, tail); // 1 [2, 3, 4, 5]

// 默认值
const [x = 0, y = 0, z = 0] = [1, 2];
console.log(x, y, z); // 1 2 0

// 交换变量
let p = 1, q = 2;
[p, q] = [q, p];
console.log(p, q); // 2 1

// 数组展开
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const merged = [...arr1, ...arr2]; // [1, 2, 3, 4, 5, 6]

// 复制数组（浅拷贝）
const copy = [...arr1];

// 字符串展开
const chars = [...'hello']; // ['h', 'e', 'l', 'l', 'o']

// 对象展开（ES2018）
const obj1 = { a: 1, b: 2 };
const obj2 = { c: 3, ...obj1 }; // { c: 3, a: 1, b: 2 }

// 合并对象（后面的覆盖前面的）
const mergedObj = { ...obj1, ...obj2 };

// 函数调用展开
const nums = [1, 2, 3, 4, 5];
console.log(Math.max(...nums)); // 5

function sum(...numbers) {
  return numbers.reduce((total, n) => total + n, 0);
}
console.log(sum(1, 2, 3, 4)); // 10

// 剩余参数必须放在最后
function format(template, ...args) {
  return template.replace(/%s/g, () => args.shift());
}
console.log(format('Hello %s, you are %s', 'Alice', 30));
// Hello Alice, you are 30

// 与解构结合
function processConfig({ debug, ...options }) {
  console.log(debug, options);
}
processConfig({ debug: true, port: 3000, host: 'localhost' });
// true { port: 3000, host: 'localhost' }

const target = { a: 1 };
const source1 = { b: 2 };
const source2 = { c: 3, a: 4 };

Object.assign(target, source1, source2);
console.log(target); // { a: 4, b: 2, c: 3 }

// 常见用途：克隆对象（浅拷贝）
const clone = Object.assign({}, target);

// 合并默认配置
const DEFAULTS = { method: 'GET', timeout: 3000 };
const config = Object.assign({}, DEFAULTS, { method: 'POST' });

const name = 'Alice';
const age = 30;

// 属性简写
const person = { name, age }; // 等同于 { name: name, age: age }

// 方法简写
const calculator = {
  add(a, b) { return a + b; },  // 等同于 add: function(a, b) { ... }
  subtract(a, b) { return a - b; }
};

// 计算属性名
const key = 'dynamicKey';
const obj = {
  [key]: 'value',
  [`${key}2`]: 'value2'
};
console.log(obj); // { dynamicKey: 'value', dynamicKey2: 'value2' }

const s1 = Symbol();
const s2 = Symbol();
console.log(s1 === s2); // false

const s3 = Symbol('description');
const s4 = Symbol('description');
console.log(s3 === s4); // false（描述相同，值不同）
console.log(s3.toString()); // Symbol(description)
console.log(s3.description); // 'description'（ES2019）

// 作为对象属性键
const secret = Symbol('secret');
const user = {
  name: 'Alice',
  [secret]: 'hidden_value'
};
console.log(user[secret]); // hidden_value
console.log(Object.keys(user)); // ['name'] — Symbol 键不会被枚举
console.log(JSON.stringify(user)); // {"name":"Alice"}
console.log(Object.getOwnPropertySymbols(user)); // [Symbol(secret)]

const s1 = Symbol.for('app.key');
const s2 = Symbol.for('app.key');
console.log(s1 === s2); // true

const s3 = Symbol('app.key');
console.log(s1 === s3); // false

// Symbol.keyFor() 返回全局注册表中的键名
console.log(Symbol.keyFor(s1)); // 'app.key'
console.log(Symbol.keyFor(s3)); // undefined（非全局注册表）

// WeakMap 的键必须是对象
const wm = new WeakMap();

let obj = { id: 1 };
wm.set(obj, 'some metadata');
console.log(wm.get(obj)); // 'some metadata'

obj = null; // 对象被回收，WeakMap 自动移除该条目

// 没有 size 属性，没有 forEach，不可遍历
// console.log(wm.size); // undefined

const privateData = new WeakMap();

class User {
  constructor(name, password) {
    privateData.set(this, { password });
    this.name = name;
  }

  checkPassword(pwd) {
    return privateData.get(this).password === pwd;
  }
}

const user = new User('Alice', 'secret123');
console.log(user.checkPassword('secret123')); // true
console.log(user.password); // undefined（私密）

// 假设在浏览器环境中
const elementData = new WeakMap();

function attachData(element, data) {
  elementData.set(element, data);
}

function getData(element) {
  return elementData.get(element);
}

// 当 DOM 元素被移除时，关联数据自动被垃圾回收

const visited = new WeakSet();

class Tracker {
  track(obj) {
    visited.add(obj);
  }
  hasVisited(obj) {
    return visited.has(obj);
  }
}

// 手动实现一个迭代器
function createIterator(array) {
  let index = 0;
  return {
    next() {
      if (index < array.length) {
        return { value: array[index++], done: false };
      } else {
        return { value: undefined, done: true };
      }
    }
  };
}

const iterator = createIterator(['a', 'b', 'c']);
console.log(iterator.next()); // { value: 'a', done: false }
console.log(iterator.next()); // { value: 'b', done: false }
console.log(iterator.next()); // { value: 'c', done: false }
console.log(iterator.next()); // { value: undefined, done: true }

// 基本用法
function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

const gen = numberGenerator();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: false }
console.log(gen.next()); // { value: undefined, done: true }

// 可用 for...of 消费
for (const n of numberGenerator()) {
  console.log(n); // 1, 2, 3
}

// yield 表达式可以接收 next() 传入的值
function* interactiveGen() {
  const a = yield '请输入第一个数';
  const b = yield '请输入第二个数';
  yield `结果是: ${a + b}`;
}

const gi = interactiveGen();
console.log(gi.next());       // { value: '请输入第一个数', done: false }
console.log(gi.next(10));     // { value: '请输入第二个数', done: false }
console.log(gi.next(20));     // { value: '结果是: 30', done: false }
console.log(gi.next());       // { value: undefined, done: true }

function* gen1() {
  yield 1;
  yield 2;
}

function* gen2() {
  yield 0;
  yield* gen1(); // 委托给 gen1
  yield* [3, 4]; // 委托给数组
  yield 5;
}

console.log([...gen2()]); // [0, 1, 2, 3, 4, 5]

// 递归生成器
function* flatten(arr) {
  for (const item of arr) {
    if (Array.isArray(item)) {
      yield* flatten(item); // 递归
    } else {
      yield item;
    }
  }
}

const nested = [1, [2, [3, 4], 5], 6];
console.log([...flatten(nested)]); // [1, 2, 3, 4, 5, 6]

function createValidator(target, schema) {
  return new Proxy(target, {
    set(obj, prop, value) {
      const rule = schema[prop];
      if (rule) {
        if (rule.type && typeof value !== rule.type) {
          throw new TypeError(`${prop} must be ${rule.type}`);
        }
        if (rule.min !== undefined && value < rule.min) {
          throw new RangeError(`${prop} must be >= ${rule.min}`);
        }
        if (rule.max !== undefined && value > rule.max) {
          throw new RangeError(`${prop} must be <= ${rule.max}`);
        }
      }
      return Reflect.set(obj, prop, value);
    }
  });
}

const userSchema = { age: { type: 'number', min: 0, max: 150 } };
const user = createValidator({}, userSchema);
user.age = 25; // 正常
// user.age = -1; // RangeError
// user.age = 'old'; // TypeError

function createLogger(target) {
  return new Proxy(target, {
    get(obj, prop) {
      const value = Reflect.get(obj, prop);
      if (typeof value === 'function') {
        return function(...args) {
          console.log(`[LOG] ${String(prop)} called with:`, args);
          const result = value.apply(this, args);
          console.log(`[LOG] ${String(prop)} returned:`, result);
          return result;
        };
      }
      return value;
    }
  });
}

const math = createLogger(Math);
// math.max(1, 2, 3); // 会有日志输出

function createPrivateObject(obj, privateKeys = []) {
  return new Proxy(obj, {
    get(target, prop) {
      if (privateKeys.includes(prop)) {
        return undefined;
      }
      return Reflect.get(target, prop);
    },
    set(target, prop, value) {
      if (privateKeys.includes(prop)) {
        throw new Error(`Cannot set private property: ${String(prop)}`);
      }
      return Reflect.set(target, prop, value);
    },
    has(target, prop) {
      if (privateKeys.includes(prop)) return false;
      return Reflect.has(target, prop);
    },
    ownKeys(target) {
      return Reflect.ownKeys(target).filter(k => !privateKeys.includes(k));
    }
  });
}

const arr = [1, 2, NaN, 4];

console.log(arr.includes(2));    // true
console.log(arr.includes(5));    // false
console.log(arr.includes(NaN));  // true（indexOf 不能）

// indexOf 的局限
console.log(arr.indexOf(NaN));   // -1（错误）

console.log(2 ** 3);      // 8
console.log(2 ** 10);     // 1024
console.log(2 ** -1);     // 0.5
console.log(2 ** (1/2));  // 1.414...（平方根）

// 注意优先级
console.log(2 ** 3 ** 2); // 512（右结合，相当于 2 ** (3 ** 2)）

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

// ES5
console.log(Object.keys(obj)); // ['a', 'b', 'c']

// ES2017
console.log(Object.values(obj));   // [1, 2, 3]
console.log(Object.entries(obj));  // [['a', 1], ['b', 2], ['c', 3]]

// 实用组合
const entries = Object.entries(obj)
  .filter(([_, v]) => v > 1)
  .map(([k, v]) => ({ [k]: v * 2 }));
console.log(entries); // [{ b: 4 }, { c: 6 }]

// padStart
console.log('5'.padStart(3, '0'));       // '005'
console.log('12345'.padStart(3, '0'));   // '12345'（长度不足不截断）
console.log('abc'.padStart(8, '123'));   // '12312abc'

// padEnd
console.log('5'.padEnd(3, '0'));         // '500'
console.log('hello'.padEnd(8, '!'));     // 'hello!!!'

// 实用：格式化时间
const hour = String(3).padStart(2, '0');
const min = String(5).padStart(2, '0');
console.log(`${hour}:${min}`); // '03:05'

function showLoading(show) { /* ... */ }

function fetchUsers() {
  showLoading(true);
  return fetch('/api/users')
    .then(res => res.json())
    .catch(err => console.error(err))
    .finally(() => showLoading(false)); // 无论成功失败，关闭加载状态
}

// 适合：loading 状态、释放资源、关闭连接

// 对象展开（前面已介绍）
const obj1 = { a: 1, b: 2 };
const obj2 = { ...obj1, c: 3 }; // { a: 1, b: 2, c: 3 }

// 对象剩余模式
const { a, ...rest } = obj2;
console.log(a);    // 1
console.log(rest); // { b: 2, c: 3 }

// 合并与覆写
const defaults = { method: 'GET', headers: {}, timeout: 5000 };
const override = { method: 'POST', headers: { 'Content-Type': 'application/json' } };
const config = { ...defaults, ...override };
// { method: 'POST', headers: { 'Content-Type': 'application/json' }, timeout: 5000 }

console.log(/hello.world/.test('hello\nworld')); // false
console.log(/hello.world/s.test('hello\nworld')); // true

// 命名捕获组
const regex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = regex.exec('2024-09-01');
console.log(match.groups);
// { year: '2024', month: '09', day: '01' }

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

// 默认展平一层
console.log(nested.flat()); // [1, 2, [3, [4]]]

// 指定展平层数
console.log(nested.flat(2));  // [1, 2, 3, [4]]
console.log(nested.flat(Infinity)); // [1, 2, 3, 4]

// flatMap = map + flat(1)
const arr = ['hello world', 'foo bar'];
console.log(arr.flatMap(s => s.split(' ')));
// ['hello', 'world', 'foo', 'bar']

// 比 map + flat 更高效

const entries = [['a', 1], ['b', 2], ['c', 3]];
const obj = Object.fromEntries(entries);
console.log(obj); // { a: 1, b: 2, c: 3 }

// 从 Map 转对象
const map = new Map([['x', 10], ['y', 20]]);
const fromMap = Object.fromEntries(map);
console.log(fromMap); // { x: 10, y: 20 }

// 实用：过滤对象
const data = { a: 1, b: 2, c: 3, d: 4 };
const filtered = Object.fromEntries(
  Object.entries(data).filter(([_, v]) => v > 2)
);
console.log(filtered); // { c: 3, d: 4 }

// ES2019 之前
try {
  JSON.parse('invalid json');
} catch (err) {
  console.error('解析失败');
}

// ES2019+ 可以省略括号和参数
try {
  JSON.parse('invalid json');
} catch {
  console.error('解析失败'); // 不关心具体错误对象
}

// 适合：错误信息已由上层处理、不需要错误详情

const str = '   hello world   ';
console.log(str.trimStart()); // 'hello world   '
console.log(str.trimEnd());   // '   hello world'
console.log(str.trim());      // 'hello world'

// 别名：trimLeft / trimRight
console.log(str.trimLeft());  // 'hello world   '

// || 的缺陷：会处理所有 falsy 值（0, '', false）
const count = 0;
console.log(count || 10);  // 10（非预期）
console.log(count ?? 10);  // 0（正确）

const name = '';
console.log(name || 'default'); // 'default'
console.log(name ?? 'default'); // ''

// ?? 只处理 null 和 undefined
const a = null;
const b = undefined;
const c = 0;
const d = false;

console.log(a ?? 'fallback'); // 'fallback'
console.log(b ?? 'fallback'); // 'fallback'
console.log(c ?? 'fallback'); // 0
console.log(d ?? 'fallback'); // false

// 与可选链结合
const config = {};
const port = config.server?.port ?? 3000;
console.log(port); // 3000

// 不能与 && 或 || 直接混合（需加括号）
// console.log(null || undefined ?? 'fallback'); // SyntaxError
console.log((null || undefined) ?? 'fallback'); // 'fallback'

const promises = [
  Promise.resolve(1),
  Promise.reject('error'),
  Promise.resolve(3)
];

Promise.allSettled(promises).then(results => {
  console.log(results);
  // [
  //   { status: 'fulfilled', value: 1 },
  //   { status: 'rejected', reason: 'error' },
  //   { status: 'fulfilled', value: 3 }
  // ]
});

// 对比 Promise.all：任意一个失败就整体失败
// Promise.all 适合「全要或全不要」
// Promise.allSettled 适合「各算各的」

const str = '2024-01-15, 2024-03-20, 2024-07-01';
const regex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;

// ES2020
const matches = str.matchAll(regex);
for (const match of matches) {
  console.log(match[0], match.groups);
  // '2024-01-15' { year: '2024', month: '01', day: '15' }
  // '2024-03-20' { year: '2024', month: '03', day: '20' }
  // '2024-07-01' { year: '2024', month: '07', day: '01' }
}

// 转为数组
const allMatches = [...str.matchAll(regex)];
console.log(allMatches.length); // 3

// 浏览器中：window
// Node.js 中：global
// Web Worker 中：self

// ES2020 之前各环境不同
// 兼容写法：
const glob = typeof window !== 'undefined' ? window :
            typeof global !== 'undefined' ? global : self;

// ES2020
console.log(globalThis);

// 直接使用
globalThis.setTimeout(() => console.log('hello'), 100);

const str = '2024-09-01';

// replace 只替换第一个（除非用全局正则）
console.log(str.replace('-', '/'));    // '2024/09-01'

// ES2021
console.log(str.replaceAll('-', '/')); // '2024/09/01'

// replaceAll 支持字符串或正则（必须带 g 标志）
console.log(str.replaceAll(/-/g, '.')); // '2024.09.01'

// 错误：不带 g 标志的正则
// str.replaceAll(/-/, '.'); // TypeError

const promises = [
  Promise.reject('Error 1'),
  new Promise(resolve => setTimeout(() => resolve('慢速成功'), 500)),
  Promise.reject('Error 2')
];

Promise.any(promises)
  .then(result => console.log(result)) // '慢速成功'（500ms 后）
  .catch(err => console.log(err));

// 全部失败
Promise.any([
  Promise.reject('A'),
  Promise.reject('B')
]).catch(err => {
  console.log(err instanceof AggregateError); // true
  console.log(err.errors); // ['A', 'B']
});

// Promise 组合对比
// Promise.all      — 全部成功 || 快速失败
// Promise.allSettled — 全部完成（无论成败）
// Promise.race     — 第一个完成（无论成败）
// Promise.any      — 第一个成功 || 全部失败

const billion = 1_000_000_000;
console.log(billion); // 1000000000

const price = 99_99;           // 9999
const hex = 0xFF_FF_FF;        // 16777215
const binary = 0b1010_1010;    // 170
const sci = 1_000_000_000_000; // 万亿

// 注意：不能放在开头、结尾或小数点两侧
// const invalid = _100; // SyntaxError
// const invalid2 = 100_; // SyntaxError

let a = 0;
let b = 1;
let c = null;

// 逻辑与赋值（a 为 truthy 时才赋值）
a &&= 10;  // a 是 0（falsy），不赋值 → a 仍然是 0
b &&= 20;  // b 是 1（truthy），赋值 → b 变为 20

// 逻辑或赋值（a 为 falsy 时才赋值）
a ||= 100; // a 是 0（falsy），赋值 → a 变为 100

// 空值合并赋值（a 为 null/undefined 时才赋值）
c ??= 200; // c 是 null，赋值 → c 变为 200

// 等价于
// a || (a = 100);
// b && (b = 20);
// c ?? (c = 200);

// 典型应用：设置默认值
let options = { timeout: 3000 };
options.timeout ??= 5000; // 已存在，不覆盖

let config = {};
config.port ??= 8080;      // 不存在，赋默认值

const arr = [10, 20, 30, 40, 50];

// 正索引
console.log(arr.at(0));  // 10
console.log(arr.at(2));  // 30

// 负索引（从末尾开始）
console.log(arr.at(-1)); // 50
console.log(arr.at(-2)); // 40

// 对比传统方式
console.log(arr[arr.length - 1]); // 50（不够优雅）
console.log(arr.slice(-1)[0]);    // 50（性能较差）

// 同样适用于 TypedArray 和 String
console.log('hello'.at(-1)); // 'o'

// fetch-config.js
// ES2022 之前：必须包在 async 函数中
// async function loadConfig() {
//   const res = await fetch('/config.json');
//   return res.json();
// }

// ES2022：模块顶层直接 await
const response = await fetch('/config.json');
const config = await response.json();

export default config;

// 依赖配置的模块
// import config from './fetch-config.js';
// console.log(config.apiUrl);

// 注意：顶级 await 只在 ES 模块中有效（type="module" 或 .mjs）
// 会阻塞模块加载，但有条件地阻塞（依赖该模块的模块才会等待）

const obj = Object.create(null); // 无原型的对象
obj.name = 'Alice';

// hasOwnProperty 可能被覆盖或不存在
// console.log(obj.hasOwnProperty('name')); // TypeError（无原型）

// ES2022
console.log(Object.hasOwn(obj, 'name')); // true
console.log(Object.hasOwn(obj, 'toString')); // false

// 对比传统方式
const regularObj = { a: 1 };
console.log(Object.hasOwn(regularObj, 'a')); // true
console.log(Object.prototype.hasOwnProperty.call(regularObj, 'a')); // true

// 创建带有原因的错误
try {
  try {
    throw new Error('数据库连接失败');
  } catch (dbError) {
    throw new Error('获取用户数据失败', { cause: dbError });
  }
} catch (err) {
  console.log(err.message);   // '获取用户数据失败'
  console.log(err.cause);     // Error: 数据库连接失败
  console.log(err.cause.message); // '数据库连接失败'
}

// 实际应用：多层错误传递
async function fetchUserData(userId) {
  try {
    const response = await fetch(`/api/users/${userId}`);
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`, { cause: response });
    }
    return await response.json();
  } catch (err) {
    throw new Error(`获取用户 ${userId} 数据失败`, { cause: err });
  }
}

class Database {
  static connection;
  static config;

  // 静态代码块 — 在类初始化时执行
  static {
    try {
      // 复杂的静态初始化逻辑
      this.config = {
        host: process.env.DB_HOST || 'localhost',
        port: parseInt(process.env.DB_PORT) || 5432
      };
      this.connection = { connected: true, ...this.config };
    } catch (err) {
      console.error('数据库初始化失败', err);
      this.connection = null;
    }
  }

  static getConnection() {
    return this.connection;
  }
}

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

// 查找最后一个大于 2 的元素
const lastLarge = arr.findLast(x => x > 2);
console.log(lastLarge); // 3（最后一个大于2的）

// 查找最后一个满足条件的索引
const lastLargeIndex = arr.findLastIndex(x => x > 2);
console.log(lastLargeIndex); // 5（最后一个大于2的索引）

// 对比 find（从头找）
const firstLarge = arr.find(x => x > 2);
console.log(firstLarge); // 3（第一个大于2的）

// 实际应用：获取数组中最后一个偶数
const lastEven = arr.findLast(x => x % 2 === 0);
console.log(lastEven); // 2

#!/usr/bin/env node
// 上面的 hashbang 会被 JavaScript 引擎自动忽略
// 使得 .js 文件可以直接作为 shell 脚本执行

console.log('Hello from executable JS file!');

// 之前需要手动处理
// #!/usr/bin/env node
// 在某些环境中需要依赖工具忽略 hashbang

const items = [
  { name: 'apple', category: 'fruit' },
  { name: 'carrot', category: 'vegetable' },
  { name: 'banana', category: 'fruit' },
  { name: 'broccoli', category: 'vegetable' },
];

// Object.groupBy — 返回普通对象
const grouped = Object.groupBy(items, item => item.category);
console.log(grouped);
// {
//   fruit: [{ name: 'apple', category: 'fruit' }, { name: 'banana', category: 'fruit' }],
//   vegetable: [{ name: 'carrot', category: 'vegetable' }, { name: 'broccoli', category: 'vegetable' }]
// }

// Map.groupBy — 返回 Map（适合非字符串键）
const numbers = [1, 2, 3, 4, 5, 6];
const parityGroups = Map.groupBy(numbers, n => n % 2 === 0 ? 'even' : 'odd');
console.log(parityGroups.get('even')); // [2, 4, 6]
console.log(parityGroups.get('odd'));  // [1, 3, 5]

// 按属性长度分组
const words = ['hello', 'world', 'hi', 'js', 'typescript'];
const byLength = Object.groupBy(words, w => w.length);
console.log(byLength);
// { '2': ['hi', 'js'], '5': ['hello', 'world'], '10': ['typescript'] }

// ES2024 之前
function createDeferred() {
  let resolve, reject;
  const promise = new Promise((res, rej) => {
    resolve = res;
    reject = rej;
  });
  return { promise, resolve, reject };
}

// ES2024
const { promise, resolve, reject } = Promise.withResolvers();

// 可以在任意地方 resolve/reject
setTimeout(() => resolve('完成'), 1000);

const result = await promise;
console.log(result); // '完成'

// 实际应用：事件转 Promise
function waitForEvent(element, eventName) {
  const { promise, resolve } = Promise.withResolvers();
  element.addEventListener(eventName, resolve, { once: true });
  return promise;
}

// v 标志启用 Unicode 属性增强
const regex = /\p{Emoji}/v;
console.log(regex.test('😀')); // true
console.log(regex.test('a'));  // false

// 集合操作：差集、交集、并集
// 匹配 ASCII 字母但不包括元音
const consonant = /[\p{ASCII}--[aeiou]]/v;
console.log(consonant.test('b')); // true
console.log(consonant.test('a')); // false

// 交集
const hexDigit = /[\p{ASCII}&&\p{Hex_Digit}]/v;
console.log(hexDigit.test('A')); // true
console.log(hexDigit.test('Z')); // false（Z 不是十六进制字符）

// 注意：v 标志需要现代化引擎支持