# 从206个console.log完全弄懂数据类型转换的前世今生 上|博客系列

> 本文通过206个console.log案例，系统讲解JavaScript中各种数据类型的转换规则，包括布尔、数字、字符串等类型的转换原理和注意事项，帮助开发者全面理解类型转换机制，提升代码质量和调试能力。

- 原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/5-%E4%BB%8E206%E4%B8%AAconsole.log%E5%AE%8C%E5%85%A8%E5%BC%84%E6%87%82%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E8%BD%AC%E6%8D%A2%E7%9A%84%E5%89%8D%E4%B8%96%E4%BB%8A%E7%94%9F%E4%B8%8A
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2025.10.25
- 可见范围：免费部分

---

## 1. 其它数据类型转布尔值

转化为布尔值的情况是很简单的。

当我们在使用`Boolean()`来进行转换时，有如下转换规则：

| 参数类型                                | 结果  |
| --------------------------------------- | ----- |
| false、undefined、null、+0、-0、NaN、"" | false |
| 除了上面的情况                          | true  |

（另外需要注意的是，如果在使用`Boolean()`时不传参数结果也是为`false`的）

### 1.1 数字转布尔值

数字转布尔值，只需要记住：

- 除了`0, -0, NaN`这三种转换为`false`，其他的一律为`true`。

#### 1.1.1 题目一

```javascript
console.log(Boolean(0))
console.log(Boolean(-0))
console.log(Boolean(NaN))

console.log(Boolean(1))
console.log(Boolean(Infinity))
console.log(Boolean(-Infinity))
console.log(Boolean(100n))
console.log(Boolean(BigInt(100)))
```

记住上面👆的规律，这边我把`bigInt`类型的也拿过来试了一下，发现它也是为`true`。

因此答案为：

```javascript
console.log(Boolean(0)) // false
console.log(Boolean(-0)) // false
console.log(Boolean(NaN)) // false

console.log(Boolean(1)) // true
console.log(Boolean(Infinity)) // true
console.log(Boolean(-Infinity)) // true
console.log(Boolean(100n)) // true
console.log(Boolean(BigInt(100))) // true
```

### 1.2 字符串转布尔值

字符串转布尔也很简单，只需要记住：

- 除了空字符串`""`都为`true`。

#### 1.2.1 题目一

```javascript
console.log(Boolean(""))

console.log(Boolean("1"))
console.log(Boolean("NaN"))
console.log(Boolean("aaa"))
```

这里特别要注意的是`"NaN"`，它并不是`NaN`哦，而是一个字符串。

所以答案为：

```javascript
console.log(Boolean("")) // false

console.log(Boolean("1")) // true
console.log(Boolean("NaN")) // true
console.log(Boolean("aaa")) // true
```

### 1.3 其它类型转布尔值

其它类型，例如`null, undefined, 引用`转布尔值，这些相信大家其实也知道：

- `null、undefined`为`false`
- 引用类型，如对象，数组，类数组，日期，正则都为`true`。

#### 1.3.1 题目一

```javascript
var divs = document.getElementsByTagName('div')
console.log(Boolean(null))
console.log(Boolean(undefined))

console.log(Boolean({}))
console.log(Boolean({ name: 'obj' }))
console.log(Boolean([]))
console.log(Boolean(divs))
console.log(Boolean(new Date()))
console.log(Boolean(/(\[|\])/g))
```

结果为：

```javascript
var divs = document.getElementsByTagName('div')
console.log(Boolean(null)) // false
console.log(Boolean(undefined)) // false

console.log(Boolean({})) // true
console.log(Boolean({ name: 'obj' })) // true
console.log(Boolean([])) // true
console.log(Boolean(divs)) // true
console.log(Boolean(new Date())) // true
console.log(Boolean(/(\[|\])/g)) // true
```

## 2. 原始值转字符串

对于原始值转字符串，也有以下总结：

| 参数类型  | 结果                                                     |
| --------- | -------------------------------------------------------- |
| Undefined | "undefined"                                              |
| Null      | "null"                                                   |
| Boolean   | 如果参数是 true，返回 "true"。参数为 false，返回 "false" |
| Number    | 可以看题目2.1                                 |
| String    | 返回与之相等的值                                         |
| Symbol    | "Symbol()"                                               |

来做几道题强化一下吧。

### 2.1 数字转字符串

#### 2.1.1 题目一

```javascript
console.log(String(0))
console.log(String(1))
console.log(String(100))
console.log(String(NaN))
console.log(String(10n))
console.log(String(10n) === '10')
```

`bigInt`类型会被当成数字来处理。

答案为：

