基本语法

// 1. 语句
// 以分号 ; 结束；可多语句一行；空语句合法
var a = 1;
var b = 2; // 示例：多个语句和空语句

// 2. 表达式
// 计算并返回值的式子，可作为语句
1 + 3; // → 4
var x = 1 + 2; // x → 3

// 3. 变量声明（var）
// var 声明；可分离声明与赋值
var a; // 声明
a = 1; // 赋值
// 关键说明：未声明直接使用 → ReferenceError；无 var 赋值 → 创建全局变量（不推荐）

// 4. 变量提升（Hoisting）
// var 声明提升到作用域顶部，赋值不提升
console.log(a); // → undefined
var a = 1;
// 相当于 var a; console.log(a); a=1;

// 5. 重复声明
// var 允许重复声明，后者覆盖
var x = 1;
var x = 2; // x → 2
// 第二次声明无效，但带赋值则覆盖

// 6. 标识符
// 字母/$/_ 开头，后续可加数字；区分大小写；中文合法
var 临时变量 = 1;
var π = 3.14;
// 不可用保留字（如 break、function、let、this 等）

// 7. 注释
// 单行 //；多行 /* */；
// 单行注释
/* 
多行注释 
*/
// 仅行首生效；多行注释不可嵌套

// 8. 块级作用域
// var 不支持块级作用域，变量泄漏至函数/全局
{
    var a = 1;
}
console.log(a); // → 1
// 现代推荐使用 let/const（块级作用域）

// 9. if 语句
// if (条件) 语句; 或带 {}
var x = 3;
if (x === 3) x++; // x → 4
// 条件强制转为布尔；避免 if (x = y)（赋值而非比较）；推荐常量在前 if (3 === x)

// 10. if…else
// 链式 else if；else 与最近 if 配对
var n = 0;
if (n > 0) {
    // 正数
} else if (n < 0) {
    // 负数
} else {
    // 零
}

// 11. switch
// switch (expr) { case 值: … break; default: … }
var value = 1;
switch (value) {
    case 1:
        console.log("one");
        break;
    default:
        console.log("other");
}

// 12. 三元运算符
// 条件 ? expr1 : expr2
var n = 4;
var s = n % 2 === 0 ? "偶" : "奇"; // s → "偶"

// 13. while 循环
// while (条件) 语句;
var i = 0;
while (i < 10) i++; // i → 10

// 14. for 循环
// for (init; cond; update) 语句;
for (var i = 0; i < 5; i++) {
    console.log(i); // 输出 0 到 4
}

// 15. do…while
// 先执行一次，再判断
var i = 0;
do {
    console.log(i);
    i++;
} while (i < 3); // 输出 0 1 2

// 16. break / continue
// break 跳出循环/块；continue 跳过本轮
for (var i = 0; i < 10; i++) {
    if (i === 5) break; // 提前结束循环
    if (i % 2 === 0) continue; // 跳过偶数
    console.log(i);
}
// 只影响最内层循环；标签可实现跳出多层

// 17. 标签 (Label)
// label: 语句；配合 break/continue label
outer: for (var i = 0; i < 3; i++) {
    inner: for (var j = 0; j < 3; j++) {
        if (i === 1 && j === 1) break outer; // 直接跳出外层循环
        console.log(i, j);
    }
}
// 可跳出/继续指定层循环或代码块；常用于嵌套循环

数据类型

// 1. 基本类型（Primitive Types）
// string, number, boolean, null, undefined, symbol, bigint
var str = "hello";
var num = 42;
var bool = true;
// 值类型，存储在栈中；不可变（赋值时创建新值）

// 2. 引用类型（Reference Types）
// object, array, function, date, regexp, map, set 等
var arr = [1, 2, 3];
var obj = { a: 1 };
var fn = function () {};
// 引用类型，存储在堆中；变量保存引用，可变（修改影响原对象）

// 3. typeof 操作符
// 判断类型，返回字符串
typeof "hello"; // → "string"
typeof 42; // → "number"
typeof undefined; // → "undefined"
// null 返回 "object"（历史遗留 bug）；数组、普通对象均返回 "object"

