前言

JS是弱类型，如果没有给变量定义类型，那么这个变量可以随便改变值的类型，所以要考虑变量类型，才能正确操作和使用。

一、数据类型

js有七种数据类型包含：六种基本类型（number、string、symbol、boolean、null、undefined），一种引用数据类型（Object）。

我们可以用 typeof 来检测数据类型（有返回结果），如：

      var a=10; // 将number 10赋值给a
      var b="10"; // 将string 10赋值给b
      console.log(typeof a); // 检测a的数据类型
      console.log(typeof b); // 检测b的数据类型

可以看到返回的数据类型结果

1、number

number类型有整型和浮点型，数值在console内显示为蓝色字体，如：

      var a= 5; // 整形
      var b= 5.5; // 浮点型
      console.log(a); // 打印a
      console.log(typeof a); // 检测a的数据类型
      console.log(b); // 打印b
      console.log(typeof b); // 检测b的数据类型

可以看到number类型在console内打印显示的是蓝色字体

2、string

只要用引号（单引号或双引号）引起来的都是string字符，string字符串只能放在引号内，字符在console内显示为黑色字体，如：

      var a= "5";
      var b= 'cab我是谁';
      console.log(a); // 打印a
      console.log(typeof a); // 检测a的数据类型
      console.log(b); // 打印b
      console.log(typeof b); // 检测b的数据类型

字符在console内显示为黑色字体

3、boolean

布尔型数据只能有两种值 true 和 false，通常布尔值是用于判断或开关，如：

      var a=true; // 把true赋值给a
      console.log(typeof a); // 检测a的数据类型
      var b=false; // 把false赋值给b
      console.log(typeof b); // 检测b的数据类型

      if(a){ // a是true，所以能进入语句打印 123456
          console.log(123456);
      }

      if(b){ // b是false，所以不能进入语句打印 654321
          console.log(654321);
      }

在条件判断语句中我们将所有的判断条件看成是一个布尔值，用来操作和使用

4、underfine

undefined 未定义值，通常指的是没有赋值的变量

      var a; // 没有赋值的变量a
      console.log(typeof a); // 检测a的数据类型

可以看到 a 的数据类型是 underfind

5、null

一个变量以指针的形式指向堆中的地址，当不需要再指向时，就必须设置该变量的值为 null空值

      var a=null; // 将a清空
      console.log(typeof a); // 检测a的数据类型

typeof a 不应该返回object，因为不同的对象在底层都表示为二进制，在Javascript中二进制前三位都为0的话，会被判断为Object类型，null的二进制表示全为0，自然前三位也是0，所以执行typeof时会返回"object"。

6、Symbol

Symbol是由ES6新增的基础数据类型。Symbol是唯一类型，无法修改，不能用于任何运算。

      let a=Symbol("a"); // symbol的写法
      let b=Symbol("abc"); // symbol的写法
      
      console.log(a==b); // 此处错误symbol无法修改其内容，不能用于任何运算
      console.log(a); // 检测a的数据类型

7、引用数据类型（Object）

数组、对象、函数，都是引用数据类型 Object

      var arr=[6,2,4,5,8,0,2,1,3,5,6]; // 数组
      var obj={a:1,b:2,c:3}; // 对象
      abc=function(){ // 函数
          
      }
      console.log(typeof arr); // 检测arr的数据类型
      console.log(typeof obj); // 检测obj的数据类型
      console.log(typeof abc) // 检测abc的数据类型

abc不应该返回function，因为JS里面的七种类型根本没有function，function是属于一种特殊的Object，函数和数组以及对象都是存放各种值的容器。对象值存储的是引用地址。

二、数据类型的变化

强制转换

主动将数据的类型强制转换成某种类型

计算机中任何数据进行计算都需要转换成二进制

1、强转字符串

   1. String(数据)    所有类型都可以转换
   
   2.（数据).toString()   null 和 undefined 不能转换 
   
   3.（数据). toString(n)  将数值转换成 n进制字符 （进制必须大于等于 2 且小于等于36 ）
   
   4.（数据). toFixed(n)   数值转成字符串并保留小数点后 n位，四舍五入（存在误差）

例子：

        console.log(String(18)); // 将数值18，转换成字符串18

        let num=20; // 将20赋值给num
        console.log(num.toString()); // 将num转换成字符串

        console.log((20).toString(16)); // 将数值20，转换成16进制字符14

        console.log((25.67591).toFixed(2)); // 将数值转换成字符串并保留后2位

可以看到数值全部转换成字符串了，字符串在conslog里是黑色，可以下去自己用 typeof检测，我这里就不多做检测了。

