javascript基礎篇:JS中的數據類型檢測專題

typeof

用來檢測數據類型的運算符
語法:typeof[value]

typeof 12 //=>'number'
typeof NaN //=>'number'
typeof ''=>'string'
var flag=true;
typeof flag //'boolen'
tpeof undefined //=>'undefined'
function fn(n,m){
    if(typeof n==='undefined'){

    }
}
typeof null //=>'object' //雖然是基本數據類型值，可是它屬於空對象指針，檢測的結果是對象
typeof {} //=>'object' 
typeof function(){} //=>'function'
typeof [] //=>'object'
typeof /^$/ //=>'object'
//使用typeof有本身的侷限性，不能具體細分當前的值是數組仍是正則(也就是不能細分對象類型的值)
typeof (1>1?0:2) //=>'number'
typeof 1>1?0:2 //=>先算typeof 1-> 'number'=> 'number'>1?0:2
typeof typeof [] //=>'string'
//=>typeof [] 'object' 
//type of 'object' =>'string'

instanceof & constructor

instanceof : 檢測某一個實例是否屬於某各種的實例
constructor : 構造函數

使用instanceof 檢測某個值是否屬於某一個數據類型的內置類，從而檢測出它是不是這個類型的值；使用instanceof能夠實現typeof實現不了的，對對象類型值詳細的區分檢測;

[] instanceof Array //=>true
[] instanceof RegExp //=>false

使用instanceof檢測也有本身的弊端：
1.基本類型值沒法基於它的檢測

var num =12;
num.toFixed(2) =>'12.00' //12是Number類的一個實例,能夠調取Number.prototype上的方法，可是它是基本類型值

var num2=new Number(12);
num2.toFixed(2) =>'12.00' 
typeof num //=>'number'
typeof num2//=>'object'
//無論是哪種方式建立基本類型值，都是本身所屬類的實例（只不過類型不同而已）
num instanceof Number //=>false
num2 instanceof Number //=>true

2.instanceof 檢測的原理是基於原型鏈檢測的：只要當前類在實例的原型鏈上，最後返回的結果都是true.

var ary=[];
ary instanceof Array //=>true
ary instanceof Object //=>true

function Fn(){}
Fn.prototype=new Array();//=>原型繼承（Fn 是Array的子類）
var f=new Fn();
f instanceof Array //=>true 可是f其實不是數組，雖然在它的原型上能夠找到數組，可是它不具有數組的基礎結構，這也是instanceof的弊端

constructor

獲取當前檢測數據值的constructor,判斷它是不是某一個數據類型內置類來檢測

var ary=[];
ary.constructor===Array //=>true
ary.constructor===RegExp //=>false
ary.constructor===Object //=>false

ary.constructor='AA'
ary.constructor===Array; //false
//=>constructor檢測數據類型很是不可靠，由於這個屬性是常常容易被修改的。

Object.prototype.toString.call

獲取Object.prototype上的toString方法，讓方法中的this變爲須要檢測的數據類型值，而且讓方法執行

在Number、String、Boolean、Array、Function、RexExp...這些類的原型上都有一個toString方法：這個方法就是將自身的值轉換爲字符串的

(12).toString() //=>'12'
(true).toString() //=>'true'
[12,23].toString() //=>'12,23'
...

在Object這個類的原型上也有一個方法toString，可是這個方法並非把值轉換爲字符串，而是 返回當前值的所屬類詳細信息[object 所屬的類]

var obj={name:'tom'}
obj.toString() //=>"[object Object]" 調取的是Object.prototype.toString 

/*
*obj.toString()
*  首先執行Object.prototype.toString 方法
*  這個方法的this就是咱們操做的數據值obj
*  =>總結：Object.prototype.toString執行的時候會返回當前方法中的this的所屬類信息
*
*  也就是，咱們想知道誰是所屬類信息，咱們就把這個toString方法執行，而且讓this變爲咱們檢測的這個數據值，那麼方法返回的結果就是當前檢測這個值的所屬類信息
*  Object.prototype.toString.call([value])
*  ({}).toString.call([value])
*  */

Object.prototype.toString.call(12) //=>'[object Number]'
Object.prototype.toString.call(true) //=>'[object Boolean]'
Object.prototype.toString.call('') //=>'[object String]'
Object.prototype.toString.call({}) //=>'[object Object]'
Object.prototype.toString.call(null) //=>'[object Null]'
Object.prototype.toString.call([]) //=>'[object Array]'
Object.prototype.toString.call(/^$/) //=>'[object RegExp]'
Object.prototype.toString.call(function(){}) //=>'[object Function]'

使用toString檢測數據類型，無論你是什麼類型值，均可以正常檢測出須要的結果(這個方法檢測是萬能的)

alert({name:'tom'})  //[object Object] alert()=>轉換爲字符串彈出 
//若是彈對象字符串 alert(JSON.stringify({name:'tom'}))

檢測數據類型方法封裝

~function(){
    let obj={
        isNumber:'Number',
        isString:'String',
        isBoolean:'Boolean',
        isNull:'Null',
        isUndefined:'Undefined',
        isPlanObject:'Object',
        isArray:'Array',
        isRegExp:'RegExp',
        isFunction:'Function'
    }
    let check={};
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            check[key]=(function(classValue){
                return function(val){
                    return new RegExp('\\[object '+classValue+'\\]').test(Object.prototype.toString.call(val))
                }
            })(obj[key])
        }
    }
    window.check=check;
}()