数据类型的转换及运算符

 一.转换成数值类型

    1.Number():====把数据看做整体转换

        语法：Number(你要转换的数据)

        结果（返回值）：转换好的数值类型的数据

        转换机制：会把你要转换的数据看作是一个整体，如果可以转换成一个合法的数字，那么结            果就是这个数字，如果转换不成那么结果就是NaN 

<script>
    var a = '10'
    var res1 = typeof a
    console.log('a的值：',a);
    console.log('res1的检测结果：', res1);

    //将a变量通过number转换成数值类型，并且把转换好的结果赋值给res2
    var res2 = Number(a)
    console.log('转好好之后a的值：',res2);
    console.log("转好之后a的数据类型",typeof res2);

    var b = '10.5'
    console.log('b变量的值：',b);
    console.log('b变量的数据类型',typeof b);
    console.log('===========转换了====');
    var res = Number(b)
    console.log('b变量转换之后的：',res);
    console.log('b变量转换之后的数据类型：',typeof res);
   
    var c = '10a'
    console.log('c变量的值：',c);
    console.log('c变量的数据类型',typeof c);
    console.log('===========转换了====');
    var res = Number(c)
    // NaN:not a number
    console.log('c变量转换之后的：',res);
    console.log('c变量转换之后的数据类型：',typeof res);
</script> 

    2.parseInt():====一位一位的检测数据（不能转换小数点，之后的数据不会看）

        语法：parseInt(你要转换的数据)

        返回值（结果）：转换成数值之后的数据

        转换规则：不管你要转的数据是什么，都是一位一位的去检测，如果第一位可以转成数字，            就转，依次往后看每一位，知道碰到不能转或者转为为止，如果转不成就直接NaN

<script>
   var d = '10'
   console.log('d变量的值：',d);
   console.log('d变量的值的数据类型：',typeof d);
   console.log('===========转换了====');
   var res = parseInt(d)
   console.log('res变量的值：',res);
   console.log('res变量的值的数据类型：',typeof res);

   var d = '10.5'
   console.log('d变量的值：',d);
   console.log('d变量的值的数据类型：',typeof d);
   console.log('===========转换了====');
   var res = parseInt(d)
   console.log('res变量的值：',res);
   console.log('res变量的值的数据类型：',typeof res);

   var d = 'b10a'
   console.log('d变量的值：',d);
   console.log('d变量的值的数据类型：',typeof d);
   console.log('===========转换了====');
   var res = parseInt(d)
   console.log('res变量的值：',res);
   console.log('res变量的值的数据类型：',typeof res);
</script>

    3.parseFloat()====一位一位去检测，只不过多认识一个小数点

        语法：parseFloat(你要转换的数据)

        返回值(结果)：转好之后的数据

        转换规则：和parseInt是一样的，都是一位一位去检测，只不过多认识了一个小数点

<script>
   var d = '10.555a'
   console.log('d变量的值：',d);
   console.log('d变量的值的数据类型：',typeof d);
   console.log('===========转换了====');
   var res = parseFloat(d)
   console.log('res变量的值：',res);
   console.log('res变量的值的数据类型：',typeof res);
</script>

4.借助于除了加法之外的运算符

   减：-、(  -0)，乘：*(  *1)、除：/(/1)  这几种情况是不改变数字本身的。

<script>
 var d = '10.5'
   console.log('d变量的值：',d);
   console.log('d变量的值的数据类型：',typeof d);
   console.log('===========转换了====');
   var res = d-0
   console.log('res变量的值：',res);
   console.log('res变量的值的数据类型：',typeof res);
</script>

二.转成字符串类型

  1.String()

    注意：所有的数值都可以转换成字符串类型;S要大写

<script>
    var a = 10
    console.log('a的值：', a);
    console.log('a的数据类型：', typeof a);
    console.log('========转换======');
    var res = String(a)
    console.log('res的值：', res);
    console.log('res的数据类型：', typeof res);
    
    var a = 10.5
    console.log('a的值：', a);
    console.log('a的数据类型：', typeof a);
    console.log('========转换======');
    var res = String(a)
    console.log('res的值：', res);
    console.log('res的数据类型：', typeof res);

    //转换布尔类型
    var a = false
    console.log('a的值：', a);
    console.log('a的数据类型：', typeof a);
    console.log('========转换======');
    var res = String(a)
    console.log('res的值：', res);
    console.log('res的数据类型：', typeof res);


</script>

  2..toString()

  语法：你要转换的数据.toString()

  注意：S要大写

<script>
    var a = true
    console.log('a的值：', a);
    console.log('a的数据类型：', typeof a);
    console.log('========转换======');
    var a = true
    console.log('a的值：', a);
    console.log('a的数据类型：', typeof a);
    console.log('========转换======');
    var res = a.toString()
    console.log('res的值：', res);
    console.log('res的数据类型：', typeof res);
</script>

  3.借助加法运算

    注意：字符串的加法不会求和而是拼接

<script>
    var a = 100
    console.log('a的值：', a);
    console.log('a的数据类型：', typeof a);
    console.log('========转换======');
    var res = '15'+a
    console.log('res的值：', res);
    console.log('res的数据类型：', typeof res);
