// let：块级作用域变量
{
  let name = 'JavaScript';
  console.log(name); // 'JavaScript'
}
// console.log(name); // ReferenceError: name is not defined

// const：常量声明
const API_URL = 'https://api.example.com';
// API_URL = 'new-url'; // TypeError: Assignment to constant variable

// 对象/数组常量仍可修改内容
const user = { name: 'Alice' };
user.name = 'Bob'; // ✅ 允许
// user = {}; // ❌ 不允许

// 传统函数
function add(a, b) {
  return a + b;
}

// 箭头函数
const add = (a, b) => a + b;

// 单参数可省略括号
const double = x => x * 2;

// 多行函数体
const createUser = (name, age) => {
  return {
    name,
    age,
    createdAt: new Date()
  };
};

// this 绑定特性
const obj = {
  name: 'Object',
  traditional: function() {
    setTimeout(function() {
      console.log(this.name); // undefined (this 指向全局)
    }, 100);
  },
  arrow: function() {
    setTimeout(() => {
      console.log(this.name); // 'Object' (继承外层 this)
    }, 100);
  }
};

const name = 'World';
const age = 25;

// 基本插值
const message = `Hello, ${name}! You are ${age} years old.`;

// 多行字符串
const html = `
  <div class="user">
    <h2>${name}</h2>
    <p>Age: ${age}</p>
  </div>
`;

// 表达式计算
const price = 100;
const tax = 0.08;
const total = `Total: $${(price * (1 + tax)).toFixed(2)}`;

// 数组解构
const [first, second, third] = [1, 2, 3];
const [, , , fourth] = [1, 2, 3, 4]; // 跳过前三个

// 对象解构
const user = { name: 'Alice', age: 30, city: 'New York' };
const { name, age } = user;

// 重命名
const { name: userName, age: userAge } = user;

// 默认值
const { name, country = 'Unknown' } = user;

// 嵌套解构
const data = {
  user: {
    profile: {
      name: 'Bob',
      email: '[email protected]'
    }
  }
};
const { user: { profile: { name, email } } } = data;

// 函数参数解构
function createUser({ name, age, city = 'Unknown' }) {
  return { name, age, city };
}
const user1 = createUser({ name: 'Alice', age: 25 });

// 默认参数
function greet(name = 'Guest', message = 'Hello') {
  return `${message}, ${name}!`;
}

// 扩展运算符 - 数组
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4, 5, 6]

// 扩展运算符 - 对象
const user = { name: 'Alice', age: 30 };
const userWithRole = { ...user, role: 'admin' };

// 剩余参数
function sum(...numbers) {
  return numbers.reduce((total, num) => total + num, 0);
}
sum(1, 2, 3, 4, 5); // 15

// 函数调用中的扩展运算符
const numbers = [1, 2, 3];
console.log(Math.max(...numbers)); // 3

// 基本类定义
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  // 实例方法
  greet() {
    return `Hello, I'm ${this.name}`;
  }

  // 静态方法
  static createAdult(name) {
    return new Person(name, 18);
  }
}

// 继承
class Employee extends Person {
  constructor(name, age, position) {
    super(name, age); // 调用父类构造函数
    this.position = position;
  }

  // 重写方法
  greet() {
    return `${super.greet()} and I'm a ${this.position}`;
  }

  work() {
    return `${this.name} is working as a ${this.position}`;
  }
}

const employee = new Employee('Alice', 28, 'Developer');
console.log(employee.greet()); // "Hello, I'm Alice and I'm a Developer"

// math.js - 导出
export const PI = 3.14159;

export function add(a, b) {
  return a + b;
}

export class Calculator {
  multiply(a, b) {
    return a * b;
  }
}

// 默认导出
export default function subtract(a, b) {
  return a - b;
}

// main.js - 导入
import subtract from './math.js'; // 默认导入
import { PI, add, Calculator } from './math.js'; // 命名导入
import * as MathUtils from './math.js'; // 导入所有

// 使用
console.log(PI);
console.log(add(2, 3));
const calc = new Calculator();
console.log(calc.multiply(4, 5));
console.log(subtract(10, 3));

// 创建 Promise
const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    const success = true;
    if (success) {
      resolve('Operation successful!');
    } else {
      reject('Operation failed!');
    }
  }, 1000);
});

