JavaScript 原始类型的‘装箱’（Boxing）过程：`Number` 原型方法调用时的隐式对象创建机制

各位同学，大家好。今天我们将深入探讨JavaScript中一个既基础又巧妙的机制——原始类型的“装箱”（Boxing）过程，特别是当我们在Number这样的原始值上调用原型方法时，幕后发生的隐式对象创建机制。这个话题看似简单，实则揭示了JavaScript类型系统设计上的精妙之处，以及它如何在原始值和对象之间建立起一座无缝的桥梁。

JavaScript的类型系统：原始值与对象

在深入装箱机制之前，我们必须首先牢固掌握JavaScript中两种核心的数据类型：原始值（Primitives）和对象（Objects）。理解它们的根本区别，是我们理解装箱机制的前提。

1.1 原始值（Primitives）

原始值是JavaScript中最基本的数据类型，它们代表单一的、不可变的值。这意味着一旦一个原始值被创建，它的值就不能被改变。我们操作的总是它的副本，而不是修改它本身。

JavaScript定义了七种原始值类型：

• string: 文本数据，例如 'hello'。
• number: 数字，包括整数和浮点数，例如 10, 3.14。
• boolean: 逻辑值，true 或 false。
• symbol: ES6引入，用于创建唯一标识符。
• bigint: ES2020引入，用于表示任意大的整数。
• undefined: 变量声明但未赋值时的默认值。
• null: 表示空或不存在的值，一个特殊的原始值。

原始值的特性：

• 不可变性（Immutability）: 原始值一旦创建，就不能被修改。例如，当你修改一个字符串时，实际上是创建了一个新的字符串。

  let str = "hello";
  str.toUpperCase(); // 返回 "HELLO"，但 str 仍然是 "hello"
  console.log(str); // 输出: "hello"
  
  let num = 10;
  num = 20; // 这不是修改 10，而是将 num 变量指向了新的原始值 20
  console.log(num); // 输出: 20

• 按值传递（Pass by Value）: 当原始值作为参数传递给函数或赋给另一个变量时，传递的是值的副本。

  let a = 10;
  let b = a; // b 得到了 a 的值 10 的副本
  b = 20;
  console.log(a); // 输出: 10 (a 不受 b 改变的影响)

• 存储在栈中（Stack Storage）: 通常，原始值直接存储在内存的栈（Stack）中，因为它们的大小是固定的且不可变。
• 相等性比较（Equality Comparison）: 两个原始值在值相等时被认为是相等的。

  console.log(10 === 10);      // true
  console.log("hello" === "hello"); // true
  console.log(true === true);  // true

1.2 对象（Objects）

对象是JavaScript中更复杂的数据类型。它们是属性的集合，每个属性都由一个键（字符串或Symbol）和一个值（可以是任何类型，包括其他对象或原始值）组成。对象是可变的，并且通过引用进行操作。

JavaScript中几乎所有的“非原始值”都是对象，包括：

• 普通对象（Plain Objects）: { key: value }
• 数组（Arrays）: [item1, item2]
• 函数（Functions）: function() {}
• 日期（Dates）: new Date()
• 正则表达式（Regular Expressions）: /pattern/
• 以及许多内置的构造函数创建的实例，如 new Number(), new String(), new Boolean() (稍后会详细讨论)。

对象的特性：

• 可变性（Mutability）: 对象的值可以被修改，例如添加、删除或修改属性。

  let obj = { name: "Alice" };
  obj.age = 30; // 修改对象
  console.log(obj); // 输出: { name: "Alice", age: 30 }

• 按引用传递（Pass by Reference）: 当对象作为参数传递给函数或赋给另一个变量时，传递的是对象的引用（内存地址），而不是值的副本。

  let obj1 = { value: 10 };
  let obj2 = obj1; // obj2 得到了 obj1 的引用
  obj2.value = 20; // 通过 obj2 修改了对象
  console.log(obj1.value); // 输出: 20 (obj1 也被修改了)

• 存储在堆中（Heap Storage）: 对象通常存储在内存的堆（Heap）中，而存储在栈中的是对象的引用（内存地址）。

• 相等性比较（Equality Comparison）: 两个对象只有在它们引用同一个内存地址时才被认为是相等的。即使它们具有相同的属性和值，如果引用不同的内存地址，它们也是不相等的。

  let objA = { x: 10 };
  let objB = { x: 10 };
  let objC = objA;
  
  console.log(objA === objB); // false (不同的引用)
  console.log(objA === objC); // true (相同的引用)

