判断类型

发表于 | 分类于 ，

JS判断类型的方式

  • typeof

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    typeof ''            // 'string'
    typeof {}            // 'object'
    typeof null          // 'object'
    typeof []            // 'object'
    typeof 5             // 'number'
    typeof NaN           // 'number'
    typeof (() => {})    // 'function'
    typeof true          // 'boolean'
    typeof undefined     // 'undefined'
    typeof Symbol()      // 'symbol'
    typeof 42n           // 'bigint'

Symbol,可以用作对象中的键。BigInt,一种方法来表示大于 253 - 1 的整数。

在 JavaScript 最初的实现中，JavaScript 中的值是由一个表示类型的标签和实际数据值表示的。对象的类型标签是 0。由于 null 代表的是空指针（大多数平台下值为 0x00），因此，null 的类型标签是 0，typeof null 也因此返回 "object"。

new 操作符： 除 Function 外的所有构造函数的类型都是 ‘object’

1
2
3
4
5
6
7
8
9
var str = new String('String');
var num = new Number(100);

typeof str; // 返回 'object'
typeof num; // 返回 'object'

var func = new Function();

typeof func; // 返回 'function'

加入了块级作用域的 let 和 const 之后，在其被声明之前对块中的 let 和 const 变量使用 typeof 会抛出一个 ReferenceError。

1
2
3
4
5
6
7
typeof newLetVariable; // ReferenceError
typeof newConstVariable; // ReferenceError
typeof newClass; // ReferenceError

let newLetVariable;
const newConstVariable = 'hello';
class newClass{};

instanceof 运算符用来检测 constructor.prototype是否存在于参数 object 的原型链上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
var a = {}
a instanceof Object // true
var b = []
b instanceof Array // true
var c = 7
c instanceof Number // false
c = new Number(7) //__proto__: Number
                  // [[PrimitiveValue]]: 7
c instanceof Number // true
var d = ''
d instanceof String // false
d = new String('')
/*
	length: 0
	__proto__: String
	[[PrimitiveValue]]: ""
	*/
d instanceof String // true

null instanceof Object // false

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}
var mycar = new Car("Honda", "Accord", 1998);
var a = mycar instanceof Car;    // true
var b = mycar instanceof Object; // true

// 注意,检测对象不是某个构造函数的实例
if (!(mycar instanceof Car)) {
  // Do something, like mycar = new Car(mycar)
}
if (!mycar instanceof Car) {} // 这段代码永远会得到 false（!mycar 将在 instanceof 之前被处理，所以你总是在验证一个布尔值是否是 Car 的一个实例）。
1
2
3
4
({}).constructor === Object // true
('').constructor === String // true
([]).constructor === Array // true
(7).constructor === Number // true
  • Object.prototype.toString 
1
2
3
4
5
6
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call('') // "[object String]"
Object.prototype.toString.call(7) // "[object Number]"
Object.prototype.toString.call([]) // "[object Array]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(function () {}) // "[object Function]"

JavaScript 标准文档中定义: [[Class]] 的值只可能是下面字符串中的一个： Arguments, Array, Boolean, Date, Error, Function, JSON, Math, Number, Object, RegExp, String.

为什么是Object.prototype.toString？而不是obj.toString?

因为toString可能被改写。

  • 其他方法
1
Array.isArray([]) // true