JS判断数据类型

    JS中的数据类型

　　   1.数值型（Number）：包括整数、浮点数。

　　 2.布尔型（Boolean）

　　 3.字符串型（String）

　　 4.对象（Object）

　　 5.数组（Array）

　　 6.空值(Null)

            7.未定义（Undefined）

 

    判断一个变量的数据类型

1.数值型（number）

　　比较常用的判断方法是：

1 function isNumber(val){
2      return typeof val === 'number';
3 }

　　但有些情况就不行，比如：

1 var a;
2 alert(isNumber(parseInt(a)));

页面弹出的结果为 true 其实a没有赋值 a为NaN

   这样的话就需要采用下面的方法：

1 function isNumber(val){
2      return typeof val === 'number' && isFinite(val);
3 }
JavaScript isFinite() 函数，isFinite() 函数用于检查其参数是否是无穷大，如果 number 是有限数字（或可转换为有限数字），那么返回 true。否则，如果 number 是 NaN（非数字），或者是正、负无穷大的数，则返回 false。
 
2.布尔型（boolean）
　　布尔类型的判断比较简单，可以用如下的方法进行判断：
      
      

       
       
1 /*
2 判断变量val是不是布尔类型
3 */
4 function isBooleanType(val) {
5     return typeof val ==="boolean";
6 }
       
       
 
       
       
3. 字符串(String)
　　字符串类型的判断比较简单，可以用如下的方法进行判断：
        
        

         
         
1 /*
2 判断变量是不是字符串类型
3 */
4 function isStringType(val) {
5     return typeof val === "string";
6 }
         
         
 
         
         
4.未定义（Undefined）
　　未定义的判断比较简单，可以用如下的方法进行判断：
          
          

           
           
1 /*
2 判断变量是不是Undefined
3 */
4 function isUndefined(val) {
5     return typeof val === "undefined";
6 }
           
           
 
           
           
5.对象（Object）
　　由于当变量是空值Null时，typeof也会返回object，所以Object不能直接用 typeof 判断。
应该这样：
            
            

             
             

              
              
             
             
             
             
1 function isObj(str){
2     if(str === null || typeof str === 'undefined'){
3         return false;
4     }
5     return typeof str === 'object';
6 }
             
             
 
             
             
6.空值（Null）
　　判断空值用 val === null 即可
              
              

               
               
1 function isNull(val){
2       return  val === null;
3 }
               
               
 
               
               
7.数组（Array）
　　数组类型不可用typeof来判断。因为当变量是数组类型是，typeof会返回object。
　　这里有两种方法判断数组类型:
                
                

                 
                 
 1 /*判断变量arr是不是数组
 2 方法一
 3 */
 4 function isArray1(arr) {
 5     return Object.prototype.toString.apply(arr) === '[object Array]';
 6 }
 7 
 8 /*判断变量arr是不是数组
 9 方法二
10 */
11 function isArray2(arr) {
12     if(arr === null || typeof arr === 'undefined'){
13         return false;
14     }
15     return arr.constructor === Array;
16 }
                 
                 
 
                 
                 
********
                 
                 
                  
                  

                      
                      

                       
                       
 
                        var 
                        type=({}).toString;  
                       
                       
                       
 
                        type.call(1); 
                        //[object Number]  
                       
                       
                       
 
                        type.call({}) 
                        //[object Object]  
                       
                       
                       
 
                        type.call( 
                        "" 
                        ) 
                        //[object String]  
                       
                       
                       
 
                        type.call( 
                        true 
                        ) 
                        //[object Boolean]  
                       
                       
                       
 
                        type.call([]) 
                        //[object Array]  
                       
                       
                       
 
                        type.call(/1/) 
                        //[object RegExp]  
                       
                       
                       
 
                        type.call( 
                        null 
                        ); 
                        //[object Null]  
                       
                       
                       
 
                        type.call(window); 
                        //[object global]  
                       
                       
                       
 
                        type.call(); 
                        //[object Undefined]  
                       
                       
                       
 
                        type.call(window.undef); 
                        //[object Undefined]  
                       
                       
                       
 
                        type.call( 
                        function 
                        (){}); 
                        //[object Function] 
                       
                      
                      
不过判断undefined最好用 typeof ：typeof qwert === "undefined"。如果对象未定义(type.call(qwert)，会报ReferenceError: qwert is not defined异常)