平凡前端之路_21.对象的扩展

关注

原创最新推荐文章于 2026-10-29 11:10:43 发布 395 阅读 AI 写同款· GEO 优化 ›

【信息科学与工程学】计算机科学与自动化——第二十四篇编译器04 LLVM编译器01 训推一体方案通过整合训练与推理流程，实现资源复用、效率提升和全链路自动化。以下从。阅读详情

系列文章

平凡前端之路_0ML与 HTML5
平凡前端之路_05.CSS与CSS3
平凡前端之路_14.ES与ES6
平凡前端之路_15.let 和 const声明
平凡前端之路_16.变量的解构赋值
平凡前端之路_17.展开操作符(Spread)/剩余参数(Rest)
平凡前端之路_18.字符串的扩展
平凡前端之路_19.数组的扩展
平凡前端之路_20.函数的扩展

对象的拓展

对象属性与方法简写

ES6 引入了对象字面量的增强写法，允许在属性名与变量名相同，或定义方法时进行简化。这不仅减少了代码冗余，还提升了可读性。

属性简写

当对象属性的‌键名‌与当前作用域中的‌变量名‌相同时，可以省略键名和冒号，直接写入变量名。

const na = '说你又不听';
const ge = '听又不懂';

// 简写写法
const us = { na, ge };
us //=> { na: '说你又不听', ge: '听又不懂'}
// 等价于传统写法
// const us = { na: na, ge: ge };

方法简写

在对象中定义方法时，可以省略 function 关键字及冒号，直接使用函数名后跟参数列表。

const et = () => '听又不懂';
const obj = {  et };
obj //=> { et: () => '听又不懂'  }
// 等价于传统写法
// const obj = {
//   et: function() { return '听又不懂'; },
// };

动态属性名

可以通过方括号 [] 包裹变量、表达式或 Symbol 来实现动态属性名定义。
方括号[]会先计算内部表达式的值，将结果转换为字符串（Symbol 类型保持不变）作为最终属性名。

动态属性名分类与用法

根据属性名的类型，可以分为‌变量/表达式动态属性名‌和 ‌Symbol 类型属性名‌，两者核心用法和区别如下：

操作类型	变量/表达式	Symbol (唯一标识符)
‌创建或定义属性‌（对象字面量中）	‌使用计算属性名：‌const key = ‘name’;const obj = { [key]: ‘Value’ };‌支持任意表达式：‌{ [‘pre_’ + suffix]: val }	‌使用 Symbol：‌const sym = Symbol(‘desc’);const obj = { [sym]: ‘Value’ };‌
关键区别与注意事项	- ‌变量/表达式‌：键最终会被转换为字符串。	- ‌Symbol‌：Symbol‌类型的键保持为 Symbol类型

操作类型	变量/表达式	Symbol (唯一标识符)
‌动态添加/修改属性‌	‌obj[dynamicKey] = newValue;‌	obj[symRef] = newValue;‌注意引用保持：‌必须持有 Symbol 的引用才能访问或修改。
关键区别与注意事项	- ‌变量‌/表达式‌：如果键已存在则覆盖，不存在则新增。	- ‌Symbol‌：即使描述相同，Symbol(‘a’) !== Symbol(‘a’)，因此必须使用同一个 Symbol 变量引用才能修改同一属性。

操作类型	变量/表达式	Symbol (唯一标识符)
‌获取属性值	‌方括号取值 (动态场景)：‌obj[keyVar]‌	‌必须使用方括号及 Symbol 引用：‌obj[symRef]‌无法通过字符串获取：‌obj[‘Symbol(desc)’] // undefined
关键区别与注意事项	- ‌变量‌/表达式‌：只要描述相同即可取值	- ‌Symbol‌：即使描述相同，Symbol(‘a’) !== Symbol(‘a’)，因此必须使用同一个 Symbol 变量引用才能取值。

点符号 vs 动态方括号特性对比

访问对象属性有两种语法：点语法 . 和方括号语法 []，两者特性区别如下：

特性	点符号 (.)	动态方括号 ([])
‌语法格式‌	object.property	object[expression]
‌属性名类型‌	必须是合法的 JavaScript 标识符（静态字符串）。	可以是任何字符串、变量、表达式、数字或 Symbol。
‌动态性‌	‌静态‌：属性名在编写代码时固定，无法使用变量值作为键。	‌动态‌：属性名在运行时计算，支持使用变量、拼接字符串或函数返回值作为键。
‌特殊字符支持‌	‌不支持‌：若属性名包含空格、连字符 - 或以数字开头，会报语法错误。	‌支持‌：可以访问包含空格、特殊字符或保留字（如 class, for）的属性名。
‌数字键支持‌	‌不支持‌：obj.123 会导致语法错误。	‌支持‌：obj[123] 或 obj[‘123’] 均可正常访问。
‌Symbol 支持‌	‌不支持‌：无法直接通过点符号访问 Symbol 类型的键。	‌支持‌：必须使用 obj[symVar] 形式访问 Symbol 键。