2、强转数值

   Number(数据)
   
   纯数字字符 => 数字 
   纯字母字符 => NaN 
   带有字母字符 => NaN
   null => 0
   undefined => NaN;
   true => 1
   false => 0
   (NaN 含义是非数值，它的类型是 number )

例子：

        console.log(Number("123456"));
        console.log(Number("adcdef"));
        console.log(Number("123adc"));
        console.log(Number(null));
        console.log(Number(undefined));
        console.log(Number(true));
        console.log(Number(false));

打印的结果：

3、强转整型

1. parseInt()

    纯数字字符 => 数字； 
    纯字母字符、以字母开头的带数字字符 => NaN；
    null => NaN；
    undefined => NaN;
    true => NaN; 
    false => NaN；
    数字开头带字母的字符 => 转换到第一个字母字符前为止，前面的数字字符转成数字

例子：

        console.log(parseInt("123456"));
        console.log(parseInt("abc123"));
        console.log(parseInt(null));
        console.log(parseInt(undefined));
        console.log(parseInt(true));
        console.log(parseInt(false));
        console.log(parseInt("123adcd"));

2. parseInt(str , n)

parseInt(str,n)；将n 进制字符串str 转换成 n进制数值。没有n，默认以10进制显示str字符串并转换程 10进制数值 parseInt(str,n )；是 (数据). toString(n) 的逆转换

例子：

        console.log(parseInt("a",16)); // 将字符串a，转换成16进制 10

        var str="FF0000";
        console.log(parseInt(str,16)) // 将16进制字符串转换为数值

4、强转浮点型

parseFloat()； 可以保留小数位，开头和结尾的空格是允许的。如果字符串的第一个字符不能被转换为数字，那么 parseFloat()会返回NaN，同parseInt。

例子：

        console.log(parseFloat("10"));
        console.log(parseFloat("10.00"));
        console.log(parseFloat("10.38"));
        console.log(parseFloat("40 60 70"));
        console.log(parseFloat(" 90 "));
        console.log(parseFloat("50 age"));
        console.log(parseFloat("a b 5"));

5、转换为布尔型

Boolean(数值)

    1. 空字符串  var str1 = "";
    2. 数值0     var str2 = 0 ;
    3. false     var str3 = false;
    4. 未定义    var str4 ;
    5. null   var str5 = null ;
    6. NaN    var str6 = NaN ;

除以上六点为false以外，其他均为 true

一个值得注意的例子：

        var str=" "; // 有空格的字符
        console.log(Boolean(str)); // 有空格是true

        var str2=""; // 没有空格的空字符
        console.log(Boolean(str2)); // 没有空格的是false

隐式转换

弱类型语句中，类型不同，弱类型语言会自动将数据转换为相同类型，然后运算。

隐式转换遵从 String()、 Number() 、Boolean()

例子：

      var a=6;
      var b="a";
      var c=true;
      console.log(a+b); // 这里将a隐式转换为字符串，+号在这里是拼接符的作用，并且相加首尾相连，所以是 6a
      console.log(a+c); // 将ture和数值相加，ture隐式转换成数值就是1，所以是6+1=7；
      console.log(b+c); // 字符串和ture相加，ture隐式转换成字符串，则+是拼接符的作用a+ture，所以是 ature；
      console.log(a-b); // 减法会隐式转换将a和b都转换为数值6-NaN，所以结果是 NaN
      
      console.log(1+"2"); // 将数值1隐式转换成字符，+号在这里是拼接符的作用，所以是 12
      console.log(1+2+"3"); // 从前向后执行，先1+2=3再把这个3转换成字符串，+号拼接所以是 33

打印结果：

1、算数运算符的隐式转换

  - * / % 减乘除取余，都是隐式转换成数值，不论有没有字符
  + 如果是字符和非字符相加，则会自动将非字符隐式转换成字符 String() ，此时+号为拼接符
  如果没有字符，则会隐式转换成数值进行计算
  数值 + NaN = NaN    true + false = 1

例子：

        console.log(10-"5"); // -号隐式转换把字符5转换成数值5运算，所以是 5
        console.log(2*"4"); // *号隐式转换把字符4转换数值4运算，所以是 8
        console.log(6/"2"); // /号隐式转换把字符2转换成4运算，所以是 3
        console.log(17%"7"); // %取余隐式把字符7转换成数值7运算。所以是 3

        console.log(12+NaN); // NaN是number类型，用什么运算符运算都是NaN
        console.log(3+true); // true隐式转换为数值1，所以是 4
        console.log(3+false); // false隐式转换为数值0，所以是 3

打印结果：