在編程語(yǔ)言中间涵，能夠表示并操作的值的類型稱作數(shù)據(jù)類型(type),編程語(yǔ)言最基本的特性就是能夠支持多種數(shù)據(jù)類型。

當(dāng)程序需要將值保存起來(lái)以備將來(lái)使用榜揖，便將其賦值給一個(gè)變量勾哩。

JavaScript的數(shù)據(jù)類型分為兩類：原始類型和對(duì)象類型

JavaScript中有兩個(gè)特殊的原始值：null和undefined只有兩個(gè)無(wú)法擁有方法

JavaScript變量是無(wú)類型的，變量可以被賦予任何類型的值举哟，同樣一個(gè)變量可以重新賦予不同類型的值思劳。

整形直接量

和其他編程語(yǔ)言不同，JavaScript不區(qū)分整數(shù)值和浮點(diǎn)數(shù)值妨猩。JavaScript中的所有數(shù)字均用浮點(diǎn)數(shù)值表示

十進(jìn)制

0
3
10000000

十六進(jìn)制

0xff 
0xCAFE911

八進(jìn)制

0377        //在嚴(yán)格模式下潜叛，八進(jìn)制是命令禁止的

浮點(diǎn)數(shù)直接量

3.14
2345.232
.323232323
6.02e23         //6.02 x 10^23
1.423232E-32    //1.423232 x 10^-23

JavaScript中的算術(shù)運(yùn)算

    Math.pow(2,53); //=> 2的53次冪
    Math.round(.6);     //=>1.0：四舍五入
    Math.ceil(.6);      //=> 1.0:向上求整
    Math.floor(.6);         //=>0.0：向下求整
    Math.abs(-5);       //=>求絕對(duì)值
    Math.max(x,y,z);    //返回最大值
    Math.min(x,y,z);    //最小值
    Math.random();      //=>生成一個(gè)大于等于0小于1.0的偽隨機(jī)數(shù)
    Math.PI;             //π:圓周率
    Math.E;             //e:自然對(duì)數(shù)的底數(shù)
    Math.sqrt(3);          //3的平方根
    Math.pow(3,3);          //3的立方根
    Math.sin(0);    Math.cos(0);  Math.atan(0);     //三角函數(shù)
    Math.log(10);       //10的自然對(duì)數(shù)
    Math.log(100)/Math.LN10;       //以10為底的100的對(duì)數(shù)
    Math.log(512)/Math.LN2 ;    //以2為底的100的對(duì)數(shù)
    Math.exp(3);        //e的三次冪

無(wú)窮大和非數(shù)字值

JavaScrip預(yù)定義了全局變量Infinity和NaN，用來(lái)表示正無(wú)窮大和非數(shù)字值

  Infinity        //將一個(gè)可讀寫(xiě)的變量初始化為Infinity
    Number.POSITIVE_INFINITY        //同樣的值
    1 / 0;                    //也是同樣的值
    Number.MAX_VALUE + 1;       //計(jì)算結(jié)果還是  Infinity
    Number.NEGATIVE_INFINITY    //該表達(dá)式表示了無(wú)窮大
    - Infinity;              //負(fù)無(wú)窮大
    -1 / 0;
    -Number.MAX_VALUE - 1;
    NaN;        //將一個(gè)可讀寫(xiě)的變量初始化為NaN
    Number.NaN;     //同樣的值
    0 / 0;        //計(jì)算結(jié)果為0
    Number.MIN_VALUE / 2;  //發(fā)生下溢：計(jì)算結(jié)果為0
    -Number.MIN_VALUE / 2;
    -1/Infinity;        //同樣是負(fù)零
    -0

NaN和任何值都不相等。
也就是沒(méi)辦法使用x == x來(lái)判斷

相反威兜，應(yīng)當(dāng)用x!=x判斷销斟，當(dāng)且僅當(dāng)x為NaN的時(shí)候，表達(dá)式才為true
函數(shù)isNaN()于此類似

isFinite() //在參數(shù)不是NaN椒舵、Infinity或者-Infinity的時(shí)候返回true蚂踊。

負(fù)零值同樣有些特殊，它和正零值是相等的笔宿，這意味著這兩個(gè)值幾乎一模一樣犁钟，除了作為除數(shù)之外

    var  zero = 0;      //正常的零值
    var negz = -0;      //負(fù)零值
    zero === negz;      //true 正零值和-0值相等
    1/zero === 1/negz;  //false：正無(wú)窮大和負(fù)無(wú)窮大不等