1.3 原始值与对象的关键区别概览

为了更清晰地对比，我们用一个表格来总结原始值和对象的关键区别：

特性	原始值（Primitives）	对象（Objects）
存储方式	通常直接存储在栈中	值存储在堆中，栈中存储的是指向堆中值的引用
可变性	不可变（Immutable）	可变（Mutable）
比较方式	按值比较（=== 检查值是否相同）	按引用比较（=== 检查是否指向同一个内存地址）
传递方式	按值传递（传递值的副本）	按引用传递（传递内存地址的副本）
拥有方法	通常没有直接的方法（但可借助装箱机制临时获得）	拥有方法（通过原型链继承或直接定义）
typeof	返回对应的类型字符串（"number", "string"等）	通常返回 "object"（函数返回 "function"）

理解了这些基础，我们现在就可以提出一个问题：如果原始值没有方法，那为什么我们可以在一个数字上调用 toFixed() 呢？

2.0 原始值的“方法”之谜

正如我们前面所强调的，原始值是不可变的，并且通常不拥有方法。然而，在JavaScript的实际编码中，我们却频繁地看到如下代码：

let price = 99.99;
let formattedPrice = price.toFixed(2); // 调用 toFixed 方法
console.log(formattedPrice); // 输出: "100.00"

let message = "hello world";
let upperMessage = message.toUpperCase(); // 调用 toUpperCase 方法
console.log(upperMessage); // 输出: "HELLO WORLD"

let isActive = true;
let boolValue = isActive.valueOf(); // 调用 valueOf 方法 (不常见但有效)
console.log(boolValue); // 输出: true

这看起来似乎与我们对原始值的定义相矛盾：一个number类型的值99.99，一个string类型的值"hello world"，它们都是原始值，却神奇地拥有了方法。这正是JavaScript中“装箱”（Boxing）机制发挥作用的地方。

为了解决这个看似矛盾的设计，JavaScript引入了一个非常优雅且几乎对开发者透明的机制：原始值包装对象（Primitive Wrapper Objects）和隐式装箱（Implicit Boxing）。

3.0 原始值包装对象：幕后的英雄

JavaScript为每种原始类型（除了null和undefined）都提供了一个对应的原始值包装对象（Primitive Wrapper Object）。这些包装对象实际上是内置的构造函数，例如Number、String、Boolean、Symbol和BigInt。

• Number 对应 number 原始值
• String 对应 string 原始值
• Boolean 对应 boolean 原始值
• Symbol 对应 symbol 原始值
• BigInt 对应 bigint 原始值

这些构造函数可以被用来显式地创建包装对象。

3.1 显式装箱（Explicit Boxing）

我们可以通过使用new关键字和这些构造函数来显式地将一个原始值“装箱”成一个对象。

// 显式装箱示例
let numPrimitive = 123;
let numObject = new Number(123); // 创建一个 Number 包装对象

let strPrimitive = "hello";
let strObject = new String("hello"); // 创建一个 String 包装对象

let boolPrimitive = true;
let boolObject = new Boolean(true); // 创建一个 Boolean 包装对象

console.log("--- Typeof Check ---");
console.log("typeof numPrimitive:", typeof numPrimitive); // "number"
console.log("typeof numObject:", typeof numObject);     // "object"

console.log("typeof strPrimitive:", typeof strPrimitive); // "string"
console.log("typeof strObject:", typeof strObject);     // "object"

console.log("typeof boolPrimitive:", typeof boolPrimitive); // "boolean"
console.log("typeof boolObject:", typeof boolObject);     // "object"

console.log("n--- Instanceof Check ---");
console.log("numObject instanceof Number:", numObject instanceof Number); // true
console.log("strObject instanceof String:", strObject instanceof String); // true
console.log("boolObject instanceof Boolean:", boolObject instanceof Boolean); // true

// 原始值不是对象的实例
console.log("numPrimitive instanceof Number:", numPrimitive instanceof Number); // false

从上面的输出我们可以清楚地看到，new Number(123) 创建的是一个object类型的值，而不是原始的number类型。它是一个真正的对象，拥有属性和方法，并且其内部包含着原始值123。

显式装箱的注意事项和陷阱：