// 4. instanceof 操作符
// 判断原型链关系（是否为某构造函数的实例）
arr instanceof Array; // → true
obj instanceof Object; // → true
// 适用于引用类型；基本类型包装对象可用；跨 iframe/window 时可能失效

// 5. 类型转换
// 隐式转换常见于运算；显式使用 Number(), String(), Boolean()
"5" - 1; // → 4（字符串转为数字）
"5" + 1; // → "51"（数字转为字符串）
!!0; // → false（转为布尔）
// + 操作符优先字符串拼接；严格相等 === 不进行类型转换（推荐）

// 6. NaN
// Not-a-Number，属于 number 类型
typeof NaN; // → "number"
0 / 0; // → NaN
// NaN !== NaN（唯一不自等的值）；判断用 Number.isNaN()（ES6）或全局 isNaN()

// 7. undefined vs null
// undefined：变量声明未赋值或对象属性不存在；null：有意表示空值
var a; // → undefined
var b = null; // → null
// undefined == null 为 true（宽松相等）；=== 为 false；通常用 null 表示“无对象”

// 8. Symbol（ES6 新增）
// 唯一且不可变的原始值，用于创建独一无二的标识符
const sym1 = Symbol("id");
const sym2 = Symbol("id"); // sym1 !== sym2
// 每次调用 Symbol() 返回新值；常用于对象属性键避免命名冲突

// 9. BigInt（ES2020 新增）
// 支持任意精度整数
const big = 9007199254740991n; // 数字后加 n
const bigger = BigInt("9007199254740991");
// 不能与普通 number 直接混合运算（会抛错）；用于超大整数计算

运算符

// 1. 算术运算符
// +, -, *, /, %, ** (幂运算，ES6)
5 + 3; // → 8
5 - 3; // → 2
5 * 3; // → 15
5 / 3; // → 1.666...
5 % 2; // → 1（取模/余数）
2 ** 3; // → 8（幂运算）
// % 对负数结果符号随被除数；** 优先级高于一元运算符

// 2. 自增自减运算符
// ++, --（前置/后置）
let i = 0;
i++; // → 0（后置：返回原值后自增，i 变为 1）
++i; // → 2（前置：先自增后返回，i 变为 2）

// 3. 比较运算符
// ==, ===, !=, !==, >, <, >=, <=
5 == "5"; // → true（宽松相等，进行类型转换）
5 === "5"; // → false（严格相等，无类型转换，推荐使用）
5 != "5"; // → false
5 !== "5"; // → true
// === / !== 避免意外类型转换；链式比较不支持（a < b < c 可能非预期）

// 4. 逻辑运算符
// &&（逻辑与），||（逻辑或），!（逻辑非）
true && false; // → false
true || false; // → true
!true; // → false
// 短路求值（&& 遇假即止，|| 遇真即止）；返回第一个决定性值或最后一个值（非布尔）

// 5. 位运算符
// &, |, ^, ~, <<, >>, >>>
5 & 3; // → 1（按位与）
5 | 3; // → 7（按位或）
5 ^ 3; // → 6（按位异或）
~5; // → -6（按位取反）
5 << 1; // → 10（左移）
5 >> 1; // → 2（有符号右移）
5 >>> 1; // → 2（无符号右移）
// 操作 32 位整数；>>> 对负数填充 0（常用于无符号处理）

// 6. 赋值运算符
// =, +=, -=, *=, /=, %=, **= 等
let x = 5;
x += 3; // → 8（等价于 x = x + 3）
x **= 2; // → 64（等价于 x = x ** 2）
// 支持所有算术及位运算符的复合形式；链式赋值从右到左

// 7. 逗号运算符
// expr1, expr2（从左到右求值，返回最后一个）
let a = (1, 2, 3); // a → 3
for (let i = 0, len = arr.length; i < len; i++) {
    /* ... */
}
// 常用于 for 循环初始化多个变量；整体表达式返回最后值

