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

> 本文深入解析JavaScript中数据类型转换的底层原理，通过206个console.log实例详细演示对象、字符串、数字等类型之间的转换流程，重点讲解toString、valueOf方法的重写及其在类型转换中的作用，帮助开发者全面理解JS的类型转换机制和最佳实践。

- 原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/6-%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%8B
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2025.10.25
- 可见范围：免费部分

---

## 1. 重写toString和valueOf

看完了上篇的对象转字符串，不知道你对`toPrimititve`的转换流程掌握了多少呢？

如果你感觉之前的那些例子还不太具有说明性，也就是说你还是没有感觉到`JS`确实是按我画的那个流程图来进行转换的话，你可以看看这里。

我们在上篇的`6.1`中提到过了，大部分的对象都是可以通过原型链查找到`Object.prototype`上的`toString`或者`valueOf`方法，然后使用它们。

但是你想想，如果我这个对象本身就有`toString`或者`valueOf`方法的话是不是就可以不用`Object.prototype`上的了，这其实就是我们常听到的重写。

你也许可以用这样的方式来覆盖原型链上的这两个方法：

```javascript
let obj = {
    toString () {
        return '1'
    },
    valueOf () {
        return 1
    }
}
```

甚至你还可以直接修改`Object.prototype`上的方法：

```javascript
Object.prototype.toString = function () {
  return 1
}
var b = {}
console.log(String(b)) // '1'
```

(当然，这种肯定是不推荐的哈，这会影响所有的对象)

### 1.1 题目一

（通过重写`toString()`和`valueOf()`来判断我们之前的`toPrimitive`流程是否正确）

上面👆两个例子我只是想告诉你，既然我们可以重写对象上的`toString()`和`valueOf`，那如果我们在重写的函数里面再加上`console.log(xxx)`，不就可以知道**对象转原始值**的具体过程是不是按我们设想的方式执行下去了吗？

比如这样：

```javascript
var b = {
  toString () {
    console.log('toString')
    return 1
  },
  valueOf () {
    console.log('valueOf')
    return [1, 2]
  },
}
console.log(Number(b))
```

想一下这里的执行结果 🤔️？

既然是用`Number()`方法来进行转换的话，那也就是执行了伪代码`toPrimitive(obj, 'number')`了。

那也就是说会先调用`valueOf()`函数，然后判断这个函数的返回值是否为原始值，再决定是继续调用`toString()`还是返回。

- 很显然，由于这里的`valueOf()`被重写了，所以调用`valueOf()`之后返回的是一个引用类型`[1, 2]`，所以它会继续执行`toString()`
- 也就是执行`[1, 2].toString()`，但是这时候的`toString()`也是被重写了的并且返回了数字`1`，所以我们根本没必要管`[1, 2].toString()`的结果了，而是直接将`1`返回。

所以整个过程结束之后，答案为：

```javascript
'valueof'
'toString'
1
```

这样看下来流程就很清晰了，它确实是按照我们预期的方向走的。

### 1.2 题目二

如果你理解了上面一题的话，咱再来看看这里：

```javascript
var b = {
  toString () {
    console.log('toString')
    return { name: 'b' }
  },
  valueOf () {
    console.log('valueOf')
    return [1, 2]
  },
}
console.log(String(b))
```

这次我是用的`String()`方法将`b`转为字符串。

而且要注意了，重写的`toString()`和`valueOf`都是返回的引用数据类型。那你可以想想到最后的结果会是什么吗？

来看看过程分析：

- 执行重写的`toString()`方法，返回引用类型`{name: 'b'}`
- 继续执行重写的`valueOf()`方法，返回引用类型`[1,2]`
- 哇，很难受，都经过两轮转换了还是引用类型，得抛错了。

没错，这里的转换过程最终是失败了的，因为还记得流程图中，最后一步了若还不是原始值的话，就会抛异常了。

所以结果为：

```javascript
'toString'
'valueOf'
Cannot convert object to primitive value at String
```

### 1.3 题目三

(数组在进行`ToString`时的不同之处)

我们都知道，当数组在进行转字符串的时候，会把里面的每一项都转为字符串然后再进行`","`拼接返回。

