由于對(duì)象的值其實(shí)是引用，所以把一個(gè)對(duì)象賦值給一個(gè)變量，實(shí)際上會(huì)產(chǎn)生該對(duì)象引用的一個(gè)副本，而不會(huì)賦值對(duì)象本身。換句話說，對(duì)象賦值不會(huì)產(chǎn)生新對(duì)象。想想看，對(duì)象的賦值與基本類型值賦值過程并沒有不同。變量間的賦值就是把保存一個(gè)盒子里的東西賦值一份再保存到另一個(gè)盒子中，而該盒子中存儲(chǔ)的可能是數(shù)值，也可能是一個(gè)引用。下圖表示基本類型賦值和對(duì)象賦值，可以想一想。

對(duì)象與其他類型值的第二個(gè)重要的區(qū)別是：

對(duì)同一個(gè)對(duì)象字面量的每次求值，都會(huì)產(chǎn)生一個(gè)新對(duì)象。

如上：腳本聲明了三個(gè)變量，創(chuàng)建了兩個(gè)對(duì)象。雖然兩個(gè)對(duì)象擁有相同的屬性，每個(gè)屬性的值也相同，但它們卻是兩個(gè)不同的對(duì)象，因此這個(gè)腳本會(huì)創(chuàng)建兩個(gè)對(duì)象。

關(guān)于變量只保存對(duì)象的引用而非對(duì)象這一點(diǎn)，不僅在賦值的時(shí)候有所體現(xiàn)，在等同性測(cè)試的時(shí)候也會(huì)有所體現(xiàn)。這兩種情況下，我們都必須搞明
白。對(duì)于測(cè)試表達(dá)式x===y，我們想知道x和y中等值是否相同。

        var a = {x:1,y:2};        // 聲明對(duì)象字面量1
        var b = a;                // 將變量a引用對(duì)象的引用賦值給變量b
        
        var c = {x:1,y:2};        // 聲明對(duì)象字面量2
        
        alert(a===b);             // true
        alert(a===c);             // false
        
        // 1. 即使兩個(gè)對(duì)象的內(nèi)部結(jié)構(gòu)相同，但是比較結(jié)果：false
        // 2. 相等運(yùn)算，比較的是引用的對(duì)象是否來自同一個(gè)對(duì)象，a、b變量引用同一個(gè)對(duì)象，全等運(yùn)算為：true
        // 3. 值得一提的是，a,b變量操作過程中，并沒有產(chǎn)生新對(duì)象
        
        // 再次強(qiáng)調(diào)！對(duì)象相等運(yùn)算比較的是，引用對(duì)象來源是否是同一個(gè)對(duì)象

如下，一個(gè)對(duì)象可以同時(shí)被多個(gè)變量引用，因此通過其中任何一個(gè)變量都可以修改對(duì)象的屬性，也都可以查看修改后的結(jié)果。

對(duì)表達(dá)式｛x:1,y:2｝=== {x:1,y:2}求值，解釋結(jié)果。

false：使用｛｝大括號(hào)就已經(jīng)聲明了對(duì)象字面量，本質(zhì)上和上面的變量a,c引用的對(duì)象是相同的，所過結(jié)果為假。

每個(gè)JavaScript對(duì)象都有一個(gè)暗藏的鏈接指向自己的原型對(duì)象（prototype），如果你讀取的的屬性不在對(duì)象本身上，那么JavaScript就會(huì)進(jìn)一步查詢這個(gè)對(duì)象的原型對(duì)象。如果在這個(gè)原型對(duì)象上也沒找到，還會(huì)進(jìn)一步查詢?cè)蛯?duì)象的原型對(duì)象，以此類推。這個(gè)原型鏈最后一個(gè)對(duì)象的暗藏鏈接，應(yīng)該指向null值。如果整個(gè)原型鏈都沒有你想讀取的屬性，那么你會(huì)看到一個(gè)錯(cuò)誤。

實(shí)際上，這里基于原型創(chuàng)建c1對(duì)象使用的是Object.create（）。這是ES5定義的操作，在老版本JavaScript引擎中，還有一種基于原型創(chuàng)建對(duì)象愛的技術(shù)，后面會(huì)繼續(xù)討論。
在需要定義大量相似對(duì)象時(shí)，原型是非常有用的。下圖又基于一個(gè)原型創(chuàng)建了兩個(gè)新對(duì)象。其中一個(gè)完全沒有自己的屬性，因而它的屬性完全繼承原型對(duì)象。

