前端筆記8

number

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Number</title>
<script type="text/javascript">
    /*
    在JS中所有的數(shù)值都是Number類型，
        包括整數(shù)和浮點數(shù)（小數(shù)）
    JS中可以表示的數(shù)字的最大值
        Number.MAX_VALUE
            1.7976931348623157e+308
        Number.MIN_VALUE 大于0的最小值
            5e-324
        如果使用Number表示的數(shù)字超過了最大值，則會返回一個
            Infinity 表示正無窮
            -Infinity 表示負(fù)無窮
            使用typeof檢查Infinity也會返回number
    NaN 是一個特殊的數(shù)字，表示Not A Number
        使用typeof檢查一個NaN也會返回number
    */
    //數(shù)字123
    var a = 123;
    //字符串123
    var b = "123";
    
    /*
    可以使用一個運算符 typeof 來檢查一個變量的類型
    語法：typeof 變量    
        檢查字符串時，會返回string
        檢查數(shù)值時，會返回number
    */
    // console.log(typeof a);
    a = Number.MAX_VALUE * Number.MAX_VALUE;
    a = Infinity;
    a = "abc" * "bcd";
    a = NaN;
    // console.log(typeof a);
    a = Number.MIN_VALUE;
    // console.log(a);
    /*在JS中整數(shù)的運算基本可以保證精確*/
    var c = 123456789 + 987654321;
    /*
    如果使用JS進行浮點運算，可能得到一個不精確的結(jié)果
    所以千萬不要使用JS進行對精確度要求比較高的運算
    */
    c = 0.1 + 0.2;
    console.log(c);
</script>
</head>
<body>

</body>
</html>

Boolean

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Boolean</title>
<script type="text/javascript">
    /*
    Boolean 布爾值
        布爾值只有兩個，主要用來做邏輯判斷
        true
            - 表示真
        false
            - 表示假
        
        使用typeof檢查一個布爾值時，會返回boolean
    */
    var bool = false;
    console.log(typeof bool);
    console.log(bool);
</script>
</head>
<body>

</body>
</html>

null和undefined

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Null和Undefined</title>
<script type="text/javascript">
    /*
    Null（空值）類型的值只有一個，就是null
        null這個值專門用來表示一個為空的對象
        使用typeof檢查一個null值時，會返回object
    Undefined（未定義）類型的值只有一個，就undefind
        當(dāng)聲明一個變量，但是并不給變量賦值時，它的值就是undefined
        使用typeof檢查一個undefined時也會返回undefined
    */
    var a = null;
    console.log(a);
    console.log(typeof a);
    var b;
    b = undefined;
    console.log(b);
    console.log(typeof b);
</script>
</head>
<body>

</body>
</html>

強制類型轉(zhuǎn)換

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>強制類型轉(zhuǎn)換</title>
<script type="text/javascript">
    /*
    強制類型轉(zhuǎn)換
        - 指將一個數(shù)據(jù)類型強制轉(zhuǎn)換為其他的數(shù)據(jù)類型
        - 類型轉(zhuǎn)換主要指，將其他的數(shù)據(jù)類型，轉(zhuǎn)換為
            String Number Boolean
    */
    /*
    將其他的數(shù)據(jù)類型轉(zhuǎn)換為String
    方式一：
        - 調(diào)用被轉(zhuǎn)換數(shù)據(jù)類型的toString()方法
        - 該方法不會影響到原變量，它會將轉(zhuǎn)換的結(jié)果返回
        - 但是注意：null和undefined這兩個值沒有toString()方法，如果調(diào)用他們的方法，會報錯
    方式二：
        - 調(diào)用String()函數(shù)，并將被轉(zhuǎn)換的數(shù)據(jù)作為參數(shù)傳遞給函數(shù)
        - 使用String()函數(shù)做強制類型轉(zhuǎn)換時，
            對于Number和Boolean實際上就是調(diào)用的toString()方法
            但是對于null和undefined，就不會調(diào)用toString()方法
            它會將 null 直接轉(zhuǎn)換為 "null"
            將 undefined 直接轉(zhuǎn)換為 "undefined"
    */
    var a = 123;
    //調(diào)用a的toString()方法
    //調(diào)用xxx的yyy()方法，就是xxx.yyy()
    a = a.toString();
    a = true;
    a = a.toString();
    a = null;
    //a = a.toString(); //報錯
    a = undefined;
    //a = a.toString(); //報錯
    a = 123;
        
    //調(diào)用String()函數(shù)，來將a轉(zhuǎn)換為字符串
    a = String(a);
    a = null;
    a = String(a);
    
    a = undefined;
    a = String(a);
    console.log(typeof a);
    console.log(a);
</script>
</head>
<body>

</body>
</html>