那么为什么会有`","`拼接这一步呢？难道`toString()`在调用的时候还会调用`join()`方法吗？

为了验证我的想法💡，我做了一个实验，重写了一个数组的`join()`方法：

```javascript
var arr = [1, 2]
arr['join'] = function () {
  let target = [...this]
  return target.join('~')
}
console.log(String(arr))
```

重写的`join`函数中，`this`表示的就是调用的这个数组`arr`。

然后将返回值改为`"~"`拼接，结果答案竟然是：

```javascript
"1~2"
```

也就是说在`String(arr)`的过程中，它确实是隐式调用了`join`方法。

但是当我们重写了`toString()`之后，就不会管这个重写的`join`了：

```javascript
var arr = [1, 2]
arr['toString'] = function () {
  let target = [...this]
  return target.join('*')
}
arr['join'] = function () {
  let target = [...this]
  return target.join('~')
}
console.log(String(arr)) // "1*2"
```

可以看出`toString()`的优先级还是比`join()`高的。

现在我们又可以得出一个结论：

对象如果是数组的话，当我们不重写其`toString()`方法，在转换为字符串类型的时候，默认实现就是将调用`join()`方法的返回值作为`toString()`的返回值。

## 2. Symbol.toPrimitive

在我正为自己弄懂了`toPrimitive`而感到骄傲的时候，我得知了一个叫做`Symbol.toPrimitive`的家伙。

看这家伙的样子，让我想起了以前见到过的一些老大哥：`Symbol.hasInstance`、`Symbol.toStringTag`。

他们都有着酷酷的纹身：`Symbol`，并且之前的老大哥是能够让我们做一些自定义的事情，不知道这家伙是不是和我想的一样，也能够帮助我们重写`toPrimitive` 🤔️？

了解了事情的真相之后，我知道了自己还是不笨的，给猜对了。

`Symbol.toPrimitive`就是比重写`toString()`和`valueOf()`更屌的一个属性。

如果你在一个对象里重写了它的话，那么甚至都不会执行重写的`toString()`和`valueOf()`了。

(`Symbol.toPrimitive`也被叫做`@@toPrimitive`)

### 2.1 题目一

（`Symbol.toPrimitive`的基本使用-返回值为一个原始值）

```javascript
var b = {
  toString () {
    console.log('toString')
    return { name: 'b' }
  },
  valueOf () {
    console.log('valueOf')
    return [1, 2]
  },
  [Symbol.toPrimitive] () {
    console.log('symbol')
    return '1'
  }
}
console.log(String(b))
console.log(Number(b))
```

这道题中，我把刚刚提到的三个属性都给重写了，你感觉结果会是什么？

😄记住刚刚说的话，`Symbol.toPrimitive`的优先级是最高的，所以这里只会执行它里面的内容。

因此结果为：

```javascript
'symbol'
'1'
'symbol'
1
```

并且大家可以看到，虽然`Symbol.toPrimitive`的返回值是`"1"`，但是最终的结果`String(b)`还是字符串，`Number(b)`还是数字，表明，最后还是会给返回值做一层对应的转换的。

### 2.2 题目二

（`Symbol.toPrimitive`的返回值为引用类型，或者没有返回值？）

如果它的返回值是引用类型，或者干脆没有返回值，就会继续执行`valueOf`或者`toString`吗？

结果并不会...来看看这里，我定义了对象`b和c`，并且重写了这三个属性：

```javascript
var b = {
  toString () {
    console.log('b.toString')
    return { name: 'b' }
  },
  valueOf () {
    console.log('b.valueOf')
    return [1, 2]
  },
  [Symbol.toPrimitive] () {
    console.log('b.symbol')
  }
}
var c = {
  toString () {
    console.log('c.toString')
    return { name: 'c' }
  },
  valueOf () {
    console.log('c.valueOf')
    return [1, 2]
  },
  [Symbol.toPrimitive] () {
    console.log('c.symbol')
    return [1, 2]
  }
}
console.log(String(b))
console.log(String(c))
```

执行结果：

```javascript
'b.symbol'
'undefined'
'c.symbol'
TypeError: Cannot convert object to primitive value
    at String
```

过程分析：