// 8. 可选链运算符（?.，ES2020）
// 安全访问嵌套属性
let city = user?.address?.city; // 若 user 或 address 为 null/undefined，返回 undefined
// 短路求值，不抛错；可用于方法调用 obj?.method() 和数组 obj?.[index]

// 9. 空值合并运算符（??，ES2020）
// 返回第一个非 null/undefined 值
let x = null ?? "default"; // → "default"
let y = 0 ?? 10; // → 0（0 是有效值）
// 区别于 ||（|| 对所有假值生效）；仅对 null/undefined 短路

// 10. 展开运算符（...，ES6/ES2018）
// 展开数组/对象/可迭代对象
let newArr = [...arr, 4, 5]; // 数组展开
let newObj = { ...obj, a: 1 }; // 对象浅拷贝并覆盖属性
function sum(...nums) {
    return nums.reduce((a, b) => a + b);
}
// 数组用于复制/合并；对象用于浅拷贝；函数参数收集剩余参数

函数

// 1. 函数声明（Function Declaration）
// function name(params) { … }
function add(a, b) {
    return a + b;
}
add(2, 3); // → 5（可在声明前调用）
// 函数声明会被整体提升（hoisting）；可在声明前调用；适合定义全局可用函数

// 2. 函数表达式（Function Expression）
// var name = function(params) { … }
var add = function (a, b) {
    return a + b;
};
add(2, 3); // → 5
// 不会被提升（仅变量名提升）；需在赋值后调用；末尾建议加分号；常用于匿名函数

// 3. 立即执行函数表达式（IIFE）
// (function(){ … })(); 或 !function(){ }(); 等模式
(function () {
    console.log("立即执行");
})();
// 创建独立作用域，避免污染全局；常用于模块化、初始化代码或私有变量封装

// 4. return 语句
// 返回值；无 return 返回 undefined
function f() {
    return 1; // 返回 1
}
function g() {} // 返回 undefined
// 可返回任意类型（包括函数、对象）；return 后代码不执行；用于显式返回值

// 5. arguments 对象
// 函数内部类数组对象，包含所有实参
function f() {
    console.log(arguments[0]); // 第一个参数
    console.log(arguments.length);
}
f(1, 2, 3); // 输出 1 和 3
// 类数组（有 length、可索引），非真数组；箭头函数中无 arguments；严格模式下行为更严格

// 6. 默认参数（ES6）
// param = defaultValue
function greet(name = "World") {
    return `Hello, ${name}!`;
}
greet(); // → "Hello, World!"
greet("Alice"); // → "Hello, Alice!"
// 调用时未传参使用默认值；默认值可为表达式（惰性求值）；位于参数列表任意位置

// 7. 剩余参数（Rest Parameters，ES6）
// ...params 接收剩余参数(接受多个参数用)
function sum(...nums) {
    return nums.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3, 4); // → 10
// 必须为最后一个参数；nums 为真数组；替代 arguments 的现代方式

// 8. 参数解构（Destructuring Parameters，ES6）
// 函数参数直接解构对象/数组
function greet({ name, age = 18 }) {
    return `Name: ${name}, Age: ${age}`;
}
greet({ name: "Alice" }); // → "Name: Alice, Age: 18"
// 简化对象/数组参数提取；支持默认值和嵌套解构；提高代码可读性

// 9. 箭头函数（Arrow Functions，ES6）
// (params) => expr 或 (params) => { … }
const add = (a, b) => a + b;
const multiply = (a, b) => {
    return a * b;
};
// 语法简洁；无自己的 this、arguments、super；不能作为构造函数（无 prototype）

// 10. this 绑定方法
// call(), apply(), bind()
function greet() {
    console.log(`Hello, ${this.name}`);
}
const obj = { name: "Alice" };
greet.call(obj); // → "Hello, Alice"
greet.apply(obj);
const bound = greet.bind(obj);
bound(); // → "Hello, Alice"
// call/apply 立即执行（apply 传数组参数）；bind 返回新函数（硬绑定 this）