虽然显式装箱展示了包装对象的存在，但在实际开发中，我们通常不推荐使用new String(), new Number(), new Boolean()来创建包装对象。这主要是因为它们会引入一些潜在的问题和混淆：

1. 类型混淆: 原始值和其包装对象在行为上可能存在细微差异，尤其是在typeof检查和相等性比较时。

   let primitiveNum = 10;
   let objectNum = new Number(10);
   
   console.log(primitiveNum === objectNum); // false (一个是原始值，一个是对象，引用不同)
   console.log(primitiveNum == objectNum);  // true (宽松相等会尝试进行类型转换，将对象转换为原始值)
   
   console.log(typeof primitiveNum); // "number"
   console.log(typeof objectNum);    // "object"

2. 布尔值的陷阱: new Boolean(false) 是一个非常常见的陷阱。作为一个对象，即使它包装的值是false，它本身也是一个“真值”（truthy value）。

   let falseObject = new Boolean(false);
   
   if (falseObject) {
       console.log("This will always execute!"); // 会执行
   }
   console.log(typeof falseObject); // "object"
   console.log(falseObject.valueOf()); // false (获取其原始值)

   这与原始的false行为截然不同，原始false是“假值”（falsy value）。

3. 性能开销: 创建对象总是比直接使用原始值有更大的内存和CPU开销，尽管对于现代JS引擎来说，这种开销通常可以忽略不计。

推荐做法: 如果需要将一个值转换为对应的原始类型，应使用不带new关键字的函数形式：Number(), String(), Boolean()。它们作为类型转换函数，会直接返回原始值，而不是包装对象。

let val = "123";
let num = Number(val); // num 是原始值 123
console.log(typeof num); // "number"

let obj = { x: 10 };
let str = String(obj); // str 是原始值 "[object Object]"
console.log(typeof str); // "string"

3.2 解箱（Unboxing）

如果我们确实有一个包装对象，并想获取其内部的原始值，可以使用valueOf()方法：

let numObject = new Number(42);
let numPrimitive = numObject.valueOf();

console.log(numPrimitive);     // 42
console.log(typeof numPrimitive); // "number"

let strObject = new String("World");
let strPrimitive = strObject.valueOf();

console.log(strPrimitive);     // "World"
console.log(typeof strPrimitive); // "string"

理解了原始值包装对象的存在和显式装箱的原理，我们现在就可以揭示JavaScript中更重要的、也是日常开发中频繁遇到的——隐式装箱机制。

4.0 核心机制：隐式装箱（Autoboxing）

隐式装箱，也被称为自动装箱（Autoboxing），是JavaScript为了提供便利性和统一性而设计的核心机制。它完美地解释了为什么原始值可以像对象一样拥有并调用方法。

当你在一个原始值上尝试访问属性或调用方法时，JavaScript引擎会执行以下三个瞬时步骤：

1. 创建临时包装对象: JavaScript会根据原始值的类型，自动创建一个对应的临时包装对象。例如，如果你在一个number上调用方法，它会创建一个new Number(primitiveValue)的实例。
2. 调用方法: 临时创建的包装对象被用来执行你所请求的方法（例如toFixed()、toUpperCase()）。
3. 销毁临时对象: 方法调用完成后，这个临时包装对象会立即被销毁（垃圾回收）。原始值本身保持不变。

这个过程是完全自动和隐式的，对于开发者来说是透明的。它使得原始值能够“借用”其对应包装对象原型上的方法，而无需开发者手动创建和管理这些对象。

4.1 深入 Number 原始值的隐式装箱过程

让我们以Number原始类型为例，详细解析当调用toFixed()方法时发生了什么。

考虑以下代码：

let myNumber = 123.456;
let fixedString = myNumber.toFixed(2);
console.log(fixedString); // "123.46"

当JavaScript引擎执行myNumber.toFixed(2)这一行时，它会识别出myNumber是一个原始的number类型，而不是一个对象。然而，toFixed方法定义在Number.prototype上，这意味着它需要在一个Number对象实例上调用。

这时，隐式装箱机制启动：

1. 临时对象创建: 引擎在内部执行类似 new Number(myNumber) 的操作，创建了一个临时的Number对象实例。这个临时对象内部包含着原始值 123.456。

   // 概念上，引擎执行：
   let tempNumberObject = new Number(123.456);