轉(zhuǎn)換為number

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>轉(zhuǎn)換為Number</title>
<script type="text/javascript">
    /*
    將其他的數(shù)據(jù)類型轉(zhuǎn)換為Number
    轉(zhuǎn)換方式一：
        使用Number()函數(shù)
            - 字符串 --> 數(shù)字
                1.如果是純數(shù)字的字符串，則直接將其轉(zhuǎn)換為數(shù)字
                2.如果字符串中有非數(shù)字的內(nèi)容，則轉(zhuǎn)換為NaN
                3.如果字符串是一個空串或者是一個全是空格的字符串，則轉(zhuǎn)換為0
            - 布爾 --> 數(shù)字
                true 轉(zhuǎn)成 1
                false 轉(zhuǎn)成 0
            - null --> 數(shù)字 0
            - undefined --> 數(shù)字 NaN
    
    轉(zhuǎn)換方式二：
        - 這種方式專門用來對付字符串
        - parseInt() 把一個字符串轉(zhuǎn)換為一個整數(shù)
        - parseFloat() 把一個字符串轉(zhuǎn)換為一個浮點數(shù)
    */
    var a = "123";
    //調(diào)用Number()函數(shù)來將a轉(zhuǎn)換為Number類型
    a = Number(a);
    a = "789abc";
    a = Number(a);
    a = "";
    a = Number(a);
    a = "      ";
    a = Number(a);
    a = true;
    a = Number(a);
    a = false;
    a = Number(a);
    a = null;
    a = Number(a);
    a = undefined;
    a = Number(a);
    a = "123.567a456px";
    //調(diào)用parseInt()函數(shù)將a轉(zhuǎn)換為Number
    //parseInt()可以將一個字符串中的有效的整數(shù)內(nèi)容去出來，然后轉(zhuǎn)換為Number
    a = parseInt(a);
    // parseFloat()作用和parseInt()類似，不同的是它可以獲得有效的小數(shù)
    a = "123.456.789px";
    a = parseFloat(a);
    //如果對非String使用parseInt()或parseFloat()，它會先將其轉(zhuǎn)換為String然后在操作
    a = true;
    a = parseInt(a);
    a = 198.23;
    a = parseInt(a);
    console.log(typeof a);
    console.log(a);
</script>
</head>
<body>

</body>
</html>

其他進制的數(shù)字

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>其他進制的數(shù)字</title>
<script type="text/javascript">
    var a = 123;
        
    /*
    在js中，如果需要表示16進制的數(shù)字，則需要以0x開頭
        如果需要表示8進制的數(shù)字，則需要以0開頭
        如果要要表示2進制的數(shù)字，則需要以0b開頭，但是不是所有的瀏覽器都支持
    */
    
    //十六進制
    a = 0x10;
    a = 0xff;
    a = 0xCafe;
    
    //八進制數(shù)字
    a = 070;
    
    //二進制數(shù)字
    //a = 0b10;
    
    //像"070"這種字符串，有些瀏覽器會當(dāng)成8進制解析，有些會當(dāng)成10進制解析
    a = "070";
    
    // a = parseInt(a);
    //可以在parseInt()中傳遞一個第二個參數(shù)，來指定數(shù)字的進制
    a = parseInt(a,10);
    
    console.log(typeof a);
    console.log(a);
</script>
</head>
<body>

</body>
</html>

轉(zhuǎn)化為Boolean

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>轉(zhuǎn)換為Boolean</title>
<script type="text/javascript">
    /*
    將其他的數(shù)據(jù)類型轉(zhuǎn)換為Boolean
        使用Boolean()函數(shù)
            - 數(shù)字 ---> 布爾
                - 除了0和NaN，其余的都是true
            - 字符串 ---> 布爾
                - 除了空串，其余的都是true
            - null和undefined都會轉(zhuǎn)換為false
            - 對象也會轉(zhuǎn)換為true
    */      
    var a = 123; //true
    a = -123; //true
    a = 0; //false
    a = Infinity; //true
    a = NaN; //false
    
    //調(diào)用Boolean()函數(shù)來將a轉(zhuǎn)換為布爾值
    a = Boolean(a);
    a = "hello";//true
    a = "true";//true
    a = "false";//true
    a = "錯誤";//true
    a = " ";//true
    a = "";//false
    a = Boolean(a);
    
    a = null; //false
    a = Boolean(a);
    
    a = undefined; //false
    a = Boolean(a);
    
    a = window; //true
    a = Boolean(a);
    
    console.log(typeof a);
    console.log(a);
</script>
</head>
<body>

</body>
</html>