// 11. 高阶函数（Higher-Order Functions）
// 函数作为参数或返回值
[1, 2, 3].map((x) => x * 2); // → [2, 4, 6]
function createAdder(n) {
    return (x) => x + n;
}
const add5 = createAdder(5);
add5(10); // → 15
// 常见于数组方法（map、filter、reduce）；支持函数式编程范式

// 12. 递归（Recursion）
// 函数调用自身
function fact(n) {
    if (n <= 1) return 1;
    return n * fact(n - 1);
}
fact(5); // → 120
// 必须有终止条件（基线案例）；避免无限递归导致栈溢出；尾递归优化（部分引擎支持）

数组

// 1. length（属性，非方法）
[1, 2, 3].length; // → 3
// 设置长度可截断或扩展（扩展部分填充 undefined）
let arr = [1, 2, 3];
arr.length = 2; // → [1,2]

// 2. push(...items) → 修改原数组，返回新长度 *
[1, 2, 3].push(4); // → 4（新长度），数组变为 [1,2,3,4]

// 3. unshift(...items) → 修改原数组，返回新长度 *
[1, 2, 3].unshift(0); // → 4（新长度），数组变为 [0,1,2,3]

// 4. pop() → 修改原数组，返回被删除的元素 *
[1, 2, 3].pop(); // → 3，数组变为 [1,2]

// 5. shift() → 修改原数组，返回被删除的元素 *
[1, 2, 3].shift(); // → 1，数组变为 [2,3]

// 6. at(index) → 安全访问索引（支持负数）
[1, 2, 3].at(2); // → 3
[1, 2, 3].at(-1); // → 3（从末尾算起）

// 7. indexOf(searchElement, fromIndex?)
[1, 2, 3].indexOf(3); // → 2
[1, 2, 3, 2].indexOf(2, 2); // → 3（从索引2开始查找）

// 8. includes(searchElement, fromIndex?)
[1, 2, 3].includes(3); // → true
[1, 2, NaN].includes(NaN); // → true（正确处理 NaN）

// 9. map(callback) → 返回新数组
[1, 2, 3].map((num) => Math.pow(num, 2)); // → [1,4,9]

// 10. filter(callback) → 返回新数组
[1, 2, 3].filter((num) => num % 2); // → [1,3]（奇数）

// 11. every(callback) → 全部满足返回 true
[1, 2, 3].every((num) => num > 1); // → false

// 12. some(callback) → 至少一个满足返回 true
[1, 2, 3].some((num) => num === 3); // → true

// 13. fill(value, start?, end?) → 修改原数组 *
[1, 2, 3].fill(10); // → [10,10,10]
[1, 2, 3, 4].fill(0, 1, 3); // → [1,0,0,4]

// 14. reduce(callback, initialValue?) → 归约成单个值
[1, 2, 3].reduce((acc, num) => acc + num, 0); // → 6

// 15. concat(...values) → 返回新数组（拼接）
[1, 2, 3].concat([4, 5]); // → [1,2,3,4,5]

// 16. reverse() → 修改原数组，反转 *
[1, 2, 3].reverse(); // → [3,2,1]

// 17. sort(compareFn?) → 修改原数组 *
[2, 1, 3].sort(); // → [1,2,3]（默认字符串排序）
[10, 2, 5].sort((a, b) => a - b); // → [2,5,10]（数值排序）

// 18. join(separator?) → 连接成字符串
[1, 2, 3].join("-"); // → "1-2-3"

// 19. flat(depth?) → 扁平化（默认 depth=1）
[1, 2, [3]].flat(); // → [1,2,3]
[1, [2, [3]]].flat(2); // → [1,2,3]
[1, [2, [3]]].flat(Infinity); // → [1,2,3]（完全展平）

// 20. find(callback) → 返回第一个满足条件的元素（或 undefined）
[1, 2, 3].find((num, i) => i === 1); // → 2

// 21. findIndex(callback) → 返回第一个满足条件的索引（或 -1）
[1, 2, 3].findIndex((num) => num === 2); // → 1