对象方法拓展静态方法

ES6 为对象新增了Object.values、Object.entries、Object.assign等实用静态方法，大幅简化了对象操作，让代码更简洁易读；静态方法不依赖实例，直接用于对象操作而非被对象调用。

对象属性获取与转换

‌键值对获取

方法	描述
Object.values	返回对象自身可枚举属性的值组成的数组
Object.entries	返回对象自身可枚举属性的键值对数组

Object.values 方法接受一个参数
Object.values 方法至少接受一个参数
参数传入为 0 个，会抛出错误。
参数传入 ≥2 个：只会生效第一个，其余参数会被忽略
参数为要遍历获取自身可枚举的值的对象
传入非对象参数会强制转换为对象
传入字符串参数会强制转换为字符串对象 Object(字符串)，字符串对象有自己的可枚举属性
传入 undefined / null 基本类型参数，不能被强制转换为对象。→ 直接报错 Uncaught TypeError
传入其他非字符串基本类型参数（如数字、布尔值等）会强制转换为相应对象，但基本没有自己的可枚举属性，返回一个空数组
传入 Map 和 Set 作为参数‌，没有可枚举的自有属性，返回一个空数组。
参数传 undefined / null ，不能被强制转换为对象。→ 直接报错 Uncaught TypeError
Object.values 方法不接受回调函数

Object.values 返回一个新数组
Object.values 返回的是数组，不是Iterator对象
Object.values 返回的数组不包含 Symbol 键的属性值

// ==========================================
// Object.values() 方法详解与示例
// ==========================================
// Object.values() 返回对象自身可枚举属性的值组成的数组。
// 语法: Object.values(obj)
// 参数：obj：需要返回自身可枚举属性值的对象。若参数不是对象（如原始类型），会被强制转换为对象。
// 返回值：返回一个由给定对象自身可枚举属性的值组成的数组。

// 案例一：普通对象(字符串键名)
// ------------------------------------------
const obj = { at: '懂又不做', br: '做你又做错' };
const va = Object.values(obj); 
va //=> ['懂又不做', '做你又做错']

// 案例二：普通对象(Symbol 键名)
// ------------------------------------------
// 原对象的键名有一个 Symbol 值，该属性会被忽略。
Object.values({ [Symbol()]: '懂又不做', foo: '做你又做错' });
// ['做你又做错']

// 案例三：字符串（强制转换）
// ------------------------------------------
// 字符串参数会强制转换为字符串对象 'foo' → Object('foo')
// 字符串对象其索引为可枚举属性
const sa = Object.values('懂又不做')
sa //=> ['懂', '又', '不', '做']

// 案例四： undefined / null  （抛出异常）
// ------------------------------------------
// 不能被强制转换为对象。→ 直接报错 Uncaught TypeError
const ua = Object.values(undefined ); // → 直接报错 Uncaught TypeError
const na = Object.values(null); // → 直接报错 Uncaught TypeError

// 案例五： 其他基本类型（Number, Boolean, BigInt, Symbol）
// ------------------------------------------
// 强制转换为相应对象，但基本没有自己的可枚举属性，返回一个空数组
const nu = Object.values(266); // 数字 {266} → Object(266)
const bo = Object.values(true); // 布尔 {true} → Object(true)
const bi = Object.values(266n); // BigInt {266n} → Object(266n)
const sy = Object.values(Symbol('做你又做错')); // Symbol {sym} → Object(sym)
nu //=> []
bo //=> []
bi //=> []
sy //=> []

// 案例六: Map（映射）、Set（集合）
// ------------------------------------------
// Map 和 Set 是内置对象，但基本没有自己的可枚举属性，返回一个空数组
const ma = Object.values(new Map([['懂又不做', '做你又做错'],['错又不认', 42]]));
const se = Object.values(new Set(['懂又不做', '做你又做错']));
ma //=> [];
se //=> [];
// 若要遍历 Map 获取 [值]，请直接使用 ma.values(); 
// 若要遍历 Set 获取 [值]，请直接使用 sa.values();

values 相似对比	方法类型	调用方式	返回值
Object.values	Object 静态方法	Object.values(obj)	真数组
Array.prototype.values	Array 原型方法	arr.values()	迭代器（Iterator）
Set.prototype.values	Set 原型方法	set.values()	迭代器（Iterator）
Map.prototype.values	Map 原型方法	map.values()	迭代器（Iterator）
URLSearchParams.prototype.values	URLSearchParams 原型方法	params.values()	迭代器（Iterator）
FormData.prototype.values	FormData 原型方法	formData.values()	迭代器（Iterator）

Object.entries 方法接受一个参数
Object.entries 至少接受一个参数
参数传入为 0 个，会抛出错误。
参数传入 ≥2 个：只会生效第一个，其余参数会被忽略
参数为要遍历获取自身可枚举的键值对的对象
传入非对象参数会强制转换为对象
传入字符串参数会强制转换为字符串对象 Object(字符串)，字符串对象有自己的可枚举属性
传入 undefined / null 基本类型参数，不能被强制转换为对象。→ 直接报错 Uncaught TypeError
传入其他非字符串基本类型参数（如数字、布尔值等）会强制转换为相应对象，但基本没有自己的可枚举属性，返回一个空数组
传入Map 和 Set 作为参数‌，没有可枚举的自有属性，返回一个空数组。
Object.entries 方法不接受回调函数

