JS类型检测

类型

首先贴下ECMA定义的类型

基本数据类型:

  • Number(数字)
  • String(字符串)
  • Boolean(布尔)
  • Symbol(符号)(第六版新增)
  • Null(空)
  • Undefined(未定义)

复杂数据类型:

  • Object

Object 包含:

  • Function(函数)
  • Array(数组)
  • Date(日期)
  • RegExp(正则表达式)
  • Error (错误)

typeof

typeof 是一元运算符,返回时数据的类型字符串,看代码

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
let number  = 1;
let str = 'str';
let func = function(){};
let arr = [];
let obj = {};
let bool = true;
let unde = undefined;
let na = NaN;
let sy = Symbol('test');
let nu = null;


console.log(typeof number); // number

console.log(typeof str); // string

console.log(typeof func); // function

console.log(typeof arr); // object

console.log(typeof obj); // object

console.log(typeof bool); // boolean

console.log(typeof unde); // undefined

console.log(typeof na); // number

console.log(typeof sy); // symbol

console.log(typeof nu); // object

typeof 能静准的判断基本数据类型,却不能精准的判断引用数据类型

instanceof

instanceof 运算符用来检测 constructor.prototype 是否存在于参数 object 的原型链上。就是检查是否属于某个目标的实例

1
2
3
4
5
6
7
8
9
10
11
12
13
function c(){}
function d(){}

let cc = new c();

console.log(cc instanceof c); // true 因为 Object.getPrototypeOf(o) === C.prototype

console.log(cc instanceof d); // false
console.log(cc instanceof Object); // true
console.log(d instanceof Object); // true

c.prototype = {};
console.log(cc instanceof c); // false c.prototype指向了一个空对象,这个空对象不在cc的原型链上

instanceof 只能检测是否是目标的实例(处于目标的原型链上)

Object.prototype.toString.call

让检测对象的prototype上有Object.prototype的toString方法

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
let number  = 1;
let str = 'str';
let func = function(){};
let arr = [];
let obj = {};
let bool = true;
let unde = undefined;
let na = NaN;
let sy = Symbol('test');
let nu = null;

const toString = Object.prototype.toString;

console.log(toString.call(number)); // [object Number]

console.log(toString.call(str)); // [object String]

console.log(toString.call(func)); // [object Function]

console.log(toString.call(arr)); // [object Array]

console.log(toString.call(obj)); // [object Object]

console.log(toString.call(bool)); // [object Boolean]

console.log(toString.call(unde)); // [object Undefined]

console.log(toString.call(na)); // [object Number]

console.log(toString.call(sy)); // [object Symbol]

console.log(toString.call(nu)); // [object Null]

完美~

安利一个函数检测数据类型:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
function isType(val,type){
return Object.prototype.toString.call(val) === `[object ${type}]`;
};

const Type = Object.defineProperties({},{
'Array': {
enumerable: true,
value: 'Array'
},
'Object': {
enumerable: true,
value: 'Object'
},
'Function': {
enumerable: true,
value: 'Function'
},
'String': {
enumerable: true,
value: 'String'
},
'Number': {
enumerable: true,
value: 'Number'
},
'Boolean': {
enumerable: true,
value: 'Boolean'
},
'Symbol': {
enumerable: true,
value: 'Symbol'
},
'Undefined': {
enumerable: true,
value: 'Undefined'
},
'Null': {
enumerable: true,
value: 'Null'
}
});

// 使用
console.log(isType(number,Type.Number));

console.log(isType(str,Type.String));

console.log(isType(func,Type.Function));

console.log(isType(arr,Type.Array));

console.log(isType(obj,Type.Object));

console.log(isType(bool,Type.Boolean));

console.log(isType(unde,Type.Undefined));

console.log(isType(sy,Type.Symbol));

console.log(isType(nu,Type.Null));