2. 方法调用: toFixed(2) 方法被调用在这个临时创建的 tempNumberObject 上。

   // 概念上，引擎执行：
   let fixedString = tempNumberObject.toFixed(2);

   toFixed方法执行其逻辑，将数字格式化为具有指定小数位数的字符串，并返回结果 "123.46"。

3. 临时对象销毁: 一旦方法调用完成并且结果被返回，tempNumberObject（这个临时的Number实例）就会被立即丢弃，等待垃圾回收。原始值 myNumber 仍然是一个纯粹的 number 原始值，没有被改变，也没有永久地变成一个对象。

关键点在于： 原始值本身并没有被修改或永久地转换为对象。装箱过程只是一个短暂的、一次性的借用行为。

4.2 为什么原始值不能添加属性？

这个隐式装箱和销毁的机制也解释了为什么我们不能给原始值添加属性：

let myNum = 10;
myNum.testProperty = "hello"; // 尝试给原始值添加属性
console.log(myNum.testProperty); // 输出: undefined
console.log(myNum);             // 输出: 10 (原始值未变)

当执行 myNum.testProperty = "hello"; 时：

1. JavaScript引擎会执行隐式装箱，创建一个临时的 new Number(10) 对象。
2. testProperty 被成功地添加到了这个临时对象上。
3. 语句执行完毕后，这个带有 testProperty 的临时对象立即被销毁。
4. 因此，在下一行 console.log(myNum.testProperty); 再次访问时，myNum 再次被隐式装箱，创建一个全新的临时 Number 对象。这个新对象上并没有 testProperty，所以返回 undefined。

这个行为进一步证明了装箱过程的临时性和原始值的不可变性。

4.3 Number 原型方法调用示例

让我们通过更多的代码示例来巩固对Number装箱机制的理解。Number.prototype上定义了许多有用的方法，它们都受益于隐式装箱。

// 1. toFixed(): 格式化数字为指定小数位的字符串
let value1 = 123.4567;
console.log(value1.toFixed(2)); // "123.46" (四舍五入)
console.log(value1.toFixed(0)); // "123"
console.log(value1.toFixed(5)); // "123.45670"

// 2. toPrecision(): 格式化数字为指定有效位数的字符串
let value2 = 123.4567;
console.log(value2.toPrecision(4)); // "123.5" (总共4位有效数字，四舍五入)
console.log(value2.toPrecision(6)); // "123.457"
console.log(value2.toPrecision(2)); // "1.2e+2" (科学计数法)

// 3. toExponential(): 格式化数字为指数表示法的字符串
let value3 = 12345;
console.log(value3.toExponential(2)); // "1.23e+4" (2位小数)
console.log(value3.toExponential());  // "1.2345e+4" (默认根据需要)

// 4. toString(): 将数字转换为指定基数（进制）的字符串
let value4 = 255;
console.log(value4.toString());    // "255" (默认基数10)
console.log(value4.toString(16));  // "ff" (十六进制)
console.log(value4.toString(2));   // "11111111" (二进制)
console.log((10).toString());      // "10" (数字字面量直接调用方法需要用括号包裹，否则点会被解析为浮点数的一部分)
console.log(10..toString());      // "10" (使用两个点，第一个点表示浮点数，第二个点才被解析为属性访问器)

// 5. valueOf(): 返回 Number 对象的原始值
// 尽管通常用于包装对象，但对原始值调用也会触发装箱，然后返回自身原始值
let value5 = 789;
console.log(value5.valueOf()); // 789
console.log(typeof value5.valueOf()); // "number"

在上述所有例子中，value1、value2、value3、value4、value5 都是原始的number类型。当它们调用.toFixed()、.toPrecision()、.toExponential()、.toString()或.valueOf()时，JavaScript引擎都会透明地执行隐式装箱，创建临时的Number对象，调用方法，然后销毁对象。

4.4 扩展：自定义Number.prototype方法

为了更直观地理解这个临时对象创建和销毁的过程，我们可以尝试给Number.prototype添加一个自定义方法。

Number.prototype.sayHello = function() {
    console.log(`Hello from Number object wrapping value: ${this.valueOf()}`);
    // this 在这里指向的是那个临时的 Number 包装对象
};

let myAge = 30;
myAge.sayHello(); // 输出: "Hello from Number object wrapping value: 30"

let anotherNumber = 123.45;
anotherNumber.sayHello(); // 输出: "Hello from Number object wrapping value: 123.45"

