前言：

　　對(duì)于程序員,學(xué)習(xí)是無(wú)止境的,知識(shí)淘換非?？?能夠快速穩(wěn)固掌握一門新技術(shù),是一個(gè)程序員應(yīng)該具備的素質(zhì).這里將分享本人一點(diǎn)點(diǎn)不成熟的心得.

　　了解一門語(yǔ)言,了解它的概念非常重要,但是一些優(yōu)秀的設(shè)計(jì)思想需要細(xì)心和大量實(shí)踐才能慢慢參悟,在這之前需要做的是能夠運(yùn)用它來(lái)開發(fā),那么了解一些基礎(chǔ)特性非常有必要,通常這些特性是需要經(jīng)驗(yàn)積累,從各種坑中累計(jì)出來(lái),但是還有一種看似很笨卻很有效的學(xué)習(xí)方法.那就是將別人的經(jīng)驗(yàn)記錄下來(lái),有事沒(méi)事都拿出來(lái)看看,集合開發(fā)中的經(jīng)驗(yàn),這會(huì)非常有效.

• 編程語(yǔ)言的詞法結(jié)構(gòu)是一套基礎(chǔ)性規(guī)則，用來(lái)描述如何使用這門語(yǔ)言的編寫程序。
• 字符集：
• • JavaScript程序是用Unicode字符集編寫的。Unicode是ASCII和Latin-1的超集，并支持地球上幾乎所有在用的語(yǔ)言
• 區(qū)分大小寫
• 空格、換行符和格式控制符
• • JavaScript會(huì)忽略程序中標(biāo)識(shí)之間的空格
• 注釋
• • 第一種注釋，在行尾“//”之后的文本都會(huì)被JavaScript當(dāng)作注釋忽略掉的
  • 第二種注釋，"/"和"/"之間的本文都會(huì)被當(dāng)作注釋
• 直接量
• • 就是程序中直接使用的數(shù)據(jù)值“12”//數(shù)字true//布爾值等等
• 標(biāo)識(shí)符和保留字
• • 標(biāo)識(shí)符就是一個(gè)名字。在JS中，標(biāo)識(shí)符用來(lái)對(duì)變量和函數(shù)名進(jìn)行命名，或用作JS代碼中某些循環(huán)語(yǔ)句中的跳轉(zhuǎn)位置的標(biāo)記。
  • 標(biāo)識(shí)符必須以字母、下劃線、美元符開始
  • 保留字就是JS把一些標(biāo)識(shí)符拿出來(lái)用作自己的關(guān)鍵字，因此，就不能再程序中把這些關(guān)鍵字用作標(biāo)識(shí)符了
• 可選的分號(hào)
• • 缺少分隔符，一條語(yǔ)句結(jié)束就成了下一條語(yǔ)句的開始
  • 在JS中，如果語(yǔ)句各自獨(dú)占一行，通?？梢允÷哉Z(yǔ)句之間的分號(hào)（“}”也可以省略），JS會(huì)在換行處自動(dòng)填補(bǔ)分號(hào)，但并不是所有換行出都會(huì)自動(dòng)填補(bǔ)，只有在可以解析的情況下才會(huì)填補(bǔ)

• 在編程語(yǔ)言中，能夠表示并操作的值的類型稱做數(shù)據(jù)類型，編程語(yǔ)言最基本的特性就是能夠支持多種數(shù)據(jù)類型。
• 當(dāng)程序需要將值保存起來(lái)以備將來(lái)使用時(shí)，便將其賦值給一個(gè)變量
• 變量是一個(gè)值的符號(hào)名稱，可以通過(guò)名稱來(lái)獲得對(duì)值的引用。變量的工作機(jī)制是編程語(yǔ)言的另一個(gè)基本特性
• JS的數(shù)據(jù)類型分為兩類
• • 原始數(shù)據(jù)（primitive type）類型，包括數(shù)字、字符串和布爾值
  • 對(duì)象（object type）類型，JS中除了數(shù)字、字符串、布爾值、Null、Undefined之外的就是對(duì)象了
  • • 對(duì)象（object）是屬性(property)的集合，每個(gè)屬性都由“名/值對(duì)”
    • JS定義了一種特殊的對(duì)象——數(shù)組（array）
    • JS定義了一種特殊的對(duì)象——函數(shù)
• 數(shù)字
• • JS不區(qū)分整數(shù)值和浮點(diǎn)數(shù)值，JS中所有數(shù)字均用浮點(diǎn)數(shù)值表示
  • 當(dāng)一個(gè)數(shù)字直接出現(xiàn)在程序中，我們稱之為數(shù)字直接量
  • JS支持多種格式的數(shù)字直接量
  • • 十進(jìn)制
    • 十六進(jìn)制
    • 數(shù)組下標(biāo)的32位整數(shù)
  • 浮點(diǎn)型直接量
  • JS中的算術(shù)運(yùn)算
  • • JS中的算術(shù)運(yùn)算在溢出、下溢或被零整除時(shí)不會(huì)報(bào)錯(cuò)。當(dāng)數(shù)字運(yùn)算結(jié)果超過(guò)了JS所能表示的數(shù)字上限，結(jié)果為一個(gè)特殊的無(wú)窮大值，JS中以Infinity表示
    • 下溢是當(dāng)運(yùn)算結(jié)果無(wú)限接近于零并比JS能表達(dá)的最小值還小的時(shí)候，JS將返回0
• 從技術(shù)上講，只有JS對(duì)象才能擁有方法。然而數(shù)字、字符串和布爾值也可以擁有自己的方法（3.6節(jié)進(jìn)行講解）
• 原始類型/對(duì)象類型
• 可變類型/不可變類型
• • 可變類型：值是可以修改的，數(shù)組與對(duì)象就是可變類型
  • 不可變類型：數(shù)字、字符串、布爾值、NULL和Undefined——比如，修改一個(gè)數(shù)值的內(nèi)容本身就說(shuō)不通
• JS可以自由地進(jìn)行數(shù)據(jù)類型轉(zhuǎn)換。比如，程序期望使用字符串的地方使用了數(shù)字，JS會(huì)自動(dòng)將數(shù)字轉(zhuǎn)換為字符串，使用布爾值的地方使用非布爾值，也會(huì)進(jìn)行自動(dòng)轉(zhuǎn)換
• JS中靈活的類型轉(zhuǎn)換規(guī)則對(duì)“判斷相等”的定義有影響。等號(hào)運(yùn)算符“==”
• JS變量是無(wú)類型的，變量可被賦值任何類型，同樣一個(gè)變量也可重新賦予不同類型的值
• 詞法作用域
• 日期和時(shí)間
• 字符串
• • 字符串是一組由16位值組成的不可變的有序序列，每個(gè)字符串通常來(lái)自于Unicode字符集
  • JS定義的各式字符串操作方法均作用于16位值
  • JS中字符串是不可變類型，JS中的字符串是固定不變的，類似replace()的方法都返回新的字符串，原始字符串本身并沒(méi)發(fā)生改變
• 字符串直接量
• 轉(zhuǎn)義字符
• • JS字符串中反斜線(\)有著特殊的用途，反斜線符號(hào)后加一個(gè)字符，就不再表示它們字面含義了，比如，\n就是一個(gè)轉(zhuǎn)義字符，它表示換行符
  • \'轉(zhuǎn)義符，表示單引號(hào)
• 字符串的使用
• • JS的內(nèi)置功能之一就是字符串連接。字符串使用加（+）號(hào)連接，表示兩數(shù)相連
• 匹配模式（正則表達(dá)式）
• 布爾值
• • 布爾值指代真或假、開或關(guān)、是或否。這個(gè)類型只有兩個(gè)值，保留字true和false
  • 程序中的比較語(yǔ)句的結(jié)果通常都是布爾值
  • 布爾值通常用于JS中的控制結(jié)構(gòu)中
  • 任意JS的值都可以轉(zhuǎn)換為布爾值。（undefined、null、0、-0、NaN、“”//空字符串）這些值都會(huì)被轉(zhuǎn)換成false。所有其他的值，包括所有對(duì)象（數(shù)組）都會(huì)轉(zhuǎn)換成true?？梢赞D(zhuǎn)換為false的值有時(shí)稱做“假值”，反之稱為“真值”
  • 布爾值包含toString()方法，這個(gè)不重要的API可以將布爾值轉(zhuǎn)換為字符串
  • “&&”運(yùn)算符執(zhí)行了邏輯與（AND）操作。當(dāng)且僅當(dāng)兩個(gè)操作數(shù)都是真值時(shí)才返回true
  • “||”運(yùn)算符是布爾或（OR）操作
  • “!”一元操作符執(zhí)行了布爾非（NOT）操作
• null和undefined
• • null是JS語(yǔ)言的關(guān)鍵字，表示一個(gè)特殊值，用來(lái)描述“空值”。對(duì)null執(zhí)行typeof預(yù)算，結(jié)果返回字符串“object”，也就是說(shuō)，可以將null認(rèn)為是一個(gè)特殊的對(duì)象值，含義是“非對(duì)象”。通常認(rèn)為null是它自有類型的唯一一個(gè)成員，它可以表示數(shù)字、字符串和對(duì)象是“無(wú)值”的。
  • undefined不是JS語(yǔ)言的關(guān)鍵字，它與null一樣表示空缺。用未定義的值表示更深層次的“空值”。它是變量的一種取值，表明變量沒(méi)有初始化。typeof運(yùn)算符得到undefined的類型，則返回“undefined”，表明這個(gè)值是這個(gè)類型的唯一成員
  • null與undefined是不同的，但是它們都是表示“值的空缺”，兩者往往可以互換。判斷相等運(yùn)算符“==”認(rèn)為兩者是相等的（喲啊使用嚴(yán)格相等運(yùn)算符“===”來(lái)區(qū)分它們）。它們都不包括任何屬性和方法。使用”.“和”[]“來(lái)存取這兩個(gè)值的成員或方法都會(huì)產(chǎn)生一個(gè)類型錯(cuò)誤
  • 或許可以認(rèn)為undefined是系統(tǒng)級(jí)的，出乎意料的或類似錯(cuò)誤的值的空缺，而null是表示程序集的、正常的或在意料之中的值的空缺。如果對(duì)他們進(jìn)行操作，賦值給變量或者屬性，或作為參數(shù)傳入函數(shù)，最佳選擇是使用null