// 使用 Promise
promise
  .then(result => console.log(result))
  .catch(error => console.error(error))
  .finally(() => console.log('Operation completed'));

// Promise 链
function fetchData() {
  return fetch('/api/data')
    .then(response => response.json())
    .then(data => {
      console.log('Data:', data);
      return processData(data);
    })
    .then(processedData => {
      console.log('Processed:', processedData);
    })
    .catch(error => {
      console.error('Error:', error);
    });
}

// Promise.all - 并行执行
const promise1 = fetch('/api/users');
const promise2 = fetch('/api/posts');
Promise.all([promise1, promise2])
  .then(([users, posts]) => {
    console.log('Users:', users);
    console.log('Posts:', posts);
  });

// Promise.race - 竞争执行
Promise.race([
  fetch('/api/fast'),
  fetch('/api/slow')
]).then(response => {
  console.log('First response:', response);
});

// Map - 键值对集合
const map = new Map();
map.set('name', 'Alice');
map.set(42, 'The answer');
map.set({}, 'Object key');

const user = { id: 1 };
map.set(user, 'User object');

// 获取值
console.log(map.get('name')); // 'Alice'
console.log(map.get(42)); // 'The answer'

// 检查键是否存在
console.log(map.has('name')); // true

// 删除键
map.delete('name');

// 遍历 Map
for (const [key, value] of map) {
  console.log(`${key}: ${value}`);
}

// Set - 唯一值集合
const set = new Set([1, 2, 3, 3, 4, 4, 5]);
console.log(set); // Set {1, 2, 3, 4, 5}

// 添加值
set.add(6);
set.add(1); // 重复值不会被添加

// 检查值是否存在
console.log(set.has(3)); // true

// 删除值
set.delete(3);

// 遍历 Set
for (const value of set) {
  console.log(value);
}

// 实际应用：数组去重
const numbers = [1, 2, 2, 3, 4, 4, 5];
const uniqueNumbers = [...new Set(numbers)]; // [1, 2, 3, 4, 5]

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

// 检查元素是否存在
console.log(numbers.includes(3)); // true
console.log(numbers.includes(6)); // false

// 支持起始位置
console.log(numbers.includes(3, 2)); // true (从索引2开始查找)
console.log(numbers.includes(1, 1)); // false (从索引1开始查找)

// 与 indexOf 的对比
// indexOf 返回位置，includes 返回布尔值
console.log(numbers.indexOf(3) !== -1); // true (旧方式)
console.log(numbers.includes(3)); // true (新方式，更直观)

// 特殊值处理
console.log([NaN].includes(NaN)); // true
console.log([NaN].indexOf(NaN) !== -1); // false (indexOf 无法正确处理 NaN)

// 基本用法
console.log(2 ** 3); // 8 (2的3次方)
console.log(10 ** 2); // 100

// 与 Math.pow() 的对比
console.log(2 ** 3); // 8
console.log(Math.pow(2, 3)); // 8 (旧方式)

// 负指数
console.log(2 ** -2); // 0.25

// 组合运算
const base = 2;
const exponent = 3;
const result = base ** exponent; // 8

// 在表达式中的使用
const area = radius => Math.PI * radius ** 2;
console.log(area(5)); // 78.53981633974483

// 右结合性
console.log(2 ** 3 ** 2); // 512 (等同于 2 ** (3 ** 2))