二進(jìn)制浮點(diǎn)數(shù)和四舍五入錯(cuò)誤

實(shí)數(shù)有無(wú)數(shù)個(gè)，但是JavaScript通過(guò)浮點(diǎn)數(shù)形式只能表示其中有限的個(gè)數(shù)泼橘。也就是說(shuō)特纤，當(dāng)在JavaScript使用實(shí)數(shù)的時(shí)候，常常只是真實(shí)值的一個(gè)近似表示

var x = .3 - .2;    //30美分減去20美分
var y = .2 - .1;    //20美分減去10美分
x == y;         // => false ：兩值不相等
x == .1;        // =>false
y == .1;       // true .2-.1=.1

日期和時(shí)間

JavaScript語(yǔ)言核心包括Date()構(gòu)造函數(shù)侥加，用來(lái)創(chuàng)建表示日期和時(shí)間的對(duì)象捧存。

var then = new Date(2018, 6, 17);   //2018年6月17日
var later = new Date(2018, 6, 17, 17, 10, 30); //2018年6月17日17時(shí)10分30秒
var now = new Date();       //當(dāng)前日期和 時(shí)間
var elapsed = now - then;   //計(jì)算時(shí)間間隔的 毫秒數(shù)
now.getFullYear();        // => 201 8
now.getMonth();           // => 6:從零開(kāi)始計(jì)數(shù)的月份
now.getDate();            // =>17:從1開(kāi)始計(jì)數(shù)的天數(shù)
now.getDay();             //=> 得到星期幾 0代表星期日，5代 表星期一
now.getHours();             //當(dāng)?shù)貢r(shí)間
now.getUTCHours();          //用UTC表 示小時(shí)時(shí)間基于時(shí)區(qū)

文本

字符串（string）是一組由16位值組成的不可變的有序序列担败，每個(gè)字符通常來(lái)自于Unicode字符集昔穴。

JavaScript采用UTF-16的編碼的Unicode字符集。

var p  = "π";       //π由16位內(nèi)碼表示
var e = "e";        //e由17位內(nèi)碼表示
p.length;           // => 1提前；p包含一個(gè)16位的值
e.length;           // => 2:e通過(guò)UTF-16編碼后包含兩個(gè)16位值

字符串直接量

在JavaScript程序中的字符串直接量吗货，是由單引號(hào)或雙引號(hào)括起來(lái)的字符序列。

"";     //空字符串：它包含0個(gè)字符
'testing';
"3.14";
'name="myform"';
"wouldn't you prefer O'Reilly's book?";
"is the ratio of a circle's circumfernce" +
"to its diameter";

在ECMAScript3中狈网，字符串直接量必須寫(xiě)在一行中宙搬，而在ECMAScript5中，字符串直接量可以拆分成數(shù)行拓哺，每行（\）結(jié)束(\n)另起一行

"two\nlines";       //這里定義了一個(gè)顯示兩行的字符串
"one\
long\
line";              // ECMAScript5 中可用

在客戶端JavaScript程序設(shè)計(jì)中勇垛，JavaScript代碼會(huì)夾雜HTML代碼的字符串，HTML也會(huì)夾雜JavaScript代碼士鸥。

<button onclick="alert('Thank you')">Click Me</button> 

轉(zhuǎn)義字符

在JavaScript字符串中闲孤，反斜杠（\）有這特殊的用途，反斜杠符號(hào)后加一個(gè)字符烤礁，就不再表示它們的字面含義了讼积，比如\n就是一個(gè)轉(zhuǎn)義字符，它是一個(gè)換行符脚仔。

反斜杠可以使我們避免使用常規(guī)方式解釋單引號(hào)勤众，但單引號(hào)不是用來(lái)標(biāo)記字符串結(jié)尾時(shí)，它只是一個(gè)撇號(hào)：

'You \'re right,it can\' be a quote';

字符串的使用

JavaScript的內(nèi)置功能之一就是字符串連接鲤脏，加號(hào)（+）負(fù)責(zé)把兩個(gè)字符串拼接在一起：

msg = "Hello," + "world";   //生成字符串“Hello 们颜， world”
greeting = "Welcome to my blog,"
+ " " + msg;