• 全局對(duì)象
• • 當(dāng)JS解釋器啟動(dòng)時(shí)或者在任何Web瀏覽器加載新頁(yè)面的時(shí)候，它將創(chuàng)建一個(gè)新的全局對(duì)象，并給它一組定義的初始屬性
  • • 全局屬性，比如undefined、Infinity和NaN
    • 全局函數(shù)，比如isNaN()、parseInt()
    • 構(gòu)造函數(shù)，比如Date()、RegExp()、String()、Object()和Array()
    • 全局對(duì)象，比如Math和JSON
  • 全局對(duì)象的初始屬性并不是保留字，但它們應(yīng)該當(dāng)作保留字來(lái)對(duì)待
  • 客戶端JS來(lái)講，Windows對(duì)象定義了一些額外的全局屬性
  • 在代碼的最頂級(jí)——不再任何函數(shù)內(nèi)的JS代碼——可以使用JS關(guān)鍵字this來(lái)引用全局對(duì)象
  • 在客戶端JS中，在其表示的瀏覽器窗口中的所有JS代碼中，Window對(duì)象充當(dāng)了全局對(duì)象。
• 包裝對(duì)象
• • JS對(duì)象是一種復(fù)合值，它是屬性或已命名值的集合。通過(guò)”.”符號(hào)來(lái)引用屬性值。當(dāng)屬性值是一個(gè)函數(shù)的時(shí)候，稱其為方法。通過(guò)o.m()來(lái)調(diào)用對(duì)象o中的方法
  • 字符串也同樣具有屬性和方法，字符串不是對(duì)象，但是有屬性。只要引用了字符串的屬性,JS就會(huì)將字符串s值通過(guò)調(diào)用new String(s)的方式轉(zhuǎn)換成對(duì)象，這個(gè)對(duì)象繼承了字符串的方法，并被用來(lái)處理屬性的引用。一旦屬性引用結(jié)束，這個(gè)新創(chuàng)建的對(duì)象就會(huì)銷毀。
  • 同字符串一樣，數(shù)字和布爾值也具有各自的方法：通過(guò)Number()和Boolean()構(gòu)造函數(shù)創(chuàng)建一個(gè)臨時(shí)對(duì)象。null和undefined沒(méi)有包裝對(duì)象，訪問(wèn)它們的屬性會(huì)造成一個(gè)類型錯(cuò)誤
  • “==”等于運(yùn)算符將原始值和其包裝對(duì)象視為相等，當(dāng)“===”全等運(yùn)算符將它們視為不相等，使用typeof運(yùn)算符可以看到原始值和其包裝對(duì)象的不同
• 不可變的原始值和可變的對(duì)象引用
• • JS中的原始值（undefined、null、布爾值、數(shù)字和字符串）與對(duì)象（包括數(shù)組和函數(shù)）有著本質(zhì)的區(qū)別。
  • 原始值是不可更改的，任何方法都無(wú)法更改一個(gè)原始值
  • 對(duì)數(shù)字和布爾值來(lái)說(shuō)改變數(shù)字的值本身就說(shuō)不通，對(duì)字符串來(lái)說(shuō)，不那么明顯，看起來(lái)字符串組成像是對(duì)各字符的數(shù)組，我們期望通過(guò)制定索引下標(biāo)來(lái)修改字符串中的字符。實(shí)際上JS是禁止這樣做的，字符串所有方法看上去返回了一個(gè)修改后的字符串，實(shí)際上返回的是一個(gè)新的字符串值
  • 原始值的比較是值的比較，只有在它們的值相等時(shí)它們才會(huì)相等
  • 如果比較兩個(gè)單獨(dú)的字符串，當(dāng)且僅當(dāng)它們的長(zhǎng)度相等且每個(gè)索引的字符都相等時(shí)，JS才認(rèn)為他們相等
  • 對(duì)象和原始值不同，它們是可變的——它們的值也是可修改的
  • 對(duì)象的比較并非值的比較，即使兩個(gè)對(duì)象包含同樣的屬性及相同的值，它們也是不相等的，各個(gè)索引元素完全相等的兩個(gè)數(shù)組也不相等
  • 通常稱對(duì)象為引用類型，以此來(lái)和JS基本類型區(qū)分開
  • 對(duì)象值都是引用，對(duì)象的比較是引用的比較
  • 當(dāng)且僅當(dāng)它們引用同一個(gè)基對(duì)象時(shí)，它們才相等
  • 將數(shù)組或?qū)ο筚x值給一個(gè)變量，僅僅是賦值的引用，對(duì)象本身并沒(méi)有復(fù)制一次
• 類型轉(zhuǎn)換
• • JS取值非常靈活，從布爾值可以看出，當(dāng)JS期望使用一個(gè)布爾值的時(shí)候，可以提供任意類型值，JS將根據(jù)需要自行轉(zhuǎn)換類型
• 顯示類型轉(zhuǎn)換
• • JS可以自動(dòng)做許多類型轉(zhuǎn)換，但為了代碼變得清晰易讀而做的顯示轉(zhuǎn)換
  • 顯示類轉(zhuǎn)換最簡(jiǎn)單的方法使用Boolean()、Number()、String()或Object()函數(shù)
• 對(duì)象轉(zhuǎn)換為原始值
• • 所有對(duì)象繼承了兩個(gè)轉(zhuǎn)換方法。
  • toString()
  • • 第一個(gè)是toString()，它的作用是返回一個(gè)反映這個(gè)對(duì)象的字符串
    • 很多類定義了更多特定版本的toString()
    • 數(shù)組類的toString()方法，將每個(gè)數(shù)組元素轉(zhuǎn)換為一個(gè)字符串，并在元素之間添加都好后合并成結(jié)果字符串
    • 函數(shù)類的toString()方法，返回這個(gè)函數(shù)的實(shí)現(xiàn)定義的表示方式，通常是將用戶定義的函數(shù)轉(zhuǎn)換為JS源代碼字符串
    • 日期類的toString()方法，返回一個(gè)可讀的日期和時(shí)間字符串
    • RegExp類的toString()方法，將RegExp對(duì)象轉(zhuǎn)換為表示正則表達(dá)式直接量的字符串
  • valueOf()
  • • 這個(gè)方法任務(wù)并未詳細(xì)定義，如果存在任意原始值，它就默認(rèn)將對(duì)象轉(zhuǎn)換為表示它的原始值
    • 對(duì)象是復(fù)合值，而且大多數(shù)對(duì)象無(wú)法真正表示為一個(gè)原始值，因此簡(jiǎn)單的valueOf()方法簡(jiǎn)單的返回對(duì)象本身，而不是返回一個(gè)原始值
• 重復(fù)聲明與遺漏聲明
• • 使用var語(yǔ)句重復(fù)聲明變量是合法且無(wú)害的。如果重復(fù)聲明帶有初始化器，那么這就跟一條簡(jiǎn)單的賦值語(yǔ)句沒(méi)什么兩樣
  • 如果試圖讀取一個(gè)沒(méi)有聲明的變量值JS會(huì)報(bào)錯(cuò)
  • 給一個(gè)沒(méi)有聲明的變量賦值也會(huì)報(bào)錯(cuò)
• 變量作用域
• • 變量的作用域是程序源代碼中定義這個(gè)變量的區(qū)域
  • 全局變量擁有全局作用域
  • 函數(shù)體內(nèi)聲明的變量作用域是局部性的，它們只在函數(shù)體內(nèi)有定義
• 函數(shù)作用域和聲明提前
• • JS沒(méi)有塊級(jí)作用域，JS取而代之的使用了函數(shù)作用域
  • JS的函數(shù)作用域是指在函數(shù)內(nèi)聲明的所有變量在函數(shù)體內(nèi)始終可見，意味著變量在聲明之前已經(jīng)可用，JS的這個(gè)特性被非正式的成為聲明提前，即JS函數(shù)里聲明的所有變量（但不涉及賦值）都被“提前”至函數(shù)體的頂部
• 作為屬性的變量
• • 當(dāng)聲明一個(gè)JS全局變量時(shí)，實(shí)際上是定義了全局對(duì)象的一個(gè)屬性
  • 當(dāng)使用var聲明一個(gè)變量時(shí)，創(chuàng)建的這個(gè)屬性是不可配置的，也就是說(shuō)這個(gè)變量無(wú)法通過(guò)delete運(yùn)算符刪除
  • JS全局變量是全局對(duì)象的屬性，這是ECMASscript規(guī)范中強(qiáng)制規(guī)定的，對(duì)于局部變量則沒(méi)有如此規(guī)定
  • ECMAScript 5 規(guī)范稱“聲明上下文對(duì)象”，JS可以允許使用this關(guān)鍵字來(lái)引用全局對(duì)象，卻沒(méi)有方法可以引用局部變量中存放的對(duì)象。這種存放局部變量的對(duì)象的特有性質(zhì)，是一種對(duì)我們不可見的內(nèi)部實(shí)現(xiàn)。
