数据类型 类型转换 NaN undefined

数据类型

基本类型

1. Number 任意数值

2. String 任意字符串

3. Boolean true/false

4. undefined 声明变量但是没有赋值时和接受函数的返回值为空时，就是undefined

   var a;
   console.log(a)                           //undefined
   
   function fn(){} 
   var f = fn()
   console.log(f)                          //undefined
   

5. null 赋值为null ，null 是一个对象，但是无法和对象一样，可以修改数据，null 是 “nothing”。它被看做不存在的事物。

   var a = null;
   console.log(typeof a)                      // object
   // a['age'] = 12;                         // Uncaught TypeError
   // a.name = "小毅"                         // Uncaught TypeError
   console.log(a)                            //null
   
   /*  null 的用法	*/
   
   // 1 、 a 还不知道要存具体的什么数据，可以先让a = null ,后面在重新赋值
   var a = null
   a = [1,2,3,4]
   console.log(a)                       //  [1, 2, 3, 4]
   
   // 2、 清空变量，数组和对象的的内容，可以让a = null 
   var b = [1,2,3,4,5]
   console.log(b.length)
   b = null
   

6. NaNNaN如果通过 == 、 != 、 === 、以及 !==与其他任何值比较都将不相等 – 包括与其他 NAN值进行比较。必须使用 Number.isNaN() 或 isNaN() 函数。在执行自比较之中：NaN，也只有NaN，比较之中不等于它自己。

   console.log(parseInt('哈哈'))                 //NaN
   NaN === NaN;                                 // false
   Number.NaN === NaN;                          // false
   isNaN(NaN);                                  // true
   isNaN(Number.NaN);                           // true
   
   function valueIsNaN(v) { return v !== v; }
   valueIsNaN(1);                               // false
   valueIsNaN(NaN);                             // true
   valueIsNaN(Number.NaN);                      // true
   

7. Undefined 与 Null 的区别

   Undefined 与 null 的值相等，但类型不相等：

   typeof undefined              // undefined
   typeof null                   // object
   null === undefined            // false
   null == undefined             // true
   

引用类型

1. Object

   var obj = {name:"小毅",age:20}
   console.log(typeof obj)               //object
   console.log(obj instanceof Object)    //true
   

2. Array

   var arr = [1,2,3,4,5]
   console.log(typeof arr)             //object
   console.log(arr instanceof Array)   //true
   

3. Function

   function fn(){
       return "哈哈"
   }
   console.log(typeof fn)
   console.log(arr instanceof Array)      //true
   console.log(fn instanceof Function)    //true
   

判断数据类型

1. typeof 可以判断所有的值类型

   请注意：

   • NaN 的数据类型是数值
   • 数组的数据类型是对象
   • 日期的数据类型是对象
   • null 的数据类型是对象
   • 未定义变量的数据类型是 undefined
   • 尚未赋值的变量的数据类型也是 undefined

   无法使用 typeof 去判断 JavaScript 对象是否是数组（或日期）（对象和数组都是Object）

   typeof "Bill"                 // 返回 "string"
   typeof 3.14                   // 返回 "number"
   typeof NaN                    // 返回 "number"
   typeof false                  // 返回 "boolean"
   typeof [1,2,3,4]              // 返回 "object"
   typeof {name:'Bill', age:62}  // 返回 "object"
   typeof new Date()             // 返回 "object"
   typeof function () {}         // 返回 "function"
   typeof myCar                  // 返回 "undefined" *
   typeof null                   // 返回 "object"
   

2. istanceof

   console.log({} instanceof(Object))  //true
   
   console.log([1,2,3] instanceof(Object))//true
   console.log([1,2,3] instanceof(Array))//true
   
   console.log(function fn(){} instanceof(Object))//true
   console.log(function fn(){} instanceof(Function))//true
   
   console.log(typeof '哈哈') //string
   console.log('哈哈' instanceof(String))//false
   

3. === 绝对等于，就是值要相等，数据的类型也要相等(两个等号 ，有时候回进行类型的装换)

   // === 可以用来判断 null 和 undefined 类型
   // 假设a为 null，b 为undefined 的值都有 空 的意思，但是类型不一定一样
   a == b // ture --》a 和 b 的类型不一定一样
   a === b // ture ---》那么a 和 b 的值一定一样，且值相等
   

数据类型装换

通过使用JavaScript 函数

1. 把数值转换为字符串

   String(x)         // 从数值变量 x 返回字符串
   String(123)       // 从数值文本 123 返回字符串
   String(100 + 23)  // 从表达式中的数值返回字符串
   

2. 利用toString()方法

   (123).toString()
   (100 + 23).toString()
   
   false.toString()     // 返回 "false"
   true.toString()      // 返回 "true"
   

3. Number 方法 转换为数字

   Number("3.14")    // 返回 3.14
   Number(" ")       // 返回 0
   Number("")        // 返回 0
   Number("99 88")   // 返回 NaN
   

4. parseInt() 解析字符串并返回整数

   console.log(parseInt('1'))      // 1
   console.log(parseInt(1.1))      // 1
   
   console.log(parseInt(1+'a'))    //1
   console.log(parseInt('a'+1))   //NaN
   console.log(parseInt('a'))     // NaN
   

5. , parseFloat() 解析字符串并返回浮点数

   console.log(parseFloat(2))          //2
   console.log(parseFloat(2.2))        //2.2
   console.log(parseFloat('2.2'))      // 2.2
   
   console.log(parseFloat('a'))       // NaN
   console.log(parseFloat(2 +'2'))    // 22
   console.log(parseFloat(2+'a'))     // 2
   

通过JavaScript本身自动转换 （隐式类型转换）

1. 一元的 + 运算符可用于把变量转换为数字或 NaN（Not a number）：

   var y = "5";      // y 是字符串
   var x = + y;      // x 是数字
   
   var y = "Bill";   // y 是字符串
   var x = + y;      // x 是数字 (NaN)
   

2. JavaScript 在操作不同类型时，会自动进行类型转换，但有时结果并不总是你所期望的：

   5 + null    // 返回 5         因为 null 被转换为 0
   "5" + null  // 返回 "5null"   因为 null 被转换为  "null"
   "5" + 2     // 返回 52        因为 2 被转换为 "2"
   "5" - 2     // 返回 3         因为 "5" 被转换为 5
   "5" * "2"   // 返回 10        因为 "5" 和 "2" 被转换为 5 和 2
   

   JavaScript 类型转换表

   下表中列出了将不同 JavaScript 值转换为数字、字符串和布尔的结果：

   原始值	转换为数字	转换为字符串	转换为逻辑
   false	0	“false”	false
   true	1	“true”	true
   0	0	“0”	false
   1	1	“1”	true
   “0”	0	“0”	true
   “000”	0	“000”	true
   “1”	1	“1”	true
   NaN	NaN	“NaN”	false
   Infinity	Infinity	“Infinity”	true
   -Infinity	-Infinity	“-Infinity”	true
   “”	0	“”	false
   “20”	20	“20”	true
   “twenty”	NaN	“twenty”	true
   [ ]	0	“”	true
   [20]	20	“20”	true
   [10,20]	NaN	“10,20”	true
   [“twenty”]	NaN	“twenty”	true
   [“ten”,“twenty”]	NaN	“ten,twenty”	true
   function(){}	NaN	“function(){}”	true
   { }	NaN	“[object Object]”	true
   null	0	“null”	false
   undefined	NaN	“undefined”	false

参考文章：

https://w3school.com.cn/js/js_type_conversion.asp

https://developer.mozilla.org/zh-CN/