Object.entries 返回一个新数组
Object.entries 返回的是数组，一个二维数组，不是Iterator对象。
Object.entries 返回数组的每个子数组包含两个元素：[key, value]。
Object.entries 返回的数组不包含 Symbol 键的键值对。

// ==========================================
// Object.entries() 方法详解与示例
// ==========================================
// Object.entries() 返回对象自身可枚举属性的键值对数组
// 语法: Object.entries(obj)
// 参数：obj：需要返回自身可枚举属性的键值对的对象。若参数不是对象（如原始类型），会被强制转换为对象。
// 返回值：返回一个由给定对象自身可枚举属性的键值对组成的数组。数组的每个元素是一个包含两个元素的数组。

// 案例一: 普通对象(字符串键名)
// ------------------------------------------
const obj = { at: '错又不认', br: '认又不改' };
const entries = Object.entries(obj); 
entries //=> [ ['at', 错又不认'], ['br', '认又不改'] ]

// 案例二: 普通对象(Symbol 键名)
// ------------------------------------------
// 原对象的键名有一个 Symbol 值，该属性会被忽略。
Object.entries({ [Symbol()]: '错又不认', foo: '认又不改' });
// [ [ 'foo', '认又不改' ] ]

// 案例三: 字符串（强制转换）
// ------------------------------------------
// 字符串参数会强制转换为字符串对象 'foo' → / Object('foo'), 
// 字符串对象其索引为可枚举属性
const sa = Object.entries('错又不认');
sa //=> [['0', '错'], ['1', '又'], ['2', '不'], ['3', '认']]

// 案例四: undefined / null  （抛出异常）
// ------------------------------------------
// 不能被强制转换为对象。→ 直接报错 Uncaught TypeError
const ua = Object.entries(undefined ); // → 直接报错 Uncaught TypeError
const na = Object.entries(null); // → 直接报错 Uncaught TypeError

// 案例五: 其他基本类型（Number, Boolean, BigInt, Symbol）
// ------------------------------------------
// 强制转换为相应对象，但基本没有自己的可枚举属性，返回一个空数组
const nu = Object.entries(266); // 数字 {266} → Object(266)
const bo = Object.entries(true); // 布尔 {true} → Object(true)
const bi = Object.entries(266n); // BigInt {266n} → Object(266n)
const sy = Object.entries(Symbol('认又不改')); // Symbol {sym} → Object(sym)
nu //=> []
bo //=> []
bi //=> []
sy //=> []

// 案例六: Map（映射）、Set（集合）
// ------------------------------------------
// Map 和 Set 是内置对象，但基本没有自己的可枚举属性，返回一个空数组
const ma = Object.entries(new Map([['错又不认', '认又不改'],['改又不服', 42]]));
const se = Object.entries(new Set(['错又不认', '认又不改']));
ma //=> [];
se //=> [];
// 若要遍历 Map 获取 [键, 值] ，请直接使用 ma.entries(); 
// 若要遍历 Set 获取 [值, 值]，请直接使用 sa.entries();

entries 相似对比	方法类型	调用方式	返回值
Object.entries	Object 静态方法	Object.entries (obj)	真数组
Array.prototype.entries	Array 原型方法	arr.entries()	迭代器（Iterator）
Set.prototype.entries	Set 原型方法	set.entries()	迭代器（Iterator）
Map.prototype.entries	Map 原型方法	map.entries()	迭代器（Iterator）
URLSearchParams.prototype.entries	URLSearchParams 原型方法	params.entries()	迭代器（Iterator）
FormData.prototype.entries	FormData 原型方法	formData.entries()	迭代器（Iterator）

键值对转换

方法	描述
Object.fromEntries	返回一个对象，将键值对列表（如 Map 或数组）转换为对象，是 Object.entries() 的逆操作。