• 作用域鏈（未完全理解）
• • JS是基于詞法作用域的語(yǔ)言：通過(guò)閱讀包含變量定義在內(nèi)的數(shù)行源碼就能知道變量的作用域。
  • 全局變量在程序中始終都是有定義的
  • 局部變量在聲明它的函數(shù)體內(nèi)以及其所嵌套的函數(shù)內(nèi)始終是有定義的
  • /*
  • 如果將一個(gè)局部變量看做是自定義實(shí)現(xiàn)的對(duì)象的屬性的話，那么可以換個(gè)角度來(lái)解讀變量作用域。
  • 每一段JS代碼（全局代碼或函數(shù)）都有一個(gè)與之關(guān)聯(lián)的作用域鏈。
  • 這個(gè)作用域鏈?zhǔn)且粋€(gè)對(duì)象列表或者鏈表，這組對(duì)象定義了這段代碼“作用域中”的變量。
  • 當(dāng)JS需要查找變量x的值的時(shí)候（這個(gè)過(guò)程稱做變量解析），它會(huì)從鏈接中的第一個(gè)對(duì)象開始查找，如果這個(gè)對(duì)象有名為x的屬性，則會(huì)直接使用這個(gè)屬性的值，如果第一個(gè)對(duì)象中不存在名為x的屬性，JS會(huì)繼續(xù)查找鏈接的下一個(gè)對(duì)象。
  • 如果第二個(gè)對(duì)象依然沒(méi)有名為x的屬性，則會(huì)繼續(xù)查找下一個(gè)對(duì)象，以此類推
  • 如果作用域鏈就上沒(méi)有任何一個(gè)對(duì)象含有屬性x，那么就認(rèn)為這段代碼的作用域鏈接上不存在x，并最終拋出一個(gè)引用錯(cuò)誤異常
  • */
  • /*
  • 在JS的最頂層代碼中（也就是不包含在任何函數(shù)定義的代碼），作用域鏈由一個(gè)全局對(duì)象組成
  • 在不包含嵌套的函數(shù)體內(nèi)，作用域鏈上有兩個(gè)對(duì)象，第一個(gè)是定義函數(shù)參數(shù)和局部變量的對(duì)象，第二個(gè)是全局對(duì)象
  • 在一個(gè)嵌套的函數(shù)體內(nèi)，作用域鏈上至少有三個(gè)對(duì)象
  • 理解對(duì)象鏈的創(chuàng)建規(guī)則是非常重要的
  • 當(dāng)定義一個(gè)函數(shù)時(shí)，它實(shí)際上保存一個(gè)作用域鏈。
  • 當(dāng)調(diào)用這個(gè)函數(shù)時(shí)，它創(chuàng)建一個(gè)新的對(duì)象來(lái)存儲(chǔ)它的局部變量，并將這個(gè)對(duì)象添加至保存的那個(gè)作用域鏈上，同時(shí)創(chuàng)建一個(gè)新的更長(zhǎng)的表示函數(shù)調(diào)用作用域的“鏈”
  • 對(duì)于嵌套函數(shù)來(lái)講，每次調(diào)用外部函數(shù)時(shí)，內(nèi)部函數(shù)又會(huì)重新定義一遍。因?yàn)槊看握{(diào)用外部函數(shù)的時(shí)候，作用域鏈都是不同的
  • 內(nèi)部函數(shù)在每次定義的時(shí)候都有微妙的差別，在每次調(diào)用外部函數(shù)的時(shí)候，每部函數(shù)的代碼都是相同的，而且關(guān)聯(lián)這段代碼的作用域也不相同

• 表達(dá)式JS中的一個(gè)短語(yǔ)，JS解釋器會(huì)將其計(jì)算出一個(gè)結(jié)果
• 常量、變量名都是一種簡(jiǎn)單的表達(dá)式
• 復(fù)雜表達(dá)式是由簡(jiǎn)單表達(dá)式組成的
• 簡(jiǎn)單表達(dá)式組合成復(fù)雜表達(dá)式最常用的方法就是使用運(yùn)算符。根據(jù)運(yùn)算符規(guī)則返回一個(gè)值
• 原始表達(dá)式
• • 最簡(jiǎn)單的表達(dá)式是“原始表達(dá)式”
  • 原始表達(dá)式是表達(dá)式的最小單位，它們不再包含其他表達(dá)式
  • JS原始表達(dá)式包含常量、關(guān)鍵字、變量
• 對(duì)象和數(shù)組的初始化表達(dá)式
• 函數(shù)定義表達(dá)式
• 屬性訪問(wèn)表達(dá)式
• 調(diào)用表達(dá)式
• 對(duì)象創(chuàng)建表達(dá)式
• 省略部分。。。。。。

• 表達(dá)式在JS中是短語(yǔ)，那么語(yǔ)句就是JS整句或命令
• 語(yǔ)句塊的結(jié)尾不需要分號(hào)。塊中的原始語(yǔ)句必須以分號(hào)結(jié)束，但語(yǔ)句塊不需要
• 語(yǔ)句塊中的縮進(jìn)，這不是必須的，但能增強(qiáng)代碼的可閱讀性
• JS中沒(méi)有塊級(jí)作用域，在語(yǔ)句塊中聲明的變量并不是語(yǔ)句私有的

• 對(duì)象是JS的基本數(shù)據(jù)類型
• 對(duì)象是一種復(fù)合值
• 對(duì)象也可看做是屬性的無(wú)序集合，每個(gè)屬性都是一個(gè)名/值對(duì)
• 屬性名是字符串，因此我們可以把對(duì)象看成是對(duì)字符串到值的映射
• 這種基本數(shù)據(jù)類型還有很多叫法，有些我們已然非常熟悉，比如散列、散列表、字典、關(guān)聯(lián)數(shù)組
• 然而對(duì)象不僅僅是字符串到值的映射，除了可以保持自有的屬性，JS對(duì)象還可以從一個(gè)稱為原型的對(duì)象繼承屬性
• 對(duì)象的方法通常是繼承的屬性，這種“原型式繼承”是JS的核心特征
• JS對(duì)象是動(dòng)態(tài)的可以增刪屬性
• 除了字符串、數(shù)字、true、false、unll、undefined之外，JS中的值都是對(duì)象
• 對(duì)象最常見的用法是創(chuàng)建、設(shè)置、查找、刪除、檢測(cè)、枚舉它的屬性
• 屬性包括名字和值
• 屬性名可以是包含空字符串在內(nèi)的任意字符串
• 對(duì)象中不能存在兩個(gè)同名的屬性
• 值可以是任意JS值，或者（在ECMASscript5中）可以是一個(gè)getter或setter函數(shù)
• 除了名字和值之外，每個(gè)屬性還有一些與之相關(guān)的值，稱為“屬性特性”
• 屬性特性
• • 可寫，表明是否餓可以設(shè)置該屬性的值
  • 可枚舉，表明是否可以通過(guò)for/in循環(huán)返回該屬性
  • 可配置，表明是否可以刪除或修改該屬性
• 對(duì)象特性
• • 對(duì)象的原型，指向另為一個(gè)對(duì)象，本對(duì)象的屬性繼承自它的原型對(duì)象
  • 對(duì)象的類，是一個(gè)標(biāo)識(shí)對(duì)象類型的字符串
  • 對(duì)象的擴(kuò)展標(biāo)記，指明了（在ECMAScript 5中）是否可以向該對(duì)象添加新屬性
• 三類JS對(duì)象的兩類屬性作區(qū)分
• • 內(nèi)置對(duì)象，是由ECMAScript規(guī)范定義的對(duì)象或類。例如數(shù)組、函數(shù)、日期、增則表達(dá)式
  • 宿主對(duì)象，是由JS解釋器所嵌入的宿主環(huán)境（比如Web瀏覽器）定義的
  • 自定義對(duì)象，是由運(yùn)行中的JS代碼創(chuàng)建的對(duì)象
  • 自有屬性，是直接在對(duì)象中定義的屬性
  • 繼承屬性，是在對(duì)象的原型對(duì)象中定義的屬性
• 創(chuàng)建對(duì)象
• • 對(duì)象直接量
  • 關(guān)鍵字new創(chuàng)建
  • Object.create()函數(shù)創(chuàng)建
• 對(duì)象直接量
• • 創(chuàng)建對(duì)象直接量最簡(jiǎn)單的方式就是在JS代碼中使用對(duì)象直接量
  • 對(duì)象直接量是由若干名/值對(duì)組成的映射表
  • 屬性名可以是JS標(biāo)識(shí)符也可以是字符串直接量（包括空字符串）
  • 對(duì)象之間量是一個(gè)表達(dá)式，這個(gè)表達(dá)式的每次運(yùn)算都創(chuàng)建并初始化一個(gè)新的對(duì)象
  • 每次計(jì)算對(duì)象之間量的時(shí)候，也都會(huì)計(jì)算它的每個(gè)屬性值
  • 重復(fù)調(diào)用的函數(shù)中的循環(huán)體內(nèi)使用了對(duì)象直接量，它將創(chuàng)建很多新對(duì)象，并且每次創(chuàng)建的對(duì)象的屬性值也有可能不同
• 通過(guò)new創(chuàng)建對(duì)象
• • new運(yùn)算符創(chuàng)建并初始化一個(gè)新對(duì)象
  • 關(guān)鍵字new后跟隨一個(gè)函數(shù)調(diào)用，這里的函數(shù)稱做構(gòu)造函數(shù)
  • JS語(yǔ)言核心中的原始類型都包含內(nèi)置構(gòu)造函數(shù)
• 原型
• • 每一個(gè)JS對(duì)象（null除外）都和另一個(gè)對(duì)象相關(guān)聯(lián)，就是原型，每一個(gè)對(duì)象都從原型繼承屬性
  • 所有對(duì)象直接量創(chuàng)建的對(duì)象都具有同一個(gè)原型對(duì)象，并可以通過(guò)JS代碼Object.prototype獲得對(duì)原型對(duì)象的引用
  • 通過(guò)new和構(gòu)造函數(shù)調(diào)用創(chuàng)建的對(duì)象的原型就是狗找函數(shù)的prototype屬性的值
  • 沒(méi)有原型的對(duì)象為數(shù)不多，Object.prototype就是其中之一
• Object.create()
• • Object.create()是一個(gè)靜態(tài)函數(shù)，而不是提供給某個(gè)對(duì)象調(diào)用的方法
  • 可以傳入?yún)?shù)null創(chuàng)建一個(gè)沒(méi)有原型的新對(duì)象，這種方式創(chuàng)建的對(duì)象不會(huì)繼承任何東西，甚至不包括基礎(chǔ)方法，比如toString(),也就是說(shuō)它將不能和“+”運(yùn)算符一起正常工作
• 屬性的查詢和設(shè)置
• 作為關(guān)聯(lián)數(shù)組的對(duì)象
• • 第一種語(yǔ)法使用點(diǎn)運(yùn)算符和一個(gè)標(biāo)識(shí)符運(yùn)算符，這和C和Java中訪問(wèn)一個(gè)結(jié)構(gòu)體或?qū)ο蟮撵o態(tài)字段非常類似
  • 第二種語(yǔ)法使用方括號(hào)和一個(gè)字符串，看起來(lái)更像數(shù)組，這個(gè)素組元素是通過(guò)字符串索引而不是數(shù)字索引，這種數(shù)組就是關(guān)聯(lián)數(shù)組，也稱散列、映射、字典
• 繼承（未完全理解）
• • JS對(duì)象具有“自有屬性”，也有一些屬性從原型對(duì)象繼承而來(lái)
  • 假設(shè)o對(duì)象的屬性x賦值，如果o中已經(jīng)有屬性x(這個(gè)屬性不是繼承來(lái)的)，那么這個(gè)賦值操作只會(huì)改變這個(gè)已有屬性x的值
  • 如果o中不存在屬性x，那么賦值操作給o添加一個(gè)新屬性x
  • 如果之前o繼承自有屬性x，那么這個(gè)繼承的屬性就被新創(chuàng)建的同名屬性覆蓋了
  • 屬性賦值操作首先檢查原型鏈，以此判斷是否允許賦值操作
  • 如果o繼承自一個(gè)只讀屬性x，那么賦值操作是不允許的，如果允許賦值操作，它也總是在原始對(duì)象上創(chuàng)建屬性或?qū)σ延械膶傩再x值，而不會(huì)去修改原型鏈
  • 在JS中，只有在查詢屬性時(shí)才會(huì)體會(huì)到繼承的存在，而設(shè)置屬性則和繼承無(wú)關(guān)，這是JS的一個(gè)重要特性，該特性讓程序員可以有選擇地覆蓋繼承的屬性
  • 屬性賦值要么失敗，要么創(chuàng)建一個(gè)屬性，要么在原始對(duì)象中設(shè)置屬性，但有一個(gè)例外，如果o繼承自屬性x，而這個(gè)屬性是一個(gè)具有setter方法的accessor屬性，那么這時(shí)將調(diào)用setter方法而不是給o創(chuàng)建一個(gè)屬性x
  • 需要注意的是，setter方法是由對(duì)象o調(diào)用的，而不是定義這個(gè)屬性的原型對(duì)象調(diào)用的。因此如果setter方法定義任意屬性，這個(gè)操作只是針對(duì)o本身，并不會(huì)修改原型鏈
• 屬性訪問(wèn)錯(cuò)誤
• • 屬性訪問(wèn)并不總是返回或設(shè)置一個(gè)值
  • 查詢一個(gè)不存在的屬性并不會(huì)報(bào)錯(cuò)，查找對(duì)象自有屬性或繼承的屬性中均為找到屬性，屬性訪問(wèn)表達(dá)式返回undefined
  • 如果對(duì)象不存在，那么試圖查詢這個(gè)不存在對(duì)象的屬性就會(huì)報(bào)錯(cuò)，因?yàn)檎业綄?duì)象返回的是undefined而unll與undefind都沒(méi)有屬性
  • 給unll和undefined設(shè)置屬性也會(huì)報(bào)類型錯(cuò)誤
  • 對(duì)象自有屬性是只讀的，不能給只讀屬性重新賦值（defineProperty()方法中有一個(gè)例外，可以對(duì)可配置的只讀屬性重新賦值）
  • 對(duì)象繼承自有屬性，且它是只讀的，不同通過(guò)同名自有屬性覆蓋只讀的繼承屬性
  • 免去其它不可賦值情況下，對(duì)象的可擴(kuò)展性是false，那么不能定義新屬性
• 刪除屬性
• • delete運(yùn)算符可以刪除對(duì)象的屬性
  • delete運(yùn)算符只是斷開屬性和宿主對(duì)象的聯(lián)系，而不會(huì)去操作屬性中的屬性
  • delete運(yùn)算符只能刪除自有屬性，不能刪除繼承屬性（要?jiǎng)h除繼承屬性必須從定義這個(gè)屬性的原型對(duì)象上刪除它，而且這會(huì)影響到所有繼承自這個(gè)原型的對(duì)象）
  • 當(dāng)刪除一個(gè)嵌套對(duì)象，由于刪除的屬性引用依然存在，可能因?yàn)檫@種不嚴(yán)謹(jǐn)?shù)拇a而造成內(nèi)存泄漏。所有在銷毀對(duì)象的時(shí)候，要遍歷屬性中的屬性，依次刪除
  • 當(dāng)delete表達(dá)式刪除成或沒(méi)有副作用（比如刪除不存在的屬性）時(shí)，它返回true，如果delete后不是一個(gè)屬性訪問(wèn)表達(dá)式（比如 delete 1），同樣返回true
  • delete不能刪除那些可配置性為false的屬性（盡管可以刪除不可擴(kuò)展對(duì)象的可配置屬性）。
• 檢測(cè)屬性
• • in——in與那算符左側(cè)是屬性名（字符串），右側(cè)是對(duì)象。如果對(duì)象自有屬性或繼承屬性中包含這個(gè)屬性則返回true
  • hasOwnProperty()——方法用來(lái)檢測(cè)給定的名字是否是對(duì)象的自有屬性。對(duì)于繼承屬性它將返回false
  • propertyIsEnumerable()——是hasOwnProperty()增強(qiáng)版，只有檢測(cè)到是自有屬性且這個(gè)屬性的可枚舉性為true時(shí)它才返回true。通常由JS代碼創(chuàng)建的屬性都是可枚舉的，除非使用特定方法改變屬性的可枚舉性
  • !==——比較值
  • 有一種場(chǎng)景必須使用in運(yùn)算符，當(dāng)對(duì)象值為undefined時(shí)
• 枚舉屬性
• • 許多實(shí)用工具庫(kù)給Object.prototype添加了新的方法或?qū)傩?，這些屬性方法可以被所有對(duì)象繼承并使用
  • for/in循環(huán)可以在循環(huán)體中遍歷對(duì)象中所有可枚舉的屬性（包括自有屬性和繼承的屬性），把屬性名稱賦值給循環(huán)變量。
  • 對(duì)象繼承的內(nèi)置方法不可枚舉的，但在代碼中給對(duì)象添加的屬性都是可枚舉的（除非轉(zhuǎn)為成不可枚舉）
  • ECMAScript 5中定義了兩個(gè)用以枚舉屬性名稱的函數(shù)Object.keys()、Object.getOwnPropertyNames()
• 屬性getter和setter
• * 屬性的特性
• • 除了包含名字和值之外，屬性還包含一些標(biāo)識(shí)它們可寫、可枚舉、可配置的特性
  • 可以認(rèn)為一個(gè)屬性包含一個(gè)名字和4個(gè)特性。數(shù)據(jù)屬性的4個(gè)特性分別是它的值、可寫性、可枚舉性、可配置性
  • 存取屬性不具有值特性和可寫性，它們的可寫性是由setter方法存在于否決定的。因此存取器屬性的4個(gè)特性是讀取、寫入、可枚舉、可配置
  • 為了實(shí)現(xiàn)屬性特性的查詢和設(shè)置操作，ECMAScript 5中定義了一個(gè)名為“屬性描述符”的對(duì)象，這個(gè)對(duì)象代表那4個(gè)特性
  • 描述對(duì)象的屬性和它們所描述的屬性特性是同名的。因此，數(shù)據(jù)屬性的描述符對(duì)象的屬性有value、writable、enumerable、configurable
  • 存取器屬性的描述符對(duì)象則用get、set屬性代替value和writable，其中writable、enumerable和configurable都是布爾值
  • 通過(guò)調(diào)用Object.getOwnPropertyDescriptor()可以獲得某個(gè)對(duì)象特定屬性的屬性描述符
  • getOwnPropertyDescriptor()只能得到自有屬性的描述符，想要得到繼承屬性的特性需要遍歷原型鏈
  • 通過(guò)definePeoperty()設(shè)置屬性的特性，屬性秒速符對(duì)象不必包含所有4個(gè)特性。這個(gè)方法要么修改已有屬性要么新建自有屬性，但不能修改繼承屬性
  • 如果要同時(shí)修改或創(chuàng)建多個(gè)屬性，則需要使用Object.defineProperties()
  • 如果對(duì)象是不可擴(kuò)展的，則可以編輯已有的自有屬性，但不能給它添加新屬性
  • 如果屬性是不可配置的，則不能修改它的可配置性和可枚舉性
  • 如果存取器屬性是不可配置的，則不能修改其getter和setter方法，也不能將它轉(zhuǎn)換為數(shù)據(jù)屬性
  • 如果數(shù)據(jù)屬性是不可配置的，則不能將它轉(zhuǎn)換為存取器屬性
  • 如果數(shù)據(jù)屬性是不可配置的，則不能將它的可寫性從false修改為true，但可以從true修改為false
  • 如果數(shù)據(jù)屬性是不可配置且不可寫的，則不能修改它的值。然而可配置但不可寫屬性的值是可以修改的（實(shí)際上是先將它標(biāo)記為可寫的，然后修改它的值，最后轉(zhuǎn)換為不可寫的）
• 對(duì)象的三個(gè)屬性
• • 每一個(gè)對(duì)象都有與之相關(guān)的原型、類、可擴(kuò)展性
  • 原型屬性
  • • 對(duì)象的原型屬性是用來(lái)繼承屬性的
    • 原型屬性是在實(shí)例對(duì)象創(chuàng)建之初就設(shè)置好的
    • 通過(guò)對(duì)象之間量創(chuàng)建的對(duì)象使用Object.prototype作為它們的原型
    • 通過(guò)new構(gòu)造函數(shù)創(chuàng)建的對(duì)象使用構(gòu)造函數(shù)的prototype屬性作為它們的原型
    • 通過(guò)object.create()創(chuàng)建的對(duì)象使用第一個(gè)參數(shù)(也可以是null)作為它們的原型
    • 在ECMScript 5中，將對(duì)象作為參數(shù)傳入Object.getPrototypeOf()可以查詢它的原型
    • 通過(guò)new表達(dá)式創(chuàng)建的對(duì)象，通常繼承一個(gè)constructor屬性，這個(gè)屬性指代創(chuàng)建這個(gè)對(duì)象的構(gòu)造函數(shù)
    • 通過(guò)直接量與object.creat創(chuàng)建的對(duì)象包含一個(gè)名為constructor的屬性，這個(gè)屬性指代Object構(gòu)造函，因此，constructor.prototype才是對(duì)象直接量的真正原型，但對(duì)于object.create()創(chuàng)建的對(duì)象則往往不是這樣
    • 使用isPrototypeOf()方法，檢測(cè)一個(gè)對(duì)象是否是另一個(gè)對(duì)象的原型
    • isPrototypeOf()函數(shù)實(shí)現(xiàn)的功能與instanceof運(yùn)算符非常類似
    • _proto_，可設(shè)置對(duì)象的原型，但是應(yīng)用不廣泛，不推薦使用
  • 類屬性
  • • 對(duì)象的類屬性是一個(gè)字符串，用以表示對(duì)象的類型信息ECMAS 3與5都未提供設(shè)置個(gè)屬性的方法，并只有一種間接方法可以查詢它。默認(rèn)的toString()方法
    • 很多對(duì)象繼承的toString()方法被重寫了，為了能調(diào)用正確版本的toString，必須間接的調(diào)用Function.call()方法
    • 通過(guò)內(nèi)置構(gòu)造函數(shù)創(chuàng)建的對(duì)象包含“類屬性”，它與構(gòu)造函數(shù)名稱相匹配
    • 通過(guò)對(duì)象直接量和Object.create創(chuàng)建的對(duì)象的類屬性是‘object’，自定義構(gòu)造函數(shù)創(chuàng)建的對(duì)象也是一樣，因此對(duì)于自定義函數(shù)來(lái)說(shuō)，沒(méi)辦法通過(guò)類屬性類區(qū)分對(duì)象的類
  • 可擴(kuò)展性
  • • 對(duì)象的可擴(kuò)展性用以表示是否可以給對(duì)象添加新屬性，所有內(nèi)置對(duì)象和自定義對(duì)象都是顯式可擴(kuò)展的
    • ECMAScript 5 定義了用來(lái)查詢和設(shè)置對(duì)象可擴(kuò)展性的函數(shù)。Object.esExtensible()判斷是否可擴(kuò)展
    • 將對(duì)象轉(zhuǎn)換為不可擴(kuò)展的，需要調(diào)用Object.preventExtensions()，一旦將對(duì)象轉(zhuǎn)換為不可擴(kuò)展的，就無(wú)法再將其轉(zhuǎn)換回可擴(kuò)展，并且只影響對(duì)象本身的可擴(kuò)展性
    • 給一個(gè)不可擴(kuò)展的原型對(duì)象添加屬性，這個(gè)不可擴(kuò)展對(duì)象同樣會(huì)繼承這些新屬性
    • Object.seal()和Object.preventExtensions()類似，除了能夠?qū)?duì)象設(shè)置為不可擴(kuò)展的，還可以將對(duì)象的所有自有屬性都設(shè)置為不可配置的。也就是說(shuō)不能給這個(gè)對(duì)象添加新屬性，而且它已有的屬性也不能刪除或配置，不過(guò)它已有的可寫屬性依然可以設(shè)置。
    • 對(duì)于已經(jīng)封閉的對(duì)象是不能解封的?？梢允褂肙bject.isSealed()來(lái)檢查對(duì)象是否封閉
    • Object.freeze()將更嚴(yán)格的鎖定對(duì)象——“凍結(jié)”。除了將對(duì)象設(shè)置不可擴(kuò)展和不可配置外，還可以將它已有數(shù)據(jù)屬性設(shè)置為只讀（如果對(duì)象的存取器屬性具有setter方法，存取器屬性將不受影響，仍可以通過(guò)屬性賦值調(diào)用它們）。使用Object.isFrozen()來(lái)檢測(cè)對(duì)象是否凍結(jié)
    • preventExtensions()seal()freeze()都返回傳入的對(duì)象，也就是說(shuō)，可以通過(guò)函數(shù)嵌套的方式調(diào)用它們
  • 序列化對(duì)象
  • • 序列化對(duì)象是指將對(duì)象的狀態(tài)轉(zhuǎn)換為字符串，也可將字符串還原為對(duì)象
    • ECMAScript 5 提供了內(nèi)置函數(shù)JSON.stringify()和JSON.parse()用來(lái)序列化和還原JS對(duì)象
    • JSON語(yǔ)法是JS語(yǔ)法的子集，并不能表示JS所有對(duì)象
    • 子集
    • • 大多數(shù)代碼都會(huì)定義它們的子集，用以更安全的方式執(zhí)行第三方代碼
      • 子集的設(shè)計(jì)目的是在容器或“沙箱”中更安全的運(yùn)行不可信的第三方JavaScript代碼
      • 所有能破壞這個(gè)沙箱并影響全局執(zhí)行環(huán)境的語(yǔ)言特性和API在這個(gè)安全子集中都是禁止的
      • 為了讓代碼靜態(tài)的通過(guò)JavaScript安全檢查，必須移除一些JavaScript特性
      • • 禁止使用this，因?yàn)樵冢ǚ菄?yán)格模式中）this訪問(wèn)全局變量
        • • 嚴(yán)格模式
          • • 嚴(yán)格模式是將更好的的錯(cuò)誤檢查引入代碼中的方法
            • 嚴(yán)格模式時(shí)，無(wú)法使用隱式聲明的變量、將賦值給只讀屬性或?qū)傩蕴砑拥讲豢蓴U(kuò)展的對(duì)象等
            • 消除JS代碼中一些不合理、不嚴(yán)謹(jǐn)之處，減少代碼怪異行為
            • 程序或函數(shù)開頭使用use strict 來(lái)聲明嚴(yán)格模式
        • with、帶.或[]表達(dá)式、function、windows和對(duì)Document的引用
    • 支持對(duì)象、數(shù)組、字符串、無(wú)窮大數(shù)字、true、false和null，并可以序列化和反序列化
    • NaN/Infinity和-Infinity序列化的結(jié)果是null
    • RegExp、Error對(duì)象和undefined值不能序列化和還原
    • JSON.stringify()只能序列化對(duì)象可枚舉的自有屬性
    • 對(duì)于不能序列化的屬性來(lái)說(shuō)，在序列化后的輸出字符串中會(huì)將這個(gè)屬性省略掉
    • stringify()parse都可以接受第二個(gè)可選參數(shù)，通過(guò)傳入需要序列化或還原的屬性列表來(lái)定制自定義的序列化或還原操作
  • 對(duì)象方法
  • toString方法
  • • toString方法沒(méi)有參數(shù)，返回一個(gè)表示調(diào)用這個(gè)方法的對(duì)象值的字符串
    • 很多類都帶有自自定義的toString方法
  • toLocaleString方法
  • • 除了基本的tostring方法外，對(duì)象都包含toLocaleString方法，這個(gè)方法返回一個(gè)表示這個(gè)對(duì)象的本地字符串
    • Date、Number類對(duì)toLocaleString方法做了定制
  • valueOf
  • • valueOf與toString非常類似，當(dāng)JS需要將對(duì)象轉(zhuǎn)換為某種原始值而非字符串的時(shí)候才會(huì)調(diào)用它，尤其轉(zhuǎn)換為數(shù)字的時(shí)候
    • 在需要使用原始值的地方使用了對(duì)象，JS就會(huì)自動(dòng)調(diào)用這個(gè)方法

• 數(shù)組是值的有序集合
• 每個(gè)值叫做一個(gè)元素，每個(gè)元素在數(shù)組中有一個(gè)位置，以數(shù)字表示，稱為索引
• 數(shù)組可以是任何類型，并且同一個(gè)數(shù)組中的不同元素也可能有不同的類型
• 數(shù)組的元素甚至也可能是對(duì)象或其他數(shù)組，這允許創(chuàng)建復(fù)雜的數(shù)據(jù)結(jié)構(gòu)
• JS數(shù)組的索引是基于零的32位數(shù)值
• JS數(shù)組是動(dòng)態(tài)的，根據(jù)需要他們會(huì)增長(zhǎng)或縮減，并且在創(chuàng)建數(shù)組時(shí)無(wú)需聲明一個(gè)固定大小或者在數(shù)組大小變化時(shí)無(wú)需重新分配空間
• JS數(shù)組可能是稀疏的，數(shù)組元素的索引不一定要連續(xù)的，它們之間可以有空缺
• 每個(gè)JS數(shù)組都有一個(gè)length屬性。針對(duì)非稀疏數(shù)組該元素就是數(shù)組元素的個(gè)數(shù)
• 針對(duì)稀疏數(shù)組，length比所有元素的索引要大
• JS數(shù)組是JS對(duì)象的特殊形式
• 通常，數(shù)組的實(shí)現(xiàn)是經(jīng)過(guò)優(yōu)化的，用數(shù)字索引來(lái)訪問(wèn)數(shù)組元素一般來(lái)說(shuō)比訪問(wèn)常規(guī)對(duì)象屬性要快很多
• 數(shù)組繼承自Array.prototype中的屬性，它定義了一套豐富的數(shù)組操作方法
• 數(shù)組直接量中的值不一定是常量，可以是任意表達(dá)式
• 它可以包含對(duì)象直接量或其他數(shù)組直接量
• 如果省略數(shù)組直接量中的某個(gè)值，省略的元素將被賦予undefined值
• 數(shù)組直接量的語(yǔ)法允許有可選的結(jié)尾的逗號(hào)
• 調(diào)用構(gòu)造函數(shù) Array()是創(chuàng)建數(shù)組的另一種方法，這種形式可以預(yù)分配一個(gè)數(shù)組空間，但數(shù)組中沒(méi)有存儲(chǔ)值，甚至數(shù)組的索引屬性還未定義
• 數(shù)組的特別之處在于，當(dāng)使用小于2的32次方的非負(fù)整數(shù)作為屬性名時(shí)數(shù)組會(huì)自動(dòng)維護(hù)其length屬性值
• 所有數(shù)組都是對(duì)象，可以為其創(chuàng)建任意名字的屬性。但如果使用的屬性是數(shù)組的索引，數(shù)組的特殊行為就是將根據(jù)需要更新它們的length屬性值
• 可以使用負(fù)數(shù)或非整數(shù)來(lái)索引數(shù)組。在這種情況下，數(shù)值轉(zhuǎn)換為字符串，字符串作屬性名來(lái)用。既然名字不是非負(fù)整數(shù)，它就只能當(dāng)作常規(guī)的對(duì)象屬性，而非數(shù)組的索引
• 使用了是非負(fù)整數(shù)的字符串，它就當(dāng)作數(shù)組索引，而非對(duì)象屬性
• 數(shù)組索引僅僅是對(duì)象屬性名的一種特殊類型，這意味著JS數(shù)組沒(méi)有“越界”錯(cuò)誤的概念
• 當(dāng)試圖查詢?nèi)魏螌?duì)象中不存在的屬性時(shí)，不會(huì)報(bào)錯(cuò)，只會(huì)得到undefined值。類似對(duì)象，對(duì)于對(duì)象同樣存在這種情況
• 既然數(shù)組是對(duì)象，那么它們可以從原型中繼承元素。在ECMASscript 5中，數(shù)組可以定義元素的getter和setter方法
• 如果一個(gè)元素確實(shí)繼承了元素或使用了元素的getter和setter方法，訪問(wèn)這種數(shù)組的元素的時(shí)間會(huì)與常規(guī)對(duì)象屬性的查找時(shí)間相近
• 訪問(wèn)數(shù)組
• • 數(shù)組是對(duì)象的特殊形式。使用方括號(hào)訪問(wèn)數(shù)組元素就像用方括號(hào)訪問(wèn)對(duì)象的屬性一樣
  • JS將指定的數(shù)字索引轉(zhuǎn)換成字符串——索引值1變成“1”——然后將其作為屬性名來(lái)使用
  • 對(duì)于常規(guī)JS對(duì)象也可以使用方括號(hào)來(lái)操作
• 創(chuàng)建數(shù)組
• • 直接量創(chuàng)建
  • new Array()構(gòu)造函數(shù)創(chuàng)建
• × 數(shù)組元素的添加和刪除
• • push()方法在數(shù)組末尾增加一個(gè)或多個(gè)元素
  • unshift()方法在數(shù)組的首部插入一個(gè)元素，并且將其他元素依次移到跟高的索引處
  • delete 直接刪除數(shù)組某個(gè)元素，并不影響數(shù)組長(zhǎng)度
  • 數(shù)組有pop方法（它和push()一起使用），后者一次使減少長(zhǎng)度1并返回被刪除元素的值
  • shift方法(它和unshift一起使用)，從數(shù)組頭部刪除一個(gè)元素。和delete不同的是shift方法將所有元素下移到比當(dāng)前索引低1的地方
• 稀疏數(shù)組
• • 稀疏數(shù)組就是包含從0開始的不連續(xù)索引的數(shù)組
  • 通常數(shù)組中的length屬性值代表數(shù)組中元素的個(gè)數(shù)。如果數(shù)組是稀疏的，length屬性值大于元素的個(gè)數(shù)
  • 可以用delete操作符來(lái)生產(chǎn)稀疏數(shù)組
  • 足夠稀疏的數(shù)組通常在實(shí)現(xiàn)上比稠密的數(shù)組更慢、內(nèi)存利用率更高，在這一的數(shù)組中查找元素的時(shí)間與常規(guī)對(duì)象屬性的查找時(shí)間一樣長(zhǎng)
  • 通過(guò)數(shù)組刪除 Array.shift() 或 Array.pop()  splice() 不會(huì)產(chǎn)生稀疏數(shù)組
• 數(shù)組長(zhǎng)度
• • 每個(gè)數(shù)組有一個(gè)length屬性，就是這個(gè)屬性使其區(qū)別于常規(guī)的JS對(duì)象
  • 在數(shù)組中肯定找不到一個(gè)元素的索引值大于或等于它的長(zhǎng)度。為了維持此規(guī)則不變化，數(shù)組有兩個(gè)特殊的行為
  • 1：當(dāng)為數(shù)組元素賦值，他的索引i大于或等于現(xiàn)有數(shù)組長(zhǎng)度時(shí)，length屬性的值將設(shè)置i+1
  • 2：設(shè)置length屬性為一個(gè)小于當(dāng)前長(zhǎng)度的非負(fù)整數(shù)n時(shí)，當(dāng)前數(shù)組中那些索引值大于或等于n的元素將從中刪除
  • 如果讓一個(gè)數(shù)組元素不能配置，就不能刪除它。如果不能刪除它，length屬性不嫩設(shè)置為小于不可配置元素的索引值
• 數(shù)組的遍歷
• • for
  • • 這是遍歷數(shù)組最常用的方法
    • 在嵌套循環(huán)或其他性能非常重要的上下文中，可以看到這種基本的數(shù)組遍歷需要優(yōu)化，數(shù)組的長(zhǎng)度應(yīng)該只查詢一次而非每次循環(huán)都要查詢
  • for/in
  • • 自動(dòng)處理稀疏數(shù)組
    • 循環(huán)每次將一個(gè)可枚舉的屬性名（包括數(shù)組索引）賦值給循環(huán)變量。不存在的所有將不會(huì)被遍歷
    • ECMAScript規(guī)范允許for/in循環(huán)以不同的孫旭遍歷對(duì)象的屬性。通常數(shù)組元素的遍歷實(shí)現(xiàn)是升序的，但不能保證一定是這樣。特別地，如果數(shù)組同時(shí)擁有對(duì)象屬性和數(shù)組元素，返回的屬性名很可能是按照創(chuàng)建的順序而非數(shù)值的大小順序。如果算法依賴于遍歷順序，那么不推薦這種遍歷方法
  • forEach
  • • ECMAScript 5定義了一些遍歷數(shù)組元素的新方法，按照索引的順序按個(gè)傳遞給定義的一個(gè)函數(shù)。這些方法中最常用的就是forEach
• 多維數(shù)組
• • JS不支持真正的多維數(shù)組，但可以用數(shù)組的數(shù)組來(lái)近似。
• × 數(shù)組方法
• join
• • Array.join()方法將數(shù)組中所有元素都轉(zhuǎn)化為字符串并連接在一起，返回最后生成的字符串
  • 可以指定一個(gè)可選的字符串在生產(chǎn)的字符串中來(lái)分割數(shù)組的各個(gè)元素。如果不指定分割符，默認(rèn)使用逗號(hào)
  • join是string.split方法的逆向操作，后者是將字符串分割成若干塊來(lái)創(chuàng)建一個(gè)數(shù)組
• reverse
• • 將數(shù)組中的元素顛倒順序，返回逆序的數(shù)組
  • 它不通過(guò)重新排列的元素創(chuàng)建新的數(shù)組，而是在原先的數(shù)組中重新排序它們
• sort
• • Array.sort()方法將數(shù)組中的元素排序并返回排序后的數(shù)組。當(dāng)不帶參數(shù)調(diào)用sort()時(shí)，數(shù)組元素以字母表順序排序
  • 如果數(shù)組包含undefined元素，它們會(huì)被排到數(shù)組的尾部
• concat
• • Array.concat()創(chuàng)建并返回一個(gè)新數(shù)組
• slice
• • Array.slice()返回指定數(shù)組的一個(gè)片段或子數(shù)組
• splice
• • Array.splice()方法是在數(shù)組中插入或刪除元素的通用方法
• push和pop
• • 允許將數(shù)組當(dāng)作棧來(lái)使用
• unshift和shift
• • 行為非常類似于push和pop，不一樣的是前者在數(shù)組的頭部而非尾部進(jìn)行元素的插入和刪除操作
• toString和toLocalString
• • 數(shù)組和其他JS對(duì)象一樣擁有toString方法
• forEach
• • 從頭至尾遍歷數(shù)組，為每個(gè)元素調(diào)用指定的函數(shù)
• map
• filter
• every和some
• reduce和reduceRight
• indexOf和astIndexOf
• 數(shù)組類型
• 類數(shù)組對(duì)象
• 作為數(shù)組的字符串

• 函數(shù)是這樣一段JS代碼，它只定義一次，但可能被執(zhí)行或調(diào)用任意次
• JS函數(shù)是參數(shù)化的，函數(shù)的定義包括一個(gè)稱為形參的標(biāo)識(shí)符列表，這些參數(shù)在函數(shù)體內(nèi)像局部變量一樣工作
• 函數(shù)調(diào)用會(huì)為形參提供實(shí)參的值
• 函數(shù)使用它們實(shí)參的值來(lái)計(jì)算返回值，成為該函數(shù)調(diào)用表達(dá)式的值
• 除了實(shí)參之外，每次調(diào)用還會(huì)擁有另一個(gè)值——本次調(diào)用的上下文——這就是this關(guān)鍵字的值
• 函數(shù)掛載在一個(gè)對(duì)象上，作為對(duì)象的一個(gè)屬性，就稱它為對(duì)象的方法。當(dāng)通過(guò)這個(gè)對(duì)象來(lái)調(diào)用函數(shù)時(shí)，該對(duì)象就是此次調(diào)用的上下文，也就是該函數(shù)的this的值
• 用于初始化一個(gè)新創(chuàng)建的對(duì)象的函數(shù)稱為構(gòu)造函數(shù)
• 在JS里，函數(shù)即對(duì)象，程序可以隨意操控它們，比如可以把函數(shù)賦值給變量，或者作為參數(shù)傳遞給其他函數(shù)。因?yàn)楹瘮?shù)就是對(duì)象，所有可以給它們?cè)O(shè)置屬性，甚至調(diào)用它們的方法
• JS的函數(shù)可以嵌套在其他函數(shù)中定義，這樣它們就可以訪問(wèn)它們被定義是所處的作用域中的任何變量。這意味著JS函數(shù)構(gòu)成了一個(gè)閉包。它給JS帶來(lái)了非常強(qiáng)勁的編程能力
• 形參和實(shí)參的區(qū)別，形參相當(dāng)于函數(shù)中定義的變量，實(shí)參是在運(yùn)行時(shí)的函數(shù)調(diào)用時(shí)傳入的參數(shù)
• 函數(shù)定義
• • 函數(shù)使用function關(guān)鍵字來(lái)定義，它可以用在函數(shù)定義表達(dá)式或者函數(shù)聲明語(yǔ)句里。在兩種形式中，函數(shù)定義都從function關(guān)鍵字開始，其后跟隨這些組成部分
• 嵌套函數(shù)
• • 有趣之處在于它們的變量作用域規(guī)則：它們可以訪問(wèn)嵌套它們（或多重嵌套）的函數(shù)的參數(shù)和變量
• 函數(shù)調(diào)用
• • 作為函數(shù)
  • 作為方法
  • 作為構(gòu)造函數(shù)
  • 通過(guò)它們的call()和apply()方法間接調(diào)用
• 方法調(diào)用
• • 一個(gè)方法無(wú)非就是保存在一個(gè)對(duì)象的屬性里的函數(shù)。這里的函數(shù)表達(dá)式本身就是一個(gè)屬性訪問(wèn)表達(dá)式，這意味著該函數(shù)被當(dāng)作一個(gè)方法，而不是普通函數(shù)
  • 方法調(diào)用與函數(shù)調(diào)用有一個(gè)重要的區(qū)別，即，調(diào)用上下文。屬性訪問(wèn)表達(dá)式由兩部分組成，一個(gè)對(duì)象和屬性名稱。
  • 方法和this關(guān)鍵字是面向?qū)ο缶幊谭独暮诵?/li>
  • 任何函數(shù)只要作為方法調(diào)用實(shí)際上都會(huì)傳入一個(gè)隱式的實(shí)參——這個(gè)實(shí)參是一個(gè)對(duì)象，方法調(diào)用的母體就是這個(gè)對(duì)象，方法調(diào)用的語(yǔ)法已經(jīng)清晰表明了函數(shù)將基于一個(gè)對(duì)象進(jìn)行操作
  • this是一個(gè)關(guān)鍵字，不是變量，也不是屬性名。JS的語(yǔ)法不允許給this賦值
  • 和變量不同，this關(guān)鍵字沒(méi)有作用域的限制，嵌套函數(shù)不會(huì)從調(diào)用它的函數(shù)中繼承this
  • 如果嵌套函數(shù)作為方法調(diào)用，其this的值指向調(diào)用它的對(duì)象。如果嵌套函數(shù)作為函數(shù)調(diào)用，其this值不是全局對(duì)象（非嚴(yán)格模式下）就是undefined（嚴(yán)格模式下）
• 方法鏈
• • 當(dāng)方法返回值是一個(gè)對(duì)象，這個(gè)對(duì)象還可以再調(diào)用它的方法
• 構(gòu)造函數(shù)調(diào)用
• • 如果函數(shù)或者方法調(diào)用之前帶有關(guān)鍵字new，它就構(gòu)造函數(shù)調(diào)用。
  • 構(gòu)造函數(shù)調(diào)用和普通函數(shù)調(diào)用以及方法調(diào)用在實(shí)參處理、調(diào)用上下文和返回值方面都有不同
  • 如果構(gòu)造函數(shù)調(diào)用在圓括號(hào)內(nèi)包含一組實(shí)參列表，先計(jì)算這些實(shí)參表達(dá)式，然后傳入函數(shù)內(nèi)，這和函數(shù)調(diào)用和方法調(diào)用是一致的。如果構(gòu)造函數(shù)沒(méi)有形參調(diào)用都可以省略圓括號(hào)
  • 構(gòu)造函數(shù)調(diào)用創(chuàng)建一個(gè)新的空對(duì)象，這個(gè)對(duì)象繼承自構(gòu)造函數(shù)的prototype屬性。構(gòu)造函數(shù)試圖初始化這個(gè)新創(chuàng)建的對(duì)象，并將這個(gè)對(duì)象用作其調(diào)用的上下文，因此構(gòu)造函數(shù)可以使用this關(guān)鍵字來(lái)引用這個(gè)新創(chuàng)建的對(duì)象
  • 構(gòu)造函數(shù)通常不使用關(guān)鍵字return，它們通常初始化新對(duì)象，當(dāng)構(gòu)造函數(shù)的函數(shù)體執(zhí)行完畢時(shí)，它會(huì)顯示返回
  • 如果構(gòu)造函數(shù)使用return語(yǔ)句但沒(méi)有指定返回值，或者返回一個(gè)原始值，那么這時(shí)將忽略返回值，同時(shí)使用這個(gè)新對(duì)象作為調(diào)用結(jié)果
• 間接調(diào)用
• • JS中的函數(shù)也是對(duì)象，和其他JS對(duì)象沒(méi)什么兩樣，函數(shù)對(duì)象也可以包含方法。其中兩個(gè)方法call和apply()可以用來(lái)間接調(diào)用函數(shù)。兩個(gè)方法都允許顯示指定調(diào)用所需的this值，也就是說(shuō)任何函數(shù)可以作為任何對(duì)象的方法來(lái)調(diào)用，哪怕這個(gè)函數(shù)不是那個(gè)對(duì)象的方法。兩個(gè)方法都可以指定調(diào)用的實(shí)參
• 函數(shù)的實(shí)參和形參
• • JS中的函數(shù)定義并 未指定函數(shù)形參的類型，函數(shù)調(diào)用也未對(duì)傳入的實(shí)參值做任何類型檢查。
  • JS函數(shù)調(diào)用甚至不檢查傳入形參的個(gè)數(shù)
• 可選形參
• • /*optional*/來(lái)強(qiáng)調(diào)形參是可選的
• 可變長(zhǎng)的實(shí)參列表：實(shí)參對(duì)象
• • 當(dāng)調(diào)用函數(shù)的時(shí)候傳入的實(shí)參個(gè)數(shù)超過(guò)函數(shù)定義是的形參個(gè)數(shù)時(shí)，沒(méi)有辦法直接獲得未命名值的引用
  • 在函數(shù)體內(nèi)，標(biāo)識(shí)符arguments是指向?qū)崊?duì)象的引用，實(shí)參對(duì)象是一個(gè)類數(shù)組對(duì)象
  • arguments并不是真正的數(shù)組，他是一個(gè)實(shí)參對(duì)象。每個(gè)實(shí)參對(duì)象都包含以數(shù)字為索引的一組元素以及l(fā)ength屬性，但并不是真正的數(shù)組?？梢岳斫鉃榕銮删哂袛?shù)字為索引的屬性
