JavaScript的第2天-CSDN博客

本文链接：https://blog.csdn.net/qq_46426476/article/details/121988374

强制转换类型为Number

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        /*
            将其他类型转换为Number
                转换方式一:
                    使用Number()函数
                        -字符串--->数字
                            1，如果是纯数字的字符串，则直接将其转换为数字
                            2，如果字符串中有非数字的内容，则转换为NAN
                            3，如果字符串是一个空串或者是一个全是空格的字符串,则转换为0
                            
                        -布尔类型的值转换为Number类型
                            4，如果转换的类型为true或false，则输出1或0
                                var a="  ";
                                a=true;
                                a=null;
                                var b=Number(a)
                                alert(b);

                        -null-->转换为Number类型  输出0
                        -undefined-->转换为Number类型 输出NAN

            转换方式二:
                -这种方式专门用来对付字符串

                -且当非String使用parseInt或parseFloat进行转换时
                    它会先将其转换为String然后再进行操作

                -parseInt() 把一个字符串转换为一个整数
                    var a="123px";
                    var b=parseInt(a);
                    alert(typeof b)
                    alert(b);

                -parseFloat() 把一个字符串转换为一个浮点数
                    var a="123.12px";
                    var b=parseFloat(a);
                    alert(typeof b)
                    alert(b);

        */
        var a=123.24;
        var b=parseFloat(a);
        alert(typeof b)
        alert(b);
    </script>
</head>
<body>
    
</body>
</html>

其他进制的数字

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        /*
            在js中，使用特殊的符号来表示其他进制的数字

                十六进制:0x
                var a=0xda;
                alert(a);

                八进制:0
                var a=034;
                alert(a);

                二进制:0b
                var a=0b10010;
                alert(a);

            在js中，parseInt()   第二个参数为指定parseInt()输出的数字是几进制的数字
        */
       var a=0b10010;
       var b= parseInt(a,10);
    </script>
</head>
<body>
    
</body>
</html>

将其他类型的数字转换为Boolean

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        /*
            将其他的数据类型转换为Boolean
                -使用Boolean()函数
                    -数字--->布尔
                        -除了0和NaN，其余都是true
                        var a=133;
                        a=-123;
                        a=0;
                        a=NaN;
                        alert(Boolean(a))

                    -字符串--->布尔
                        -除了空串，其余都是true
                               var a="false"; //true
                                a="";
                                alert(Boolean(a))

                    -null和undefined都会转换为false
                           var a=null; 
                            a=undefined;
                            alert(Boolean(a)) 

                    对象也会转换为true        
        */
       var a=null; 
       a=undefined;
       alert(Boolean(a))  
    </script>
</head>
<body>
    
</body>
</html>

算数运算符

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        /*
            运算符也叫操作符
                通过运算符可以对一个或多个值进行运算，并获取运算结果
                比如:typeof就是运算符，可以来获得一个值得类型
                    它会将该值的类型以字符串的形式进行返回
                    var a=123;
                    var b=typeof(a);
                    var c=typeof(b);
                    alert(c);  //string
                    alert(b);   //number
                
                算数运算符 + - * / %
                +: 
                当对非Number类型的值进行运算时，会将这些值转换为Number类型再进行运算
                var result=true+1;   //2  //true转Number类型为1  
                result=true+false;  //1   false转Number类型为0
                result=2+null;      //2   null为0
                result=2+NaN;        //NaN   任何值和NaN进行运算都得NaN
                alert(result);

                可以对两个值进行加法运算，并将结果返回，
                如果对两个字符串进行加法运算，则会进行拼串
                -----将两个字符串进行拼接形成一个字符串并返回
                       var a="我是";
                       var b="shh";
                       alert(a+b);   //我是shh

                任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串进行拼接操作
                       var a="123";
                       var b="shh";
                       alert(a+b);   //123shh

                我们可以利用这个特性，来将一个任意的数据类型转换为String
                    我们只需要为任意的数据类型 + 一个"" 即可将其转换为String
                    这是一种隐式的类型转换，由浏览器自动完成，实际上也是调用String()函数
                    var a=123;
                    a=a+"";
                    alert(typeof a);  //string


                除了涉及到的字符串+法，其他几种运算符都是自动将数据转换成number后进行运算
                我们可以利用这一点进行隐式类型的类型转换
                    可以为一个值-0 *1 /1 来转换为Number类型
                    var a="23";  //NaN  不能在有typeof运算符的时候再进行运算，否则为NaN
                    var a="24"-0;  //number
                    a="25"/1;  //number
                    a="36"*1;  //number
                    alert(typeof a) 

                -:可以对两个值进行减法运算，并将结果返回
                var a=123;
                a=a-true;
                alert(a);  //122

                *：可以对两个值进行乘法运算，并将结果返回
                var a=123;
                a=a*true;
                alert(a);  //123

                /：可以对两个值进行除法运算，并将结果返回
                var a=123;
                a=a/"2";
                alert(a);  //61.5

                %：可以对两个值进行取模（余数）运算，并将结果返回
                var a=123;
                a=a%"2";
                alert(a);  //1
        */
       var a="23";  //NaN  不能在有typeof运算符的时候再进行运算，否则为NaN
       var a="24"-0;  //number
       a="25"/1;  //number
       a="36"*1;  //number
       alert(typeof a)  
    </script>