// 22. toString() → 转换为字符串
[1, 2, 3].toString(); // → "1,2,3"

// 23. slice(start?, end?) → 浅拷贝 + 截取，返回新数组
[1, 2, 3].slice(1, 3); // → [2,3]
[1, 2, 3].slice(-2); // → [2,3]

// 24. splice(start, deleteCount?, ...items) → 修改原数组，返回被删除元素数组 *
[1, 2, 3, 4].splice(1, 2); // → [2,3]，数组变为 [1,4]
[1, 4].splice(1, 0, 2, 3); // → []（无删除），数组变为 [1,2,3,4]

// 25. Array.isArray(value)（静态方法）
Array.isArray([1, 2, 3]); // → true
Array.isArray("{1,2,3}"); // → false

// 26. Array.from(arrayLike, mapFn?)（静态方法）
Array.from("123"); // → ['1','2','3']
Array.from([1, 2, 3], (x) => x * 2); // → [2,4,6]

// 27. forEach(callback) → 遍历，无返回值
[1, 2, 3].forEach((num) => console.log(num)); // 输出 1 2 3（逐行）

// 28. flatMap(callback) → 先 map 后 flat(1)
[1, 2, 3].flatMap((x) => [x, x * 2]); // → [1,2, 2,4, 3,6]

• 带 * 的方法会修改原数组
• 未带 * 的方法通常返回新值，原数组保持不变

字符串

// 1. 创建字符串
// 单引号、双引号、模板字符串（反引号）
let str1 = "hello";
let str2 = "hello";
let name = "World";
let str3 = `Hello ${name}!`; // → "Hello World!"
// 三种方式等价；模板字符串支持 ${} 表达式插值和多行文本（保留换行）

// 2. 字符串长度
// str.length（只读属性）
"hello".length; // → 5
"😊".length; // → 2（UTF-16 码元计数）
// 返回 UTF-16 码元数量；代理对（如 emoji）计为 2；不可修改

// 3. 访问字符
// str[index] 或 str.charAt(index)
let str = "hello";
str[0]; // → "h"
str.charAt(0); // → "h"
str[10]; // → undefined
str.charAt(10); // → ""
// [] 越界返回 undefined；charAt 越界返回空字符串；字符串不可变

// 4. concat()
// 连接字符串
"hello".concat(" ", "world"); // → "hello world"
// 返回新字符串；现代更推荐 + 操作符或模板字符串

// 5. slice()
// 提取子串
"hello world".slice(1, 4); // → "ell"
"hello world".slice(-5); // → "world"
// 参数 start, end（不包含 end）；支持负数（从末尾算）；返回新字符串

// 6. substring()
// 提取子串
"hello world".substring(1, 4); // → "ell"
// 类似 slice；若 start > end 自动交换；不支持负数；返回新字符串

// 7. substr()（已废弃）
// 提取子串
//"hello world".substr(1, 3);       // → "ell"
// 参数 start, length；已废弃，不推荐使用；优先 slice/substring

// 8. indexOf()
// 查找子串首次出现索引
"hello world".indexOf("world"); // → 6
"hello".indexOf("x"); // → -1
"hello hello".indexOf("hello", 6); // → 6（从索引 6 开始）
// 返回首次出现位置；不存在返回 -1；区分大小写

// 9. lastIndexOf()
// 从末尾查找子串索引
"hello hello".lastIndexOf("hello"); // → 6
// 返回最后一次出现位置；支持从指定位置向前搜索

// 10. includes()（ES6）
// 判断是否包含子串
"hello world".includes("world"); // → true
"hello".includes("world", 6); // → false
// 返回 boolean；区分大小写；支持从指定位置开始检查

// 11. startsWith()（ES6）
// 判断是否以指定字符串开头
"hello world".startsWith("hello"); // → true
"hello".startsWith("lo", 3); // → true
// 返回 boolean；支持从指定位置开始检查