• callee和caller屬性
• 非標(biāo)準(zhǔn)的，但是大多瀏覽器都有實(shí)現(xiàn)，通過(guò)caller屬性可以訪問(wèn)調(diào)用棧
• 將對(duì)象屬性用作實(shí)參
• • 當(dāng)一個(gè)函數(shù)包含超過(guò)三個(gè)形參時(shí)，對(duì)程序員來(lái)說(shuō)，要記住嗲用函數(shù)中實(shí)參的正確順序非常頭疼。通過(guò)傳入對(duì)象可以簡(jiǎn)化這一步
• 作為函數(shù)的值
• • 函數(shù)可以定義，也可調(diào)用，這時(shí)函數(shù)最重要的特性
  • 函數(shù)定義和調(diào)用是JS的詞法特性
  • JS中函數(shù)不僅是一種語(yǔ)法，也是值，可以將函數(shù)賦值給變量，存儲(chǔ)在對(duì)象的屬性或數(shù)組的元素中，作為參數(shù)傳入另外一個(gè)函數(shù)等
• 自定義函數(shù)屬性
• • JS中的函數(shù)并不是原始值，而是一種特殊的對(duì)象，也就是說(shuō)函數(shù)可以擁有屬性
• 作為命名空間的函數(shù)
• • 函數(shù)作用域的概念：在函數(shù)中聲明的變量在函數(shù)體內(nèi)都是可見的（包括在嵌套函數(shù)中），在函數(shù)的外部是不可見的
  • JS中無(wú)法聲明只在一個(gè)代碼塊內(nèi)部可見的變量，基于這個(gè)原因，我們常常是用函數(shù)用作臨時(shí)命名空間，在這個(gè)命名空間內(nèi)定義的變量都不會(huì)污染到全局命名空間