// 尝试给原始值添加属性，并不能被后续访问到
myAge.customProp = "This won't stick";
console.log(myAge.customProp); // undefined

// 但如果是在包装对象上，就可以
let objAge = new Number(30);
objAge.customProp = "This will stick";
console.log(objAge.customProp); // "This will stick"
console.log(objAge.valueOf());  // 30

在这个例子中，当 myAge.sayHello() 被调用时，myAge (原始值 30) 被隐式装箱成一个临时的 Number 对象。sayHello 方法在这个临时对象上执行，this 关键字指向的就是这个临时对象。方法执行完毕后，这个临时对象被销毁。因此，原始值 myAge 仍然是原始值，它并没有获得 customProp 这样的新属性。

5.0 其他原始类型的装箱机制

隐式装箱机制并非Number类型独有，它同样适用于String、Boolean、Symbol和BigInt这些具有对应包装对象的原始类型。

5.1 String 原始值的装箱

string类型是最常用到装箱机制的原始类型之一，因为字符串有大量的内置方法（如length属性，以及toUpperCase(), substring(), indexOf()等方法）。

let myString = "JavaScript";

// 访问 length 属性 (实际上也是通过装箱访问包装对象的属性)
console.log(myString.length); // 10

// 调用 toUpperCase 方法
console.log(myString.toUpperCase()); // "JAVASCRIPT"

// 调用 substring 方法
console.log(myString.substring(0, 4)); // "Java"

// 尝试添加属性
myString.newProp = "test";
console.log(myString.newProp); // undefined (同 Number 的情况)

在这些例子中，每次对myString进行属性访问或方法调用时，都会发生以下隐式装箱过程：

1. 创建一个临时的String对象，其内部值为"JavaScript"。
2. 在这个临时String对象上访问length属性或调用toUpperCase()/substring()方法。
3. 临时对象被销毁。

5.2 Boolean 原始值的装箱

boolean类型的原始值也有其对应的Boolean包装对象。尽管我们很少直接在boolean原始值上调用方法（因为它们的方法相对较少且不常用），但装箱机制同样存在。

let isEnabled = true;

// 调用 valueOf 方法
console.log(isEnabled.valueOf()); // true
console.log(typeof isEnabled.valueOf()); // "boolean"

// 调用 toString 方法
console.log(isEnabled.toString()); // "true"
console.log(typeof isEnabled.toString()); // "string"

// 尝试添加属性
isEnabled.extra = 123;
console.log(isEnabled.extra); // undefined

5.3 Symbol 和 BigInt 原始值的装箱

ES6引入的symbol和ES2020引入的bigint也遵循相同的装箱原则。它们各自有Symbol和BigInt包装对象。

Symbol 装箱示例:

let mySymbol = Symbol('description');

// 访问 description 属性
console.log(mySymbol.description); // "description"

// 调用 toString 方法
console.log(mySymbol.toString()); // "Symbol(description)"

// 尝试添加属性
mySymbol.name = "my unique symbol";
console.log(mySymbol.name); // undefined

这里同样，mySymbol在访问description属性或调用toString()方法时被隐式装箱为new Symbol('description')的临时对象。

BigInt 装箱示例:

let largeNum = 9007199254740991n; // BigInt 原始值

// 调用 toString 方法
console.log(largeNum.toString()); // "9007199254740991"

// 调用 valueOf 方法
console.log(largeNum.valueOf()); // 9007199254740991n

// 尝试添加属性
largeNum.extra = "big";
console.log(largeNum.extra); // undefined

BigInt原始值在调用其方法时也会被隐式装箱为new BigInt(9007199254740991n)的临时对象。

5.4 null 和 undefined – 不可装箱的原始值

值得注意的是，null和undefined这两个原始值是唯一没有对应包装对象的原始类型。因此，尝试在它们上面访问属性或调用方法，会导致运行时错误，通常是TypeError。

let nothing = null;
// nothing.toString(); // TypeError: Cannot read properties of null (reading 'toString')

let noValue = undefined;
// noValue.valueOf(); // TypeError: Cannot read properties of undefined (reading 'valueOf')

这再次印证了装箱机制的必要性：只有当原始值有对应的包装对象时，才能通过装箱来“借用”方法。

6.0 性能考量与最佳实践

理解装箱机制固然重要，但在日常开发中，我们应该如何看待它带来的影响呢？

6.1 性能开销：通常可忽略不计