要確定一個(gè)字符串的長(zhǎng)度，比如要確定字符串s的長(zhǎng)度

s.length

除了length屬性，字符串還提供了許多可以調(diào)用的方法

var s = "Hello,World";      //定義一個(gè)字符串
s.charAt(0);                //=> "h":第一個(gè)字符
s.charAt(s.length-1);       //=>"d":最后一個(gè)字符
s.substring(1,4);           //=> "ell":第二至四個(gè)字符
s.slice(1,4);               //=>"ell":第二至四個(gè)字符
s.slice(-3);                //=>"rld":最后三個(gè)字符
s.indexOf("l");             //=>2:字符l第一次出現(xiàn)的位置
s.lastIndexOf("l");         //=>10：字符最后一次出現(xiàn)的位置
s.indexOf("l",3);           //=>3:在位置3及以后首次出現(xiàn)字符l的位置
s.split(",");               //=>["Hello", "World"]:
s.replace("H","2");         //=>2ello,World :全文字符替換
s.toUpperCase();            //HELLO,WORLD:轉(zhuǎn)成大寫(xiě)

記住掌桩，在JavaScript中字符串是固定不變的類似于replace()和toUpperCase()方法都返回新的字符串，原字符串本身并沒(méi)有改變姑食。

在ECMAScript5中波岛，字符串可以當(dāng)做只讀數(shù)組，除了使用charAt()方法音半，也可以使用方括號(hào)來(lái)訪問(wèn)字符串中的單個(gè)字符串

s = "hello,world";
s[0]                    //=> "h"
s[s.length-1]           //=> "d"

模式匹配

在兩條斜線之間的文本構(gòu)成了一個(gè)正則表達(dá)式直接量则拷。第二條斜線之后也可以跟隨一個(gè)或多個(gè)字母，用來(lái)修飾匹配模式的含義

/^HTML/  //匹配以HTML開(kāi)始的字符串
/[1-9][0-9]*/  //匹配一個(gè)非零數(shù)字曹鸠，后面是任意個(gè)數(shù)字
/\bjavascript\b/i //匹配單詞'javascript'

RegExp對(duì)象定義了很多有用的方法煌茬，字符串同樣具有可以接收餓RegExp參數(shù)的方法。

       var text = "testing: 1 , 2,3";

        var pattern = /\d+/g    //匹配所有包含一個(gè)或多個(gè)數(shù)字的實(shí)例
        console.log(pattern.test(text));    //匹配成功
        console.log(text.search(pattern))       //首次匹配成功的位置
        console.log(text.match(pattern))        //所有匹配組成的數(shù)組
        console.log(text.replace(pattern,"#"))
        console.log(text.split(/\D+/))  //非數(shù)字字符截取字符串

布爾值

布爾值代指真或假彻桃，開(kāi)或關(guān)坛善，是或否。
JavaScript程序中的比較語(yǔ)句的結(jié)果通常都是布爾值

布爾值通常用于JavaScript中的控制結(jié)構(gòu)中

       if (a == 4)
            b = b + 1;
        else 
            a = a + 1;

任意JavaScript的值都可以轉(zhuǎn)換為布爾值邻眷，下面這些值都會(huì)被轉(zhuǎn)為false

 undefined
 null
 0
 -0
 NaN
 ""      //空字符串

null和undefined

null是JavaScript語(yǔ)言的關(guān)鍵字眠屎，它表示一個(gè)特殊值，常用來(lái)描述空

undefined是預(yù)定義的全局變量肆饶，它的值就是“未定義”

全局對(duì)象

全局對(duì)象在JavaScript中有著重要的用途改衩，全局對(duì)象的屬性是全局定義的符號(hào)，JavaScript程序可以直接使用驯镊。當(dāng)JavaScript解釋器啟動(dòng)時(shí)葫督，它將創(chuàng)建一個(gè)新的全局對(duì)象，并給它一組定義的初始值

• 全局屬性

•   undefined
  

•   Infinity
  

•   NaN
  

• 全局函數(shù)

•   isNaN()
  

•   parseInt()
  

•   eval()
  

• 構(gòu)造函數(shù)

•   Date()
  

•   RegExp()
  

•   String()
  

•   Object()
  

•   Array()
  

