1.typeof类型检测
var a;
var b=null;
var c=true;
var d=1;
var e='s';
var f=[1,2];
var g={name:'kk'};
var h=function(){};
var i=new h();
console.log(typeof(a));
console.log(typeof(b));
console.log(typeof(c));
console.log(typeof(d));
console.log(typeof(e));
console.log(typeof(f));
console.log(typeof(g));
console.log(typeof(h));
console.log(typeof(i));
结果
typeof返回结果
可以发现
- typeof返回的内容有undefinded,boolen,number,string,object,function.
- null返回的是object而undefined还是undefined。数组返回的也是object，typeof不区分对象是由谁创建的，包括内置对象
2.instanceof
用法：o instanceof c,如果o继承自c.propotype(可以不是直接继承)，则返回true。如果o不是对象的话则返回false
var a;
var b=null;
var c=true;
var d=1;
var e='s';
var f=[1,2];
var g={name:'kk'};
var h=function(){};
var i=new h();
var j=/\s/;
console.log(a instanceof Object);
console.log(b instanceof Object);
console.log(c instanceof Boolean);
console.log(c instanceof Object);
console.log(d instanceof Object);
console.log(e instanceof Object);
console.log(f instanceof Object);
console.log(f instanceof Array);
console.log(g instanceof Object);
console.log(h instanceof Object);
console.log(i instanceof h);
console.log(j instanceof RegExp);
结果
instanceof
可以发现
- instanceof是检测对象用的，可以检测对象的特定类型，只要左边不是对象就返回false，如
var a=true; a instanceof Boolean==>false, - function的instanceof是object
3.Object.propotype.toString.call(obj).slice(8,-1)
类属型法。
很多对象重写了toSting，需要调用Object对象上的，返回形式[object class].
function classof(o){
if(o===null) return 'Null';
if(o===undefined) return 'Undefined';
return Object.prototype.toString.call(o).slice(8,-1);
}
var a;
var b=null;
var c=false;
var d=1;
var e='s';
var f=[1,2];
var g={name:'kk'};
var h=function(){};
var i=new h();
var j=/\s/;
console.log(classof(a));
console.log(classof(b));
console.log(classof(c));
console.log(classof(d));
console.log(classof(e));
console.log(classof(f));
console.log(classof(g));
console.log(classof(h));
console.log(classof(i));
console.log(classof(j));
结果
类属性法
可以发现
- 能够识别内置对象但不能识别自定义对象的类别。
- 返回Null，Undefined，Boolean，Number，String，Array，Object，自定义对象。
4.constructor法
原理:返回构造函数的名称。
Function.prototype.getName=function(){
if('name' in this) return this.name;
return this.name=this.toString().match(/function\s*([^(]*)\(/);
}
function typeAndValue(x){
if(x===null) return 'Null';
if(x===undefined) return 'Undefined';
return x.constructor.getName();
}
var a;
var b=null;
var c=false;
var d=1;
var e='s';
var f=[1,2];
var g={name:'kk'};
var h=function(){};
var i=new h();
var j=/\s/;
console.log(typeAndValue(a));
console.log(typeAndValue(b));
console.log(typeAndValue(c));
console.log(typeAndValue(d));
console.log(typeAndValue(e));
console.log(typeAndValue(f));
console.log(typeAndValue(g));
console.log(typeAndValue(h));
console.log(typeAndValue(i));
console.log(typeAndValue(j));
结果
constructor法
可以看出
- 能够返回自定义对象与内置对象的名称
- null与undefined没有constructor需要自己处理。
- 有的对象没有constructor需要特殊处理。
原型链上没有constructor的情况
Function.prototype.getName=function(){
if('name' in this) return this.name;
return this.name=this.toString().match(/function\s*([^(]*)\(/);
}
function typeAndValue(x){
if(x===null) return 'Null';
if(x===undefined) return 'Undefined';
return x.constructor.getName();
}
function Range(from,to){
this.from=from;
this.to=to;
}
Range.prototype={
toString:function(){
return '('+this.from+','+this.to+')'
}
}
var r=new Range(3,4);
console.log(typeAndValue(r))
console.log(Object.prototype.toString(r).slice(8,-1));
结果
都为object
几种方法的综合
function type(o){
var t,c,n
if(o===null) return 'Null';//处理Null
if(o!==o) return 'NaN';//处理NaN特殊
if((t=typeof(o))!=='object') return t;//处理string，boolean，number，function,undefined。
if((c=classof(o))!=='Object') return c//处理内置对象Date
if(o.constructor && typeof(o.constructor)==='function'&&(n=o.constructor.getName())) {return n;}//处理自定义对象
return 'object';
}
function classof(o){
return Object.prototype.toString.call(o).slice(8,-1);
}
Function.prototype.getName=function(){
if('name' in this) return this.name;
return this.name=this.toString().match(/function\s*([^(]*)\(/)[1];
}
var a;
var b=null;
var c=false;
var d=1;
var e='s';
var f=[1,2];
var g={name:'kk'};
var h=function(){};
var i=new h();
var j=/\s/;
console.log(type(a));
console.log(type(b));
console.log(type(c));
console.log(type(d));
console.log(type(e));
console.log(type(f));
console.log(type(g));
console.log(type(h));
console.log(type(i));
console.log(type(j));
结果
综合
可以发现
- 以typeof处理基本类型（undefined，boolean，number，string，function）第一个字母是小写的。
- 以类属性法处理内置对象Object.prototype.toString.call(obj).slice(8,-1)（Date，RegExp），第一个字母大写的
- 以constructor法处理自定义类别和普通的Object（Object，h），注意Object是首字母大写。