• × 閉包
• • JS采用詞法作用域，函數(shù)的執(zhí)行依賴于變量作用域，這個(gè)作用域是在函數(shù)定義時(shí)決定的，而不是函數(shù)調(diào)用時(shí)決定的
  • JS函數(shù)對(duì)象內(nèi)部不僅包含函數(shù)的代碼邏輯，還必須引用當(dāng)前的作用域鏈
  • 函數(shù)對(duì)象通過(guò)作用域鏈互關(guān)聯(lián)起來(lái)，函數(shù)體內(nèi)部的變量都可以保存在函數(shù)作用域內(nèi)，這種特性在計(jì)算機(jī)科學(xué)文獻(xiàn)中稱為“閉包”
  • 從技術(shù)角度將，所有JS函數(shù)都是閉包：它們都是對(duì)象，它們都關(guān)聯(lián)到作用域鏈
  • 定義大多數(shù)函數(shù)時(shí)的作用域鏈在調(diào)用函數(shù)時(shí)依然有效，但這并不影響閉包
  • 待更新........
• 函數(shù)屬性、方法和構(gòu)造函數(shù)
• length屬性
• • arguments.length表示傳入函數(shù)的實(shí)參的個(gè)數(shù)。而函數(shù)本身的length屬性是只讀的，它代表函數(shù)定義時(shí)形參的數(shù)量
• prototype屬性
• • 每一個(gè)函數(shù)都包含一個(gè)prototype屬性，這個(gè)屬性指向一個(gè)對(duì)象的引用，這個(gè)對(duì)象稱作“原型對(duì)象”
• call方法和apply方法
• bind方法
• toString方法
• function構(gòu)造函數(shù)
• 可調(diào)用的對(duì)象
• 函數(shù)式編程
• • JS并非函數(shù)式編程語(yǔ)言
  • JS中可以向操作對(duì)象一樣操控函數(shù)，也就是說(shuō)可以在JS中應(yīng)用函數(shù)式編程技術(shù)