說說什么是自有屬性，什么是繼承屬性。

如果運(yùn)行protoCircle.radius = 5,那么訪問c1.radius和c2.radius結(jié)果發(fā)生什么？

對(duì)象的屬性可以引用自身，兩個(gè)對(duì)象也可以通過屬性相互作用。但這種情況下，光靠對(duì)象字面量無法描述了。

于是先使用對(duì)象字面量創(chuàng)建對(duì)象的部分屬性，然后在通過賦值方式定義其他屬性。當(dāng)然也可以為彼此賦值。

數(shù)組是一種特殊的對(duì)象,它的屬性是從0開始的連續(xù)非負(fù)整數(shù)，而且有一個(gè)名為length的對(duì)應(yīng)屬性。之所以說數(shù)組特殊，主要是因?yàn)椴荒苁褂贸Ｒ?guī)的對(duì)象字面量來創(chuàng)建它，必須使用另一種專用語法：

        var a = [];
        var b =[8,false,[[null,9]]];
        var numbers = [
            "zero",
            "one",
            "two",
            "three",
            "four",
            "five",
            "six"
        ];

這種專用語法實(shí)際上是用來創(chuàng)建屬性0，1,2...，還有length的。當(dāng)然，length屬性也很特殊：為它賦值可以擴(kuò)大或縮小數(shù)組，那么新增屬性會(huì)被設(shè)定為undefined。另外，在超過數(shù)組長(zhǎng)度的某個(gè)位置上賦值也可以擴(kuò)大數(shù)組。

        var a = [9,3,2,1,3];    // a[0]值為9，a.length等于5
        a[20] = 6;              // a[5]到a[19]的值都是undefined，a[20]說明有20 + a[0]個(gè)值，length:21
        alert(a.length);        // 21
        a.length = 50;          // a[21]到a[49]的值都是undefined
        a.length = 3;           // a現(xiàn)在是[9,3,2]

基于某個(gè)分隔符拆分（split）字符串、切割（slice）現(xiàn)有數(shù)組都可以創(chuàng)建新數(shù)組，另外把兩個(gè)數(shù)組拼接（concat）起來也可以創(chuàng)建新數(shù)組。反之，把數(shù)組元素連接（join）起來可以創(chuàng)建一個(gè)由同一個(gè)分隔符分隔的字符串：

        var s = "A red boat";
        var a = s.split(" ");        // a是["A","red","boat"]
        var b = [9,3,2,1,3,7];
        var c = b.slice(2,5);        // c是[2,1,3]
        var d = c.concat(a);         // d是[2,1,3,"A","red","boat"]
        console.log(d.join("|"))     // "2|1|3|A|red|blat"

注意，使用slice切割數(shù)組b中從位置2到位置5的元素，返回?cái)?shù)組是[ b[2],b[3],b[4] ]。換句話說，切割得到的數(shù)組包含位于切割起點(diǎn)的元素，不包含位于切割終點(diǎn)的元素；和substring截取字符串的操作相同。a.slice(x,y)，則返回a[x]和a[y-1]構(gòu)成的數(shù)組。還有另外兩種slice操作：

        var a = [9,4,1,7,8];                        
        var b = a.slice(2);           // a[2]開始到最后
        var c = a.slice();            // 所有索引，得到a的副本

拆分字符串的split操作不會(huì)修改原字符串、切割（slice）、拼接(concat)和連接(join)數(shù)組元素也不會(huì)修改原數(shù)組。不過。確實(shí)有一些操作會(huì)修改數(shù)組對(duì)象本身。比如，可以使用push在數(shù)組末尾、使用unshift在數(shù)組開頭添加元素；反之，可以使用pop在數(shù)組末尾、使用shift在數(shù)組開頭刪除元素。另外，還可使用reverse反轉(zhuǎn)數(shù)組元素的順序，使用sort對(duì)數(shù)組元素進(jìn)行排序。這些會(huì)修改數(shù)組本身的操作為可變操作（mutator）。

        var a = [];            // a是長(zhǎng)度（length）為0的數(shù)組
        var b = [3,5];         // length：2
        b.push(2);             // [3,5,2]
        b.unshift(7);          // [7,3,5,2]
        
        a.push(3,10,5);        // [3,10,5]
        a.reverse();           // [5,10,3]
                
        a.pop();               // [5,10]
        a.shift();             // [10]
        
        b.push(a[0],1);        // [7,3,5,2,10,1]
        b.sort();              // [1,10,2,3,5,7]
        b.reverse();           // [7,5,3,2,10,1]

