# 原生JS补给(上)|博客系列

> 本文系统讲解了原生JavaScript的类型基础知识，包括数据类型转换、toString方法的使用原理及常见易错点，帮助读者深入理解JS底层机制，提升前端开发能力。

- 原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javascript/-%E5%8E%9F%E7%94%9FJS%E8%A1%A5%E7%BB%99(%E4%B8%8A)
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2025.10.25
- 可见范围：免费部分

---

## 第一补： JS类型基础

### 1. '1'.toString()为什么可以调用，1.toString()却不行？

我们知道如果在代码中使用：

```javascript
'1'.toString()
// 或者是
true.toString()
```

都是可以正常调用的，这是因为`toString`它是`Object.prototype`上的方法，任何能访问到`Object`原型的元素都可以调用它。

而在此处，对于`'1'.toString()`相当于是做了一层转换，将其转为了一个`"对象"`，这样就可以调用`toString()`方法了。

也就是这样：

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

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

这一部分三元分析的已经挺多了，我主要是想补充一下`1.toString()`为什么就不行。

当我们在代码中试图使用`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()) // "1"

// 或者
console.log((1).toString()) // "1"
```

### 2. 为什么可以使用new Number却不能使用new Symbol?

```javascript
var num = new Number(1) // Number{1}
var str = new String('1') // String{'1'}
var bol = new Boolean(true) // Boolean{true}

var symbol = new Symbol(1) // TypeError
```

像上面这种使用`new Number、new String`等创建的基本数据类型被称之为：**围绕原始数据类型创建一个显式包装器对象**。

通俗点说就是：用`new`来创建基本类型的包装类。

而这种做法在`ES6`之后就不被支持了，从`new Symbol(1)`报错就可以看出来，现在使用的是不带`new`的方式：`var symbol = Symbol(1)`，所以它作为构造函数来说是不完整的。

但是因为历史遗留的原因，`new Number`仍然可以这样用，不过并不推荐。

如果你真的想创建一个 Symbol 包装器对象 (`Symbol wrapper object`)，你可以使用 `Object()` 函数：

```javascript
var sym = Symbol(1)
console.log(typeof sym) // "symbol"
var symObj = Object(sym)
console.log(typeof symObj) // "object"
```

## 第二补：JS类型检测

### 1. instanceof能否判断基本数据类型？

什么意思呢 🤔️？

正常来说，`instanceof`是用来判断某个对象的原型链上是否能够查找到某个构造函数的原型对象。

来看看通俗点的简介：

`a instanceof B`

`实例对象a instanceof 构造函数B`

检测`a`的原型链`(__proto__)`上是否有`B.prototype`，有则返回`true`，否则返回`false`。

那么它可以用来判断基本数据类型吗？

也就是说我定义了一个`var num = 1`，我可以用`instanceof`来判断它是一个`number`类型的变量吗？

如果你试图这样写：

```javascript
var num = 1;
console.log(num instanceof Number) // false
```

发现结果是`false`。

此时你可以用`Symbol.hasInstance`来实现一个自定义`instanceof`的行为。

首先想想我们是要实现一个什么功能？

```javascript
a instanceof B
```

左侧的`a`是一个变量，而右侧的`B`是一个构造函数，而`class`的本质也是一个构造函数。

所以在这个需求中，我们可以定义一个叫做`MyNumber`的类，在其里面封装一层，暴露一个静态方法用来判断数据类型：

```javascript
class MyNumber {
    static [Symbol.hasInstance](instance) {
        return typeof instance === 'number'
    }
}
var num = 1;
console.log(num instanceof MyNumber) // true
```

- 在类`MyNumber`中定义了一个名为`Symbol.hasInstance`的静态方法
- 这个方法接收的是一个实例对象`instance`
- 返回值为`typeof`判断是否是`number`类型

这里比较难理解的就是`Symbol.hasInstance`了，第一次接触它也不知道它是个啥 😂。找了一波[MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance) 上对它的介绍：

`用于判断某对象是否为某构造器的实例。`

然后试着写了几个案例，发现也不用把它想的那么复杂，你就简单理解，当我们在使用`instanceof`的时候，能够自定义右侧构造函数(类)它的`instanceof`验证方式就可以了。