• 使用函數(shù)處理數(shù)組
• • 高階函數(shù)就是操作函數(shù)的函數(shù)，它接收一個(gè)或多個(gè)函數(shù)作為參數(shù)，并返回一個(gè)新函數(shù)
• 高階函數(shù)
• 不完全函數(shù)
• 記憶

• 在JS中可以定義對(duì)象的類，讓每個(gè)對(duì)象都共享某些屬性
• 在JS中類的實(shí)現(xiàn)是基于其原型繼承機(jī)制的
• 兩個(gè)實(shí)例都從同一個(gè)原型對(duì)象繼承了屬性，我們說(shuō)他們是同一個(gè)類的實(shí)例
• 如果兩個(gè)對(duì)象繼承自同一個(gè)原型，往往意味著（擔(dān)不是絕對(duì)）它們是由同一個(gè)構(gòu)造函數(shù)創(chuàng)建并初始化
• JS中類的一個(gè)重要特性是“動(dòng)態(tài)可繼承”
• 類和原型
• • 在JS中，類的所有實(shí)例對(duì)象都從同一個(gè)原型對(duì)象上繼承屬性，因此，原型對(duì)象是類的核心
• 類和構(gòu)造函數(shù)
• • 構(gòu)造函數(shù)是用來(lái)初始化新創(chuàng)建的對(duì)象的
  • 調(diào)用構(gòu)造函數(shù)的一個(gè)重要特征是，構(gòu)造函數(shù)的prototype屬性被用做新對(duì)象的原型。這意味著同一個(gè)構(gòu)造函數(shù)創(chuàng)建的所有對(duì)象都繼承自一個(gè)相同的對(duì)象，因此他們都是同一個(gè)類的成員