// 12. endsWith()（ES6）
// 判断是否以指定字符串结尾
"hello world".endsWith("world"); // → true
"hello".endsWith("lo", 5); // → true（检查前 5 个字符）
// 返回 boolean；第二个参数指定检查长度

// 13. trim()
// 去除首尾空白字符
"  hello world  ".trim(); // → "hello world"
// 返回新字符串；去除空格、制表符、换行等；不修改原字符串

// 14. trimStart() / trimEnd()（ES2019）
// 去除开头/结尾空白
"  hello  ".trimStart(); // → "hello  "
"  hello  ".trimEnd(); // → "  hello"
// 别名 trimLeft()/trimRight()；返回新字符串

// 15. toUpperCase()
// 转换为大写
"hello".toUpperCase(); // → "HELLO"
// 返回新字符串；有 toLocaleUpperCase() 支持本地化规则

// 16. toLowerCase()
// 转换为小写
"Hello".toLowerCase(); // → "hello"
// 返回新字符串；有 toLocaleLowerCase() 支持本地化规则

// 17. replace()
// 替换子串
"hello world".replace("world", "JS"); // → "hello JS"
// 默认只替换第一个；支持正则（如 /world/g 全局替换）

// 18. replaceAll()（ES2021）
// 替换所有匹配
"hello hello".replaceAll("hello", "hi"); // → "hi hi"
// 返回新字符串；等价于 replace(/hello/g, "hi")

// 19. split()
// 分割为数组
"a,b,c".split(","); // → ["a", "b", "c"]
"hello".split(""); // → ["h","e","l","l","o"]
"hello".split(); // → ["hello"]
// 返回数组；可指定分隔符和最大长度

// 20. repeat()（ES6）
// 重复字符串
"abc".repeat(3); // → "abcabcabc"
"abc".repeat(0); // → ""
// 参数为次数；非整数取整；负数或 Infinity 报错

// 21. padStart() / padEnd()（ES2017）
// 填充到指定长度
"5".padStart(4, "0"); // → "0005"
"5".padEnd(4, "0"); // → "5000"
// 若已达长度不填充；填充字符串可循环使用

// 22. match()
// 正则匹配
"abc123abc".match(/abc/g); // → ["abc", "abc"]
"abc123".match(/abc/); // → ["abc", ...详细信息]
// 返回数组或 null；带 g 返回所有匹配；无 g 返回捕获组等详细信息

// 23. search()
// 正则搜索首次匹配索引
"hello world".search(/world/); // → 6
"hello".search(/x/); // → -1
// 返回首次匹配索引；不支持 g 标志

// 24. charAt() / charCodeAt()
// 获取字符或 UTF-16 码点
"hello".charAt(1); // → "e"
"hello".charCodeAt(1); // → 101
// charCodeAt 支持 codePointAt() 处理大码点；charAt 越界返回 ""

// 25. String.fromCharCode()（静态方法）
// 从码点创建字符串
String.fromCharCode(65, 66); // → "AB"
// 处理 UTF-16 码点；推荐 fromCodePoint() 支持完整 Unicode

// 26. 模板字符串
// 反引号，支持插值和多行
let name = "World";
`Hello
${name}!`; // 多行字符串，保留格式
// ${} 内可执行任意表达式；常用于 HTML 模板、复杂字符串构建

// 27. String.raw()（静态方法）
// 原始模板字符串
String.raw`Hello\nWorld`; // → "Hello\\nWorld"
// 转义序列原样保留（如 \n 不换行）；常用于正则、路径等场景

对象

// 1. 创建对象
// {} 或 new Object()
var obj = { a: 1, b: 2 };
var obj2 = new Object();
// 推荐使用字面量 {}；属性名可加引号（用于特殊字符或保留字）

// 2. 访问属性
// obj.key 或 obj["key"]
obj.name; // 点语法（适用于有效标识符）
obj["first-name"]; // 括号语法（支持表达式或特殊字符）

// 3. 添加/修改属性
// obj.key = value;
obj.age = 25; // 添加新属性或修改现有属性
obj.age = 30; // 修改
// 对象是可变的；直接赋值即可添加或覆盖