每次隐式装箱都会涉及创建一个临时对象，然后将其销毁。这确实会带来一定的内存分配和垃圾回收的开销。然而，现代JavaScript引擎（如V8、SpiderMonkey）在优化这些常见模式方面已经做得非常出色。它们通常能够非常高效地处理隐式装箱，甚至可能通过JIT编译等技术将其优化掉，使得这种开销在大多数情况下可以忽略不计。

因此，不应过度担心隐式装箱带来的性能问题而进行不必要的优化。编写清晰、可读的代码通常比微观优化装箱过程更重要。只有在确实遇到性能瓶颈，并通过性能分析工具确认装箱是主要原因时，才需要考虑优化。

6.2 避免显式装箱

如前所述，我们强烈建议避免在日常代码中显式地使用new Number(), new String(), new Boolean()来创建包装对象。它们引入的类型混淆（原始值 vs. 对象、typeof结果、严格相等性）和潜在的逻辑错误（如new Boolean(false)的真值问题）远大于其带来的任何好处。

如果你需要将一个值转换为原始类型，请使用不带new关键字的函数形式：

• Number(value): 将value转换为原始number。
• String(value): 将value转换为原始string。
• Boolean(value): 将value转换为原始boolean。

let obj = { x: 10 };
let num = Number(obj); // NaN (obj无法转换为数字)
let str = String(obj); // "[object Object]"
let bool = Boolean(obj); // true (任何非null/undefined对象都是真值)

console.log(typeof num, typeof str, typeof bool); // "number" "string" "boolean"

这些函数形式执行的是类型转换，返回的是原始值，而不是包装对象。

6.3 严格相等性 (===) 的重要性

理解装箱机制也强化了使用严格相等运算符===的重要性。它不仅比较值，还比较类型。

let primitiveOne = 1;
let objectOne = new Number(1);

console.log(primitiveOne == objectOne);  // true (宽松相等，objectOne 被解箱成原始值 1)
console.log(primitiveOne === objectOne); // false (类型不同，一个是 number，一个是 object)

let primitiveFalse = false;
let objectFalse = new Boolean(false);

console.log(primitiveFalse == objectFalse);  // true (宽松相等，objectFalse 被解箱成原始值 false)
console.log(primitiveFalse === objectFalse); // false (类型不同，一个是 boolean，一个是 object)

使用===可以避免因原始值和其包装对象之间的隐式转换而导致的意外行为。

7.0 ECMAScript规范视角下的装箱

从ECMAScript规范的角度来看，装箱机制是通过抽象操作实现的。当JavaScript引擎在原始值上尝试执行属性访问（Property Access）时，会调用一个名为ToObject的抽象操作。

ToObject操作会根据传入的原始值类型，返回一个对应的包装对象：

• ToObject(undefined) 抛出 TypeError
• ToObject(null) 抛出 TypeError
• ToObject(boolean) 返回 new Boolean(boolean)
• ToObject(number) 返回 new Number(number)
• ToObject(string) 返回 new String(string)
• ToObject(symbol) 返回 new Symbol(symbol)
• ToObject(bigint) 返回 new BigInt(bigint)
• 如果值已经是对象，则直接返回该对象。

这个ToObject操作正是隐式装箱的内部实现。它确保了在需要对象上下文（例如调用方法或访问属性）时，原始值能够临时地表现出对象的行为，而又不改变其原始的不可变特性。

总结

今天我们深入探讨了JavaScript原始类型的装箱机制，特别是当Number等原始值调用原型方法时，幕后发生的隐式对象创建过程。我们了解到：

• JavaScript区分原始值和对象，原始值是不可变的，对象是可变的。
• 为了让原始值能够像对象一样拥有方法，JavaScript引入了“原始值包装对象”（如Number、String、Boolean等）。
• 当在原始值上尝试调用方法或访问属性时，JavaScript引擎会执行“隐式装箱”：临时创建一个对应的包装对象，在其上执行操作，然后立即销毁该临时对象。
• 这个过程对于开发者是透明的，赋予了原始值强大的功能，而又不牺牲其核心的不可变特性。
• 我们应避免显式装箱，并理解其对性能和严格相等性比较的影响。

装箱机制是JavaScript设计哲学的一个典范：它在保持语言简洁性和一致性的同时，为开发者提供了极大的便利性。理解这一机制，不仅能帮助我们更好地编写健壮的JavaScript代码，还能更深入地领会这门语言的精妙之处。