就像是上面👆那个案例一样，我在`MyNumber`重写了静态方法`Symbol.hasInstance`，让它的验证方式变成`type instance === 'number'`。

那么为什么是静态方法呢(也就是在方法前面加上`static`)，通过阅读[《🔥【何不三连】比继承家业还要简单的JS继承题-封装篇(牛刀小试)》](https://juejin.im/post/5e707417e51d45272054d5d3)我们知道，静态方法是挂载在`MyNumber`这个类上的方法，因此我们甚至可以把下面的内容换一种写法：

```javascript
console.log(num instanceof MyNumber) // true
// 换成：
console.log(MyNumber[Symbol.hasInstance](num)) // true
```

看到了吧，它其实就是一个方法名而已，而这个方法因为是静态的，在`MyNumber`上的，因此我们可以用`MyNumber[Symbol.hasInstance]`这种方式调用。

想想，如果没有`static`这个关键字呢？

没有`static`的话，定义在类里的方法就相当于是挂载到类的原型对象上，那么如果我们想要使用它，一种就是直接用`MyNumber.prototype`调用，还有一种就是使用`new MyNumber()`生成一个实例来调用：

```javascript
class MyNumber {
    [Symbol.hasInstance](instance) { // 没有 static
        return typeof instance === 'number'
    }
}
var num = 1

console.log(num instanceof new MyNumber()) // true
console.log(num instanceof MyNumber.prototype) // true

// 转化为：
console.log(MyNumber.prototype[Symbol.hasInstance](num)) // true
console.log(new MyNumber()[Symbol.hasInstance](num)) // true
```

所以现在回过头来看看：

```javascript
class MyNumber {
    static [Symbol.hasInstance](instance) {
        return typeof instance === 'number'
    }
}
var num = 1;
console.log(num instanceof MyNumber) // true
```

是不是就好理解多了呢？

那么假如我现在想要你实现一个用`instanceof`判断是不是数组的类`MyArray`，该如何去写呢？

思考🤔...

唔...上答案：

```javascript
class MyArray {  
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}
console.log([] instanceof MyArray); // true
```

### 2. instanceof的查找路线？

上面我们说到了`instanceof`是用来判断某个对象的原型链上是否能够查找到某个构造函数的原型对象。

并且是会沿着原型链一层一层的向上查找，直到到达原型链的末位。

那这个过程具体是怎样的呢？让我们来看一个例子🌰：

```javascript
function Parent () {
  this.name = 'parent'
}
function Child () {
  this.sex = 'boy'
}
Child.prototype = new Parent()
var child1 = new Child()

console.log(child1 instanceof Child)
console.log(child1 instanceof Parent)
console.log(child1 instanceof Object)
```

结果为：

```
true
true
true
```

这里其实用到了原型链继承，`Chind`继承于`Parent`，而且三个构造函数的原型对象都存在于`child1`的原型链上。

也就是说，左边的`child1`它会向它的原型链中不停的查找，看有没有右边那个构造函数的原型对象。

例如`child1 instanceof Child`的查找顺序：

```javascript
child1 -> child1.__proto__ -> Child.prototype
```

`child1 instanceof Parent`的查找顺序：

```javascript
child1 -> child1.__proto__ -> Child.prototype
-> Child.prototype.__proto__ -> Parent.prototype
```

还不理解？

没关系，我还有大招：

我在上面👆原型链继承的思维导图上加了三个查找路线。

被⭕️标记的`1、2、3`分别代表的是`Child、Parent、Object`的原型对象。

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

好滴，一张图简洁明了。以后再碰到`instanceof`这种东西，按照我图上的查找路线来查找就可以了 😁 ～

### 3. isPropertypeOf()有什么作用？

既然说到了`instanceof`，那么就不得不提一下`isPrototypeOf`这个方法了。

它属于`Object.prototype`上的方法，这点你可以将`Object.prototype`打印在控制台中看看。

`isPrototypeOf()`的用法和`instanceof`相反。

它是用来判断指定对象`object1`是否存在于另一个对象`object2`的原型链中，是则返回`true`，否则返回`false`。 

例如还是上面👆这道题，我们将要打印的内容改一下：

```javascript
function Parent () {
  this.name = 'parent'
}
function Child () {
  this.sex = 'boy'
}
Child.prototype = new Parent()
var child1 = new Child()

console.log(Child.prototype.isPrototypeOf(child1))
console.log(Parent.prototype.isPrototypeOf(child1))
console.log(Object.prototype.isPrototypeOf(child1))
```

这里输出的依然是三个`true`：

```javascript
true
true
true
```

判断的方式只要把**原型链继承instanceof查找思维导图**这张图反过来查找即可。

更多关于`instanceOf`的内容可以戳这里👇：

[💦【何不三连】做完这48道题彻底弄懂JS继承(1.7w字含辛整理-返璞归真)](https://juejin.im/post/5e75e22951882549027687f9#heading-9)

### 4. Object.is()和===的区别？

- 对于`+0`和`-0`的判断不同
- 对于`NaN`和`NaN`的判断不同

```javascript
console.log(+0 === -0) // true
console.log(Object.is(+0, -0)) // false
console.log(NaN === NaN) // false
console.log(Object.is(NaN, NaN)) // true
```

其实不需要特意的去记，你只需要理解，`Object.is()`在`===`的基础上修复了这些特殊情况的失误。

也就是说：`+0`和`-0`本就该不相等的，这点从`1 / +0`为`Infinity`，`1 / -0`为`-Infinity`上可以看出。

(但是`+0`和`0`是没有区别的)

而`NaN`表示的都是非数字，所以应该是相等的。

因此`Object.is()`的内部其实是做了一些修复的处理：

```javascript
function is (x, y) {
  if (x === y) {
    return x !== 0 || 1 / x === 1 / y;
  } else {
    return x !== x && y !== y;
  }
}
```

这里可以怎样理解呢 🤔️？

- 当`x === y`的时候，就是用来处理`+0, -0, 0`的特殊情况。

在这个判断中，首先会判断出`x和y`是不是都是`+0, -0, 0`中的其中一个(因为我们知道不论是这三个中的哪一个和`0`进行全等比较，结果都会是`true`，所以`x !== 0`就会是`false`)，而根据`||`的短路原则，前面一项为`false`，那么最终的结果取决于后面一项。

所以`x !== 0`相当于是把`x, y`为`+0, -0, 0`的情况推给了`1 / x === 1 / y`，用它的结果来决定最后的结果。

(在三元的原文中这段判断是这样写的`return x !== 0 || y !== 0 || 1 /x === 1 / y`，比我这里多了一个`|| y !== 0`。经评论区小伙伴[matteokjh](https://juejin.im/user/5c7747976fb9a049ac79d82c)提示，觉得可以把`|| y !== 0`的判断省略掉，另外[MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/is)上对它的`polyfill`也是没有这一步的，我想了一下：因为能进入到`x === y`里，那么如果`x !== 0` 成立的话，那么`y !== 0`肯定也成立了，貌似是可以省去。另外我把省去的代码执行了一下，和没有省去时的执行结果一样的，所以我感觉可行。)

而且我们又知道`1 / +0`为`Infinity`，`1 / -0`为`-Infinity`，所以如果`x, y`为`+0或者-0`的时候是不相等的，以此来实现`Object.is(+0, -0)的结果为false`。

- 当`x !== y`的时候，就是用来处理`NaN, NaN`的特殊情况。

因为我们知道`NaN !== NaN`的，那么如果`x`和`y`都不和它们自己相等的话，说明两个都是`NaN`了，而如果都是`NaN`的话，`Object.is(NaN, NaN)`的结果为`true`。

## 第三补：toString()方法的妙用

### 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/14.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()`方法

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

### 2. 谁可以调用toString()？

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

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

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

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

### 3. 如何用toString()判断某个数据的具体类型？

可能大家看的比较多的一种用法是这样的：

```javascript
Object.prototype.toString.call({ name: 'obj' }) // '[object Object]'
```

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javascript/-%E5%8E%9F%E7%94%9FJS%E8%A1%A5%E7%BB%99(%E4%B8%8A)
