JS类型检测

类型

首先贴下ECMA定义的类型

基本数据类型：

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

复杂数据类型:

• Object

Object 包含：

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

typeof

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

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 的原型链上。就是检查是否属于某个目标的实例

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方法

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]

完美~

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

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));