JS typeof、显式类型转换、隐式类型转换的细节

一、typeof操作符，一共可以返回6种类型的数据：string、boolean、number、undefined、function、object。

使用方法有两种如：typeof(demo)和typeof demo。

var demo;
// demo = "abc";    //string
// demo = false;    //boolean
// demo = 123;         //number
// demo = undefined; //undefined
// demo = function(){}; //function
// demo = null;      //object
// demo = {};            //object
// demo = [];            //object
// demo = new Date();    //object
// demo = /\d/;            //object
                
console.log(typeof demo);
console.log(typeof typeof demo); //string

二、显示类型转换：

1.Number()：函数把对象的值转换为数字，如果对象的值无法转换为数字，那么 Number() 函数返回 NaN。

var demo ;
//demo = '123';         //number 123
//demo = '123 234';    //number NaN
//demo = 1.555;        //number 1.555
//demo = false;         //number 0
//demo = true;          //number 1
//demo = undefined;     //number NaN
//demo = null;          //number 0
//demo = '';            //number 0
//demo = '10px';        //number NaN
//demo = [];            //number 0
//demo = [1,2,3];     //number NaN
//demo = {};            //number NaN
//demo = NaN;            //number NaN
//demo = function(){};    //number NaN
//demo = new Date();     //number 1512717020724
//demo = /\d/;            //number NaN
                
var result = Number(demo);
console.log(typeof result, result);    

2.parseInt(string[, radix]) 函数可解析一个字符串，并返回一个整数。【parseInt 是全局函数，不属于任何对象】

var demo;
demo = '123.5';  //number 123
demo = '100.5px';//number 100
demo = 'abc'; //number NaN
demo = false; /number NaN
demo = true; //number NaN
var result = parseInt(demo);
console.log(typeof result, result);

//会把要解析的字符串当成[radix]指定的进制，转为10进制【将目标进制转换为10进制】
demo = 10;    //number 16
var result = parseInt(demo,16);
console.log(typeof result, result);

//参数[radix]:  可选。表示要解析的数字的基数。该值介于 2 ~ 36 之间。
//　　　　　　　　如果省略该参数或其值为 0，则数字将以 10 为基础来解析。如果它以 “0x” 或 “0X” 开头，将以 16 为基数。
//　　　　　　　　如果该参数小于 2 或者大于 36，则 parseInt() 将返回 NaN。

demo = 0x10;    //number 16    当成16进制进行解析，使demo解析成为十进制
demo = 010;    //number 8  当成8进制进行解析，使demo解析成为十进制。
var result = parseInt(demo);
console.log(typeof result, result);


demo = 010; //number NaN
var result = parseInt(demo，37);
console.log(typeof result, result);

3.parseFloat(string)函数可解析一个字符串，并返回一个浮点数。【parseFloat 是全局函数，不属于任何对象】

//该函数指定字符串中的首个字符是否是数字：
//如果是，则对字符串进行解析，直到到达数字的末端为止，然后以数字返回该数字，而不是作为字符串。
//如果不是，则 parseFloat 返回 NaN。
var　　demo;
　　　　demo = '10';   //number 10
　　　　demo = '10.00';//number 10
var result = parseFloat(demo);
console.log(typeof result, result);

4.String() 函数把需要转换的值转换为字符串，并返回。

var demo;
　　demo = 10;    //string 10
　　demo = 10.00;     //string 10 
var result = String(demo);
console.log(typeof result, result);


//如果要转为字符串类型的，一个比较简单的方法，可以“”+要转换的数据。

5.toString([radix])

    var demo;
        demo = 123;//string 123
        demo = false; //string false
        demo = undefined;//报错  Uncaught TypeError: Cannot read property 'toString' of undefined
        demo = null; //报错  Uncaught TypeError: Cannot read property 'toString' of null
    var result = demo.toString();
    console.log(typeof result, result);

 

//会把要解析的字符串当成10进制，转为[radix]指定的进制【将10进制，转换为目标进制】

var 　demo;
　　　 demo = 10; //string a
var result = demo.toString(16);
console.log(typeof result, result);

var 　demo;
　　　 demo = 10; //string 12
var result = demo.toString(8);
console.log(typeof result, result);

var 　demo;
　　　 demo = 10; //string 1010
var result = demo.toString(2);
console.log(typeof result, result);

6.Boolean():

 

var demo;
    demo = undefined;//boolean false
    demo = null; //boolean false
    demo = 0;//boolean false
    demo = 2;//boolean true
    demo = '';//boolean false
    demo = 'a';//boolean true
    demo = [];//boolean true
    demo = {};//boolean true
var result = Boolean(demo);    
console.log(typeof result, result);

 

 

 三、隐式类型转换

1.isNaN(): 判断一个数据是否是NaN，如果给定值为NaN ，则为true;  否则为，false。

//【该方法内部会隐式调用Number()】
var demo; 
　　demo = null;//boolean false
　　demo = undefined;//boolean true
　　demo = [];//boolean false
　　demo = {}; //boolean true
　　demo = '';//boolean false

var result = isNaN(demo);
console.log(typeof result, result);        

2. ++/--、+/-(正负)：

//【运算符内部会隐式调用Number()】
var demo;
    demo = '1';//number 2
    demo = 'a';//number NaN
var result 
　　 result = ++demo;
　　 result = +demo;

console.log(typeof result, result);

3. - * / %:

//【运算符内部会隐式调用Number()】
var demo;
    demo = '3';//number 0
    demo = 'a';//number NaN
var result = demo - 2; //- * / %结果一样
console.log(typeof result, result);    

4. +：

//【+运算符内部会隐式调用String()】 如果要转为字符串类型的，一个比较简单的方法，可以空字符串 "" + '要转换的数据'，就自动转为字符串类型。
var demo;
    demo = '1';//string 11
    demo = 'a';//string a1
var result = demo + 1;
console.log(typeof result, result);    

5.&& || !:

//【内部会隐式调用Bollean()】
var    demo;
       demo = 4; //boolean false
       demo = 'a';//boolean false
       demo = [];//boolean false
       demo = {};//boolean false
       demo = null;//boolean true
       demo = undefined;//boolean true
       demo = 0;//boolean true
       demo = '';//boolean true
var result = !demo;
console.log(typeof result, result);

6.<   >    <=   >=   ==    !=:

//【内部会隐式调用Bollean()】
var demo;
    demo = 1 < 2; //boolean true
    demo = 1 < "2"; //boolean true
    demo = '1'<'2';//boolean true
                
    demo = undefined > 0;//boolean false
    demo = undefined < 0;//boolean false
    demo = undefined == 0;//boolean false

    demo = null > 0;//boolean false
    demo = null < 0;//boolean false
    demo = null == 0;//boolean false

    demo = undefined == null;//boolean true
                
    demo = undefined == false;//boolean false
    demo = undefined == true;//boolean false
                
    demo = null == false;//boolean false
    demo = null == true;//boolean false
                
console.log(typeof demo, demo);

 

转载于:https://www.cnblogs.com/maryaha/p/8005542.html