JavaScript默認(rèn)是將所有的數(shù)組元素都當(dāng)成字符串來排序的，就算數(shù)組中包含數(shù)值、布爾值、對(duì)象或別的數(shù)據(jù)也一樣。既然是按字符串排序，那排序標(biāo)準(zhǔn)就是字母表，因此字符串"1"小于"10",后者有小于"2"（就如同"foot"小于"football"，后者又小于"goal"）。實(shí)際上也可以按照數(shù)值進(jìn)行排序，具體后面章節(jié)會(huì)介紹。

把數(shù)組放到對(duì)象字面量中，或者反之，可以創(chuàng)造出任何復(fù)雜的數(shù)組結(jié)構(gòu)：

       var song = {
            title:"In My Head",
            track_number:10,
            album:"Rock Steady",
            artist:"No Doubt",
            authors:["Gwen Stefani","Tony Kannal","Tom Dumont"],
            duration:205
        };
        var triangle = [{x:0,y:0},{x:3,y:-6},{x:-4,y:-1.5}];

實(shí)踐中，我們會(huì)使用對(duì)象（多帶帶）描述一種具體的事物，如裙子、人、歌曲和坐標(biāo)點(diǎn)等等，會(huì)用數(shù)組描述一組事物，如一張專輯中的歌曲或一個(gè)多邊形的頂點(diǎn)。數(shù)組也不是構(gòu)造數(shù)據(jù)集合的唯一方式。

把變量song和triangle用圖表示出來，包括引用的對(duì)象。（PS大法...這書實(shí)在啊，教JS順便復(fù)習(xí)PS基礎(chǔ)操作：）

請(qǐng)把變量a引用的數(shù)組在執(zhí)行下列操作之后的結(jié)果用圖示形式畫出來：
var a = [1,2,3,4];a.unshift(a.pop());

答：圖就免了，pop()；會(huì)刪除數(shù)組末尾元素并返回，之后被unshift()接收，添加至數(shù)組頭部，需要注意的是，由于數(shù)組長(zhǎng)度不變，刪除末尾元素后，只是a[3]的值變?yōu)閡ndefined，所以最后a數(shù)組內(nèi)元素是:[4,1,2,3,undefined]

目前，接觸到的從操作符，如：

        布爾值 && 布爾值
        布爾值 || 布爾值
        !布爾值
        -數(shù)值
        數(shù)值+,-,*,/,%數(shù)值
        Math.sqrt(ceil,floor,PI,pow,random...)(數(shù)值)
        字符串+字符串
        字符串.toUpperCase()
        字符串.indexOf(數(shù)值)
        對(duì)象[字符串]
        ...

如果讓操作符搭配一個(gè)或多個(gè)"錯(cuò)誤的"的類型會(huì)怎么樣？

這里是數(shù)值：

        7 * false            // 0    
        7 * true             // 7
        7 * "5"              // 35
        7 * " "              // 0
        7 * "dog"            // NaN
        7 * null             // 0
        7 * undefined        // NaN
        7 * {x:1}            // NaN

這里是布爾值：

        !5                   // false
        !0                   // true
        !"dog"               // false
        !""                  // true
        !" "                 // false
        !null                // true
        !undefined           // true
        !{x:1}               // false

這里是字符串：

        "xyz"+false          // "xyzfalse"
        "xyz"+true           // "xyztrue"
        "xyz"+7              // "xyz7"
        "xyz"+null           // "xyznull"
        "xyz"+undefined      // "xyzundefined"
        "xyz"+{x:1}          // xyz[object Object]
        "xyz"+[1,2,3]        // xyz1,2,3

通過以上實(shí)驗(yàn)，可以看出操作符搭配錯(cuò)誤的類型，不僅不會(huì)報(bào)錯(cuò)，還會(huì)正常顯示。通過類型轉(zhuǎn)換以有意義的方式處理了錯(cuò)誤類型的值。

轉(zhuǎn)換為數(shù)值：false被轉(zhuǎn)換為0，true被轉(zhuǎn)換為1，字符串為轉(zhuǎn)換成可能的值,null被轉(zhuǎn)換成0；如果無法把字符轉(zhuǎn)換成數(shù)值，則轉(zhuǎn)換成NaN。對(duì)象x會(huì)調(diào)用x.valueOf()；