在代碼最頂級(jí)————不存任何函數(shù)內(nèi)的JavaScript代碼————可以使用JavaScript關(guān)鍵字this來(lái)引用全局對(duì)象：

var global = this; //定義一個(gè)引用全局對(duì)象的全局變量

包裝對(duì)象

JavaScript對(duì)象時(shí)一種復(fù)合值：它的屬性或已命名的集合板惑。

var s = "hello world";  //一個(gè)字符串
var word = s.substring(s.indexOf(" ") + 1,s.length);//使用字符串屬性

只要引用了字符串s的屬性橄镜，JavaScript就會(huì)將字符串值通過(guò)調(diào)用new String(s)的方式傳換成對(duì)象，這個(gè)對(duì)象繼承了字符串的方法冯乘，并被用來(lái)處理屬性的引用

    var s = "test", n = 1, b = true;  //一個(gè)字符串蛉鹿、數(shù)字和布爾值
    var s = new String(s);      //一個(gè) 字符串對(duì)象
    var N = new Number(n)       //一個(gè)數(shù)字對(duì)象
    var B = new Boolean(b)      //一個(gè)布爾地域性

“= =”等于運(yùn)算符將原始值和其包裝對(duì)象視為相等。但是“===”全等運(yùn)算符將它們視為不等往湿。通過(guò)typeof運(yùn)算符可以看到原始值和其包裝對(duì)象的不同妖异。

不可變的原始值和可變的對(duì)象引用

字符串中所有的方法看上去返回了一個(gè)修改后的字符串，實(shí)際上返回的是一個(gè)新的字符串值领追。

    var s = "hello";        //定義一個(gè)由小寫(xiě)字母 組成的文本

    s.toUpperCase();        //返回“HELLO”他膳，但是并沒(méi)有改變s的值

    console.log(s);     //返回“hello”：原始字符串的值并沒(méi)有改變

如果比較兩個(gè)單獨(dú)的字符串，當(dāng)且僅當(dāng)它們的長(zhǎng)度相等且每個(gè)索引的字符都相等時(shí)绒窑，JavaScript才認(rèn)為它們相等

    var o = {x: 1};       //定義了一個(gè)對(duì)象
    o.x = 2;            //通過(guò)修改對(duì)象屬性值來(lái)更改對(duì)象
    o.y = 3;        //更改對(duì)象
    var a = [1, 2, 3];    //數(shù)組也是可修改的
    a[0] = 0;           //更改數(shù)組的一個(gè)元素
    a[3] = 4;
    console.log(a)

對(duì)象的比較并非值得比較：即使兩個(gè)對(duì)象包含同樣的值棕孙，它們也是不相等的，各個(gè)索引元素完全相等的兩個(gè)數(shù)組也不相等。

    var o = {x: 1}, p = {x: 1};     //具有相同屬性的兩個(gè)對(duì)象

    console.log(o === p);         // => false :單獨(dú)兩個(gè)對(duì)象永不相等

    var a = [], b = [];     //兩個(gè)單獨(dú)的空數(shù)組

    console.log(a === b);     //兩個(gè)單獨(dú)的數(shù)組永不相等

我們通常將對(duì)象稱為引用類型蟀俊，以此來(lái)和JavaScript的基本類型區(qū)分開(kāi)來(lái)钦铺。依照術(shù)語(yǔ)的叫法，對(duì)象值都是引用肢预，對(duì)象的比較均是引用的比較L當(dāng)且僅當(dāng)它們引用同一個(gè)基 對(duì)象時(shí)矛洞，它們才相等。

    var a = [];
    var b = a;
    b[0] = 1;
    a[0];
    a === b;

復(fù)制數(shù)組

    var a = ['a', 'b', 'c'];        //待復(fù)制的數(shù)組

    var b = [];         //復(fù)制到的目標(biāo)空數(shù)組

    for (var i = 0; i < a.length; i++) {
        b[i] = a[i];
    }
    console.log(b);

比較數(shù)組

    function equalArrays(a, b) {
        if (a.length != b.length) return false;     //兩個(gè)長(zhǎng)度不同的數(shù)組不相等

        for (var i = 0; i < a.length; i++) {

            if (a[i] !== b[i]) return false;
        }
        return true;

    }
    equalArrays([1,3,4],[1,3,4])