運算符：

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>運算符</title>
<script type="text/javascript">
    /*
    運算符也叫操作符
        通過運算符可以對一個或多個值進行運算,并獲取運算結(jié)果
        比如：typeof就是運算符，可以來獲得一個值的類型，它會將該值的類型以字符串的形式返回
            "number" "string" "boolean" "undefined" "object"
    算數(shù)運算符
        當(dāng)對非Number類型的值進行運算時，會將這些值轉(zhuǎn)換為Number然后在運算
        任何值和NaN做運算都得NaN
        +
            +可以對兩個值進行加法運算，并將結(jié)果返回
            如果對兩個字符串進行加法運算，則會做拼串，會將兩個字符串拼接為一個字符串，并返回
            任何的值和字符串做加法運算，都會先轉(zhuǎn)換為字符串，然后再和字符串做拼串的操作
        -
            - 可以對兩個值進行減法運算，并將結(jié)果返回
        *
            * 可以對兩個值進行乘法運算
        /
            / 可以對兩個值進行除法運算
        %
            % 取模運算（取余數(shù)）
    */      
    var a = 123;
    var result = typeof a;
    // console.log(result);
    // console.log(typeof a);
    result = a + 1;
    result = 456 + 789;
    result = true + 1;
    result = true + false;
    result = 2 + null;
    result = 2 + NaN;
    result = "123" + "456";
    result = "你好" + "小帥哥";
    // console.log(result);
    var str = "鋤禾日當(dāng)午，汗滴禾下土，誰知盤中餐，粒粒皆辛苦";
    // console.log(str);
    result = 123 + "1";
    result = true + "hello";
    // console.log(result);
    //任何值和字符串相加都會轉(zhuǎn)換為字符串，并做拼串操作
    /*
    我們可以利用這一特點，來將一個任意的數(shù)據(jù)類型轉(zhuǎn)換為String
        我們只需要為任意的數(shù)據(jù)類型 + 一個 "" 即可將其轉(zhuǎn)換為String
        這是一種隱式的類型轉(zhuǎn)換，由瀏覽器自動完成，實際上它也是調(diào)用String()函數(shù)
    */
    var c = 123;
    c = String(c);
    c = null;
    c = c + "";
    // console.log(typeof c);
    // console.log(c);
    c = 123;
    // console.log("c = " + c);
    result = 1 + 2 + "3";//33
    result = "1" + 2 + 3; //123
    result = 100 - 5;//95
    result = 100 - true;//99
    result = 100 - "1";//99
    result = 2 * 2;//4
    result = 2 * "8";
    result = 2 * undefined;//NaN
    result = 2 * null;//0
    result = 4 / 2;//2
    result = 3 / 2;//1.5
    // console.log("result = "+result);
    /*
    任何值做- * /運算時都會自動轉(zhuǎn)換為Number
    我們可以利用這一特點做隱式的類型轉(zhuǎn)換
        可以通過為一個值 -0 *1 /1來將其轉(zhuǎn)換為Number
        原理和Number()函數(shù)一樣，使用起來更加簡單
    */
    var d = "123";
    d = d - 0;
    // console.log(typeof d);
    // console.log(d);
    result = 9 % 3;//0
    result = 9 % 4;//1
    result = 9 % 5;//4
    
    console.log("result = "+result);
</script>
</head>
<body>

</body>
</html>

一元運算符

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>一元運算符</title>
<script type="text/javascript">
    /*
    一元運算符，只需要一個操作數(shù)
        + 正號
            - 正號不會對數(shù)字產(chǎn)生任何影響
        - 負(fù)號
            - 負(fù)號可以對數(shù)字進行符號的取反
    
        - 對于非Number類型的值，它會將先轉(zhuǎn)換為Number，然后再運算
        - 可以對一個其他的數(shù)據(jù)類型使用+,來將其轉(zhuǎn)換為number，它的原理和Number()函數(shù)一樣
    */
        
    var a = 123;
    a = +a;
    a = -a;
    
    a = true;
    a = -a;
    
    a = "18";
    a = +a;
    
    /*console.log("a = " + a);
    console.log(typeof a);*/
    
    var result = 1 + +"2" + 3;
    
    console.log("result = "+result);
</script>
</head>
<body>

</body>
</html>

自增和自減

代碼：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>自增和自減</title>
<script type="text/javascript">
    /*
    自增 ++
        - 通過自增可以使變量在自身的基礎(chǔ)上增加1
        - 對于一個變量自增以后，原變量的值會立即自增1
        - 自增分成兩種：后++(a++) 和 前++(++a)    
            無論是a++還是++a，都會立即使原變量的值自增1
            不同的是a++和++a的值不同
            a++的值等于原變量的值（自增前的值）
            ++a的值等于新值 （自增后的值）
    
    自減 --
        - 通過自減可以使變量在自身的基礎(chǔ)上減1
        - 自減分成兩種：后--(a--) 和 前--(--a)
            無論是a--還是--a都會立即使原變量的值自減1
            不同的是a-- 和 --a的值不同
                a-- 是變量的原值 （自減前的值）
                --a 是變量的新值 （自減以后的值）
    */
    var a = 1;
    
    //使a自增1
    //a++;
    //++a;
    
    //console.log("++a = " + ++a);
    //console.log("a++ = " + a++);
    
    //console.log("a = " + a);
    
    
    var c = 10;
    
    //第一次c++，是在10的基礎(chǔ)上自增
    c++;
    
    //第二次c++，是在11的基礎(chǔ)上自增
    //console.log(c++);
    
    var d = 20;
    
    //console.log(++d);//21
    //console.log(++d);//22
    
    //20 + 22 + 22
    var result = d++ + ++d + d ;
    console.log("result = " + result);
</script>
</head>
<body>

</body>
</html>
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容