// 基本语法
async function fetchData() {
  try {
    const response = await fetch('/api/data');
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

// 使用 async 函数
async function main() {
  try {
    const data = await fetchData();
    console.log('Data:', data);
  } catch (error) {
    console.error('Failed to fetch data:', error);
  }
}

// 箭头函数形式
const fetchUserData = async (userId) => {
  const response = await fetch(`/api/users/${userId}`);
  return response.json();
};

// 并行执行多个异步操作
async function fetchMultipleData() {
  const [users, posts, comments] = await Promise.all([
    fetch('/api/users').then(r => r.json()),
    fetch('/api/posts').then(r => r.json()),
    fetch('/api/comments').then(r => r.json())
  ]);
  
  return { users, posts, comments };
}

// 顺序执行异步操作
async function processItems(items) {
  const results = [];
  for (const item of items) {
    const result = await processItem(item);
    results.push(result);
  }
  return results;
}

// async 函数返回 Promise
async function getValue() {
  return 42;
}
const promise = getValue(); // 返回 Promise
promise.then(value => console.log(value)); // 42

const user = {
  name: 'Alice',
  age: 30,
  city: 'New York',
  email: '[email protected]'
};

// Object.values() - 获取所有值
const values = Object.values(user);
console.log(values); // ['Alice', 30, 'New York', '[email protected]']

// Object.entries() - 获取键值对数组
const entries = Object.entries(user);
console.log(entries);
// [
//   ['name', 'Alice'],
//   ['age', 30],
//   ['city', 'New York'],
//   ['email', '[email protected]']
// ]

// 实际应用：对象转换
const transformed = Object.entries(user).map(([key, value]) => ({
  key,
  value,
  type: typeof value
}));
console.log(transformed);

// 对象过滤
const filteredEntries = Object.entries(user)
  .filter(([key, value]) => typeof value === 'string')
  .reduce((obj, [key, value]) => {
    obj[key] = value;
    return obj;
  }, {});
console.log(filteredEntries); // { name: 'Alice', city: 'New York', email: '[email protected]' }

// 与 Map 的转换
const userMap = new Map(Object.entries(user));
console.log(userMap.get('name')); // 'Alice'

// padStart() - 在字符串开头填充
const str = '5';
console.log(str.padStart(3, '0')); // '005'

const name = 'Alice';
console.log(name.padStart(10, '*')); // '*****Alice'

// padEnd() - 在字符串末尾填充
console.log(str.padEnd(3, '0')); // '500'
console.log(name.padEnd(10, '*')); // 'Alice*****'

// 实际应用：数字格式化
function formatNumber(num, length = 2) {
  return String(num).padStart(length, '0');
}
console.log(formatNumber(5));   // '05'
console.log(formatNumber(12));  // '12'
console.log(formatNumber(123)); // '123' (超过长度不截断)

// 表格对齐
const users = [
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 25 },
  { name: 'Charlie', age: 35 }
];

users.forEach(user => {
  const namePadded = user.name.padEnd(10, ' ');
  const agePadded = String(user.age).padStart(3, ' ');
  console.log(`${namePadded} | ${agePadded}`);
});
// Alice      |  30
// Bob        |  25
// Charlie    |  35

// 对象扩展
const user = { name: 'Alice', age: 30 };
const additionalInfo = { city: 'New York', country: 'USA' };

const completeUser = { ...user, ...additionalInfo };
console.log(completeUser);
// { name: 'Alice', age: 30, city: 'New York', country: 'USA' }

// 属性覆盖
const updatedUser = { ...user, age: 31 };
console.log(updatedUser); // { name: 'Alice', age: 31 }

// 浅拷贝
const userCopy = { ...user };
console.log(userCopy === user); // false (不同对象)

// 嵌套对象注意事项
const original = {
  user: { name: 'Alice', age: 30 },
  settings: { theme: 'dark' }
};

const copy = { ...original };
copy.user.name = 'Bob';
console.log(original.user.name); // 'Bob' (嵌套对象仍然是引用)

// 深拷贝需要其他方法
const deepCopy = JSON.parse(JSON.stringify(original));

// 在函数中使用
function updateUser(updates) {
  const defaultUser = { name: 'Guest', age: 0, active: true };
  return { ...defaultUser, ...updates };
}

const newUser = updateUser({ name: 'Alice', age: 25 });
console.log(newUser); // { name: 'Alice', age: 25, active: true }

// 异步迭代器
async function* asyncGenerator() {
  yield await Promise.resolve(1);
  yield await Promise.resolve(2);
  yield await Promise.resolve(3);
}

// 使用 for-await-of
async function processAsyncData() {
  for await (const value of asyncGenerator()) {
    console.log(value); // 1, 2, 3
  }
}

// 异步可迭代对象
const asyncIterable = {
  async *[Symbol.asyncIterator]() {
    let i = 1;
    while (i <= 3) {
      yield new Promise(resolve => {
        setTimeout(() => resolve(i * 2), 1000);
      });
      i++;
    }
  }
};

async function processAsyncIterable() {
  for await (const value of asyncIterable) {
    console.log(value); // 2, 4, 6 (每秒输出一个)
  }
}

// 实际应用：分页数据获取
async function* fetchPages(url) {
  let page = 1;
  let hasMore = true;
  
  while (hasMore) {
    const response = await fetch(`${url}?page=${page}`);
    const data = await response.json();
    
    yield data.items;
    
    hasMore = data.hasMore;
    page++;
  }
}

async function getAllItems(url) {
  const allItems = [];
  
  for await (const items of fetchPages(url)) {
    allItems.push(...items);
  }
  
  return allItems;
}

// 基本用法
fetch('/api/data')
  .then(response => response.json())
  .then(data => console.log('Success:', data))
  .catch(error => console.error('Error:', error))
  .finally(() => console.log('Request completed'));

// 实际应用：加载状态管理
function showLoading() {
  console.log('Loading...');
}

function hideLoading() {
  console.log('Loading complete');
}

async function fetchDataWithLoading() {
  showLoading();
  
  try {
    const response = await fetch('/api/data');
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Fetch failed:', error);
    throw error;
  } finally {
    hideLoading(); // 无论成功失败都会执行
  }
}

// 资源清理
function withResource(resource, callback) {
  return resource
    .then(callback)
    .catch(error => {
      console.error('Error:', error);
      throw error;
    })
    .finally(() => {
      // 清理资源
      resource.close && resource.close();
    });
}

// flat() - 数组扁平化
const nestedArray = [1, [2, 3], [4, [5, 6]]];
console.log(nestedArray.flat()); // [1, 2, 3, [4, [5, 6]]]

// 指定扁平化深度
console.log(nestedArray.flat(2)); // [1, 2, 3, 4, 5, 6]

// 完全扁平化
const deeplyNested = [1, [2, [3, [4, [5]]]]];
console.log(deeplyNested.flat(Infinity)); // [1, 2, 3, 4, 5]

// flatMap() - 映射并扁平化
const sentences = [
  'Hello world',
  'How are you',
  'Fine thank you'
];

const words = sentences.flatMap(sentence => sentence.split(' '));
console.log(words);
// ['Hello', 'world', 'How', 'are', 'you', 'Fine', 'thank', 'you']

// 与 map + flat 的对比
const result1 = sentences.map(s => s.split(' ')).flat();
const result2 = sentences.flatMap(s => s.split(' '));
console.log(result1.length === result2.length); // true

// 实际应用：数据转换
const data = [
  { id: 1, tags: ['javascript', 'nodejs'] },
  { id: 2, tags: ['react', 'javascript'] },
  { id: 3, tags: ['vue', 'nodejs'] }
];

const allTags = data.flatMap(item => item.tags);
const uniqueTags = [...new Set(allTags)];
console.log(uniqueTags); // ['javascript', 'nodejs', 'react', 'vue']

// 复杂数据处理
const orders = [
  { id: 1, items: [{ name: 'Book', price: 20 }, { name: 'Pen', price: 5 }] },
  { id: 2, items: [{ name: 'Laptop', price: 1000 }] }
];

const allItems = orders.flatMap(order => 
  order.items.map(item => ({ ...item, orderId: order.id }))
);
console.log(allItems);
// [
//   { name: 'Book', price: 20, orderId: 1 },
//   { name: 'Pen', price: 5, orderId: 1 },
//   { name: 'Laptop', price: 1000, orderId: 2 }
// ]

// 基本用法：将键值对数组转换为对象
const entries = [
  ['name', 'Alice'],
  ['age', 30],
  ['city', 'New York']
];

const obj = Object.fromEntries(entries);
console.log(obj); // { name: 'Alice', age: 30, city: 'New York' }

// 与 Object.entries() 的配合使用
const original = { name: 'Bob', age: 25, city: 'London' };
const transformed = Object.fromEntries(
  Object.entries(original).map(([key, value]) => [
    key.toUpperCase(),
    typeof value === 'string' ? value.toUpperCase() : value
  ])
);
console.log(transformed);
// { NAME: 'BOB', AGE: 25, CITY: 'LONDON' }

// 实际应用：查询参数处理
const queryString = 'name=Alice&age=30&city=New+York';
const params = new URLSearchParams(queryString);
const paramsObj = Object.fromEntries(params);
console.log(paramsObj); // { name: 'Alice', age: '30', city: 'New York' }

// 对象过滤
const user = {
  name: 'Alice',
  age: 30,
  password: 'secret123',
  email: '[email protected]',
  token: 'abc123'
};

const publicUser = Object.fromEntries(
  Object.entries(user).filter(([key]) => 
    !['password', 'token'].includes(key)
  )
);
console.log(publicUser);
// { name: 'Alice', age: 30, email: '[email protected]' }

// Map 转换为对象
const map = new Map([
  ['name', 'Charlie'],
  ['age', 35]
]);
const mapObj = Object.fromEntries(map);
console.log(mapObj); // { name: 'Charlie', age: 35 }

const message = '   Hello, World!   ';

// trimStart() - 去除开头空白
console.log(message.trimStart()); // 'Hello, World!   '

// trimEnd() - 去除末尾空白
console.log(message.trimEnd()); // '   Hello, World!'

// trim() - 去除两端空白
console.log(message.trim()); // 'Hello, World!'

// 别名方法
console.log(message.trimLeft() === message.trimStart()); // true
console.log(message.trimRight() === message.trimEnd()); // true

// 实际应用：用户输入处理
function cleanInput(input) {
  return input.trimStart().trimEnd();
}

const userInput = '   [email protected]   ';
const cleanEmail = cleanInput(userInput);
console.log(cleanEmail); // '[email protected]'

// 代码格式化
function formatCode(code) {
  return code
    .split('\n')
    .map(line => line.trimStart())
    .join('\n');
}

const messyCode = `
  function test() {
    console.log('Hello');
  }
`;

console.log(formatCode(messyCode));
// function test() {
// console.log('Hello');
// }

// 传统方式：必须指定错误参数
try {
  JSON.parse('invalid json');
} catch (error) {
  console.log('Something went wrong');
}

// ES10：可以省略错误参数
try {
  JSON.parse('invalid json');
} catch {
  console.log('Something went wrong');
}

// 实际应用：错误处理简化
function safeParse(jsonString) {
  try {
    return JSON.parse(jsonString);
  } catch {
    return null;
  }
}

console.log(safeParse('{"name": "Alice"}')); // { name: 'Alice' }
console.log(safeParse('invalid json')); // null

// 多个 try-catch 块
async function processFiles(files) {
  const results = [];
  
  for (const file of files) {
    try {
      const content = await readFile(file);
      const parsed = JSON.parse(content);
      results.push(parsed);
    } catch {
      // 忽略错误，继续处理下一个文件
      console.log(`Failed to process ${file}`);
    }
  }
  
  return results;
}

const user = {
  name: 'Alice',
  address: {
    street: '123 Main St',
    city: 'New York'
  }
};

// 传统方式：多层检查
const city = user && user.address && user.address.city;
console.log(city); // 'New York'

// 可选链：简洁安全
const city2 = user?.address?.city;
console.log(city2); // 'New York'

// 处理不存在的属性
const country = user?.address?.country;
console.log(country); // undefined

// 数组可选链
const users = [
  { name: 'Alice', posts: [{ title: 'Post 1' }] },
  { name: 'Bob' }
];

const firstPostTitle = users[0]?.posts?.[0]?.title;
console.log(firstPostTitle); // 'Post 1'

const secondPostTitle = users[1]?.posts?.[0]?.title;
console.log(secondPostTitle); // undefined

// 函数调用可选链
const userWithMethod = {
  name: 'Alice',
  greet: function() {
    return 'Hello!';
  }
};

const greeting = userWithMethod.greet?.();
console.log(greeting); // 'Hello!'

const noGreeting = userWithMethod.sayGoodbye?.();
console.log(noGreeting); // undefined

// 实际应用：API 响应处理
function getUserCity(user) {
  return user?.profile?.address?.city ?? 'Unknown';
}

console.log(getUserCity({ profile: { address: { city: 'Beijing' } } })); // 'Beijing'
console.log(getUserCity({ profile: {} })); // 'Unknown'
console.log(getUserCity(null)); // 'Unknown'

// 基本用法：仅在 null 或 undefined 时使用默认值
const name = null ?? 'Guest';
console.log(name); // 'Guest'

const age = undefined ?? 18;
console.log(age); // 18

const active = false ?? true;
console.log(active); // false (false 不是 null 或 undefined)

const count = 0 ?? 10;
console.log(count); // 0 (0 不是 null 或 undefined)

// 与 || 操作符的对比
const value1 = 0 || 10;     // 10 (0 是 falsy)
const value2 = 0 ?? 10;     // 0 (0 不是 null/undefined)
const value3 = '' || 'default'; // 'default' (空字符串是 falsy)
const value4 = '' ?? 'default'; // '' (空字符串不是 null/undefined)

// 实际应用：配置默认值
const config = {
  timeout: null,
  retries: undefined,
  enabled: false,
  port: 0
};

const finalConfig = {
  timeout: config.timeout ?? 5000,    // 5000
  retries: config.retries ?? 3,      // 3
  enabled: config.enabled ?? true,   // false (保持原值)
  port: config.port ?? 3000          // 0 (保持原值)
};

// 函数参数默认值
function createUser(options = {}) {
  return {
    name: options.name ?? 'Guest',
    age: options.age ?? 0,
    email: options.email ?? null,
    active: options.active ?? true
  };
}

const user1 = createUser({ name: 'Alice', age: 0, active: false });
console.log(user1);
// { name: 'Alice', age: 0, email: null, active: false }

// 嵌套使用
const data = {
  user: {
    profile: null
  }
};

const bio = data.user?.profile?.bio ?? 'No bio available';
console.log(bio); // 'No bio available'

// 基本动态导入
async function loadModule() {
  const module = await import('./math.js');
  console.log(module.add(2, 3)); // 5
}

// 条件导入
async function loadFeature(featureName) {
  if (featureName === 'charts') {
    const charts = await import('./charts.js');
    charts.init();
  } else if (featureName === 'maps') {
    const maps = await import('./maps.js');
    maps.init();
  }
}

// 基于用户交互的懒加载
document.getElementById('loadCharts').addEventListener('click', async () => {
  const charts = await import('./charts.js');
  charts.renderChart();
});

// 路由级别的代码分割
const routes = {
  home: () => import('./pages/home.js'),
  about: () => import('./pages/about.js'),
  contact: () => import('./pages/contact.js')
};

async function loadPage(pageName) {
  try {
    const pageModule = await routes[pageName]();
    pageModule.default.render();
  } catch (error) {
    console.error(`Failed to load ${pageName}:`, error);
  }
}

// 动态导入多个模块
async function loadUtils() {
  const [dateUtils, stringUtils, mathUtils] = await Promise.all([
    import('./utils/date.js'),
    import('./utils/string.js'),
    import('./utils/math.js')
  ]);
  
  return { dateUtils, stringUtils, mathUtils };
}

// 创建 BigInt
const bigInt1 = 123n; // 字面量方式
const bigInt2 = BigInt(123); // 构造函数方式
const bigInt3 = BigInt('123456789012345678901234567890');

// 基本运算
const a = 123n;
const b = 456n;

console.log(a + b); // 579n
console.log(a * b); // 56088n
console.log(a / b); // 0n (整数除法)
console.log(a % b); // 123n

// 与普通数字的比较
console.log(123n === 123); // false (类型不同)
console.log(123n == 123);  // true (值相等)

// 大数计算
const hugeNumber = BigInt('9007199254740991'); // 超过 Number.MAX_SAFE_INTEGER
const result = hugeNumber * 2n;
console.log(result); // 18014398509481982n

// 实际应用：精确计算
function preciseCalculation(a, b) {
  return BigInt(a) * BigInt(b);
}

const result1 = preciseCalculation('12345678901234567890', '98765432109876543210');
console.log(result1.toString()); // '1219326311370217952237463801111263526900'

// JSON 序列化支持（需要自定义）
const data = { bigNumber: 123n };
const json = JSON.stringify(data, (key, value) =>
  typeof value === 'bigint' ? value.toString() + 'n' : value
);
console.log(json); // '{"bigNumber":"123n"}'

// 基本用法
const promises = [
  Promise.resolve(1),
  Promise.reject('Error 1'),
  Promise.resolve(3),
  Promise.reject('Error 2')
];

Promise.allSettled(promises).then(results => {
  results.forEach((result, index) => {
    if (result.status === 'fulfilled') {
      console.log(`Promise ${index}: ${result.value}`);
    } else {
      console.log(`Promise ${index}: ${result.reason}`);
    }
  });
});

// 与 Promise.all 的对比
async function comparePromiseMethods() {
  const promises = [
    Promise.resolve('Success 1'),
    Promise.reject('Error'),
    Promise.resolve('Success 2')
  ];

  try {
    // Promise.all - 任一失败则整体失败
    const allResults = await Promise.all(promises);
    console.log('All succeeded:', allResults);
  } catch (error) {
    console.log('Promise.all failed:', error);
  }

  // Promise.allSettled - 等待所有完成
  const settledResults = await Promise.allSettled(promises);
  console.log('All settled:', settledResults);
}

// 实际应用：批量操作
async function uploadFiles(files) {
  const uploadPromises = files.map(file => 
    uploadFile(file).catch(error => ({ error, file }))
  );

  const results = await Promise.allSettled(uploadPromises);
  
  const successful = results
    .filter(result => result.status === 'fulfilled')
    .map(result => result.value);
    
  const failed = results
    .filter(result => result.status === 'rejected')
    .map(result => result.reason);

  return { successful, failed };
}

// 数据获取：即使部分失败也返回成功的数据
async function fetchMultipleAPIs() {
  const apis = [
    'https://api.example.com/users',
    'https://api.example.com/posts',
    'https://api.example.com/comments'
  ];

  const results = await Promise.allSettled(
    apis.map(url => fetch(url).then(r => r.json()))
  );

  return results.reduce((acc, result, index) => {
    const apiName = apis[index].split('/').pop();
    acc[apiName] = result.status === 'fulfilled' ? result.value : null;
    return acc;
  }, {});
}

// 逻辑与赋值 (&&=)
let user = { name: 'Alice', age: 30 };
user.age &&= user.age > 18 ? 'adult' : 'minor';
console.log(user.age); // 'adult'

// 等价于
// if (user.age) {
//   user.age = user.age > 18 ? 'adult' : 'minor';
// }

// 逻辑或赋值 (||=)
let settings = { theme: 'dark' };
settings.language ||= 'en';
console.log(settings.language); // 'en'

// 等价于
// settings.language = settings.language || 'en';

// 空值合并赋值 (??=)
let config = { timeout: null };
config.timeout ??= 5000;
console.log(config.timeout); // 5000

// 等价于
// if (config.timeout === null || config.timeout === undefined) {
//   config.timeout = 5000;
// }

// 实际应用：配置更新
function updateConfig(currentConfig, newConfig) {
  // 只更新非空值
  newConfig.theme &&= (currentConfig.theme = newConfig.theme);
  newConfig.language ??= (currentConfig.language = newConfig.language);
  newConfig.timeout ||= (currentConfig.timeout = newConfig.timeout);
  
  return currentConfig;
}

const current = { theme: 'light', language: null, timeout: 0 };
const updates = { theme: 'dark', language: 'zh', timeout: null };

const updated = updateConfig(current, updates);
console.log(updated);
// { theme: 'dark', language: 'zh', timeout: 0 }

// 对象属性的条件更新
const user = { name: 'Alice', email: null, age: 25 };

user.email ??= '[email protected]'; // 设置默认邮箱
user.age &&= user.age >= 18 ? 'adult' : 'minor'; // 根据年龄设置状态

console.log(user);
// { name: 'Alice', email: '[email protected]', age: 'adult' }

// 基本用法：使用下划线分隔数字
const billion = 1_000_000_000;
const million = 1_000_000;
const thousand = 1_000;

console.log(billion); // 1000000000
console.log(million); // 1000000

// 小数部分
const pi = 3.141_592_653;
console.log(pi); // 3.141592653

// 二进制、八进制、十六进制
const binary = 0b1010_1011_1100_1101;
const octal = 0o12_34_56;
const hex = 0xAB_CD_EF;

console.log(binary); // 43981
console.log(octal);  // 34230
console.log(hex);    // 11259375

// 实际应用：提高可读性
const price = 1_299_99; // $1,299.99
const phoneNumber = 138_0013_8000; // 手机号
const macAddress = 0xAA_BB_CC_DD_EE_FF; // MAC地址

// 科学计数法
const largeNumber = 1.234e5_678; // 123400000
console.log(largeNumber);

// 注意事项：不能连续使用分隔符
// const invalid = 123__456; // SyntaxError
// const invalid2 = 123_; // SyntaxError
// const invalid3 = _123; // SyntaxError

// 在计算中的使用
const calculation = (1_000_000 * 2) + (500_000 / 10);
console.log(calculation); // 2050000