類型轉(zhuǎn)換

    10 + " objects";        //=> "10 objects"數(shù)字10轉(zhuǎn)換成字符串
    "7" * "4";              // => 28:兩個(gè)字符串均轉(zhuǎn)換為數(shù)字
    var n = 1 - "x";    //=> NaN：字符串“x”無(wú)法轉(zhuǎn)換為數(shù)字
    n + "object";       //=> "NaN object"：NaN轉(zhuǎn)換為字符串"NaN object "

轉(zhuǎn)換和相等性

由于JavaScript可以做靈活的類型轉(zhuǎn)換锭沟，因此其“==”相等運(yùn)算符也隨相等的含義靈活多變抽兆。

    null == undefined;      //這兩值被認(rèn)為相等

    "0"  == 0;      //在比較之前字符串轉(zhuǎn)換成數(shù)字

    0 == false;     //在比較之前布爾值轉(zhuǎn)換成數(shù)字

    "0" == false;       //在比較之前字符串和布爾值都轉(zhuǎn)換成數(shù)字

顯示類型轉(zhuǎn)換

盡管JavaScript可以自動(dòng)做許多類型轉(zhuǎn)換，但有時(shí)仍需要做顯示轉(zhuǎn)換族淮，或者為了使代碼變得清晰易讀而顯示轉(zhuǎn)換

    Number("3");        //=>3
    String(false);     false.toString(); //=>"false"或者使用false.toString()
    Boolean([]);        //=> true
    Object(3)           //=》new Number(3)

    x + "";     //等價(jià)于String(x)
    +x;         //等價(jià)于Number(x)
    !!x;        //等價(jià)于Boolean(x) 注意是雙嘆號(hào)

    var n = 17;

    binary_string = n.toString(2);

    octal_string = "0" + n.toString(8);

    hex_string = "0x" + n.toString(16);

    var n = 123456.789;
    n.toFixed(0);       //123456
    n.toFixed(2);       //123456.79
    n.toFixed(5);
    n.toExponential(1);     //"1.2e+5"
    n.toExponential(3);     //"1.235e+5"
    n.toPrecision(4);  //1.235e+5
    n.toPrecision(7);   //123456.8

    parseInt("3 blind mice");   //=>3
    parseFloat("3.14 meters")   //=> 3.14
    parseInt("-12.34");         //=>-12
    parseInt("0xFF");       //=>255
    parseInt("0xff");       //255
    parseInt("-0XFF");          //-255
    parseFloat(".1");   //0.1
    parseInt("0.1");      //0
    parseInt(".1");     //NaN
    parseFloat("$72.47");       //NaN

    parseInt("11", 2);  // 3
    parseInt("ff", 16); // 255
    parseInt("zz", 36);  // 1369
    parseInt("077", 8); //63
    parseInt("077", 10);    //77

對(duì)象轉(zhuǎn)換為原始值

    var now = new Date();
    typeof (now + 1)        //=>"string"
    typeof (now - 1)         //=>"number"
    now == now.toString()       //true
    now > (now - 1)  //=>true 將日期轉(zhuǎn)化為數(shù)字

變量聲明

變量是使用關(guān)鍵字var來(lái)聲明

    var i;
    var sum;

也可以通過(guò)一個(gè)var關(guān)鍵字來(lái)聲明多個(gè)變量

 var i, sum;

而且可以將變量的初始賦值和變量聲明和寫(xiě)在一起

 var message = "hello";
 var i = 0, j = 0, k = 0;

如果未在var聲明語(yǔ)句中給定變量指定初始值辫红，那么雖然聲明了這個(gè)變量，但是在給他存入一個(gè)值之前祝辣，它的初始值就是undefined

在for和for/in循環(huán)中同樣可以使用var語(yǔ)句厉熟。

 for (var i = 0; i < 10; i++) {
        console.log(i)
    }

    for (var i = 0, j = 10; i < 10; i++, j++) {
        console.log(i * j);
    }

    for (var p in "nihao") {
        console.log(p);
    }

在JavaScript中首先將數(shù)字賦值給一個(gè)變量，隨后再講字符串賦值給這個(gè)變量较幌，這完全合法的

   var i = 10;
   i = "ten";

變量的作用域

