// let - 可重新赋值
let count = 0;
count = 1;

// const - 不可重新赋值
const name = '张三';
// name = '李四'; // Error

// 数组解构
const [a, b] = [1, 2];
const [first, ...rest] = [1, 2, 3];

// 对象解构
const { name, age } = { name: '张三', age: 25 };

// 函数参数解构
function greet({ name, age }) {
  console.log(`${name}, ${age}岁`);
}

greet({ name: '李四', age: 30 });

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

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

// 无参数
const greet = () => console.log('Hello');

// 单个参数
const double = x => x * 2;

// 箭头函数没有 this
const obj = {
  name: '张三',
  greet: () => console.log(this.name)
};

const name = '张三';
const age = 25;

const greeting = `你好, ${name}! 今年 ${age} 岁`;

const str = 'Hello World';

// includes
str.includes('World');  // true

// startsWith / endsWith
str.startsWith('Hello');  // true
str.endsWith('World');    // true

// repeat
str.repeat(3);  // "Hello WorldHello WorldHello World"

// padStart / padEnd
str.padStart(10, '0');  // "000Hello World"
str.padEnd(20, '-');    // "Hello World---------"

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

nested.flat();           // [1, 2, [3, [4]]]
nested.flat(2);          // [1, 2, 3, [4]]
nested.flat(Infinity);   // [1, 2, 3, 4]

const arr = [1, 2, 3];
arr.flatMap(x => [x, x * 2]);  // [1, 2, 2, 4, 3, 6]

const arr = [1, 2, 3];

arr.indexOf(2);  // 1
arr.includes(2); // true

Array.from('abc');           // ['a', 'b', 'c']
Array.from({ length: 3 });   // [undefined, undefined, undefined]

Array.of(1, 2, 3);           // [1, 2, 3]

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

// entries
Array.from(arr.entries());  // [[0, 'a'], [1, 'b'], [2, 'c']]

// keys
Array.from(arr.keys());     // [0, 1, 2]

// values
Array.from(arr.values());   // ['a', 'b', 'c']

const name = '张三';
const age = 25;

// 之前
const obj1 = { name: name, age: age };

// 现在
const obj2 = { name, age };

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

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

const obj1 = { name: '张三', age: 25 };
const obj2 = { city: '北京' };

const mergedObj = { ...obj1, ...obj2 };

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

const result = { ...target, ...source };  // { a: 1, b: 2, c: 3 }

const key = 'name';
const value = '张三';

const obj = {
  [key]: value
};

const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('成功');
  }, 1000);
});

promise.then(value => {
  console.log(value);  // "成功"
}).catch(error => {
  console.error(error);
});

const p1 = Promise.resolve(1);
const p2 = Promise.resolve(2);
const p3 = Promise.resolve(3);

Promise.all([p1, p2, p3]).then(values => {
  console.log(values);  // [1, 2, 3]
});

Promise.race([p1, p2, p3]).then(value => {
  console.log(value);
});

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    return `你好, ${this.name}`;
  }
}

const person = new Person('张三', 25);
person.greet();  // "你好, 张三"

class Employee extends Person {
  constructor(name, age, salary) {
    super(name, age);
    this.salary = salary;
  }

  work() {
    return `${this.name} 正在工作，月薪 ${this.salary}`;
  }
}

class MathUtils {
  static add(a, b) {
    return a + b;
  }
}

MathUtils.add(1, 2);  // 3

class Person {
  constructor(name) {
    this._name = name;
  }

  get name() {
    return this._name;
  }

  set name(newName) {
    this._name = newName;
  }
}

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

// 命名导出
export const name = '张三';
export function greet() {
  console.log('Hello');
}

// 默认导入
import add from './math';

// 命名导入
import { name, greet } from './utils';

const arr = [1, 2, 3];

for (const num of arr) {
  console.log(num);
}

// Map
const map = new Map();
map.set('name', '张三');
map.get('name');  // "张三"

// Set
const set = new Set();
set.add(1);
set.add(2);
set.has(1);  // true

const symbol = Symbol('description');

const obj = {
  [symbol]: 'symbol value'
};

const key = {};
const map = new WeakMap();
map.set(key, 'value');

const weakSet = new WeakSet();
weakSet.add(key);

Number.isFinite(1);         // true
Number.isNaN(NaN);         // true
Number.isInteger(1.0);     // true
Number.isInteger(1.2);     // false

Number.EPSILON;            // 2.220446049250313e-16
Number.MAX_SAFE_INTEGER;   // 9007199254740991
Number.MIN_SAFE_INTEGER;   // -9007199254740991

Math.trunc(3.14);           // 3
Math.sign(-5);              // -1
Math.cbrt(8);               // 2