Object.fromEntries 方法接受一个参数
Object.fromEntries 至少接受一个参数
参数传入为 0 个，会抛出错误。
参数传入 ≥2 个：只会生效第一个，其余参数会被忽略
参数为可迭代对象，且可迭代对象中的每个元素应包含两个值，分别作为结果对象的键和值。
能直接正确处理默认迭代器为 entries 的可迭代对象(如Map、 URLSearchParams‌、FormData‌）作为参数‌。
Object.fromEntries方法不接受回调函数

Object.fromEntries方法返回一个‌新对象
Object.fromEntries 返回的对象中，重复键出现时，后出现的键值会覆盖先前的值。
即使描述相同，Symbol(‘a’) !== Symbol(‘a’)，因此Object.fromEntries 返回的对象中，必须是同一个 Symbol 变量引用，后出现的键值会覆盖先前的值。。
Object.fromEntries 返回的对象的键名只能是‌字符串‌或 ‌Symbol‌。
Object.fromEntries 返回的对象的键名返回非字符串/非 Symbol 类型（如数字、布尔值、对象）时，会被强制转换为字符串。
Object.fromEntries 创建的 Symbol 键属性无法通过 Object.entries 完整恢复。
Object.fromEntries 处理的 Map、URLSearchParams 、FormData等无法通过 Object.entries 完整恢复。

// ==========================================
// Object.fromEntries() 方法详解与示例
// ==========================================
// Object.fromEntries() 方法把键值对列表转换为一个对象。
// 是 Object.entries() 的逆操作。
// 语法: Object.fromEntries(iterable)
// 参数 iterable: 类似 Array、Map 或者其它实现了可迭代协议的可迭代对象。

// 案例一: Array (数组)
// ------------------------------------------
// 将二维数组转换为对象。
// 数组中的每个子数组必须包含两个元素：[key, value]。
// 否则，若数组元素非键值对格式，需先通过 map 等方法将其转换为 [key, value] 形式的二维数组，
// 再进行Object.fromEntries转换，否则会报错或结果不符合预期
let ar1 = Object.fromEntries([ ['认又不改', '改又不服'], ['不服你不说', 42]])
// 解析过程:
// Array 默认的迭代器为 values()
// ['认又不改', '改又不服'] -> 键: '认又不改', 值: '改又不服'
// ['不服你不说', 42]    -> 键: '不服你不说', 值: 42
ar1 //=> { '认又不改': '改又不服', '不服你不说': 42 }

// 显式调用 .entries() 
let a2 = Object.fromEntries(['认又不改', '改又不服'].entries())
// 解析过程:
// ['0', '认又不改']  -> 键: '0', 值: '认又不改'
// ['1', '改又不服']  -> 键: '1', 值: '改又不服'
ar2 //=> { '0': '认又不改', '1': '改又不服'}

// 缺少值的异常情况
let ar3 = Object.fromEntries([ ['认又不改'], ['改又不服']])
// 解析过程:
// ['认又不改'] -> 键: '认又不改', 值: undefined 
// ['改又不服'] -> 键: '改又不服', 值: undefined
ar3 //=> { '认又不改': undefined, '改又不服': undefined }

// 存在多余元素的处理
let ar4 = Object.fromEntries([ ['认又不改', '改又不服', 'extra'], ['不服你不说', 42]])
// 只使用前两个元素，多余元素会被忽略
// 解析过程:
// ['认又不改', '改又不服'] -> 键: '认又不改', 值: '改又不服'
// ['不服你不说', 42]    -> 键: '不服你不说', 值: 42
ar4 //=> { '认又不改': '改又不服', '不服你不说': 42 }


// 案例二: Set (集合)
// ------------------------------------------
// 注意: Set 本身存储的是唯一值。
// 如果 Set 中存储的是数组（即二维结构），则可以直接转换。
let se1 = Object.fromEntries(new Set([['认又不改', '改又不服'], ['不服你不说', 42]]))
// 解析过程:
// Set 的默认迭代器 为 values()
// new Set([['认又不改', '改又不服'], ['不服你不说', 42]]) 创建了一个包含两个数组元素的 Set。
// Object.fromEntries 遍历 Set，取出每个数组作为 [key, value] 对。
se1 //=> { '认又不改': '改又不服', '不服你不说': 42 }

// 如果 Set 中存储的是原始值或非键值对结构，则需要先调用 .entries() 或其他方法将其转化为键值对形式。
// Set.prototype.entries() 返回一个迭代器，其中每个值都是 [value, value] 的形式。
let se2 = Object.fromEntries(new Set(['认又不改', 'bar']).entries())
// 解析过程:
// new Set(['认又不改', '改又不服']) 创建包含 '认又不改' 和 '改又不服' 的 Set。
// .entries() 生成迭代器: ['认又不改', '认又不改'], ['改又不服', '改又不服']。
// Object.fromEntries 将其转换为对象，键和值相同。
se2 //=> { '认又不改': '认又不改', '改又不服': '改又不服'}


// 案例三: Map (映射)
// ------------------------------------------
// Map 对象天然就是键值对的集合，因此非常适合转换为普通对象。
let ma1 = Object.fromEntries(new Map([['认又不改', '认又不改'],['不服你不说', 42]]))
// 解析过程:
// new Map(...) 创建 Map 对象。
// Map 的默认迭代器 为 entries()
// Object.fromEntries 直接遍历 Map 的键值对。
ma1 //=> { '认又不改': '认又不改', '不服你不说': 42 }

// 显式调用 .entries() 效果相同，因为 Map 默认迭代器就是 entries。
let ma2 = Object.fromEntries(new Map([['认又不改', '认又不改'],['不服你不说', 42]]).entries())
// 解析过程:
// .entries() 返回 MapIterator，内容与 Map 本身一致。
ma2 //=> { '认又不改': '认又不改', '不服你不说': 42 }


// 案例四: URLSearchParams (URL 查询参数)
// ------------------------------------------
// URLSearchParams 对象用于处理 URL 的查询字符串。
// 它也是可迭代的，迭代时产生 [key, value] 对。
let us1 = Object.fromEntries(new URLSearchParams('foo=bar&baz=42'))
// 解析过程:
// new URLSearchParams('foo=bar&baz=42') 解析查询字符串。
// 迭代时产生: ['foo', 'bar'], ['baz', '42']。
// 注意: URL 参数值始终是字符串类型，所以 42 变成了 '42'。
us1 //=> { 'foo': 'bar', 'baz': '42' }

// 显式调用 .entries() 效果相同。
let us2 = Object.fromEntries(new URLSearchParams('foo=bar&baz=42').entries())
// 解析过程:
// .entries() 返回迭代器，内容同上。
us2 //=> { 'foo': 'bar', 'baz': "42" }


// 案例五: FormData (表单数据)
// ------------------------------------------
// FormData 对象用于处理表单数据
// 它也是可迭代的，迭代时产生 [key, value] 对。

// 手动创建 FormData 示例
let formData = new FormData()
formData.append('认又不改', '改又不服')
formData.append('不服你不说', 42)

let fd1 = Object.fromEntries(formData )
// 解析过程:
// new FormData() 构造表单数据。
// 迭代时产生: ['认又不改', '改又不服'], ['不服你不说', '42']。
// 注意: FormData所有值都是字符串或 File 对象，所以 42 变成了 '42'。
fd1 //=> { '认又不改': '改又不服', '不服你不说': '42' }

// 显式调用 .entries() 效果相同。
let fd2 = Object.fromEntries(formData.entries())
// 解析过程:
// .entries() 返回迭代器，内容同上。
fd2 //=> { '认又不改: '改又不服', '不服你不说': '42'  }

对象操作与合并

对象合并与复制

方法	描述
Object.assign	将一个或者多个[源Source‌]中所有可枚举的自有属性复制到[目标Target‌]，并返回修改后的[目标Target‌]。

Object.assign 方法接受多个参数
Object.assign 方法至少接受一个参数
参数传入为 0 个，会抛出TypeError 错误。
参数传入为 1 个，参数为[目标Target‌]（若为 null 或 undefined 会报错，其他原始值会转为包装对象）。
参数传入 ≥2 个：第一个参数为[目标Target‌]，后续参数为[源Source‌]；所有[源Source‌]的可枚举属性都会合并到[目标Target‌]中（同名属性后者覆盖前者）
第一个参数为[目标Target‌]（若为 null 或 undefined 会报错，其他原始值会转为包装对象）。
其他参数为一个或多个包含要应用的属性的[源Source‌]。参数如果不是对象，会尝试转换为对象（若为 null 或 undefined，则‌跳过‌该参数，不会报错，也不会合并任何属性；其他原始值会转为包装对象）。
Object.assign 方法不接受回调函数

Object.assign 返回是经过 ToObject 转换后的[目标Target‌]。
[目标Target‌]原本是‌对象‌，则返回‌原对象引用
[目标Target‌]是‌基本类型‌（非 null/undefined），则返回一个‌新生成的包装对象‌（引用不同）
Object.assign 会覆盖同名属性，且仅合并可枚举属性。
Object.assign 返回的[目标Target‌]可包含 Symbol 键的属性，仅合并可枚举属性。

// ==========================================
// Object.assign() 方法详解与示例
// ==========================================
// Object.assign() 方法将一个或者多个[源Source‌]中所有可枚举的自有属性复制到[目标Target‌]，并返回修改后的[目标Target‌]。
// 语法: Object.assign(target, source1, source2)
// 参数 target: [目标Target‌]，用于接收[源Source‌]的属性。
// 		source1, source2, ...: [源Source‌]，提供需复制的属性（可接受多个）。
// 返回值：返回经过 ToObject 转换、并被修改后的[目标Target‌]。

// 案例一：普通对象
// ------------------------------------------
// 后面的[源Source‌]属性会覆盖前面的同名属性
// 1. 普通对象(字符串键名)
const target = { at: '改又不服', br: '不服你不说t' }, 
	source1 = { br: '不服你不说1', cv: '那叫我怎么办1' }, 
	source2 = { cv: '那叫我怎么办2' };

const result1 = Object.assign(target, source1, source2);
// 解析过程:
//  source1 的 br: '不服你不说1' 覆盖了 target 的 br: '不服你不说t'
//  source1 的 cv: '那叫我怎么办1' 添加给了 target 
//  source2 的 cv: '那叫我怎么办2'  覆盖了 source1 提供给target  的 cv: '那叫我怎么办1'
//  target 本身被修改，result1 === target 为 true
result1 //=>  { at: '改又不服', br: '不服你不说1', cv: '那叫我怎么办2' }

// 2. 普通对象(Symbol 键名)
const symA = Symbol('改又不服');
const symB = Symbol('那叫我怎么办');
const targetSym = { [symA]: '改又不服' };
const sourceSym = { [symA]: '不服你不说', [symB]: '那叫我怎么办' };
const resultSym = Object.assign(targetSym, sourceSym);
resultSym //=> { Symbol(改又不服): '不服你不说', Symbol(那叫我怎么办): '那叫我怎么办' }

// 案例二：字符串（强制转换）
// ------------------------------------------
// 字符串参数会强制转换为字符串对象 '改又不服' → Object('改又不服')
// 字符串对象其索引为可枚举属性，被转换为类数组对象，索引作为键
// 1.[目标Target‌]是字符串
const obj1 =  Object.assign('改又不服');
const obj2 =  Object.assign('改又不服', {cv: '不服你不说'});
obj1 // => { 0:'改', 1:'又', 2:'不', 3:'服'};
obj2 // => { 0:'改', 1:'又', 2:'不', 3:'服', cv: '不服你不说' };
// [目标Target‌]只读属性赋值不可写，赋值失败，复制中断
// [目标Target‌]的某个属性是‌只读的‌（writable: false）或者设置了 setter 且抛出异常
// 并停止执行。‌但是‌，在此之前已经成功复制的属性‌不会回滚‌，会保留在[目标Target‌]中。
const obj2 = Object.assign('改又不服', '不服你不说'); // 报错
const obj3 = Object.assign('改又不服', ['不','服']); // 报错
const obj4 = Object.assign('改又不服', {0: '不', 1: '服'}); /// 报错
// 如果赋值期间出错，例如如果属性不可写，则会抛出 TypeError；如果在抛出异常之前已经添加了一些属性，则这些属性会被保留，而 [目标Target‌]也会被修改。

// 2.[源Source‌]是字符串
const str = '改又不服';
const obj1 = Object.assign({}, str);
const obj2 = Object.assign({},  Object(str));
const obj3 = Object.assign({},  Object(str), '不服你不说');
// 解析: 字符串被视为可迭代对象，字符按索引位置作为属性名复制
obj1 // => { 0:'改', 1:'又', 2:'不', 3:'服'};
obj2 // => { 0:'改', 1:'又', 2:'不', 3:'服'};
obj3 // => { 0:'不', 1:'服', 2:'你', 3:'不', 4:'说'};


// 案例三： undefined / null  
// ------------------------------------------
// 1.[目标Target‌] undefined / null -> 报错
// 不能被强制转换为对象。→ 直接报错 Uncaught TypeError
const obj1 = Object.assign(undefined, { at: '改又不服' }); // → 直接报错 Uncaught TypeError
const obj2 = Object.assign(null, { at: '改又不服' }); // → 直接报错 Uncaught TypeError

// 2.[源Source‌] undefined / null -> 跳过，忽略，不会报错
const resultSafe = Object.assign({ at: '改又不服' }, null, undefined, { br: 2 });
resultSafe //=> { at: '改又不服', br: '不服你不说' }

// 案例四： 其他基本类型（Number, Boolean, BigInt, Symbol）
// ------------------------------------------
// 1.[目标Target‌]，其他基本类型（Number, Boolean, BigInt, Symbol）
// 强制转换为相应对象，返回的是相应对象对象

const nu = Object.assign(266); // 数字 {266} → Object(266)
const bo = Object.assign(true); // 布尔 {true} → Object(true)
const bi = Object.assign(266n); // BigInt {266n} → Object(266n)
const sy = Object.assign(Symbol('不服你不说')); // Symbol {sym} → Object(sym)
nu //=>  Number {266}
bo //=>  Boolean {true}
bi //=>  BigInt {266n}
sy //=>  Symbol {不服你不说}

// 2.[源Source‌] 其他基本类型（Number, Boolean, BigInt, Symbol）
// 强制转换为相应对象，但基本没有自己的可枚举属性， 不会对[目标Target‌]产生任何属性拷贝效果
const ou = Object.assign({ at: '改又不服' }, 266, true, 266n, Symbol('不服你不说'));
ou //=>  { at: '改又不服' }

// 案例五：Map（映射）、Set（集合）
// ------------------------------------------
// Map 和 Set 是内置对象，没有自己的可枚举属性，
// 1.[目标Target‌]，Map 和 Set 是内置对象
const ma = Object.assign(new Map([['改又不服', '不服你不说'],['那叫我怎么办', 42]]));
const se = Object.assign(new Set(['改又不服', '不服你不说']));
const ma1 = Object.assign(new Map([['改又不服', '不服你不说'],['那叫我怎么办', 42]]), { ma: 266});
const se1 = Object.assign(new Set(['改又不服', '不服你不说']), { ma: 266});
ma //=> {'改又不服' => '不服你不说', '那叫我怎么办' => 42}
se //=> {'改又不服', '不服你不说'}
Object.entries(ma1) //=> [['ma', 266]]  
ma1.entries() //=> {'改又不服' => '不服你不说', '那叫我怎么办' => 42}
Object.entries(se1) //=> [['ma', 266]]  
se1.entries() //=> {'改又不服' => '改又不服', '不服你不说' => '不服你不说'}

// 2.[源Source‌] ，Map 和 Set 是内置对象，但基本没有自己的可枚举属性，不会对[目标Target‌]产生任何属性拷贝效果
const ma = Object.assign({ at: '认又不改' }, new Map([['改又不服', '不服你不说'],['那叫我怎么办', 42]]));
const se = Object.assign({ at: '认又不改' }, new Set(['改又不服', '不服你不说']));
ma //=> { at: '认又不改' }
se //=> { at: '认又不改'}
// 如果想合并 Map，应使用 new Map([...map1, ...map2])
// 如果想合并 Set，应使用 new Set([...set1, ...set2])

数据分组

方法	描述
Object.groupBy	根据回调函数返回值对可迭代对象的元素分组。

Object.groupBy 接受两个参数
Object.groupBy 至少接受两个参数。
参数传入 < 2 个，会抛出错误。
参数传入 ≥ 3 个，只会生效前两个，其余参数会被忽略。
第一个参数为一个可迭代对象（通常是数组），包含需要被分组的元素。当不是可迭代对象时，会抛出错误。
第二个参数为对可迭代对象中的每个元素执行的函数。当不是函数时，会抛出错误。

Object.groupBy 方法能接受一个回调函数，即第二个参数，是‌一个必需的参数，且必须是一个函数，该回调函数接受三个参数
- element‌：当前遍历到的元素（可迭代对象中的元素）。
- index‌：当前遍历到的元素的索引。
- iterable：调用 groupBy 方法时传入的整个可迭代对象本身。
回调函数的返回值用于构建结果对象的属性名，相同值的元素会被归入同一个组。
当回调函数无返回值时，默认返回 undefined，被转换为字符串 “undefined” 作为分组键。

Object.groupBy‌ 返回一个‌无原型的新对象
Object.groupBy 返回的是 Object.create(null) 类型的对象（无原型）。
Object.groupBy 返回的对象的键名只能是‌字符串‌或 ‌Symbol‌。
Object.groupBy 返回的对象的键名返回非字符串/非 Symbol 类型（如数字、布尔值、对象）时，会被强制转换为字符串。
如果需要更复杂的键类型（如对象、未转换的数字、NaN 等作为独立键），应使用 Map.groupBy，它返回一个 Map 对象，支持任意类型的键。

// ==========================================
// Object.groupBy‌() 方法详解与示例
// ==========================================
// Object.groupBy‌() 方法根据回调函数返回值对可迭代对象的元素分组。
// 语法: Object.groupBy(iterable, callbackFn)
// 参数：iterable：类似 Array、Map 或者其它实现了可迭代协议的可迭代对象。
//		 callbackFn‌：对可迭代对象中的每个元素执行的函数。
// 返回值：返回一个普通对象

// 案例 1：基础字符串分组
// ------------------------------------------
const array = [1, 2, 3, 4, 5, 6];
const result = Object.groupBy(array, (num) => num % 2 === 0 ?  'even': 'odd');
result //=> { 'even': [2, 4, 6], 'odd': [1, 3, 5]}

// 案例 2：按动态计算的条件分组
// ------------------------------------------
// 使用模板字符串生成复合键
const array = [1, 2, 3, 4, 5, 6];
const result = Object.groupBy(array, (num, index) =>  num % 2 === 0 ?  `even_mod${index%4}`: `odd_mod${index%4}`);
result //=>  { 'even_mod1': [2, 6], 'even_mod3': [4], 'odd_mod0': [1, 5],  'odd_mod2': [3]}

// 案例 3：使用 Symbol‌ 作为键进行分组
// ------------------------------------------
const array = [1, 2, 3, 4, 5, 6];
const even = Symbol('even'); 
const result = Object.groupBy(array, (num) => num % 2 === 0 ?  even: Symbol('odd'));
// 解析过程：
// 即使描述相同，Symbol('a') !== Symbol('a')，因此必须使用同一个 Symbol 变量引用才能分到同一组。
// Symbol('odd') 每次调用都会生成一个新的唯一值，（1 、 3 、5）各自单独成组。
// 使用同一个Symbol('even')变量引用 （2 、 4和 6）归为一组。
result //=> { Symbol('odd'): [1], Symbol('odd'): [3], Symbol('odd'): [5], Symbol('even'): [2, 4] }

groupBy 相似对比	方法类型	调用方式	返回值
Object.groupBy	Object 静态方法	Object.groupBy(iterable, callbackFn)	普通对象
Map.groupBy	Map 静态方法	Map.groupBy(iterable, callbackFn)	Map 对象

Object.groupBy‌兼容性
Chrome	Chrome 117
Edge	Edge 117
Firefox	Firefox 119
Safari	Safari 17.4
Node	Node.js 21

值比较

严格值比较

方法	描述
Object.is	返回一个布尔值，比较两个值是否严格相等，与 === 类似，但处理了 NaN 和 +0 、 -0 的特殊情况。

Object.is 接受两个参数
严格接受且仅处理前两个参数。
参数传入 ≥2 个：只会生效前两个参数，其余参数会被忽略。
参数传入 <2 个：缺失的参数会被视为 undefined。0 个参数时，相当于 undefined 相互比较；1个参数时，相当于参数与 undefined 相比较。
Object.is 方法不接受回调函数

Object.is 返回一个布尔值
若参数都是NaN，则两个值相同。返回 true。
若参数一个+0，一个-0，则两个值不同。返回 false。
若参数都是symbol，即使描述相同，Symbol(‘a’) !== Symbol(‘a’) ，因此必须是同一个 Symbol 变量引用，两个值才相同，返回 true，否则返回 false。
若参数是引用类型，不同数组/对象即使内容相同，若不是同一个变量引用，返回 false。

// ==========================================
// Object.is() 方法详解与示例
// ==========================================
// Object.is() 方法用于判断两个值是否为同一个值，返回一个布尔值表示判断结果。
// 语法: Object.is(value1, value2)
// 参数：value1：第一个需要比较的值。
//		 value2：第二个需要比较的值。
// 返回值：返回一个布尔值，若两个值为同一个值则返回 true，否则返回 false。

// 案例1: 引用类型比较 (与 === 行为一致)
// ------------------------------------------
// Object.is 比较的是内存地址，不同数组/对象即使内容相同，地址也不同
Object.is([], []); // false: 两个不同的空数组实例，内存地址不同

const foo = { at: '不服你不说' },  bar = { at: '不服你不说' };
const sameFoo = foo;

Object.is(foo, foo); // true: 同一个引用，内存地址相同
Object.is(foo, bar); // false: 虽然内容相同，但是两个不同的对象实例
Object.is(foo, sameFoo); // true: sameFoo 指向 foo 的同一内存地址


// 案例2: 带符号的零 (+0 和 -0)
// ------------------------------------------
// 这是 Object.is 与 === 的主要区别之一
Object.is(+0, -0); // false: Object.is 能区分正零和负零
Object.is(-0, -0); // true: 相同的负零

+0 === -0; // true: 严格相等运算符认为 +0 和 -0 相等


// 案例3: NaN 的比较
// ------------------------------------------
// 这是 Object.is 与 === 的另一个主要区别
Object.is(NaN, NaN); // true: Object.is 认为 NaN 等于自身
Object.is(NaN, 0 / 0); // true: 0/0 的结果是 NaN，Object.is 能正确识别
Object.is(NaN, Number.NaN); // true: 标准 NaN 常量比较

NaN === NaN; // false: 根据 IEEE 754 标准，NaN 不等于任何值，包括它自己

应用与注意事项

应用场景

配置合并：使用 Object.assign() 合并默认配置和用户配置
数据转换：使用 Object.entries() + Object.fromEntries() 进行对象转换
数据分组：使用 Object.groupBy() 对数组数据进行分类统计
严格比较：使用 Object.is() 进行包含 NaN 和 ±0 的精确比较

注意事项

性能考虑：Object.assign() 是浅拷贝，嵌套对象需递归处理
Symbol 处理：Symbol 键属性在遍历和转换时需特殊处理
兼容性：Object.groupBy() 需要较新浏览器/Node.js 版本支持
类型转换：注意基本类型参数的自动转换行为
错误处理：了解各方法对 undefined/null 的不同处理方式

知识题

题目	答案
Object.values会保留属性名为 Symbol 值的属性么	不保留，Object.values 不保留 Symbol 类型的属性名
Object.fromEntries会保留属性名为 Symbol 值的属性么	能保留，Object.fromEntries 能保留 Symbol 类型的属性名
Object.fromEntries 是 Object.entries() 的逆操作，Object.entries 能完整恢复 Object.fromEntries 处理的数据	不能，Object.fromEntries 创建的 Symbol 键属性无法通过 Object.entries 完整恢复。
new Boolean(false ) / Object(false ) / Boolean(false)的typeof 的结果是否一致	一致，都是 object
new String(‘266’) / Object(‘266’) / String(‘266’)的typeof 的结果是否一致	一致，都是 object
BigInt(266n) / Object(266n ) 的typeof 的结果是否一致	不一致，BigInt(45n) 为 bigint， Object(45n ) 为 object
new Number(266) / Object(266) /Number(266) 的typeof 的结果是否一致	一致，都是 object
Symbol(“test”) / Object(Symbol(“test”)) 的typeof 的结果是否一致	不一致，Symbol(“test”) 为 symbol, Object(Symbol(“test”)) 为 object
new Function() / Object(function(){}) 的typeof 的结果是否一致	一致，都是 function
Object.assign(45n) 的typeof 的结果与 BigInt(45n) / Object(45n ) 的typeof 的结果哪个是一致的	Object.assign(45n) 的typeof 的结果是 object, 与 Object(45n )的结果一致
new Boolean(false) / Object(false) 与 false 在 if 语句中的区别	new Boolean(false) / Object(false) 是一个对象，在 if 语句中会被判定为 true（因为所有对象都是真值），这与原始值 false 的行为截然不同