• 構(gòu)造函數(shù)和類的標(biāo)識(shí)
• • 原型對(duì)象是類的唯一標(biāo)識(shí)，當(dāng)且僅當(dāng)兩個(gè)對(duì)象繼承自同一個(gè)原型對(duì)象時(shí)，它們才是屬于同一個(gè)類的實(shí)例。而初始化的構(gòu)造函數(shù)則不能作為類的標(biāo)識(shí)，兩個(gè)構(gòu)造函數(shù)的prototype屬性可能指向同一個(gè)原型對(duì)象。那么這兩個(gè)構(gòu)造函數(shù)有創(chuàng)建的實(shí)例屬于同一個(gè)類
  • 構(gòu)造函數(shù)是類的“外在表現(xiàn)”。構(gòu)造函數(shù)名字通常用做類名
  • instanceof的語(yǔ)法強(qiáng)化了“構(gòu)造函數(shù)是類的公有標(biāo)識(shí)”概念
• constructor屬性
• • 任何JS函數(shù)都可以用作構(gòu)造函數(shù)，并且調(diào)用構(gòu)造函數(shù)是需要用到一個(gè)prototye屬性的
  • 每個(gè)JS函數(shù)（ECMAScript5中的Function.bind()方法返回的函數(shù)除外）都自動(dòng)擁有一個(gè)prototype屬性。這個(gè)屬性的值是一個(gè)對(duì)象，這個(gè)對(duì)象包含唯一一個(gè)不可枚舉屬性constructor。constructor屬性值是一個(gè)函數(shù)對(duì)象