- `String(b)` 过程中打印出了`b.symbol`，说明还是执行了`Symbol.toPrimitive`方法的，但是这个方法并没有返回值，且也没有继续执行`valueOf()`或者`toString()`了，而是返回了字符串`"undefined"`
- `String(c)`过程中也打印了`c.symbol`，但是`Symbol.toPrimitive`的返回值是一个对象，却报错了。

所以从这道题，我们可以看出：

`Symbol.toPrimitive`它可谓是`一夫当关，万夫莫开`，只要有它在，就不会继续往下走了，它的返回结果就是作为最终的返回结果。

而且通过`String(c)`我们可以看出来：如果返回的是一个对象的话，也不会继续执行`valueOf()、toString()`了，而是判断它的返回值，如果是原始值那就返回，否则就抛出错误。

### 2.3 题目三

（带参数的`Symbol.toPrimitive`）

你以为`Symbol.toPrimitive`仅仅是这么简单吗？

No😺，它竟然还能接收参数！！！

它接收一个字符串类型的参数：`hint`，表示要转换到的原始值的预期类型。

且参数的取值为以下字符串的其中一个：

- `"number"`
- `"string"`
- `"default"`

嗯😺？我一惊，这怎么和之前介绍的`toPrimitive`那么像啊：

```javascript
toPrimitive(obj, 'number')
toPrimitive(obj, 'string')
```

也就是说传入了之后，就是告诉`Symbol.toPrimitive`要转换成哪个类型咯？

这么屌的功能，赶紧来试试：

```javascript
var b = {
  toString () {
    console.log('toString')
    return '1'
  },
  valueOf () {
    console.log('valueOf')
    return [1, 2]
  },
  [Symbol.toPrimitive] (hint) {
    console.log('symbol')
    if (hint === 'string') {
      console.log('string')
      return '1'
    }
    if (hint === 'number') {
      console.log('number')
      return 1
    }
    if (hint === 'default') {
      console.log('default')
      return 'default'
    }
  }
}
console.log(String(b))
console.log(Number(b))
```

这道题重写了`toString、valueOf、Symbol.toPrimitive`三个属性，通过上面👆的题目我们已经知道了只要有`Symbol.toPrimitive`在，前面两个属性就被忽略了，所以我们不用管它们。

而对于`Symbol.toPrimitive`，我将三种`hint`的情况都写上了，如果按照我的设想的话，在调用`String(b)`的时候应该是要打印出`string`的，调用`Number(b)`打印出`number`，结果也正如我所预想的一样：

```javascript
'string'
'1'
'number'
1
```

那么这里面的`"default"`是做什么的呀？它是什么时候执行的呢？

开始我的想法是如果没有`if (hint === 'string')`这一个判断的时候，是不是就会执行`"default"`了呢？

于是我把`if (hint === 'string')`和`'number'`这两个判断的内容给去掉了，发现它还是不会执行`"default"`：

```javascript
var b = {
  toString () {
    console.log('toString')
    return '1'
  },
  valueOf () {
    console.log('valueOf')
    return [1, 2]
  },
  [Symbol.toPrimitive] (hint) {
    console.log('symbol')
    // if (hint === 'string') {
    //   console.log('string')
    //   return '1'
    // }
    // if (hint === 'number') {
    //   console.log('number')
    //   return 1
    // }
    if (hint === 'default') {
      console.log('default')
      return 'default'
    }
  }
}
console.log(String(b))
console.log(Number(b))

// 'symbol'
// 'undefined'
// 'symbol'
// NaN
```

可以看到，执行结果竟然和题`2.2`中那个没有返回值的`b`有点像。

所以也就是说，这个`hint`它是在调用`Symbol.toPrimitive`的时候就已经确定了的，后面并不会改变。

比如`String(b)`时传的是`string`，`Number(b)`时传的是`number`。

而`default`这个情况，它涉及到`+`运算符，在第四节中会说到。

### 2.4 题目四

小伙子(姑娘)，听说你已经掌握`Symbol.toPrimitive`了？

OK👌，让我们来做个题巩固一下：