轉(zhuǎn)換為布爾值：0、空字符串（""）、null、undefined、NaN。其他值都被轉(zhuǎn)換成true。false一般稱為假值，true則為真值；

轉(zhuǎn)換為字符串：JavaScript會(huì)按常理處理，如例子所示。只是對(duì)象x會(huì)調(diào)用x.toString()，具體后面會(huì)討論。
關(guān)于valueOf和toString的詳細(xì)解釋，&&與||其實(shí)他們并不是真的需要比較布爾值，后續(xù)繼續(xù)討論。

由于存在隱式數(shù)據(jù)類型轉(zhuǎn)換，JavaScript被稱為弱類型編程語言。在強(qiáng)類型編程語言中，由錯(cuò)誤類型值構(gòu)成的表達(dá)式會(huì)導(dǎo)致錯(cuò)誤。如果腳本里含有這種"病句"，要么不會(huì)被允許執(zhí)行，要么干脆直接停止工作，要么會(huì)在問題表達(dá)式被求值時(shí)拋出異常。

有時(shí)候，這種自動(dòng)類型轉(zhuǎn)換會(huì)造成一些意外。比如isNaN有時(shí)會(huì)產(chǎn)生一些難以理解的行為，我們知道它的作用是判斷某個(gè)值是不是非數(shù)值（Not a Number）。一般來說，我們會(huì)覺得布爾值、字符串、null會(huì)被判定為非數(shù)值，但實(shí)驗(yàn)表明并非如此。

        isNaN(true);            // false,因?yàn)閠rue轉(zhuǎn)換成了1
        isNaN(null);            // false,因?yàn)閚ull轉(zhuǎn)換成了0
        isNaN("water");         // true,很明顯
        isNaN("100");           // false,因?yàn)?100"轉(zhuǎn)換成了100

看來，應(yīng)該把isNaN的作用解讀為"不能轉(zhuǎn)換成數(shù)值"。再比如數(shù)值與字符串間的轉(zhuǎn)換，也是不可避免會(huì)碰到的：

        var x = prompt("Enter a number");            
        var y = prompt("Enter another number");
        alert(x+y);                // 結(jié)果是拼接后的字符串，而非數(shù)學(xué)意義上的加法

每次提示都輸入2，結(jié)果是22，因?yàn)閷?duì)prompt求值的結(jié)果總是字符串，而+操作符又同時(shí)適用于數(shù)值和字符串。如果提示框顯示x-y，執(zhí)行的那就是數(shù)值減法。因?yàn)?b>-在JavaScript只能用于數(shù)值，所以得到的字符串都會(huì)先被轉(zhuǎn)換成數(shù)值。當(dāng)然，乘法和除法也是"安全的"。但不管怎樣，在數(shù)值和字符串相遇的時(shí)候，你總得自己多加小心才是。

鑒于字符串與數(shù)值間的轉(zhuǎn)換容易出問題，很多JavaScript程序員傾向于在代碼中顯式地實(shí)現(xiàn)字符串到數(shù)值的轉(zhuǎn)換。
如：

        "3.14"-0;              // 3.14
        "3.14"*1;              // 3.14
        ("3.14"/1);            // 3.14
        +"3.14";               // 3.14    [速度最快]
        Number("3.14");        // 3.14 [清除，速度最慢]
        parseFloat("3.14");    // 3.14

前三個(gè)表達(dá)式使用了-、*、/，作為數(shù)值操作符，它們會(huì)在執(zhí)行計(jì)算（在這里都是無效計(jì)算）之前把字符串轉(zhuǎn)換成數(shù)值。第四個(gè)表達(dá)式也使用了一個(gè)數(shù)值操作符，叫做一元加。把它放到數(shù)值前面，不會(huì)產(chǎn)生任何操作，而與之對(duì)應(yīng)的一元減操作符就不一樣了。

        +4        // 4 [一元加]
        -4        // -4 [一元減]

由于一元加需要一個(gè)數(shù)值參與計(jì)算，因此如果它后面是一個(gè)字符串，JavaScript就會(huì)把這個(gè)字符串轉(zhuǎn)換成數(shù)值。使用+把字符串轉(zhuǎn)換成數(shù)值的做法顯得有點(diǎn)神秘，但這種技術(shù)很方便，而且也并不少見。類似這種的編程方法被稱為：習(xí)語，對(duì)外人并不顯見，必須習(xí)而得之。

        var x = +prompt("Enter a nunber");
        var y = +prompt("Enter another nunber");
        alert(x+y);                    // 算術(shù)加法