```javascript
console.log(String(0)) // '0'
console.log(String(1)) // '1'
console.log(String(100)) // '100'
console.log(String(NaN)) // 'NaN'
console.log(String(10n)) // '10'
console.log(String(10n) === '10') // true
```

### 2.2 Boolean、Symbol转为字符串

#### 2.2.1 题目一

这三种类型转换为字符串，比较简单：

```javascript
console.log(String(true))
console.log(String(false))
console.log(String(Symbol(1)))
```

答案：

```javascript
console.log(String(true)) // 'true'
console.log(String(false)) // 'false'
console.log(String(Symbol(1))) // 'Symbol(1)'
```

## 3. 原始值转数字

| 参数类型  | 结果                                                         |
| --------- | ------------------------------------------------------------ |
| Undefined | NaN                                                          |
| Null      | +0                                                           |
| Boolean   | 如果参数是 true，返回 1。参数为 false，返回 +0               |
| Number    | 返回与之相等的值                                             |
| String    | 纯数字的字符串(包括小数和负数、各进制的数)，会被转为相应的数字，否则为NaN |
| Symbol    | 使用Number()转会报错                                         |

#### 3.1 题目一

先来看看大家都知道的`string、null、undefined、Symbol`转数字

```javascript
console.log(Number("1"))
console.log(Number("1.1"))
console.log(Number("-1"))
console.log(Number("0x12"))
console.log(Number("0012"))

console.log(Number(null))
console.log(Number("1a"))
console.log(Number("NaN"))
console.log(Number(undefined))
console.log(Number(Symbol(1)))
```

答案为：

```javascript
console.log(Number("1")) // 1
console.log(Number("1.1")) // 1.1
console.log(Number("-1")) // -1
console.log(Number("0x12")) // 18
console.log(Number("0012")) // 12

console.log(Number(null)) // 0
console.log(Number("1a")) // NaN
console.log(Number("NaN")) // NaN
console.log(Number(undefined)) // NaN
console.log(Number(Symbol(1))) // TypeError: Cannot convert a Symbol value to a number
```

其实很好记：

- 纯数字的字符串(包括小数和负数、各进制的数)，会被转为相应的数字
- `null`转为`0`
- `Symbol`会报错
- 其它的基本类型，包括非纯数字的字符串、`NaN`，`undefined`都会被转为`NaN`

#### 3.2 题目二

（`Boolean`类型转数字）

布尔值转数字也是非常简单的，只有两种情况：

```javascript
console.log(Number(true)) // 1
console.log(Number(false)) // 0
```

### 3.3 题目三

还有一种大家可能会用到的转数字的方式，那就是使用：

- `parsetInt`，将结果转换为整数
- `parseFloat`，将结果转换为整数或者浮点数

它们在转换为数字的时候是有这么几个特点的：

- 如果字符串以`0x或者0X`开头的话，`parseInt`会以十六进制数转换规则将其转换为十进制，而`parseFloat`会解析为`0`
- 它们两在解析的时候都会跳过开头任意数量的空格，往后执行
- 执行过程中会尽可能多的解析数值字符，如果碰到不能解析的字符则会跳出解析忽略后面的内容
- 如果第一个不是非空格，或者开头不是`0x、-`的数字字面量，将最终返回`NaN`

来看几道题练习一下 😄：

```javascript
console.log(parseInt('10')) // 10
console.log(parseFloat('1.23')) // 1.23

console.log(parseInt("0x11")) // 17
console.log(parseFloat("0x11")) // 0

console.log(parseInt("  11")) // 11
console.log(parseFloat("  11")) // 11

console.log(parseInt("1.23a12")) // 1
console.log(parseFloat("1.23a12")) // 1.23

console.log(parseInt("  11")) // 11
console.log(parseFloat("  11")) // 11

console.log(parseInt("1a12")) // 1
console.log(parseFloat("1.23a12")) // 1.23

console.log(parseInt("-1a12")) // -1
console.log(parseFloat(".23")) // 0.23
```

一直做到现在感觉都还挺简单的哈 😄。

## 4. 原始值转对象

原始值，也就是基础数据类型。

### 4.1 String对象

让我们先来认识一个叫做`String`的对象，它的原型链是这样的：