• JS中Java式的類繼承
• • 構(gòu)造函數(shù)對(duì)象
  • • 構(gòu)造函數(shù)（對(duì)象）為JS類定義名字。任何添加到這個(gè)構(gòu)造函數(shù)對(duì)象中的屬性都是類字段和類方法（如果屬性值是函數(shù)的話就是類方法）
  • 原型對(duì)象
  • • 原型對(duì)象的屬性被類的所有實(shí)例所繼承，如果原型對(duì)象的屬性值是函數(shù)的話，這個(gè)函數(shù)就作為類的實(shí)例的方法來(lái)調(diào)用
  • 實(shí)例對(duì)象
  • • 類的每個(gè)實(shí)例都是一個(gè)獨(dú)立的對(duì)象，直接給這個(gè)實(shí)例定義屬性是不會(huì)為所有實(shí)例對(duì)象所共享的。定義在實(shí)例上的非函數(shù)屬性，實(shí)際上是實(shí)例的字段
  • JS中定義類的步驟
  • • 第一步，定義一個(gè)構(gòu)造函數(shù)，并設(shè)置初始化新對(duì)象的實(shí)例屬性
    • 第二步，給構(gòu)造函數(shù)的prototype對(duì)象定義實(shí)例的方法
    • 第三步，給構(gòu)造函數(shù)定義類字段和類屬性
• 類的擴(kuò)充
• • JS中基于原型的繼承機(jī)制是動(dòng)態(tài)的，對(duì)象從其原型繼承屬性，如果創(chuàng)建對(duì)象之后原型的屬性發(fā)生變化，也會(huì)影響到繼承這個(gè)原型的所有實(shí)例對(duì)象
• 類和類型
• • JS定義了少量的數(shù)據(jù)類型：null、undefined、布爾值、數(shù)字、字符串、函數(shù)和對(duì)象
• instanceof運(yùn)算符
• • 左操作符是待檢測(cè)其類對(duì)象，右操作數(shù)是定義類的構(gòu)造函數(shù)。返回布爾值，這里檢測(cè)繼承可以不是直接繼承