// 4. 删除属性
// delete obj.key;
delete obj.age; // → true（成功删除）
delete obj.nonexistent; // → true（不存在的属性也返回 true）
// 返回 boolean；删除后属性变为 undefined；不影响原型链

// 5. 对象方法
// 属性值为函数
var obj = {
    greet: function () {
        console.log("Hello");
    },
};
obj.greet(); // 输出 "Hello"
// 方法内 this 指向对象本身；推荐使用简写形式（见下文）

// 6. 遍历对象
// for...in, Object.keys(), Object.values(), Object.entries()
for (let key in obj) {
    console.log(key, obj[key]);
}
Object.keys(obj); // → ["a", "b"]
// for...in 会遍历原型链（需 hasOwnProperty 检查）；Object.keys() 只遍历自身可枚举属性

// 7. Object.keys()
// 返回所有自身可枚举属性名数组
Object.keys(obj); // → ["a", "b"]
// 返回字符串数组；不包含 Symbol 属性或不可枚举属性

// 8. Object.values()（ES2017）
// 返回所有自身可枚举属性值数组
Object.values(obj); // → [1, 2]
// 顺序与 keys 对应；不包含 Symbol 值

// 9. Object.entries()（ES2017）
// 返回 [key, value] 数组的数组
Object.entries(obj); // → [["a", 1], ["b", 2]]
// 常用于 Map 转换或迭代；可与 Object.fromEntries() 反转

// 10. Object.assign()（ES2015）
// 合并对象，浅拷贝
let merged = Object.assign({}, obj1, obj2);
// 修改第一个参数（目标对象）；相同属性后者覆盖；仅浅拷贝

// 11. 展开运算符（ES2018）
// {...obj} 展开对象
const newObj = { ...obj, a: 3 }; // 浅拷贝并覆盖 a
// 创建新对象；支持属性覆盖；比 Object.assign 更简洁

// 12. 对象解构（ES6）
// const { key } = obj;
const { name, age = 18 } = person; // 支持默认值
// 可嵌套解构；支持重命名 { old: newName }

// 13. 属性简写（ES6）
// key 与变量名相同时可简写
const name = "Tom";
const obj = { name }; // 等价于 { name: name }
// 简化对象字面量定义

// 14. 方法简写（ES6）
// { method() { … } }
const obj = {
    greet() {
        console.log("Hello");
    },
};
// 省略 function 关键字；this 绑定同普通方法

// 15. 计算属性名（ES6）
// [expr]: value
const key = "name";
const obj = { [key]: "Tom" };
// 属性名可用表达式计算；支持动态键名

// 16. Object.freeze()
// 冻结对象，不可添加/删除/修改
Object.freeze(obj);
obj.newProp = 1; // 严格模式下报错，非严格模式静默失败
// 浅冻结（嵌套对象仍可修改）；防止意外变更

// 17. Object.seal()
// 密封对象，不能添加/删除，可修改现有属性
Object.seal(obj);
obj.existing = 2; // 可修改
obj.new = 1; // 不可添加
// 现有属性仍可改值；常用于配置对象

// 18. hasOwnProperty()
// 检查是否为自身属性（不检查原型链）
obj.hasOwnProperty("name"); // → true/false
// 推荐现代替代 Object.hasOwn(obj, "name")（ES2022）

// 19. in 操作符
// 检查属性是否在对象或原型链中
"name" in obj; // → true（包含继承属性）
// 区别于 hasOwnProperty（后者只查自身）

// 20. getter/setter（访问器属性）
// get/set 定义计算属性
const obj = {
    _first: "John",
    _last: "Doe",
    get fullName() {
        return this._first + " " + this._last;
    },
    set fullName(name) {
        [this._first, this._last] = name.split(" ");
    },
};
obj.fullName; // → "John Doe"
obj.fullName = "Jane Smith";
// 不存储实际值；getter 无参数，setter 一个参数；不能与普通属性同名