![](https://s.poetries.top/gitee/2020/09/138.png)

可以看到，它本质上是一个构造函数，`String.__proto__`指向的是`Function.prototype`。

`String`其实有两种用法，一种是配合`new`来当构造函数用，一种是不用`new`：

- 当 String() 和运算符 new 一起作为构造函数使用时，它返回一个新创建的 String 对象，存放的是字符串 *s* 或 *s* 的字符串表示(不过自从推出了`Symbol`之后就不推荐使用`new String`这种做法了)。
- 当不用 new 运算符调用 String() 时，它只把 *s* 转换成原始的字符串，并返回转换后的值

什么意思呢 🤔️？通俗点来说：

```javascript
typeof String(1) // 'string'
typeof new String(1) // 'object'
```
使用`typeof`会发现类型都是不同的。

### 4.2 基本类型的包装对象

哈哈哈。

和它一起的其实还有另外两个`"亲兄弟"`：`Number、Boolean`；

以及它的`"表哥表妹"`：`Symbol、BigInt`。 😄

为什么说`Number、Boolean`就是亲的，而后面两个就是表的呢 🤔️？

这个是以相似程度来区分的。

也就是说`Number、Boolean`和`String`一样都有两种用法，带`new`和不带`new`。

而`Symbol、BigInt`就只能不带`new`使用。(因为它们是`ES6`之后出来的，对它们调用`new`会报错)

所以你会看到这个现象：

```javascript
console.log(Number(1)) // 1
console.log(new Number(1)) // Number{1}
console.log(Boolean(true)) // true
console.log(new Boolean(true)) // Boolean{true}

console.log(Symbol(1)) // Symbol(1)
console.log(BigInt(1)) // 1n
console.log(new Symbol(1)) // TypeError: Symbol is not a constructor
console.log(new BigInt(1)) // TypeError: BigInt is not a constructor
```

而上面的`Number{1}、Boolean{true}`，它就是我要介绍的**基本类型的包装对象**，也被称为**基本类型的包装类**，也可以叫做**原始值包装对象**（有很多的叫法不过大家应该都知道它表示的就是这个意思）。

可以看到要想产生一个基础数据类型的包装对象只需要使用`new`来调用它们各自的构造函数即可：

```javascript
console.log(new Number(1)) // Number{1}
console.log(new String('1')) // String{1}
console.log(new Boolean(true)) // Boolean{true}
```

这个`基本类型的包装对象`有什么特点呢？

- 使用`typeof`检测它，结果是`object`，说明它是一个对象
- 使用`toString()`调用的时候返回的是原始值的字符串(题`6.8.3`中会提到)

`But!!!`

前面已经说到了，目前`ES6`规范是不建议用`new`来创建基本类型的包装类的，我想大概是为了和`Symbol、BigInt`它们统一吧。

那么现在更推荐用什么方式来创建基本类型的包装类呢？

唔...那就是`Object`这个构造函数。

### 4.3 Object()

`Object()`构造函数它可以接收一个任意类型的变量，然后进行不同的转换。

也就是说七种基本数据类型，或者引用数据类型你都可以传入进去。

不过这里我主要是为了介绍基本数据类型转对象，所以就以几个基本数据类型来做分析：

```javascript
console.log(new Object('1')) // String{'1'}
console.log(new Object(1)) // Number{1}
console.log(new Object(true)) // Boolean{true}
console.log(new Object(Symbol(1))) // Symbol{Symbol(1)}
console.log(new Object(10n)) // BigInt{10n}

console.log(new Object(null)) // {}
console.log(new Object(undefined)) // {}
```

可以看到，你传入的基本数据类型是什么类型的，那么最终的结果就会转为对应的包装类，但是对于`null、undefined`它们会被忽略，生成的会是一个空对象。

### 总结-原始值转对象

原始值转对象主要有以下总结：

- `String、Number、Boolean`有两种用法，配合`new`使用和不配合`new`使用，但是`ES6`规范不建议使用`new`来创建基本类型的包装类。
- 现在更加推荐用`new Object()`来创建或转换为一个基本类型的包装类。

**基本类型的包装对象的特点：**

- 使用`typeof`检测它，结果是`object`，说明它是一个对象
- 使用`toString()`调用的时候返回的是原始值的字符串(题`6.8.3`中会提到)

## 5. 对象转字符串/数字前期准备

对象转字符串和数字的过程比较复杂，会涉及到一个可能大家之前没有听到过的方法：**toPrimitive()**

它的作用其实就是输入一个值，然后返回一个**一定是基本类型的值**，否则会抛出一个类型错误异常。

先上一张执行流程图，让大家感受一下`绝望、孤独、寂寞、冷...`

![](https://s.poetries.top/gitee/2020/09/139.png)

虽然它的功能会有些复杂，不过问题不大，待看完后面的内容之后你就能搞懂它了，在介绍`toPrimitive()`之前，我得先详细介绍一下`toString()`和`valueOf()`方法才行，因为弄懂了它们你才能彻底吃透`toPrimitive()`。😄

## 6. toString()

### 6.1 toString()存在于哪里

在此之前，我翻了很多关于`toString()`的资料，大多都是介绍了它的用法，但是它真正存在于哪里呢？

可能比较常见的一种说法是它存在于`Object`的原型对象中，也就是`Object.prototype`上，那么对于基本数据类型，`Number、String、Boolean、 Symbol、BigInt`呢？它们自身有这个方法吗？或者它们的原型对象上有吗？

本着一探到底的精神，我打印出了`Number`和`Number.prototype`：

```javascript
console.log(Number)
console.log(Number.prototype)
```

![](https://s.poetries.top/gitee/2020/09/140.png)

然后我发现了几件事：

- `Number`只是一个构造函数，打印出来显示的会是源代码
- `Number.prototype`上确实也有`toString()`
- `Number.prototype.__proto__`也就是`Object.prototype`上也有`toString()`

然后我又试了一下`String、Boolean、Symbol`发现结果也和上面一样。

其实不难理解，看过[《💦【何不三连】做完这48道题彻底弄懂JS继承(1.7w字含辛整理-返璞归真)》](https://juejin.im/post/5e75e22951882549027687f9)的小伙伴都知道，所有对象的原型链到最后都会指向`Object.prototype`，算是都"继承"了`Object`的对象实例，因此都能使用`toString()`方法，但是对于不同的内置对象为了能实现更适合自身的功能需求，都会重写该方法，所以你可以看到`Number.prototype`上也会有该方法。

**所以我们可以先得出第一个结论：**

- 除了`null、undefined`以外的其它数据类型(基本数据类型+引用数据类型)，它们构造函数的原型对象上都有`toString()`方法
- 基本数据类型构造函数原型对象上的`toString()`会覆盖`Object`原型对象上的`toString()`方法

（当然，等你看到`6.9`之后你就会发现这种说法其实并不太准确，但是大多数时候我们都只是关心谁可以用它，而不是它存在于哪里）

### 6.2 谁可以调用toString()

这个问题，其实在上面👆已经给出答案了，所有对象除了`null、undefined`以外的任何值都可以调用`toString()`方法，通常情况下它的返回结果和`String`一样。

其实这里，我们最容易搞混的就是`String`和`toString`。

之前总是为了将某个类型转为字符串胡乱的用这两个属性。

- `String`是一个类似于`Function`这样的对象，它既可以当成对象来用，用它上面的静态方法，也可以当成一个构造函数来用，创建一个`String`对象
- 而`toString`它是除了`null、undefined`之外的数据类型都有的方法，通常情况下它的返回结果和`String`一样。

但是就会有小伙伴问了，那为什么`'1'.toString()`也可以成功呢？那是因为代码在运行的时候其实是做了转换为包装类的处理，类似于下面这段代码：

```javascript
var str = new Object('1');
str.toString();
str = null;
```

过程解析：

- 创建`Object`实例，将`s`变为了`String{"1"}`对象
- 调用实例方法`toString()`
- 用完之后立即销毁这个实例

可是我们之前不是看到了一个`String`的东西吗？这里的第一步为什么不能使用`var str = new String('1')`呢？

其实前面也已经说到了，由于`Symbol`和`BigInt`它们是不能使用`new`来调用的，会报错，并且目前`ES6`的规范也不推荐使用`new`来创建这种基本类型的包装类，所以这里使用的是`new Object()`。

但是当我们在代码中试图使用`1.toString()`，发现编辑器已经报错不允许我们这样做了。

难道数字就不可以吗 🤔️？最开始会有这么奇怪的疑问是因为我们都忽视了一件事，那就是`.`它也是属于数字里的一部分啊 😂。

比如`1.2`、`1.3`。所以当你想要使用`1.toString()`的时候，`JavaScript`的解释器会把它作为数字的一部分，这样就相当于`(1.)toString`了，很显然这是一段错误的代码。

既然这样的话，如果我还(`喝唔安黄`)给代码一个`.`是不是就可以了，于是我尝试了一下：

```javascript
console.log(1.1.toString())
```

发现它竟然能正常打印出来：

```javascript
"1.1"
```

这也就再次证明了`1.toString()`会将`.`归给`1`所属，而不是归给`toString()`。

当然如果你用的一个变量来承载这个数字的话也是可以的：

```javascript
var num = 1;
console.log(num.toString()) // true
```

所以在此我们只需要先记住谁可以调用`toString`：

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/5-%E4%BB%8E206%E4%B8%AAconsole.log%E5%AE%8C%E5%85%A8%E5%BC%84%E6%87%82%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E8%BD%AC%E6%8D%A2%E7%9A%84%E5%89%8D%E4%B8%96%E4%BB%8A%E7%94%9F%E4%B8%8A
