js判断对象是否是某一类型

判断JavaScript对象是否是某一类型有多种方法，下面介绍几种主要的方法。

1. 使用typeof运算符

typeof 运算符可以判断值的类型，对基本类型具有很好的支持。不过对于一些引用类型，typeof 返回的结果并不准确。

const num = 1;
console.log(typeof num); // "number"

const str = "hello";
console.log(typeof str); // "string"

const bool = true;
console.log(typeof bool); // "boolean"

const arr = [1,2,3];
console.log(typeof arr); // "object"

const obj = { name: "Tom", age: 18 };
console.log(typeof obj); // "object"

const func = function() {};
console.log(typeof func); // "function"

可以看到 typeof 运算符的结果是一个字符串，它返回值的类型名称。 对于基本数据类型有较好的支持，不过对于数组、函数和对象这些引用类型，typeof 判断的结果都是 "object"，这就显得不够准确。

2. 使用instanceof运算符

instanceof 运算符使用方法：对象 instanceof 类型

const num = new Number(1);
console.log(num instanceof Number); // true

const str = new String("hello");
console.log(str instanceof String); // true

const bool = new Boolean(true);
console.log(bool instanceof Boolean); // true

const arr = [1,2,3];
console.log(arr instanceof Array); // true

const obj = { name: "Tom", age: 18 };
console.log(obj instanceof Object); // true

function Person(name) {
  this.name = name;
}
const person = new Person("Mike");
console.log(person instanceof Person); // true

可以看到，instanceof 运算符可以准确地判断对象是否属于某一类型。但是如果检查一个对象是否属于 Object 类型，instanceof 运算符并不能给出正确的结果。

3. 使用toString()方法

const num = 1;
console.log(Object.prototype.toString.call(num)); // "[object Number]"

const str = "hello";
console.log(Object.prototype.toString.call(str)); // "[object String]"

const bool = true;
console.log(Object.prototype.toString.call(bool)); // "[object Boolean]"

const arr = [1,2,3];
console.log(Object.prototype.toString.call(arr)); // "[object Array]"

const obj = { name: "Tom", age: 18 };
console.log(Object.prototype.toString.call(obj)); // "[object Object]"

const func = function() {};
console.log(Object.prototype.toString.call(func)); // "[object Function]"

这种方式在各种对象类型的判断上都表现良好，但是麻烦的是需要借用 Object.prototype.toString() 方法来确定类型。

4. 使用ES6新特性，检查是否实现了Symbol.hasInstance方法

ES6 提供的 Symbol.hasInstance 方法可以判断一个对象是否是一个构造函数的实例。

一般写法：

class Person {}

const person = new Person();
console.log(person instanceof Person); // true

const num = 1;
console.log(num instanceof Number); // false
console.log(Number[Symbol.hasInstance](num)); // true

const str = "hello";
console.log(str instanceof String); // false
console.log(String[Symbol.hasInstance](str)); // true

const bool = true;
console.log(bool instanceof Boolean); // false
console.log(Boolean[Symbol.hasInstance](bool)); // true

const arr = [1,2,3];
console.log(arr instanceof Array); // true
console.log(Array[Symbol.hasInstance](arr)); // true

const obj = { name: "Tom", age: 18 };
console.log(obj instanceof Object); // true
console.log(Object[Symbol.hasInstance](obj)); // true

function Person2(name) {
  this.name = name;
}
Person2[Symbol.hasInstance] = function(obj) {
  if (obj instanceof Array) {
    return true;
  }
  return false;
}
const person2 = new Person2("Mike");
console.log(person2 instanceof Person2); // false
console.log(person2 instanceof Array); // true

可以看到，这种方式不仅支持原有的判断对象类型的方式，还支持用户自定义检查方式。

因此，从上面的介绍中，我们可以看到不同的方式都有其各自不同的优缺点，应根据实际情况选择合适的方法来判断对象是否是某一类型。