js检测数据类型的几种方法总结

文章目录

• 一、typeof
• 二、instanceof
• • 1. 基础类型
  • 2. 复杂类型（万物皆对象）
• 三、constructor
• 四、Object.prototype.toString.call()
• • Object.prototype.toString.call(obj)类型检测原理

---

一、typeof

1. typeof在对值类型number、string、boolean 、symbol、 undefined、 function的反应是精准的；
2. 但对于对象{ } 、数组[ ] 、null 都会返回 object

console.log(typeof ""); // string
console.log(typeof 1); // number
console.log(typeof NaN); // number
console.log(typeof true); // boolean
console.log(typeof Symbol(1)) // "symbol"
console.log(typeof undefined); // undefined
console.log(typeof function(){}); // function

console.log(typeof null); // object   (巨坑...)
console.log(typeof []); // object
console.log(typeof {}); //object

---

二、instanceof

typeof运算符把对象、数组、null都返回object，为了弥补这一点，instanceof从原型的角度，来判断该对象是谁的实例。

1. 用 instanceof 判断一个实例是否属于某种类型
2. instanceof 运算符只能用于对象，不能用于原始类型的值

// 检测构造函数B的原型是否有出现在对象A的原型链上。
A instanceof B 

[] instanceof Array // true
[].__proto__ == Array.prototype // true

1. 基础类型

console.log("1" instanceof String); // false
console.log(1 instanceof Number); // false
console.log(NaN instanceof Number); // false
console.log(true instanceof Boolean); // false

上面之所以都返回false是因为不是对象，而是基本类型。

封装成对象后才返回true，如下：

console.log(new String("1") instanceof String); // true
console.log(new Number(1) instanceof Number); // true
console.log(new Number(NaN) instanceof Number); // true
console.log(new Boolean(true) instanceof Boolean); // true

new是封装成对象，而没有new的只是基础类型转换，还是基础类型

一个是引用类型，一个是基本类型

console.log(new String("1"), "1");
console.log(new Number(1), 1);
console.log(new Number(NaN), NaN);
console.log(new Boolean(true), true);

2. 复杂类型（万物皆对象）

console.log([] instanceof Array); // true
console.log([] instanceof Object); // true

console.log({} instanceof Object); //true

console.log(function(){} instanceof Function); // true
console.log(function(){} instanceof Object); // true

console.log((new Number(1)) instanceof Number); // true
console.log((new Number(1)) instanceof Object); // true

小坑

console.log(undefined instanceof undefined); // 报错
console.log(null instanceof null); // 报错

巨坑

console.log(null instanceof Object); // false
console.log(typeof null); // object

---

三、constructor

constructor 是每个实例对象都拥有的属性

function Hello() {}; // 构造函数
var h = new Hello(); // 实例化对象

console.log(Hello.prototype.constructor == Hello); // true
console.log(h.constructor == Hello); // true ()

console.log(("1").constructor === String); // true
console.log((1).constructor === Number); // true
console.log((NaN).constructor === Number); // true
console.log((true).constructor === Boolean); // true
console.log(([]).constructor === Array); // true
console.log((function () {}).constructor === Function); // true
console.log(({}).constructor === Object); // true
console.log((Symbol(1)).constructor === Symbol); // true

console.log((null).constructor === Null); // 报错
console.log((undefined).constructor === Undefined); // 报错

用costructor来判断类型看起来是完美的，然而，如果我创建一个对象，更改它的原型，这种方式也变得不可靠了。

function Fn(){};
Fn.prototype=new Array(); // 改变原型
var f=new Fn();

console.log(f.constructor===Fn);    // false
console.log(f.constructor===Array); // true 

这里声明了一个Fn的构造函数，并且把他的原型指向了Array的原型，所以这种情况下，constructor也显得力不从心了。

---

四、Object.prototype.toString.call()

完美精准 的返回各种数据类型

const a = Object.prototype.toString;

console.log(a.call(1)); // [object Number]
console.log(a.call("1")); // [object String]
console.log(a.call(NaN)); // [object Number]
console.log(a.call(true)); // [object Boolean]
console.log(a.call(Symbol(1))); // [object Symbol]
console.log(a.call(null)); // [object Null]
console.log(a.call(undefined)); // [object Undefined]
console.log(a.call([])); // [object Array]
console.log(a.call({})); // [object Object]
console.log(a.call(function () {})); // [object Function]


function Fn(){};
Fn.prototype=new Array(); // 改变原型
var f=new Fn();
console.log(a.call(Fn)); // [object Function]

稍微简单封装下：

// 定义检测数据类型的功能函数
function checkedType(target) {
	return Object.prototype.toString.call(target).slice(8, -1);
}

console.log(checkedType(1)); // Number
console.log(checkedType("1")); // String
console.log(checkedType(NaN)); // Number
console.log(checkedType(true)); // Boolean
console.log(checkedType(Symbol(1))); // Symbol
console.log(checkedType(null)); // Null
console.log(checkedType(undefined)); // Undefined
console.log(checkedType([])); // Array
console.log(checkedType({})); // Object
console.log(checkedType(function () {})); // Function

Object.prototype.toString.call(obj)类型检测原理

首先，这句话的意思是让我们用Object原型上的toString方法作用在传入的obj的上下文中（通过call将this指向obj），那么我们知道数组本身也有toString()方法，那我们为什么非要用Object上的呢？

Object.toString() // "function Object() { [native code] }"
Object.prototype.toString() // "[object Object]"

Object输出的是其函数体function Object() { [native code] }，而Object上输出的是其类型。
我们可以看出Object对象和它的原型链上各自有一个toString()方法，第一个返回的是一个函数，第二个返回的是值类型。

toString为Object的原型方法，而Array 、Function等类型作为Object的实例，都重写了toString方法。不同的对象类型调用toString方法时，根据原型链的知识，调用的是对应的重写之后的toString方法（Function类型返回内容为函数体的字符串，Array类型返回元素组成的字符串…），而不会去调用Object上原型toString方法（返回对象的具体类型），所以采用obj.toString()不能得到其对象类型，只能将obj转换为字符串类型；因此，在想要得到对象的具体类型时，应该调用Object上原型toString方法。

我们可以验证一下，将数组的toString方法删除，看看会是什么结果：

var arr=[1,2,3];

console.log(Array.prototype.hasOwnProperty("toString"));//true
console.log(arr.toString());//1,2,3

delete Array.prototype.toString;//delete操作符可以删除实例属性

console.log(Array.prototype.hasOwnProperty("toString"));//false

// 删除后的数组再次使用 toString() 时，会向上层访问这个方法，即 Object 的 toString()
console.log(arr.toString());//"[object Array]"

当我们把Array自身的toString()方法删除之后，再次使用它时，由原型链它会向上查找这个方法，即Object的toString()，也便将Object上的toString()方法作用在数组上，得出其数据类型[object Array]