</script>

三.布尔类型的转换

   语法；Boolean(要转的数据)

        在js当中有5个特殊的数据：undefined、null、数值0、空的字符串''、数值NaN

        这5个转布尔类型最终的结果都是false,其余全都是true

<script>
   var a = 'a'
   console.log('a的值',a);
   console.log('a的数据类型',typeof a);
   console.log("======转换==========");
   var res =  Boolean(a)
   console.log('res的值',res);
   console.log('res的数据类型',typeof res);
   var a = ''
   console.log('a的值',a);
   console.log('a的数据类型',typeof a);
   console.log("======转换==========");
   var res =  Boolean(a)
   console.log('res的值',res);
   console.log('res的数据类型',typeof res); 
</script>

四.运算符

1. 算数运算：

            +: 注意：如果都是数值类型就是求和， 如果涉及字符串，那么就是拼接

            - ：减

            *：乘

            /：除

            %：取余（求余数）

            **：幂运算,几的几次方

<script>
    var x = 2
    var y = 5
    console.log('x+y的结果:', x + y);
    console.log('x-y的结果:', x - y);
    console.log('x*y的结果:', x * y);
    console.log('x/y的结果:', x / y);
    console.log('x%y的结果:', x % y);
    console.log('**运算',x**y);//2**5
</script>

2.赋值运算符

        =

        +=

        -=

        *=

        /=

        %=

<script>
    var a = 10
 /*    a = a + 2
    a += 2 */
    // a %= 2//等价于a = a%2
    console.log(a);

</script>

3.比较运算符：

        最终结果一定是布尔类型的，要么是true，要么就是false

        大于号：>

        小于号：<

        大于等于：>=

        小于等于：<=

        ==:判断是否相等(只需要看值是否一致，不需要看类型)

        ===：判断是否相等(要求数值和类型必须都一致)

        !=:判断是否不等(只要值不等就是true，值相等false 不看类型)

        !==:判断是否不等（只要值和数据类型只要有一个不等结果就是true，值和类型都相等结果局势false）

<script>
    var x = 4
    var y = 4
    console.log(3 == '3');
    //true  只需要看值是否一致，不需要看类型
    console.log(3 === '3');
    //false 要求数值和类型必须都一致

    console.log(3 != 4);//true
    console.log(3 !== 4);//true


    console.log(3 != '4');
    //true  值不一样，所以就是true
    console.log(3 !== '4');
    //true 会看值和类型，只要值和类型有一个不等结果就是true


    console.log(3 != '3');
    //false  看值  因为值是一样的，所以结果就是flase
    console.log(3 !== '3');
    //true 看值和类型，只要其中一个不等，就是true（值一样但是类型不一样，所以结果就是true）
    console.log(3 !== 3);
    //看值和类型，只要其中一个不等，就是true（因为值和类型都一样，所以结果就是false）


</script>

 5.逻辑运算符

            &&：逻辑与：是并且的意思，可以写多个判断条件，要求所有的条件都满足，结果才是true，只要有一个不满足，结果就是false 。记住：一假则假

            ||：逻辑或：可以写多个判断条件，要求只需要满足其中一个条件即可，只要有一个为true，最终结果就是true，只有当所有的条件都为false的时候，结果才是false

            ！：逻辑非,就是一个取反操作

<script>
    console.log(3 > 4 && 3 == 3);//false&&true===false
    console.log(3 > 4 && 3 < 5 && 3 == 3);//false
    console.log(3 < 4 && 3 < 5 && 3 == 3);//true&&true&&true====true
    // ====================
    console.log(3 > 4 || 3 == 3);//false||true=====true
    console.log(3 > 4 || 3 < 5 || 3 == 3);//false||true=====true
    console.log(3 < 4 || 3 < 5 || 3 == 3);//true
    console.log(3 == 4 || 3 > 4);//false||false=====false

    // ================================
    console.log(3>4);//false
    console.log(!(3>4));//true
    console.log(!true);
    console.log(!false);
</script>

 6.自增自减运算符

自增：++ 意思就是让他自己+1

        前置++：后置++：

        共同点：不管是前置还是后置，最终他自己本身都会+1

 不同点：

        前置++：会先把变量的值+1进行改变，然后再拿改变完成之后的数据参与运算

                先算再用

        后置++：会先把变量的值拿出来参与运算，然后再让变量本身进行+1操作

                先用再算

  自减：--

        意思就是让他自己-1  前置--：后置--：

<script>
    var x = 10
    var y = 15 + --x + ++x + x-- + x++ + --x
    //x:9
    //y:15 + 9 + 10 + 10 + 9 + 9
    console.log(x);//9
    console.log(y);//62
</script>

附：isNaN方法

 isNaN()=====主要作用：检测是否是非数字

    是非数字：true   是数字：false

分析： '10'====false，检测结果如果是false，证明isNaN认识'10'是一个数字

           '10a'===true，检测结果如果是true，证明isNaN认为'10a'不是一个数字

    isNaN()检测规则：会尝试做一个类型转换，看是否能转成数字，如果可以就会拿转换好之后的结果去使用

<script>
   var x = '10'
   var res = isNaN(x)
   console.log(res);
</script>