```javascript
class Person {
  constructor (name) {
    this.name = name
  }
  [Symbol.toPrimitive] (hint) {
    if (hint === 'default') {
      console.log('default')
      return 'default'
    }
    if (hint === 'string') {
      console.log('string')
      return '1'
    }
    if (hint === 'number') {
      console.log('number')
      return 1
    }
  }
}
let p1 = new Person('p1');
let p2 = new Person('p2');

console.log(String(p1))
console.log(Number(p2))
console.log(p1)
console.log(p2)
```

我把原来的对象，换成了现在的`class`，你不用想多，其实用它生成的实例就是一个对象，且能使用`Symbol.toPrimitive`。

所以这里的结果为：

```javascript
'string'
'1'
'number'
1
Person{ name: 'p1' }
Person{ name: 'p2' }
```

注意：这里的`p1、p2`为什么是没有表现出`Symbol.toPrimitive`函数的呢？

别忘了[《【何不三连】比继承家业还要简单的JS继承题-封装篇(牛刀小试)》](https://juejin.im/post/5e707417e51d45272054d5d3)这里说的，定义在`class`中的所有方法都相当于是定义在其原型对象上，也就是`Person.prototype`上，所以这里`p1、p2`虽然是遵循`Symbol.toPrimitive`，但是使用的却是它原型链上的。

### 总结-Symbol.toPrimitive

咱来总结一下哈。

- 如果重写了某个对象或者构造函数中的`toString、valueOf、Symbol.toPrimitive`方法，`Symbol.toPrimitive`的优先级是最高的
- 若是`Symbol.toPrimitive`函数返回的值不是基础数据类型(也就是原始值)，就会报错
- `Symbol.toPrimitive`接收一个字符串参数`hint`，它表示要转换到的原始值的预期类型，一共有`'number'、'string'、'default'`三种选项
- 使用`String()`调用时，`hint`为`'string'`；使用`Number()`时，`hint`为`'number'`
- `hint`参数的值从开始调用的时候就已经确定了

说实话，这回是真的有些膨胀了，现在不管是`toPrimitive`的执行机制，还是`Symbol.toPrimitive`的自定义咱都给搞懂了。

## 3. 使用==比较时的类型转换

上面👆整了这么多题，你倒是给👴来点实际会考的东西啊。

好哦，其实在实际中我们被考的比较多的可能就是用`==`来比较判断两个不同类型的变量是否相等。

而全等`===`的情况比较简单，一般不太会考，因为全等的条件就是：如果类型相等值也相等才认为是全等，并不会涉及到类型转换。

但是`==`的情况就相对复杂了，先给大家看几个比较眼熟的题哈：

```javascript
console.log([] == ![]) // true
console.log({} == true) // false
console.log({} == "[object Object]") // true
```

怎样？这几题是不是经常看到呀 😁，下面就让我们一个一个来看。

首先，我们还是得清楚几个概念，这个是硬性规定的，不看的话咱没法继续下去啊。

当使用`==`进行比较的时候，会有以下转换规则（判断规则）：

1. 两边类型如果相同，值相等则相等，如 `2 == 3`肯定是为`false`的了
2. 比较的双方都为基本数据类型：

- 若是一方为`null、undefined`，则另一方必须为`null或者undefined`才为`true`，也就是`null == undefined`为`true`或者`null == null`为`true`，因为`undefined`派生于`null`
- 其中一方为`String`，是的话则把`String`转为`Number`再来比较
- 其中一方为`Boolean`，是的话则将`Boolean`转为`Number`再来比较

3. 比较的一方有引用类型：

- 将引用类型遵循`ToNumber`的转换形式来进行比较(实际上它的`hint`是`default`，也就是`toPrimitive(obj, 'default')`，但是`default`的转换规则和`number`很像，具体可以看`3.10`)
- 两方都为引用类型，则判断它们是不是指向同一个对象

在一些文章中，会说道：

> 如果其中一方为Object，且另一方为String、Number或者Symbol，会将Object转换成字符串，再进行比较

(摘自[《神三元-(建议收藏)原生JS灵魂之问, 请问你能接得住几个？(上)》](https://juejin.im/post/5dac5d82e51d45249850cd20#heading-20)中的`3. == 和 ===有什么区别？`)

这样认为其实也可以，因为想想`toPrimitive(obj, 'number')`的过程：

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javaScript2/6-%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%8B