</head>
<body>
    
</body>
</html>

一元运算符

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        /*
            一元运算符，只需要一个操作数
                + 正号
                    --正号不会对数字进行任何影响
                    var a=+12;
                    alert(a);   //12

                - 负号
                    --负号可以对数字进行负号的取反
                    var a=-12;
                    alert(a);   //-12
                
                对于一元运算符而言，对于非Number类型的值
                    --它会先将值转换为Number，然后再进行运算
                可以在需要进行转换为Number类型的值前加+来进行转换，
                原理和调用Number函数一样，但是相对较简单
                var a=+"14";
                alert(a);   //14
                
                var a=1+ +"14"+1;
                alert(a);   //16
        */
       var a=1+ +"14"+1;
       alert(a);   //16
    </script>
</head>
<body>
    
</body>
</html>

自增和自减

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        /*
            自增 ++:
                --通过自增可以使变量在自身的基础上增加1
                --对于一个变量自增以后，原变量的值会立即自增1
                --自增分为两种：后++(a++) 和 前++(++a)
                 无论是a++ 还是++a，都会立即使原变量的值自增1
                      不同的是a++ 和 ++a两个表达式的值不同
                    a++的值等于原变量的值(自增前的值)
                    ++a的值等于新值(自增后的值)
                var a=10;
                console.log(a++);  //10
                console.log(++a);  //12


            自减 --:
                --通过自减可以使变量在自身的基础上减1
                --自减分为两种：后--(a--) 和 前--(--a)
                 无论是a-- 还是--a，都会立即使原变量的值自减1
                      不同的是a-- 和 --a两个表达式的值不同
                    a--的值等于原变量的值(自减前的值)
                    --a的值等于新值(自减后的值)

                    var a=10;
                    console.log(a--);  //10
                    console.log(+a);  //9
        */

        var a=10;
        console.log(a--);  //10
        console.log(+a);  //9
    </script>
</head>
<body>
    
</body>
</html>

逻辑运算符

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        /*
            逻辑运算符:
             !非
                    --!可以用来对一个值进行非运算
                    --所谓非运算就是对一个布尔值进行取反操作
                        true变false，false变true
                    --如果对一个值进行两次取反，它不会变化
                    --如果对非布尔值进行取反，则会将其先转换为布尔值，然后再进行取反
                        所以我们可以利用该特点，来将一个其他数据类型转换为布尔值
                        可以为任意一个数据类型两次取反，来将其转换为布尔值，原理和Boolean()函数一样
                        var a=false;
                        c="da";
                        b=!!c;
                        alert(!a); //true
                        alert(b); //true
                        alert(typeof c)
                        alert(typeof b)  //boolean

             &&与
                --&&可以对符号两侧的值进行运算并返回结果
                --运算规则
                    --两个值只要有一个值为false就返回false，
                        只有两个值都为true时，才返回true
                    --js中的“与”属于短路的与
                        如果第一个值为false，则程序不会执行第二个值
                    var a=false;
                    var b=true;
                    var c=a&&b;
                    var d=a&&alert("dawdwa")  //没有输出，说明已短路
                    alert(c); //false

             || 或
                --||可以对符号两侧的值进行或运算并返回结果
                --运算规则
                    --两个值只要有一个值为true就返回true，
                        只有两个值都为false时，才返回false
                    --js中的“或”属于短路的或
                        如果第一个值为true，则程序不会执行第二个值
                    var a=false;
                    var b=true;
                    var c=a||b;
                    var d=b||alert("dawdwa")  //alert没有输出，说明已短路
                    alert(c); //true
        */
        var a=false;
        var b=true;
        var c=a||b;
        var d=b||alert("dawdwa")  //alert没有输出，说明已短路
        alert(c); //true
    </script>
</head>
<body>
</body>
</html>