那么Number（s）和parseFloat(s)中s如果是字符串，結(jié)果又會(huì)怎么樣？

        var x = Number(prompt("Enter....number"));
        var y = Number(prompt("Enter another...ber"));
        alert(x+y);                    //    算術(shù)加法

不過，很多程序員并不使用這種方式，因?yàn)樾实停篔avaScript引擎在運(yùn)行以上代碼時(shí)會(huì)額外多做一些工作，導(dǎo)致腳本執(zhí)行速度降低，內(nèi)存占用增多。究其原因，就是Number生成的并非基本類型值，而是一個(gè)包裝著數(shù)值的對(duì)象，這個(gè)對(duì)象在被當(dāng)成數(shù)值使用時(shí)會(huì)把數(shù)值拿出來。對(duì)象比基本類型值更讓JavaScript引擎費(fèi)勁，一方面創(chuàng)建對(duì)象需要分配空間，而在不需要對(duì)象時(shí)，還要銷毀對(duì)象。然而，有時(shí)候可讀性確實(shí)比效率更重要，也可以使用Number。

還可以使用parseFloat及parseInt顯式把字符串轉(zhuǎn)換成數(shù)值。轉(zhuǎn)換從字符串開頭開始，但不一定轉(zhuǎn)換整個(gè)字符串，而且首尾的空格會(huì)被忽略。

        console.log(parseFloat("23.9"));            // 23.9
        console.log(parseFloat("5.663E2"));         // 566.3
        console.log(parseFloat("     8.11 "));      // 8.11
        console.log(parseFloat("52.3xyz"));         // 52.3
        console.log(parseFloat("xyz52.3"));         // NaN
        console.log(parseFloat("3 .5 .6"));         // 3
        console.log(parseFloat("123456 454"));      // 123456

        // 首尾空格忽略
        // 除了+、-、數(shù)字、小數(shù)點(diǎn)、科學(xué)計(jì)數(shù)法(E或e)這些符號(hào),其他的字符本身以及后面的所有字符都會(huì)被忽略
        // 如果參數(shù)字符串第一個(gè)字符串不能被解析為數(shù)字，會(huì)直接返回NaN

W3C官方說明：

parseFloat 是全局函數(shù)，不屬于任何對(duì)象。
parseFloat 將它的字符串參數(shù)解析成為浮點(diǎn)數(shù)并返回。如果在解析過程中遇到了正負(fù)號(hào)（+ 或 -）、數(shù)字 (0-9)、小數(shù)點(diǎn)，或者科學(xué)記數(shù)法中的指數(shù)（e 或 E）以外的字符，則它會(huì)忽略該字符以及之后的所有字符，返回當(dāng)前已經(jīng)解析到的浮點(diǎn)數(shù)。同時(shí)參數(shù)字符串首位的空白符會(huì)被忽略。

如果參數(shù)字符串的第一個(gè)字符不能被解析成為數(shù)字，則 parseFloat 返回 NaN。提示：您可以通過調(diào)用 isNaN 函數(shù)來判斷 parseFloat 的返回結(jié)果是否是 NaN。如果讓 NaN 作為了任意數(shù)學(xué)運(yùn)算的操作數(shù)，則運(yùn)算結(jié)果必定也是 NaN。

parseInt得到的數(shù)值沒有小數(shù)部分，其實(shí)parseInt中的Int就是integer，整數(shù)的意思。數(shù)值中含有小數(shù)的叫浮點(diǎn)數(shù)（Why?）

        console.log(parseInt("23.9"));            // 23
        console.log(parseInt("5.663E2"));         // 5
        console.log(parseInt("    8.11 "));       // 5        
        console.log(parseInt("52.3xyz"));         // 52
        console.log(parseInt("xyz52.3"));         // NaN

使用parseInt可以轉(zhuǎn)換基數(shù)為2到36的任何數(shù)值，進(jìn)制轉(zhuǎn)換。

        console.log(parseInt("75EF2",16));            // 483058
        console.log(parseInt("50",8));                // 40
        console.log(parseInt("110101",2));            // 53        
        console.log(parseInt("hello",30));            // 14167554
        console.log(parseInt("36",2));                // NaN