在函數(shù)體內(nèi)揍瑟，局部變量的優(yōu)先級(jí)高于同名的全局變量。如果在函數(shù)內(nèi)聲明的一個(gè)局部變量或者函數(shù)參數(shù)中帶有的變量和全局變量重名乍炉，那么全局變量就被局部變量所覆蓋绢片。

 var scope = "global";   //聲明一個(gè)全局變量
    
    function checkscope() {
        var scope = "local";        //聲明一個(gè)同名的局部變量
        return scope;               //返回局部變量的值，而不是全局變量的值
    }

    checkscope();           //=>"local"

盡管在全局作用域編寫(xiě)代碼是可以不寫(xiě)var語(yǔ)句岛琼，但是聲明局部變量的時(shí)候則必須使用var語(yǔ)句底循，

 scope = "global";       //聲明一個(gè)全局變量，甚至不同var來(lái)聲明
    function checkscope(){
        scope = "local";
        myscope = "local";  //糟糕槐瑞！我們聲明了一個(gè)全新的全局變量
        return [scope , myscope];   //返回這兩個(gè)值
    }
    console.log(checkscope())   //["local","local"]

函數(shù)定義是可以嵌套的熙涤，由于每個(gè)函數(shù)都有它自己的作用域，因此會(huì)出現(xiàn)幾個(gè)局部作用域嵌套的情況

var scope = "global scope";   //全局變量

    function checkscope() {
        var scope = "local scope";

        function nested() {
            var scope = "nested scope";

            return scope;
        }

        return nested();
    }
    console.log(checkscope());

函數(shù)作用域和聲明提前

變量在聲明它們的函數(shù)體以及這個(gè)函數(shù)體鑲嵌的任意函數(shù)體內(nèi)都是有定義的

   function test(o) {
        var i = 0;
        if (  o == "object") {
            var j = 0;
            for (var k = 0; k < 10; k++) {
                console.log(k);
            }
            console.log(k)
        }
        console.log(j)
    }
    test("object")

JavaScript函數(shù)里聲明的所有變量都被“提前”至函數(shù)體的頂部

   var scope = "global";
    function f() {
        console.log(scope);
        var scope = "local";
        console.log(scope);
    }
    f();

將函數(shù)內(nèi)的變量聲明“提前”至函數(shù)體頂部困檩，同時(shí)變量初始化留在原來(lái)的位置

作為屬性的變量

  var truevar = 1;    //聲明一個(gè)不可刪除的全局變量

    falevar = 2;        //創(chuàng)建全局變量的一個(gè)可刪除屬性

    this.falevar2 = 3;  //同上

    console.log(delete falevar)        //刪除

    console.log(delete this.falevar2)      //刪除

無(wú)窮大和非數(shù)字值

JavaScrip預(yù)定義了全局變量Infinity和NaN祠挫，用來(lái)表示正無(wú)窮大和非數(shù)字值

  Infinity        //將一個(gè)可讀寫(xiě)的變量初始化為Infinity
    Number.POSITIVE_INFINITY        //同樣的值
    1 / 0;                    //也是同樣的值
    Number.MAX_VALUE + 1;       //計(jì)算結(jié)果還是  Infinity
    Number.NEGATIVE_INFINITY    //該表達(dá)式表示了無(wú)窮大
    - Infinity;              //負(fù)無(wú)窮大
    -1 / 0;
    -Number.MAX_VALUE - 1;
    NaN;        //將一個(gè)可讀寫(xiě)的變量初始化為NaN
    Number.NaN;     //同樣的值
    0 / 0;        //計(jì)算結(jié)果為0
    Number.MIN_VALUE / 2;  //發(fā)生下溢：計(jì)算結(jié)果為0
    -Number.MIN_VALUE / 2;
    -1/Infinity;        //同樣是負(fù)零
    -0

NaN和任何值都不相等。
也就是沒(méi)辦法使用x == x來(lái)判斷

相反悼沿，應(yīng)當(dāng)用x!=x判斷等舔，當(dāng)且僅當(dāng)x為NaN的時(shí)候，表達(dá)式才為true
函數(shù)isNaN()于此類似

isFinite() //在參數(shù)不是NaN糟趾、Infinity或者-Infinity的時(shí)候返回true慌植。

負(fù)零除數(shù)之外

    var  zero = 0;      //正常的零值
    var negz = -0;      //負(fù)零值
    zero === negz;      //true 正零值和-0值相等
    1/zero === 1/negz;  //false：正無(wú)窮大和負(fù)無(wú)窮大不等