javascript四种类型识别的方法

JavaScript 数据类型

值类型(基本类型)：字符串（String）、数字(Number)、布尔(Boolean)、对空（Null）、未定义（Undefined）、Symbol。

引用数据类型：对象(Object)、数组(Array)、函数(Function)。

注：Symbol 是 ES6 引入了一种新的原始数据类型，表示独一无二的值。

typeof运算符

typeof是一元运算符，放在单个操作数的前面，返回值为表示操作数类型的首字母小写的字符串

　　[注意]typeof运算符后面带不带圆括号都可以

识别

　　【1】可以识别标准类型(将Null识别为'object')　

　　【2】不能识别具体的对象类型(Function除外)

  console.log(typeof 1); // number
  console.log(typeof '1'); // string
  console.log(typeof null); // object
  console.log(typeof d); // undefined
  console.log(typeof {}); // object
  console.log(typeof []); // object
  console.log(typeof function () {}); // function
  console.log(typeof Symbol('h')); // symbol

由以上可以看出typeof可以判断大多数数据类型，但是对于null、数组和对象返回的都是object。

 [注意]判断一个值是否为null类型的最佳方法是直接和null进行恒等比较

  console.log(null === null); // true
  console.log(undefined === null); // false

instanceof运算符

    　　　　instanceof是一个二元运算符，左操作数是一个对象，右操作数是一个构造函数。如果左侧的对象是右侧构造函数的实例对象，则表达式返回true；否则返回false

　　如果左操作数不是对象，返回false，如果右操作数不是函数，则抛出一个类型错误异常TypeError

　[注意]所有的对象都是Object的实例

识别

　　【1】可以识别内置对象类型、自定义类型及其父类型

　　【2】不能识别标准类型，会返回false

　　【3】不能识别undefined、null，会报错

　　基本类型

  console.log("string" instanceof String);//false
  console.log(1 instanceof Number);//false
  console.log(Symbol('h') instanceof Symbol); // false
  console.log(true instanceof Boolean);//false
  console.log(undefined instanceof Undefined);//报错
  console.log(null instanceof Null);//报错

　　内置对象类型

  var arr = [], obj = {}, fun = function () {};
  console.log(arr instanceof Array, arr instanceof Object, arr instanceof Function); // true true false
  console.log(obj instanceof Array, obj instanceof Object, obj instanceof Function); // false true false
  console.log(fun instanceof Array, fun instanceof Object, fun instanceof Function); // false true true

  console.log(new Date instanceof Date); // true
  console.log(/d/ instanceof RegExp); // true

　　typeof 结合 instanceof 封装一个识别数据类型的方法，可以识别数组与对象。

function getType(param) {
    var typeString = typeof param;
    if (param === null) return 'null';
    if (typeString !== 'object') return typeString; 
    if (!(param instanceof Array)) return 'object';
    if (param instanceof Array) return 'array';
    return '未知类型';
  }

我们可以用下面的代码实现instanceof。

function instance(left,right){
    let prototype = right.prototype;  //获取类型的原型
    let proto = left.__proto__;       //获取对象的原型
    while(true){    //循环判断对象的原型是否等于类型的原型，直到对象原型为null，因为原型链最终为null
       if (proto === null || proto === undefined){
           return false;
       }
       if (proto === prototype){
           return true;
       }
       proto = proto.__proto__;
     }
}
console.log(instance({},Object)); //true
console.log(instance([],Number)); //false

　　

constructor属性

实例对象的constructor属性指向其构造函数。如果是内置类型，则输出function 数据类型(){[native code]}；如果是自定义类型，则输出function 数据类型(){}

识别

　　【1】可以识别标准类型、内置对象类型及自定义类型

　　【2】不能识别undefined、null，会报错，因为它俩没有构造函数

  var s = Symbol('s'), fun = function () {};
  console.log((1).constructor); // ƒ Number() { [native code] }
  console.log(('1').constructor); // ƒ String() { [native code] }
  console.log(true.constructor); // ƒ Boolean() { [native code] }
  console.log([].constructor); // ƒ Array() { [native code] }
  console.log({}.constructor); // ƒ Object() { [native code] }
  console.log(fun.constructor); // ƒ Function() { [native code] }
  console.log(s.constructor); // ƒ Symbol() { [native code] }

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

    使用构造函数封装一个识别数据类型的方法

  function getType(param) {
    if (param === null) return 'null';
    if (param === undefined) return 'undefined';
    var typeString = param.constructor.toString();
    return typeString.replace(/^function (w+)().+$/,'$1'); 
  }

Object.prototype.toString()方法

　　对象的类属性是一个字符串，用以表示对象的类型信息。javascript没有提供设置这个属性的方法，但有一种间接方法可以查询它。Object.prototype.toString()方法返回了如下格式的字符串：[object 数据类型]

识别

　　【1】可以识别标准类型及内置对象类型

　　【2】不能识别自定义类型

  console.log(Object.prototype.toString.call(1)); // [object Number]
  console.log(Object.prototype.toString.call('1')); // [object String]
  console.log(Object.prototype.toString.call(true)); // [object Boolean]
  console.log(Object.prototype.toString.call(null)); // [object Null]
  console.log(Object.prototype.toString.call(undefined)); // [object Undefined]
  console.log(Object.prototype.toString.call([])); // [object Array]
  console.log(Object.prototype.toString.call({})); // [object Object]
  console.log(Object.prototype.toString.call(function () {})); // [object Function]
  console.log(Object.prototype.toString.call(Symbol('s'))); // [object Symbol]

  将Object.prototype.toString()方法封装成一个类型识别方法

  function getType(param) {
    return Object.prototype.toString.call(param).replace(/^[object (w+)]$/,'$1'); 
  }