W3C官方說明：

當(dāng)參數(shù) radix 的值為 0，或沒有設(shè)置該參數(shù)時(shí)，parseInt() 會(huì)根據(jù) string 來判斷數(shù)字的基數(shù)（前提）。
舉例，如果 string 以 "0x" 開頭，parseInt() 會(huì)把 string 的其余部分解析為十六進(jìn)制的整數(shù)。如果 string 以 0 開頭，那么 ECMAScript v3 允許 > parseInt() 的一個(gè)實(shí)現(xiàn)把其后的字符解析為八進(jìn)制或十六進(jìn)制的數(shù)字。如果 string 以 1 ~ 9 的數(shù)字開頭，parseInt() 將把它解析為十進(jìn)制的整數(shù)。

因?yàn)镴avaScript是弱類型的，所以在執(zhí)行+-*/<等計(jì)算時(shí)，要確保數(shù)據(jù)的類型匹配，就算是相等操作符，也會(huì)發(fā)生同樣的類型轉(zhuǎn)換。

        console.log(false === 0)        // false 嚴(yán)格相等比較（類型不轉(zhuǎn)換）
        console.log(false == 0)         // true  相等比較（類型轉(zhuǎn)換）

JavaScript提供兩種相等測(cè)試機(jī)制，一種會(huì)執(zhí)行隱式類型轉(zhuǎn)換，一種不會(huì)。
相等操作符===當(dāng)且僅當(dāng)兩個(gè)表達(dá)式的值相同，類型相同時(shí)才會(huì)返回true（除了null）。而!==的結(jié)果自然與===截然相反。這兩種相等操作符叫做嚴(yán)格相等操作符。
另一種測(cè)試機(jī)制==和!=被人喻為嚴(yán)格操作符的"邪惡表親"。==在測(cè)試之前會(huì)不顧一切地轉(zhuǎn)換表達(dá)式類型，因此盡量不要使用它。
不過，==的轉(zhuǎn)換是有意義的，只是要記住比難。JavaScript官方規(guī)范對(duì)此有詳細(xì)描述，但我們這里可以簡(jiǎn)短歸納。

要確定x == y的結(jié)果，JavaScript會(huì)嘗試對(duì)它們進(jìn)行類型轉(zhuǎn)換，以便比較。

如果x和y中有一個(gè)字符串，有一個(gè)數(shù)值，JavaScript會(huì)把字符串轉(zhuǎn)換成數(shù)值。

如果一個(gè)是布爾值，另一個(gè)不同，JavaScript會(huì)把布爾值轉(zhuǎn)換成數(shù)值。

如果是一個(gè)對(duì)象，另一個(gè)是字符串是或數(shù)值，JavaScript會(huì)把對(duì)象轉(zhuǎn)換成字符串或者數(shù)值。

最后，undefined == null、null == undefined。待尋找原因。

由于上述情況復(fù)雜，一般更傾向于使用嚴(yán)格相等操作符===和!==。雖然松散相等操作符==和!==可以像前面討論的那樣在代碼提供一些快捷操作，即自動(dòng)幫我們實(shí)現(xiàn)字符串到數(shù)值的轉(zhuǎn)換，但轉(zhuǎn)換結(jié)果很多情況下無法預(yù)見，規(guī)則很難牢記。

使用===和!==，盡量不使用==和!=。

有時(shí)候，你可能必須某個(gè)值的類型。JavaScript有一個(gè)古怪的typeof操作符，能夠返回關(guān)于表達(dá)式類型的字符串描述。說它古怪，是因?yàn)樗姆祷刂涤袝r(shí)候可信，有時(shí)候又不可信。

        typeof 101.3;            // number
        typeof false;            // boolean
        typeof "dog";            // string
        typeof {x:1,y:2};        // object
        typeof undefined;        // undefined
        typeof null;             // object
        typeof [1,2,3];          // object
        typeof alert;            // function
        
        typeof (typeof 1);       // string

null的類型沒有里有是object。數(shù)組的類型返回object倒可以理解，畢竟數(shù)組是對(duì)象?？蔀槭裁春瘮?shù)的類型又不是了呢？函數(shù)也是一種對(duì)象啊。

測(cè)試typeof Infinity和typeof NaN

        console.log(typeof Infinity);        // number
        console.log(typeof NaN);            // number