索引
目錄
購買書籍
(廣告，請勿封鎖。)

索引

數位索引注意事項

索引項目中的連結會顯示為該項目出現的章節標題。由於有些章節有多個索引標記，因此項目有多個連結到同一個章節是很常見的。點選任何連結都會直接帶您到文字中標記出現的地方。

符號

！ (驚嘆號)
!= (不等於) 算子，相等運算子，相等運算子：=== 相對於 ==，寬鬆不等於 (!=)
!== (嚴格不等於) 算子，相等運算子，相等運算子：=== 相對於 ==，嚴格不等於 (!==)，普遍接受的最佳實務
檢查 NaN，陷阱：檢查值是否為 NaN
邏輯非運算子，布林值和數字運算子，邏輯非運算子 (!)
" " (雙引號)
JavaScript 最佳實務，普遍接受的最佳實務
用於字串文字，字串，字串文字
$ (美元符號)
用於替換字串中，使用正規表示式測試、比對和替換
% (百分比符號)
%= 複合賦值運算子，複合賦值運算子
餘數運算子，運算子，算術運算子，算術運算子
& (與符號)
& (按位元 AND) 運算子，布林值和數字運算子，二元按位元運算子
&& (邏輯 AND) 運算子，二元邏輯運算子，布林值和數字運算子，二元邏輯運算子：And (&&) 和 Or (||)，邏輯 And (&&)
&= (按位元 AND 和賦值) 運算子，複合賦值運算子
' ' (單引號)
JavaScript 最佳實務，普遍接受的最佳實務
用於字串文字，字串，字串文字
* (星號)
*= 複合賦值運算子，複合賦值運算子
乘法運算子，運算子，算術運算子
+（加號）
++（遞增）運算子，運算子，算術運算子，遞增運算子
+= 複合賦值運算子，複合賦值運算子
+= 運算子，連結字串，字串運算子
加法運算子，運算子，算術運算子
字串連結運算子，字串運算子，字串文字中的跳脫字元，連結：加號 (+) 運算子
效能，連結：加入字串片段陣列
,（逗號）運算子，逗號運算子
-（減號）
--（遞減運算子），遞增運算子
--（遞減）運算子，運算子，算術運算子
-= 複合賦值運算子，複合賦值運算子
負號運算子，運算子，算術運算子
減法運算子，運算子，算術運算子
.（逗號），物件文字和陣列文字中的尾隨逗號，語法變更
.（點運算子），值
用來呼叫方法，呼叫方法
用來存取屬性，值，點運算子 (. )：透過固定鍵存取屬性
使用物件，秘笈：使用物件
/（斜線）
/* 和 */ 界定多行註解，註解
// 界定單行註解，註解
/= 複合賦值運算子，複合賦值運算子
除法運算子，運算子，算術運算子
0（零），正負，兩個零–區分兩個零
1TBS（唯一正確的大括號樣式），1TBS（唯一正確的大括號樣式）
32 位元整數，JavaScript 中的整數
有號，有號 32 位元整數
透過位元運算子，透過位元運算子處理 32 位元整數
64 位元精度、JavaScript 數字，數字的內部表示
;（分號）
始終使用，最佳實務，普遍接受的最佳實務
在 JavaScript 程式碼中，分號，使用分號的規則–陷阱：ASI 可能意外地未觸發
終止 IIFE 的分號，透過 IIFE 導入新的範圍
<（小於）
<（小於）運算子，排序運算子，比較字串
<<（位元左位移）運算子，布林值和數字的運算子，位移運算子，位元位移運算子
<<=（位元左位移和指定運算子），複合指定運算子
<=（小於或等於）運算子，排序運算子，比較字串
=（等號）
==（等於）運算子，等於運算子，等於運算子：=== 與 ==，一般（寬鬆）等於（==、!=）
沒有有效的用例，== 沒有有效的用例
陷阱，陷阱：寬鬆等於不同於轉換為布林值
===（嚴格等於）運算子，等於運算子，等於運算子：=== 與 ==，搜尋值（非破壞性），普遍接受的最佳實務
檢查未定義或 null 值，檢查 null
檢查值是否為 NaN，陷阱：檢查值是否為 NaN
物件與原始值比較，原始值與物件
賦值 (=) 與相等比較 (===)，語法概觀，語法概觀
賦值運算子，賦值運算子
設定物件屬性，設定屬性
> (大於)
> (大於) 運算子，排序運算子，比較字串
>= (大於或等於) 運算子，排序運算子，比較字串
>> (位元右移) 運算子，布林值和數字運算子，位移運算子，位元位移運算子
>>= (位元右移並賦值運算子)，複合賦值運算子
>>> (位元右移並以零填充) 運算子，布林值和數字運算子，位移運算子，位元位移運算子
>>>= (位元右移並以零填充且賦值運算子)，複合賦值運算子
? (問號)
? : (條件式) 運算子，條件式與條件表達式，條件式運算子 ( ? : )，比較數字
括在括號中，語法
巢狀，條件式運算子
[ ] (方括號)
存取陣列元素，將參數轉換為陣列
存取字串中的字元，字元存取
存取字串中的單一字元，字串
方括號運算子，不尋常的屬性金鑰，方括號運算子 ([])：透過計算金鑰存取屬性，秘笈：使用物件
計算屬性金鑰，任意屬性金鑰
建立陣列和存取陣列元素，陣列字面值
取得和設定屬性，任意屬性金鑰
\ (反斜線)
開始字元跳脫序列，字串字面值中的跳脫
跳脫字串中的字元，字串，字串字面值中的跳脫
{ } (大括號)
封裝區塊，控制流程陳述式和區塊
在條件和控制流程陳述式中，條件
樣式，大括號樣式
用於防止 if 陳述式中出現懸空 else，陷阱：懸空 else
| (垂直線)
按位元 OR 算子，布林值和數字運算子，二進制按位元運算子
將數字轉換為整數，按位元或 (|)
|= (按位元 OR 和賦值) 運算子，複合賦值運算子
|| (邏輯 OR) 運算子，二進制邏輯運算子，布林值和數字運算子，二進制邏輯運算子：And (&&) 和 Or (||)，邏輯或 (||)，選用參數
模式，提供預設值，模式：提供預設值，預設值
~ (波浪號)
按位元 NOT 運算子，按位元 Not 運算子
“單行註解”），語法的概觀
‸ (按位元 XOR) 運算子，布林值和數字運算子

A

存取器，屬性的種類
和繼承，存取器和繼承
透過物件字面值定義，透過物件字面值定義存取器
透過屬性描述符定義，透過屬性描述符定義存取器
在 ECMAScript 5 中，新功能
特定於的屬性屬性，屬性屬性
Ajax，JavaScript 歷史里程碑
Allman 風格（大括號），Allman 風格
AMD（非同步模組定義），模組系統
角度，與弧度的轉換，三角函數
匿名函式表達式，函式表達式
作為名稱的空字串，函式的名稱
Apache CouchDB，JavaScript 歷史里程碑
apply() 方法，func.apply(thisValue, argArray)，Function.prototype.apply()
(另請參閱 Function.prototype.apply() 方法)
對於建構函式，建構函式的 apply()
手動模擬，手動模擬建構函式的 apply()
arguments 物件，特殊變數 arguments，依索引的所有參數：特殊變數 arguments
特徵，依索引的所有參數：特殊變數 arguments
轉換為陣列，將 arguments 轉換為陣列
定義，術語：「參數」與「引數」
已棄用的功能，arguments 的已棄用功能
在嚴格模式下較少的屬性，arguments 物件的屬性較少
hasOwnProperty() 方法，依索引的所有參數：特殊變數 arguments
長度，檢查，強制執行元數
引數，太多或太少，引數太多或太少
算術運算子，運算子，布林值和數字的運算子，算術運算子–算術運算子
元數，強制執行，強制執行元數，強制參數，強制執行最小元數
陣列文字，優雅的部份
尾隨逗號，語法變更
Array() 建構函式，Array 建構函式
偏好文字而非建構函式，偏好文字而非建構函式
類陣列物件，陷阱：類陣列物件
與通用方法，類陣列物件與通用方法
使用範例，使用類陣列物件的範例
Array.isArray() 方法，陷阱：跨越領域（框架或視窗），Array 建構函式方法
Array.prototype，通用方法的縮寫，通用方法
Array.prototype.concat() 方法，串接、切片、合併（非破壞性）
Array.prototype.every() 方法，檢查方法
Array.prototype.filter() 方法，陣列迭代方法，轉換方法
Array.prototype.forEach() 方法，陣列迭代方法，檢查方法，檢查方法
迭代陣列元素，迭代陣列
透過迭代跳過空洞，稀疏陣列與稠密陣列
thisValue，解決方法 3：forEach() 的 thisValue
Array.prototype.indexOf() 方法，搜尋值（非破壞性）
Array.prototype.join() 方法，串接、切片、合併（非破壞性）
Array.prototype.lastIndexOf() 方法，搜尋值（非破壞性）
Array.prototype.map() 方法，轉換方法
Array.prototype.pop() 方法，新增和移除元素（破壞性）
Array.prototype.push() 方法，新增和移除元素（破壞性）
Array.prototype.reduce() 方法，簡化方法
Array.prototype.reduceRight() 方法，簡化方法
Array.prototype.reverse() 方法，排序和反轉元素（破壞性）
Array.prototype.shift() 方法，新增和移除元素（破壞性）
Array.prototype.slice() 方法，串接、切片、合併（非破壞性）
Array.prototype.some() 方法，檢查方法
Array.prototype.sort() 方法，排序和反轉元素（破壞性）
Array.prototype.splice() 方法，新增和移除元素（破壞性）
Array.prototype.unshift() 方法，新增和移除元素（破壞性）
陣列，物件，陣列–正規表示式，語法概觀，物件，陣列–最佳實務：反覆處理陣列
新增和移除元素，新增和移除元素（破壞性）
是映射，不是元組，陣列是映射，不是元組
陣列文字，陣列文字
最佳實務，避免使用 Array() 建構函式，優先使用文字而非建構函式
一般性地呼叫陣列方法，一般性地呼叫方法的範例
串接、切片和合併，串接、切片、合併（非破壞性）
串接，合併字串片段的陣列，串接：合併字串片段的陣列
轉換引數為，轉換引數為陣列
建立字元碼陣列，擷取子字串
陣列中的洞，陣列中的洞–移除陣列中的洞
建立，建立洞
忽略或考慮洞的運算，哪些運算會忽略洞，哪些會考慮洞？
移除，移除陣列中的洞
稀疏陣列與稠密陣列，稀疏陣列與稠密陣列
索引，陣列索引
刪除陣列元素，刪除陣列元素
詳細資訊，陣列索引的詳細資訊
in 運算子與，in 運算子與索引
反覆處理，反覆處理陣列
最佳實務，最佳實務：反覆處理陣列
不使用 for-in 迴圈，最佳實務：不要對陣列使用 for-in
使用 for 迴圈，for
反覆處理方法，反覆處理（非破壞性）–簡化方法
長度，length
清除陣列，清除陣列
清除共用陣列，清除共用陣列
減少陣列長度，減少陣列長度
增加陣列長度，手動增加陣列長度
最大長度，最大長度
方法，陣列方法
多維，多維陣列
概觀，概觀
屬性，陣列也可以有屬性
原型方法，陣列原型方法
ECMAScript 5 新功能，新方法
搜尋值，搜尋值（非破壞性）
排序和反轉元素，排序和反轉元素（破壞性）
將字串分割成子字串陣列，擷取子字串
在 JavaScript 中太過靈活，怪癖和非正統功能
使用假設的三點運算子 (...) 轉換成參數，範例，建構函式的 apply()
使用 Array() 建構函式，陣列建構函式
避免使用元素初始化陣列，使用元素初始化陣列（避免！）
建立具有指定長度的空陣列，建立具有指定長度的空陣列
ASI（自動分號插入），自動分號插入
範例，透過閉合大括號的 ASI，範例：透過閉合大括號的 ASI
範例，透過非法代碼的 ASI，範例：透過非法代碼的 ASI
陷阱，ASI 預期外未觸發，陷阱：ASI 可能預期外未觸發
陷阱，預期外中斷陳述式，陷阱：ASI 可能預期外中斷陳述式
正則表達式中的斷言，斷言，正則表達式秘笈
後向參照，手動實作，手動實作後向參照
沒有斷言的正規表示式，陷阱：沒有斷言（例如 ^、$），正規表示式會在任何地方找到
指定，指定
指定到屬性，屬性：定義與指定
繼承的唯讀屬性，無法指定繼承的唯讀屬性
複合指定運算子，複合指定運算子
使用點運算子將值指定到屬性，值
指定運算子 (=)，語法的概觀, 語法的概觀, 指定運算子
指定運算子，複合，複合指定運算子
非同步模組定義 (AMD)，模組系統
屬性（屬性），屬性的反覆運算和偵測, 屬性屬性和屬性描述子
所有屬性共有的，屬性屬性
預設值，預設值
透過屬性描述子取得和設定，透過描述子取得和定義屬性
透過屬性描述子管理，元程式設計
封存以防止變更，封存
自動分號插入（請參閱 ASI）

B

正規表示式中的反向參照，原子：群組
最佳實務（編碼樣式），公認的最佳實務
二元邏輯運算子，二元邏輯運算子, 二元邏輯運算子：And (&&) 和 Or (||)
二進位數字，輸入和輸出，輸入和輸出二進位數字
數字的二進位表示法，數字的內部表示法
bind() 方法，擷取方法, func.bind(thisValue, arg1, ..., argN)
透過建立建構函式，手動模擬建構函式的 apply()
防止覆蓋 this，解決方法 2：bind()
位元運算子，布林值和數字的運算子, JavaScript 中的整數, 位元運算子
二進位，二進位位元運算子
位元移位運算子，位元移位運算子
將數字轉換為整數，透過位元運算子取得 32 位元整數–我是否應該使用位元運算子轉換為整數？
區塊範圍，變數具有函式範圍
透過 IIFE 模擬，透過 IIFE 導入新的範圍
區塊
用來取代陳述式，控制流程陳述式和區塊
分號 (;) 終止，分號
陳述式以無分號結尾，區塊結尾的陳述式後不加分號
用於迴圈主體，迴圈和條件式的主體
BOM（位元組順序標記），重要的 Unicode 概念
Boolean() 函式，轉換為布林值、數字、字串和物件的函式，手動轉換為布林值
布林值，布林值，語法的概觀，原始值，布林值–相等運算子、排序運算子
轉換為布林值並進行寬鬆相等性比較，陷阱：寬鬆相等性與轉換為布林值不同
將值轉換為布林值，轉換為布林值、數字、字串和物件的函式，轉換為布林值，手動轉換為布林值
呼叫 Boolean() 作為建構函式，手動轉換為布林值
邏輯非 (!) 運算子，邏輯非 (!)
布林值和數字的運算子，布林值和數字的運算子
真值和假值，真值和假值
布林值的包裝器物件，原始值的包裝器物件
拆封，包裝和拆封原始值
Bower（套件管理員），套件管理員
大括號樣式，大括號樣式
中括號運算子 ([])、不尋常的屬性鍵、秘笈：使用物件
透過存取屬性，中括號運算子 ([])：透過計算鍵存取屬性
透過呼叫方法，透過中括號運算子呼叫方法
透過刪除屬性，透過中括號運算子刪除屬性
透過設定屬性，透過中括號運算子設定屬性
迴圈中的中斷陳述式，迴圈、與迴圈一起使用的機制
瀏覽器作為作業系統，JavaScript 歷史里程碑
Browserify，套件管理員
瀏覽器
輸入 JavaScript 的主控台，JavaScript 命令列
全域物件，window，跨平台考量
javascript：網址和，void 用於什麼？
舊版，使用舊版瀏覽器的提示，使用舊版瀏覽器的提示
套件管理員，套件管理員
建置工具，更多工具
位元組順序標記 (BOM)，重要的 Unicode 概念

C

call() 方法（請參閱 Function.prototype.call() 方法）
回呼和萃取方法，回呼和萃取方法
案例
將字串轉換為小寫，轉換
將字串轉換為大寫，轉換
switch 陳述式中的案例子句，條件式、switch
catch 子句
在 try-catch 陳述式中，例外處理、建構函式屬性的使用案例
在 try-catch-finally 陳述式中，try-catch-finally
正規表示式中的字元類別跳脫，原子：一般
正規表示式中的字元類別，原子：字元類別
字元跳脫序列，字串文字中的跳脫
正規表示式中的字元跳脫，原子：一般
字元屬性，重要的 Unicode 概念
字元
存取字串中的 字元存取
和字位元，重要的 Unicode 概念
Chrome 作業系統，JavaScript 歷史里程碑
CJS（CommonJS 模組），模組系統
類別，文件化（JSDoc）
子類化，子類化
類別，文件化（JSDoc），語法，文件化類別
透過建構函式定義類別，透過建構函式定義類別
透過物件文字定義類別，透過物件文字定義類別
透過具有 @constructs 方法的物件文字定義類別
具有 @constructs 方法的物件文字，透過具有 @constructs 方法的物件文字定義類別
Closure 編譯器，更多工具
閉包，閉包，閉包：函式保持與其誕生範圍的連線
避免用於私人資料，物件導向
定義，閉包：函式保持與其誕生範圍的連線
透過環境處理，透過環境處理閉包
無意間共用環境，陷阱：無意間共用環境
碼點，重要的 Unicode 概念，碼點
使用正規表示式比對任何，比對任何碼元和任何碼點
程式碼樣式指南，元程式碼樣式指南–結論
可接受的聰明，可接受的聰明
大括號樣式，大括號樣式
公認的最佳實務，公認的最佳實務
不建議的聰明範例，不要耍小聰明
現有的樣式指南，現有的樣式指南
一般提示，一般提示
易於閱讀的程式碼，程式碼應易於理解
撰寫一致的程式碼，程式碼應保持一致
其他提示，其他
偏好使用文字而非建構函式，偏好使用文字而非建構函式
語法，有爭議的規則
緊密空白，語法
使用變數，變數
程式碼單位，重要的 Unicode 概念
使用正規表示式比對任何內容，比對任何程式碼單位和任何程式碼點
強制轉換，強制轉換，類型強制轉換
(另請參閱類型強制轉換)
提示，其他
逗號運算子，陷阱：ASI 可能意外地未觸發，逗號運算子
命令列，JavaScript 命令列
與互動，命令列互動
逗號，物件和陣列文字中的尾隨逗號，語法變更
註解，語法的概觀，語法的概觀，程式碼應易於理解
JSDoc，JSDoc：產生 API 文件，語法
單行和多行，語法，註解，註解
CommonJS 模組 (CJS)，模組系統
比較運算子，排序運算子
比較字串，比較字串
複合賦值運算子，複合賦值運算子
壓縮原始碼，JavaScript 的本質
串接陣列，串接、切片、合併（非破壞性）
串接字串，字串運算子，串接字串
String.prototype.concat() 方法，轉換
條件運算子 (? :)，條件式與條件表達式，條件運算子 ( ? : )，比較數字
巢狀，條件運算子
放入括號中，語法
條件式陳述句，語法概述，條件式，語法概述
主體，迴圈和條件式的主體
if 陳述句串接，串接 if 陳述句
if-then-else，if-then-else
主控台 API，主控台 API
檢查和計數方法，檢查和計數
除錯說明，除錯的語言機制
記錄方法，簡單記錄
分析和計時方法，分析和計時
不同引擎間的標準化，不同引擎間的主控台 API 標準化程度如何？
建構函式，第 3 層：建構函式—實例工廠
實例的建構函式屬性，實例的建構函式屬性
最佳實務，最佳實務
使用案例，建構函式屬性的使用案例
建構函式，建構函式：物件工廠，JavaScript 中函式的三個角色，第 3 層：建構函式—實例工廠–將全域資料附加至方法，建構函式
apply() 方法，建構函式的 apply()
手動模擬，手動模擬建構函式的 apply()
內建，子類化，內建子類化–另一種解決方案：委派
類別與建構函式，在 JSDoc 中，記錄類別
原型屬性中的資料，原型屬性中的資料
在嚴格模式中，非方法函式中的 this 是未定義的
建構函式之間的繼承，第 4 層：建構函式之間的繼承–秘笈：使用物件
避免硬編碼超建構函式的名稱，避免硬編碼超建構函式的名稱
使用物件的秘笈，秘笈：使用物件
確保 instanceof 運作，確保 instanceof 運作
範例：使用建構函式繼承，範例：使用建構函式繼承
範例：內建建構函式的繼承階層，範例：內建建構函式的繼承階層
泛型方法：從原型借用方法，泛型方法：從原型借用方法
實例屬性，繼承實例屬性
進行超呼叫，進行超呼叫
所有物件的方法，所有物件的方法
覆寫方法，覆寫方法
陷阱：將物件當成地圖使用，陷阱：將物件當成地圖使用
原型繼承和屬性，方法，原型繼承和屬性
原型屬性，繼承原型屬性
透過超建構函式的實例取得原型，反模式：原型是超建構函式的實例
呼叫 Boolean() 作為，手動轉換為布林值
使用 new 運算子呼叫，物件運算子，第 3 層：建構函式—實例工廠
保持資料私密，保持資料私密–附加全域資料到方法
文字值相對於，優先使用文字值而非建構函式
new 運算子，在 JavaScript 中實作，在 JavaScript 中實作 new 運算子
避免忘記 new 運算子的防護措施：嚴格模式，避免忘記 new：嚴格模式
從中傳回任意物件，從建構函式傳回任意物件
樣式指南，物件導向
術語：原型，術語：兩個原型
基本資料類型的包裝物件，基本資料類型的包裝物件
迴圈中的 continue 陳述式，迴圈
控制流程陳述式，控制流程陳述式和區塊
CouchDB，JavaScript 歷史里程碑
Crockford 隱私模式，建構函式環境中的私密資料（Crockford 隱私模式），範例
優缺點，Crockford 隱私模式的優缺點
跨平台應用程式，圖形使用者介面
跨領域 instanceof，陷阱：跨越領域（框架或視窗）
目前範圍，陷阱：無意間共用環境

D

資料類型，JavaScript 的類型系統
強制轉換，強制轉換，類型強制轉換–範例：實際運作的 ToPrimitive()
JSDoc 中的命名，命名類型
靜態與動態類型檢查，靜態類型檢查與動態類型檢查
靜態與動態型別，靜態與動態
TypeError，錯誤建構函式
Date() 函式，Date 建構函式
Date.parse() 方法，Date 建構函式方法
Date.UTC() 方法，Date 建構函式方法
日期，日期–將日期轉換為數字
建構函式方法，Date 建構函式方法
建構函式，Date 建構函式
轉換為數字，將日期轉換為數字
日期時間格式，日期時間格式
合併，日期時間格式
日期格式（無時間），日期格式（無時間）
時間格式（無日期），時間格式（無日期）
原型方法
將日期轉換為字串，將日期轉換為字串
ECMAScript 5 中的新增功能，新方法
時間單位 getter 和 setter，時間單位 getter 和 setter
各種 getter 和 setter，各種 getter 和 setter
toJSON() 方法，toJSON() 方法
將日期字串轉換為日期物件，JSON.parse(text, reviver?)
debugger 陳述式，debugger 陳述式，用於偵錯的語言機制
偵錯，用於偵錯的語言機制，用於偵錯的語言機制
預設值
對於可選參數，可選參數
對於屬性特徵，預設值
使用 || 算子提供，模式：提供預設值，預設值
定義屬性，屬性：定義與指定
委派，另一種解決方案：委派
delete 算子，單一物件，物件算子，刪除屬性
刪除陣列元素，刪除陣列元素
傳回值，delete 的傳回值
數字的非正規化表示法，特殊指數
密集陣列，稀疏陣列與密集陣列
破壞性與非破壞性的陣列方法，陣列原型方法
字典模式，dict 模式：沒有原型的物件是更好的映射，陣列是映射，不是元組
JavaScript 資源目錄，JavaScript 資源目錄
除以零，錯誤：除以零
區分帶正負號的零，區分兩個零
do-while 迴圈，迴圈，do-while
文件
在 JavaScript 中尋找文件，快速尋找文件
使用 JSDoc 產生 API 文件，JSDoc：產生 API 文件–其他有用的標籤
撰寫文件提示，程式碼應易於理解
Dojo Toolkit，JavaScript 歷史里程碑
DOM（文件物件模型），JavaScript 歷史里程碑
jQuery 用於 DOM 操作，JavaScript 歷史里程碑
點運算子 (.)，值
雙精度（浮點數），數字的內部表示法
動態維度（變數），環境：管理變數
動態 HTML，JavaScript 重要里程碑
動態語意，背景：靜態與動態
動態型別，靜態型別與動態型別

E

ECMAScript，JavaScript 與 ECMAScript，標準化：ECMAScript
國際化 API，四個語言函式庫，ECMAScript 國際化 API
型別，JavaScript 的型別
版本和主要功能，標準化：ECMAScript
ECMAScript 6，標準化：ECMAScript
ECMAScript 5，您需要了解本書的內容，ECMAScript 5 的新功能–與舊版瀏覽器搭配使用的提示
新功能，新功能
標準函式庫的新功能，標準函式庫的新功能
保留字作為屬性鍵，ECMAScript 5：保留字
語法變更，語法變更
尾隨逗號，ECMAScript 5：尾隨逗號
ECMAScript 6
安全整數，ECMAScript 6 中的定義
艾奇，布蘭登，JavaScript 的創建方式
JavaScript 的優雅部分，優雅的部分
else 子句，懸空 else，陷阱：懸空 else
空陳述式，空陳述式
空字串，轉換為數字，轉換為數字
屬性的可列舉性，屬性的反覆運算和偵測
最佳實務，可列舉性：最佳實務
影響，可列舉性的影響
環境，全域物件，環境：管理變數
透過處理封閉，透過環境處理封閉
無意間共用，陷阱：無意間共用環境
雙精度 epsilon 值，處理捨入誤差
等號比較
物件與原始值，原始值與物件
等號運算子，等號運算子，等號運算子：=== 與 ==–順序運算子
===（嚴格等號）運算子，語法的概觀，語法的概觀，搜尋值（非破壞性）
字串比較，比較字串
檢查 Infinity，檢查 Infinity
區分兩個零，最佳實務：假裝只有一個零
一般等號（==）與一般不等於（!=）運算子，等號運算子：=== 與 ==，一般（寬鬆）等號（==, !=）–順序運算子
嚴格等號（===）與嚴格不等於（!==）運算子，等號運算子：=== 與 ==，普遍接受的最佳實務
檢查 NaN，陷阱：檢查值是否為 NaN
比較不同型別的值，嚴格等號（===, !==）
NaN 與嚴格等號，陷阱：NaN
嚴格不等於（!==）比較，嚴格不等於（!==）
錯誤物件
建構函式，錯誤建構函式，錯誤建構函式
實作你自己的，實作你自己的錯誤建構函式
屬性，錯誤建構函式
錯誤，產生 NaN，NaN
跳脫序列，跳脫序列
字串文字中的跳脫，字串文字中的跳脫
ESLint（樣式檢查器），更多工具
eval() 函式
最佳實務，最佳實務
在嚴格模式中較乾淨，eval() 在嚴格模式中較乾淨
評估物件文字，透過 eval() 評估物件文字
透過 eval() 評估程式碼，使用 eval() 評估程式碼
間接 eval() 在全域範圍內評估，間接 eval() 在全域範圍內評估
在嚴格模式中使用，在嚴格模式中使用 eval()
與 new Function() 相較，eval() 與 new Function()
EvalError 建構函式，錯誤建構函式
透過 eval() 和 new Function() 評估 JavaScript 程式碼，透過 eval() 和 new Function() 動態評估 JavaScript 程式碼
最佳實務，最佳實務
eval() 與 new Function() 相較，eval() 與 new Function()
間接 eval() 在全域範圍內評估，間接 eval() 在全域範圍內評估
正當的使用案例，正當的使用案例
使用 eval()，使用 eval() 評估程式碼
使用 new Function()，使用 new Function() 評估程式碼
every() 方法，反覆運算陣列，陣列反覆運算方法
例外處理，語言的影響和性質, 例外處理, 什麼是例外處理？–實作您自己的錯誤建構函式
定義，什麼是例外處理？
錯誤建構函式，錯誤建構函式
範例，任何值都可以拋出，範例
實作您自己的錯誤建構函式，實作您自己的錯誤建構函式
在 JavaScript 中，JavaScript 中的例外處理
堆疊追蹤，堆疊追蹤
throw 陳述式，throw
try-catch-finally 陳述式，try-catch-finally
例外物件，throw, 堆疊追蹤
執行內容，環境：管理變數
指數表示法，Number.prototype.toExponential(fractionDigits?)
指數，指數，數字的內部表示
特殊，特殊指數
表達式陳述式，陳述式對上表達式，陳述式
表達式
條件式陳述式對上條件式表達式，條件式陳述式對上條件式表達式
定義，表達式
捨棄結果，void 用來做什麼？
IIFE（立即呼叫函式表達式），透過 IIFE 引入新的作用域
陳述式對上，陳述式對上表達式
使用模稜兩可的表達式作為陳述式，使用模稜兩可的表達式作為陳述式
防止物件的擴充，防止擴充

F

快速失敗，其他
finally 子句（try-finally），try-catch-finally，範例
Firebug，在不同引擎中，主控台 API 有多標準化？
Firefox OS，JavaScript 歷史里程碑
正規表示式的旗標，旗標，正規表示式秘笈
flag /g 的問題，flag /g 的問題
浮點數，數字
將整數表示為，將整數表示為浮點數
for each-in 迴圈，for each-in
for 迴圈，迴圈，for
透過 for 迴圈進行陣列迭代，稀疏陣列對上稠密陣列
for-in 迴圈，for-in，for-in 迴圈
小心使用 for-in 迴圈處理物件，最佳實務：小心使用 for-in 迴圈處理物件
屬性的列舉性，影響，列舉性的影響
不使用 for-in 迴圈迭代陣列，最佳實務：不要使用 for-in 迴圈處理陣列
forEach() 方法（請參閱 Array.prototype.forEach() 方法）
凍結物件，Freezing
函數宣告，Functions
定義函數，Function Declarations
提升，Function Declarations Are Hoisted，Hoisting
與函數表達式比較，Which Is Better: A Function Declaration or a Function Expression?
函數表達式，Functions Inside a Method，Function Expressions
模稜兩可的表達式用作陳述句，Using ambiguous expressions as statements
使用函數定義，Functions
函數宣告與函數表達式比較，Which Is Better: A Function Declaration or a Function Expression?
IIFE（立即呼叫函數表達式），The IIFE Pattern: Introducing a New Scope，Immediately invoking a function expression
(另請參閱 IIFE)
命名，Named function expressions
名稱，The Name of a Function
Function() 建構函數，The Function Constructor，Evaluating Code Using new Function()
函數作用域變數，Variables Are Function-Scoped
Function.prototype.apply() 方法，Function.prototype.apply(thisValue, argArray)，Function.prototype.bind(thisValue, arg1?, ..., argN?)
破壞性地將陣列附加到另一個陣列，Adding and Removing Elements (Destructive)
陣列中的孔洞，轉換為未定義元素，Function.prototype.apply()
Function.prototype.call() 方法，More Control over Function Calls: call(), apply(), and bind()，Function.prototype.call(thisValue, arg1?, arg2?, ...)
函數，Functions–Simulating Named Parameters in JavaScript
呼叫，An Overview of the Syntax
在設定 this 時呼叫，Calling Functions While Setting this: call(), apply(), and bind()
閉包，Closures
建構函式，建構函式：物件的工廠
定義，語法的概觀、語法的概觀、定義函式
使用函式宣告，函式宣告
使用函式表達式，函式表達式
使用 Function() 建構函式，Function 建構函式
定義和呼叫，函式
文件化 (JSDoc)，文件化函式和方法
針對每個函式啟用嚴格模式，嚴格模式
函式宣告與函式表達式的比較，哪個比較好：函式宣告或函式表達式？
處理缺少或多餘的參數，處理缺少或多餘的參數
arguments 變數，所有參數按索引：特殊變數 arguments
提升，提升
隱式傳回未定義值，未定義的出現
在嚴格模式中，函式必須宣告在範圍的最上層
在方法內部，方法內部的函式
強制執行最小參數個數的強制參數，強制參數，強制執行最小參數個數
更能控制函式呼叫，更能控制函式呼叫：call()、apply() 和 bind()
apply() 方法，func.apply(thisValue, argArray)
bind() 方法，func.bind(thisValue, arg1, ..., argN)
名稱，函式名稱
命名參數，命名參數–在 JavaScript 中模擬命名參數
在 JavaScript 中模擬，在 JavaScript 中模擬命名參數
可選參數，可選參數
參數與引數，術語：「參數」與「引數」
傳遞為另一個函式的參數，陷阱：意外的可選參數
在 JavaScript 中的角色，函式在 JavaScript 中的三個角色
模擬傳址參數，模擬傳址參數
this 作為隱式參數，this 作為函式和方法的隱式參數
太多或太少的引數，太多或太少的引數

G

通用方法，通用方法：從原型借用方法，通用方法
透過文字存取 Object.prototype 和 Array.prototype，透過文字存取 Object.prototype 和 Array.prototype
類陣列物件和，類陣列物件和通用方法
範例，通用呼叫方法的範例
清單，所有通用方法的清單
取得器和設定器（請參閱存取器）
保持全域資料為私人，透過 IIFE 保持全域資料為私人
使用 IIFE 將全域資料附加至單例物件，將私人全域資料附加至單例物件
透過 IIFE 附加至方法，將全域資料附加至方法
保持所有建構函式的私人，保持全域資料對所有建構函式為私人
全域物件，全域物件
跨平台考量，跨平台考量
window 的使用案例，使用案例：標記全域變數
全域範圍，全域變數
使用 window 在其中建立事物，使用案例：在全域範圍中建立事物
其中的非建構函式函式，非建構函式函式
分類和剖析數字，分類和剖析數字
編碼和解碼文字，編碼和解碼文字
其中的其他變數，命名空間和特殊值
全域變數，識別字和變數名稱，全域變數，建構函式–命名空間和特殊值
避免建立，最佳實務：避免建立全域變數
檢查是否存在，使用案例：檢查全域變數是否存在
透過指定未宣告的變數來建立，變數宣告會提升
透過使用模組來消除，模組系統導致較少的全域變數
樣式檢查器和，使用案例：樣式檢查器
字形，重要的 Unicode 概念
字位，重要的 Unicode 概念
貪婪比對（正規表示式），量詞
正規表示式中的群組，原子：群組
擷取群組或傳回所有相符的子字串，String.prototype.match：擷取群組或傳回所有相符的子字串
在比對時擷取群組，RegExp.prototype.exec：擷取群組
Grunt，更多工具
Gulp，更多工具

H

十六進位跳脫序列（字串文字），字串文字中的跳脫，原始碼內部
十六進位數字文字，數字文字
高位元代理代碼，Unicode 編碼
提升，提升
函式宣告，函式宣告會提升，哪個比較好：函式宣告或函式表達式？
變數宣告，函式宣告會提升，變數作用域和封閉，變數會提升，變數宣告會提升
陣列中的洞，刪除陣列元素，陣列中的洞–從陣列中移除洞
建立，建立洞
忽略或考慮洞的運算，哪些運算會忽略洞，哪些會考慮洞？
移除，從陣列中移除洞
稀疏陣列與稠密陣列，稀疏陣列與稠密陣列
home 物件，進行超呼叫
HTML，語法
動態 HTML，JavaScript 歷史里程碑
HTML5，圖形使用者介面
整合到 Windows 8，JavaScript 歷史里程碑

I

識別碼，識別碼和變數名稱
屬性金鑰，任意屬性金鑰，點運算子 (. )：透過固定金鑰存取屬性
保留字，識別碼和變數名稱，合法的識別碼
命名規則，合法識別碼
IEEE 754 浮點數運算標準，數字
if 敘述，條件式與條件運算式的差異
串接，串接 if 敘述
懸浮的 else 子句，陷阱：懸浮的 else
範例，語法的概觀
不透過邏輯運算子來縮寫，縮寫 if 敘述
if-then-else 敘述，條件式
if-then-else，作為敘述或運算式，敘述與運算式的差異
IIFE（立即呼叫函式運算式），IIFE 範例：引入新的範圍，立即呼叫函式運算式
已在運算式內容中，IIFE 變形：已在運算式內容中
IIFE 的應用，IIFE 應用
透過 IIFE 將全域資料附加至方法，將全域資料附加至方法
將全域資料附加至單例物件，將私有全域資料附加至單例物件
透過封閉避免無意間共用，IIFE 使用案例：透過封閉無意間共用
帶有參數的 IIFE，IIFE 變形：帶有參數的 IIFE
透過 IIFE 導入新的範圍，透過 IIFE 導入新的範圍
前置運算子，IIFE 變形：前置運算子
用於避免 with 敘述，避免 with 敘述的技巧
隱式類型轉換，強制轉換
in 運算子，單一物件，物件運算子
與陣列索引，in 運算子與索引
檢查物件是否有屬性，檢查屬性是否存在，其他
繼承的影響，繼承的影響
與 arguments 物件一起使用，依索引取得所有參數：特殊變數 arguments
與陣列一起使用，陣列文字
程式碼縮排，公認的最佳實務，語法
不等於運算子，等於運算子：=== 與 ==，寬鬆不等於 (!=)
(另請參閱等於運算子)
無限大，數字，無限大，命名空間和特殊值
檢查，檢查無限大
運算，使用無限大運算
錯誤，數字的數值太大，錯誤：數字的數值太大
錯誤，除以零，錯誤：除以零
負和正，區分兩個零
Number.NEGATIVE_INFINITY 屬性，Number 建構函數屬性
Number.POSITIVE_INFINITY 屬性，Number 建構函數屬性
繼承
在建構函數之間，第 4 層：建構函數之間的繼承–秘笈：使用物件
原型繼承和屬性，方法，原型繼承和屬性
基於原型的，第 2 層：物件之間的原型關係–第 3 層：建構函數—實例工廠
最佳實務，反覆運算自己的屬性，最佳實務：反覆運算自己的屬性
反覆運算和偵測屬性，反覆運算和偵測屬性
覆寫屬性，覆寫
設定和刪除只影響自己的屬性，設定和刪除只影響自己的屬性
內部和外部範圍，背景：變數的範圍
實例屬性，公開屬性
依需求建立，依需求建立實例屬性
文件化 (JSDoc)，文件化變數、參數和實例屬性
從超建構函數繼承，繼承實例屬性
正規表示式的，正規表示式的實例屬性
實例原型，術語：兩個原型
instanceof 運算子，使用 typeof 和 instanceof 分類值，instanceof 運算子，確保 instanceof 運作
檢查物件是否為給定建構函數的實例，instanceof：檢查物件是否為給定建構函數的實例
跨越領域，陷阱：跨越領域（框架或視窗）
陷阱，物件不是物件實例，陷阱：物件不是物件實例
整數，數字，JavaScript 中的整數
轉換為
使用 parseInt()，透過 parseInt() 處理整數
將數字轉換為，轉換為整數
使用位元運算子，透過位元運算子處理 32 位元整數
使用 Math.ceil()，透過 Math.floor()、Math.ceil() 和 Math.round() 處理整數
使用 Math.floor()，透過 Math.floor()、Math.ceil() 和 Math.round() 處理整數
使用 Math.round()，透過 Math.floor()、Math.ceil() 和 Math.round() 處理整數
使用 ToInteger() 自訂函式，透過自訂函式 ToInteger() 處理整數
範圍，整數範圍
表示為浮點數，將整數表示為浮點數
JavaScript 中的安全整數，安全整數
算術運算的安全結果，算術運算的安全結果
有符號的 32 位元整數，有符號的 32 位元整數
字串化的整數作為陣列索引，陣列索引詳解
在 JavaScript 中處理整數的最佳實務，最佳實務
內部屬性，屬性的種類
isFinite() 函式，檢查無限大，數字函式
isNaN() 函式，陷阱：檢查值是否為 NaN，數字函式
isNegativeZero() 函式，區分兩個零
isObject() 函式，將任何值轉換為物件
同構 JavaScript，JavaScript 歷史里程碑
isSafeInteger() 函式，ECMAScript 6 中的定義
反覆運算方法，陣列，反覆運算（非破壞性）
檢查方法，檢查方法
忽略陣列中的孔洞，陣列迭代方法
簡化方法，簡化方法
轉換方法，轉換方法

J

Jasmine（單元測試框架），更多工具
Java，JavaScript 的建立
JavaScript
命令列，JavaScript 命令列
了解整個生態系統，下一步該做什麼
歷史里程碑，JavaScript 歷史里程碑–JavaScript 歷史里程碑
如何以及為何建立，JavaScript 的建立
本質，JavaScript 的本質–影響
優雅的部分，優雅的部分
受其他程式語言影響，影響
怪癖與非傳統功能，怪癖與非傳統功能
選擇的原因，為何選擇 JavaScript？
JavaScript 的美好未來，JavaScript 是否有未來？
JavaScript 的優雅，JavaScript 是否優雅？
免費取得，JavaScript 是否免費取得？
圖形使用者介面，圖形使用者介面
其他補充 JavaScript 的技術，其他補充 JavaScript 的技術
JavaScript 的速度，JavaScript 是否夠快？
工具，JavaScript 是否有好的工具？
JavaScript 的廣泛使用，JavaScript 是否被廣泛使用？
標準化，ECMAScript，標準化：ECMAScript
語法，語法，JavaScript 的語法–嚴格模式中禁止的功能
控制流程陳述式和區塊，控制流程陳述式和區塊
基本語法的範例，語法概觀，語法概觀
識別碼，合法識別碼
識別碼和變數名稱，識別碼和變數名稱
呼叫數字文字上的方法，呼叫數字文字上的方法
分號，分號
程式碼中的分號，使用分號的規則–陷阱：ASI 可能意外地未觸發
陳述式與表達式，陳述式與表達式，表達式與陳述式–立即呼叫函式表達式
嚴格模式，開啟嚴格模式–嚴格模式中禁止的功能
值，基本類型，語法概觀
JavaScript 物件表示法 (請參閱 JSON)
javascript: URL，void 用於什麼？
join() 方法，將陣列中的洞轉換為空字串，其他陣列方法
jQuery，JavaScript 的歷史里程碑
JSDoc，產生 API 文件，JSDoc：產生 API 文件–其他有用的標籤
基本標籤，基本標籤
文件類別，文件類別–其他有用的標籤
透過建構函式定義類別，透過建構函式定義類別
透過物件文字定義類別，透過物件文字定義類別
透過物件文字定義類別，並使用 @constructs 方法，透過具有 @constructs 方法的物件文字定義類別
子類別化，子類別化
文件化函式和方法，文件化函式和方法
文件化變數、參數和實例屬性，文件化變數、參數和實例屬性
內嵌類型資訊，內嵌類型資訊（「內嵌文件化註解」）
命名類型，命名類型
其他有用的標籤，其他有用的標籤
語法，語法
JSHint（樣式檢查器），更多工具
JSLint（樣式檢查器），更多工具
JSON（JavaScript 物件表示法），補充 JavaScript 的其他技術, JavaScript 歷史里程碑, JSON–JSON.parse()
資料格式，資料格式
語法，語法
歷史，歷史
ECMAScript 5 中的支援，JSON
toJSON() 方法，toJSON() 方法
透過節點訪客轉換資料，透過節點訪客轉換資料
JSON.parse()，JSON.parse(text, reviver?)
反覆運算 JavaScript 資料，JSON.parse()
JSON.stringify()，手動轉換為字串, JSON.stringify(value, replacer?, space?)
反覆運算 JavaScript 資料，JSON.stringify()
被忽略的屬性，被 JSON.stringify() 忽略的資料

L

length 屬性
arguments 物件，依索引的所有參數：特殊變數 arguments, 強制執行最小參數個數的強制參數
陣列，陣列文字, 概觀, length–最大長度
字串，字串，字串實例屬性長度
詞法（靜態）維度（變數），環境：管理變數
詞法範圍，背景：變數範圍
詞法語意，背景：靜態與動態
函式庫，其他補充 JavaScript 的技術，四個語言函式庫–JavaScript 資源目錄
JavaScript 資源目錄，JavaScript 資源目錄
ECMAScript 國際化 API，ECMAScript 國際化 API
在 JavaScript 中處理 Unicode，函式庫
shim 與 polyfill，shim 與 polyfill
字串換行，字串文字的跳脫字元
換行符號，JavaScript 正規表示式與 Unicode
lint 工具，更多工具
文字，優先於建構函式，優先使用文字而非建構函式
Lo-Dash 函式庫，四個語言函式庫
記錄方法，主控台 API，簡單記錄
邏輯運算子，布林值和數字的運算子，二元邏輯運算子：And (&&) 和 Or (||)
縮寫 if 陳述式，縮寫 if 陳述式
邏輯 NOT (!)，邏輯 Not (!)
後向肯定，手動實作，手動實作後向肯定
迴圈，迴圈，迴圈和條件式的主體–for each-in
主體，迴圈和條件式的主體
do-while 迴圈，do-while
for each-in 迴圈，for each-in
for 迴圈，for
for-in 迴圈，for-in
可與迴圈搭配使用的機制，可與迴圈搭配使用的機制
離開迴圈，可與迴圈搭配使用的機制
while 迴圈，while，while
低位元替身碼元，Unicode 編碼

M

機器 epsilon，處理捨入誤差
map() 方法
從現有陣列建立新陣列，遍歷陣列
parseInt() 函數傳遞為參數，陷阱：意外的選用參數
映射
陣列為，陣列是映射，不是元組
使用物件作為，陷阱，陷阱：使用物件作為映射
標記的屬性金鑰，具有標記金鑰的屬性中的私有資料
Math 物件，Math–其他函數
算術函數，Math
數值函數，數值函數
其他函數，其他函數
屬性，Math 屬性
三角函數，三角函數
Math.abs() 函數，數值函數
Math.acos() 函數，三角函數
Math.asin() 函數，三角函數
Math.atan() 函數，三角函數
Math.atan2() 函數，區分兩個零, 三角函數
Math.ceil() 函數，透過 Math.floor()、Math.ceil() 和 Math.round() 取得整數, 數值函數
Math.cos() 函數，三角函數
Math.exp() 函數，數值函數
Math.floor() 函數，透過 Math.floor()、Math.ceil() 和 Math.round() 取得整數, 數值函數
Math.log() 函數，數值函數
Math.max() 函數，其他函數
Math.min() 函數，其他函數
Math.pow() 函數，區分兩個零, 數值函數
Math.random() 函數，其他函數
Math.round() 函數，透過 Math.floor()、Math.ceil() 和 Math.round() 取得整數, 數值函數
Math.sin() 函數，三角函數
Math.sqrt() 函數，數值函數
MDN（Mozilla 開發者網路），快速尋找文件
JavaScript 檔案的媒體類型，外部原始碼
JSDoc 中的元資料標籤，基本標籤
方法，單一物件，JavaScript 中函式的三個角色，屬性的種類
透過 IIFE 附加全域資料，將全域資料附加到方法
呼叫，語法的概觀
使用方括號運算子呼叫，透過方括號運算子呼叫方法
使用點運算子呼叫，呼叫方法
所有物件共有的，所有物件的方法，秘笈：使用物件
文件化（JSDoc），文件化函式和方法
擷取，擷取方法
回呼和，回呼和擷取的方法
遺失 this，陷阱：擷取方法時遺失 this
內部函式，方法內部的函式
遮蔽 this，陷阱：方法內部的函式遮蔽 this
泛型（請參閱泛型方法）
在數字文字上呼叫，在數字文字上呼叫方法，在文字上呼叫方法
使用點運算子呼叫，值
ECMAScript 5 中的新方法，新方法
覆寫，覆寫方法
特權，建構函式環境中的私人資料（Crockford 隱私模式），特權方法
超呼叫，進行超呼叫
this 作為隱含參數，this 作為函式和方法的隱含參數
縮小，JavaScript 的本質
縮小的工具，外部原始碼，更多工具
mocha（單元測試架構），更多工具
模組系統，模組系統
保持全域資料的私密性，將全域資料保持對所有建構函式私密
導致較少的全域變數，模組系統導致較少的全域變數
快速且簡陋的模組，快速且簡陋的模組
Mozilla Developer Network (MDN)，快速尋找文件
多維陣列，多維陣列
多行註解，註解，註解

N

命名存取器屬性，屬性的種類
命名資料屬性，屬性的種類
命名函式表達式，命名函式表達式，函式的名稱
命名參數，命名參數–在 JavaScript 中模擬命名參數
作為描述，命名參數作為描述
選用，選用命名參數
選用參數，選用參數
在 JavaScript 中模擬，在 JavaScript 中模擬命名參數
NaN（非數字），數字，NaN，命名空間和特殊值
透過嚴格相等比較，陷阱：NaN
isNaN() 函式，數字函式
陷阱，檢查值是否為 NaN，陷阱：檢查值是否為 NaN
Netscape，JavaScript 的誕生
new 營運子，建構函式：物件工廠，JavaScript 中函式的三個角色，第 3 層：建構函式—實例工廠，JavaScript 中實作的 new 營運子
使用建構函式時忘記保護，保護忘記 new：嚴格模式
Node 封裝模組 (NPM)，套件管理員
節點訪客
透過節點訪客轉換資料，透過節點訪客轉換資料
節點訪客 (JSON)，JSON.parse(text, reviver?)
Node.js，JavaScript 命令列，其他補充 JavaScript 的技術
全域物件和，跨平台考量
在伺服器上實作 JavaScript，JavaScript 歷史里程碑
非破壞性陣列方法，陣列原型方法
非方法函式，JavaScript 中函式的三個角色
正常 (或寬鬆) 相等，相等運算子
正規化 (Unicode)，重要的 Unicode 概念，Unicode 正規化
數字的正規化表示，特殊指數
null，undefined 和 null，原始值，undefined 和 null
檢查，檢查 null，使用案例：檢查 undefined 或 null
檢查 undefined 或 null，檢查 undefined 或 null
歷史，undefined 和 null 的歷史
出現，null 的出現
Number() 函式，轉換為布林值、數字、字串和物件的函式，Number 函式
手動轉換為數字，手動轉換為數字
Number.MAX_VALUE 屬性，Number 建構函式屬性
Number.MIN_VALUE 屬性，Number 建構函式屬性
Number.NEGATIVE_INFINITY 屬性，Number 建構函式屬性
Number.POSITIVE_INFINITY 屬性，Number 建構函式屬性
Number.prototype 方法，Number 原型方法
Number.prototype.toExponential() 方法，Number.prototype.toExponential(fractionDigits?)
Number.prototype.toFixed() 方法，Number.prototype.toFixed(fractionDigits?)
Number.prototype.toPrecision() 方法，Number.prototype.toPrecision(precision?)
Number.prototype.toString() 方法，輸入和輸出二進制數字，Number.prototype.toString(radix?)
JavaScript 中的數字，數字，語法的概述，原始值，數字–本章的來源
運算符，布林值和數字的運算符，算術運算符–算術運算符
位元運算符，位元運算符
分類和剖析，函式，分類和剖析數字
在陣列中比較，比較數字
將日期轉換為數字，將日期轉換為數字
將物件轉換為數字，陷阱：所有物件都是真值
轉換為整數，將數字轉換為整數
將值轉換為數字，轉換為布林值、數字、字串和物件的函式，轉換為數字
手動轉換，手動轉換為數字
函式，數字的函式
處理捨入誤差，處理捨入誤差
整數，JavaScript 中的整數
內部表示，數字的內部表示
特殊指數，特殊指數
呼叫數字文字的函式，呼叫數字文字的函式
數字文字，數字文字
指數，指數
呼叫的函式，呼叫文字的函式
排序運算子，排序運算子
原型函式，數字原型函式
特殊數字值，特殊數字值
無限大，無限大
非數值，非數值
兩個零，兩個零–區分兩個零
基本資料型別的包裝物件，基本資料型別的包裝物件

O

物件文字，物件, 精緻的部分, 物件文字, 秘笈：使用物件
透過空物件文字存取 Object.prototype，透過文字存取 Object.prototype 和 Array.prototype
含糊的表達式或陳述式，使用含糊的表達式作為陳述式
比 Object() 建構函式更好的選擇，將任何值轉換為物件
透過 (JSDoc) 定義類別，透過物件文字定義類別
透過定義存取器，透過物件文字定義存取器
使用 eval() 評估，透過 eval() 評估物件文字
尾隨逗號，語法變更
Object() 函式，轉換為布林值、數字、字串和物件的函式
將值轉換為物件，將任何值轉換為物件
呼叫作為建構函式，將任何值轉換為物件
Object，用於元程式設計功能的命名空間的全球變數，命名空間和特殊值
JavaScript 中的面向物件程式設計 (OOP)，物件和繼承–秘笈：使用物件
層級 1，單一物件，物件和繼承–層級 2：物件之間的原型關係
層級 2，物件之間的原型關係，層級 2：物件之間的原型關係–層級 3：建構函式—實例的工廠
層級 3，建構函式，實例的工廠，層級 3：建構函式—實例的工廠–將全域資料附加到函式
層級 4，建構函式之間的繼承，層級 4：建構函式之間的繼承–秘笈：使用物件
風格指南，物件導向
Object.create() 函式，建立具有特定原型的物件
Object.defineProperties() 方法，範例，透過描述子取得和定義屬性
Object.defineProperty() 方法，透過描述子取得和定義屬性
Object.freeze() 方法，凍結
Object.getOwnPropertyDescriptor() 方法，透過描述子取得和定義屬性
Object.getOwnPropertyNames() 方法，列出自己的屬性金鑰
Object.getPrototypeOf() 方法，讀取物件的原型，術語：兩個原型
Object.keys() 方法，列出自己的屬性金鑰，可列舉性的影響
Object.preventExtensions() 方法，防止擴充
Object.prototype，通用方法的縮寫，通用方法
Object.prototype.hasOwnProperty() 方法，找出定義屬性的物件，檢查屬性是否存在，原型繼承和屬性
檢查屬性是否存在，其他
Object.prototype.isPrototypeOf() 方法，檢查一個物件是否為另一個物件的原型，所有物件的方法，原型繼承和屬性
Object.prototype.propertyIsEnumerable() 方法，原型繼承和屬性
Object.prototype.toLocaleString() 方法，Object.prototype.toLocaleString()
Object.prototype.toString() 方法，轉換為原始值
Object.prototype.valueOf() 方法，轉換為原始值
Object.seal() 方法，密封
物件，物件，物件和建構函式–陣列，語法概觀，物件，物件和繼承–秘笈：使用物件
存取器，存取器（取得器和設定器）
和繼承，存取器和繼承
透過物件文字定義存取器，透過物件文字定義存取器
透過屬性描述符定義存取器，透過屬性描述符定義存取器
陣列，物件，物件
最佳實務，迭代自有屬性，最佳實務：迭代自有屬性
特性，物件，物件
使用秘技表，秘技表：使用物件
在陣列排序中比較，比較物件
透過寬鬆相等（==）比較，陷阱：寬鬆相等和物件
透過嚴格相等（===）比較，嚴格相等（===，!==）
建構函式，建構函式：物件工廠
轉換成布林值
所有物件都是真值，陷阱：所有物件都是真值
轉換成數字，轉換成數字
轉換成字串，轉換成布林值、數字、字串和物件的函式
將值轉換成，將任何值轉換成物件
使用屬性描述符複製，複製物件
從中萃取方法，萃取方法
instanceof 運算子，instanceof：檢查物件是否為特定建構函式的實例
迭代和偵測屬性，屬性的迭代和偵測
檢查屬性是否存在，檢查屬性是否存在
可列舉性的影響，可列舉性的影響
繼承的影響，繼承的影響
範例，範例
列出所有可列舉屬性金鑰，列出所有屬性金鑰
列出自己的屬性鍵，列出自己的屬性鍵
物件的自有屬性數量，計算物件的自有屬性數量
使用 for-in 迴圈遍歷所有屬性，for-in
小心，最佳實務：小心使用 for-in 迴圈處理物件
方法，JavaScript 中函式的三個角色
所有物件共用的方法，所有物件的方法, 秘笈：處理物件
不只是映射，物件字面值
不是 Object 實例的物件，陷阱：不是 Object 實例的物件
運算子與，運算子與物件
運算子用於，物件運算子
基本值與，基本值與物件, 基本值與物件
屬性屬性和屬性描述子，屬性屬性和屬性描述子
保護，保護物件, 秘笈：處理物件, 元程式設計
陷阱，保護是淺層的，陷阱：保護是淺層的
透過原型共用資料，透過原型在物件之間共用資料
單一，單一物件, 第 1 層：單一物件
用作映射
無原型物件的優點，無原型物件
最佳實務，最佳實務
dict 模式，沒有原型的物件，dict 模式：沒有原型的物件是更好的映射
陷阱，陷阱：使用物件作為映射
與基本值，基本值與物件
基本值的包裝物件，基本值的包裝物件–類型強制轉換
一元補數，按位非運算子
運算子，運算子–物件運算子
+（加號）運算子，加號運算子（+）
，（逗號）運算子，逗號運算子
？：（條件式）運算子，條件式運算子（？：）
與物件，運算子與物件
算術運算子，運算子
賦值運算子，賦值運算子
二元邏輯運算子，二元邏輯運算子，布林值與數字運算子，二元邏輯運算子：And（&&）與 Or（||）
強制轉換運算元為所需的型別，型別強制轉換
複合賦值運算子，複合賦值運算子
相等運算子，相等運算子，相等運算子：=== 與 ==–排序運算子
用於布林值與數字，布林值與數字運算子
用於物件，物件運算子
用於字串，字串運算子
instanceof，使用 typeof 和 instanceof 分類值，透過 typeof 和 instanceof 分類值–物件運算子
排序運算子，排序運算子
優先順序，物件導向
產生布林值，布林值
typeof，使用 typeof 和 instanceof 分類值，透過 typeof 和 instanceof 分類值–物件運算子
void 運算子，void 運算子
選用參數，選用參數
命名，可選命名參數
意外，陷阱：意外的可選參數
排序運算子，排序運算子
評估比較，演算法
外部範圍，背景：變數的範圍
覆寫
方法，覆寫方法

P

套件管理員，模組系統和套件管理員，套件管理員
參數
定義，術語：「參數」與「引數」
文件記錄（JSDoc），文件記錄函式和方法，文件記錄變數、參數和實例屬性
強制執行特定數量，強制執行元數，強制參數、強制執行最小元數
IIFE 與參數，IIFE 變形：具有參數的 IIFE
處理遺失或額外的參數，處理遺失或額外的參數
遺失或未定義，undefined 的出現
命名，命名參數–在 JavaScript 中模擬命名參數
可選，可選參數，可選參數
模擬傳遞參照，模擬傳遞參照參數
位置，命名參數
提供預設值，範例 1：參數的預設值
在嚴格模式中，參數有更嚴格的規則，函式參數的更嚴格規則
this 作為函式和方法的隱含參數，this 作為函式和方法的隱含參數
parseFloat() 函式，parseFloat()，數字函式
parseInt() 函式，透過 parseInt() 取得整數，Number.prototype.toString(radix?)，數字函式
數字轉換為整數不正確，基數
解析二進位表示法的字串，輸入和輸出二進位數字
傳遞為 map() 的引數，陷阱：意外的選用參數
基數，基數
部分函數應用，func.bind(thisValue, arg1, ..., argN)，Function.prototype.bind(thisValue, arg1?, ..., argN?)
正規表示式中的模式字元，原子：一般
PhoneGap，JavaScript 歷史里程碑
純粹物件，物件文字
平面（Unicode），碼點
polyfill，shim 與 polyfill
多型原型屬性，多型原型屬性
位置參數，命名參數
與命名參數結合，在 JavaScript 中模擬命名參數
前置運算子，IIFE 變形：前置運算子
原始值
特性，原始值，原始值
使用寬鬆相等（==）比較包裝器實例，使用案例：比較包裝器實例與原始值
轉換為，轉換為原始值
使用 ToPrimitive() 函數將值轉換為，演算法：ToPrimitive()—將值轉換為原始值
將其他值轉換為的函數，轉換為布林值、數字、字串和物件的函數
使用原始值的運算子，運算子和物件
類型，原始值
與物件比較，原始值與物件，原始值與物件
原始值的包裝器物件，原始值的包裝器物件–類型強制轉換
包裝器物件與原始值之間的差異，包裝器物件與原始值不同
封裝和解封，封裝和解封基本型別
物件的私有資料，保持資料私密–將全域資料附加到方法
Crockford 隱私模式，一個範例
在建構函式環境中，建構函式環境中的私有資料（Crockford 隱私模式）
在具有標記式金鑰的屬性中，具有標記式金鑰屬性中的私有資料
在具有具象化金鑰的屬性中，具有具象化金鑰屬性中的私有資料
透過 IIFE 保持全域資料私密，透過 IIFE 保持全域資料私密
私有值（Crockford 隱私模式），建構函式環境中的私有資料（Crockford 隱私模式），私有值
特權方法（Crockford 隱私模式），建構函式環境中的私有資料（Crockford 隱私模式），特權方法
程式範圍，全域變數
影響 JavaScript 的程式語言，影響
屬性
透過點運算子存取，點運算子 (.): 透過固定金鑰存取屬性
任意屬性金鑰，任意屬性金鑰
陣列，陣列文字，陣列也可以有屬性
檢查是否存在，其他
定義與指定，屬性：定義與指定
刪除，刪除屬性
可列舉性，屬性的反覆運算和偵測
透過方括號運算子取得，透過方括號運算子取得屬性
在嚴格模式中非法操作，在嚴格模式中設定和刪除不可變屬性會失敗，並產生例外
反覆運算和偵測，秘笈：使用物件
種類，屬性種類
合法屬性金鑰，不尋常的屬性金鑰
列出，ECMAScript 5 的新功能，元程式設計
不存在或未定義，未定義的發生
物件用作映射，陷阱：使用物件作為映射
檢查屬性是否存在，檢查屬性是否存在
收集屬性金鑰，收集屬性金鑰
取得屬性值，取得屬性值
繼承與讀取屬性，陷阱 1：繼承影響讀取屬性
物件，物件，單一物件，物件
可變性，物件
原始值，原始值，原始值
值，值，值
屬性為物件中的項目，第 1 層：單一物件
保留字作為屬性鍵，語法變更
設定，設定屬性
使用標記鍵，屬性中私有資料，屬性中使用標記鍵的私有資料
使用實體化鍵，屬性中私有資料，屬性中使用實體化鍵的私有資料
屬性屬性（請參閱屬性）
屬性描述符，屬性屬性和屬性描述符，屬性描述符
透過屬性描述符定義存取器，透過屬性描述符定義存取器
函式，透過描述符取得和定義屬性
透過屬性描述符取得和定義屬性，秘笈：使用物件
透過屬性描述符管理屬性屬性，元程式設計
使用屬性描述符複製物件，複製物件
proto 屬性，特殊屬性 __proto__，陷阱 3：特殊屬性 __proto__
原型屬性，公開屬性
原型屬性中的資料，原型屬性中的資料
繼承，繼承原型屬性
避免非多型，避免非多型原型屬性
多型，多型原型屬性
避免使用具有執行個體屬性初始值的原型屬性，避免使用具有執行個體屬性初始值的原型屬性
原型屬性，建構函式：物件工廠
與原型關係比較，術語：兩個原型
物件之間的原型關係，第 2 層：物件之間的原型關係–第 3 層：建構函式—執行個體工廠
變更原型鏈中的任何屬性，變更原型鏈中的任何屬性
檢查物件是否為另一個物件的原型，檢查一個物件是否為另一個物件的原型
使用給定的原型建立新物件，使用給定的原型建立新物件
刪除繼承的屬性，刪除繼承的屬性
尋找定義屬性的物件，尋找定義屬性的物件
取得並設定原型，取得並設定原型
屬性的繼承，繼承
覆寫屬性，覆寫
讀取原型，讀取物件的原型
設定屬性，設定屬性
設定和刪除僅影響自己的屬性，設定和刪除僅影響自己的屬性
特殊屬性 proto，特殊屬性 __proto__
原型與原型屬性，術語：兩個原型
公開屬性（Crockford 隱私模式），建構函式的環境中的私人資料（Crockford 隱私模式）

Q

正規表示式中的量詞，量詞, 正規表示式秘笈
字串文字的引號，字串, 字串文字
最佳實務，公認的最佳實務
quoteText() 函式，引用文字

R

基數
Number.prototype.toString()，Number.prototype.toString(radix?)
parseInt()) 函式，基數
亂數，其他函式
RangeError 建構函式，錯誤建構函式
整數範圍，整數範圍
領域，陷阱：跨越領域（框架或視窗）
方法呼叫的接收者，this 作為函式和方法的隱含參數
方法呼叫的接收者，物件文字
簡化方法，簡化方法
ReferenceError 建構函式，錯誤建構函式
RegExp() 建構函式，文字與建構函式
RegExp.prototype.exec() 方法，RegExp.prototype.exec：擷取群組
RegExp.prototype.text() 方法，RegExp.prototype.test：是否有符合的項目？
正規表示式，物件、正規表示式、物件、正規表示式–正規表示式秘笈
擷取群組或傳回所有符合的子字串，String.prototype.match：擷取群組或傳回所有符合的子字串
與字串比對時擷取群組，RegExp.prototype.exec：擷取群組
檢查正規表示式是否符合字串，RegExp.prototype.test：是否有符合的項目？
建立，建立正規表示式
範例，建立正規表示式的範例
旗標，旗標
使用文字或建構函式，文字與建構函式
exec() 方法，比對與擷取群組，exec() 方法：比對與擷取群組
在字串中尋找文字，搜尋與比較
找到符合項目的索引，String.prototype.search：在什麼索引位置有符合的項目？
實例屬性，正規表示式的實例屬性
JavaScript、Unicode 和，JavaScript 正規表示式與 Unicode
協助的函式庫，函式庫
比對任何程式碼單位和任何程式碼點，比對任何程式碼單位和任何程式碼點
手動實作後向參照，手動實作後向參照
比對所有或沒有項目，比對所有或沒有項目
/g 旗標的問題，/g 旗標的問題
快速參考，正規表示式秘笈
引用文字，引用文字
replace() 方法，搜尋並取代，方法 replace()：搜尋並取代
搜尋並取代，String.prototype.replace：搜尋並取代
取代是一個函式，取代是一個函式
取代是一個字串，取代是一個字串
語法，正規表示式語法
斷言，斷言
字元類別，原子：字元類別
析取，析取
一般原子，原子：一般
群組，原子：群組
量詞，量詞
test() 方法，正規表示式
測試、比對和取代字串中的文字，使用正規表示式進行測試、比對和取代
Unicode 和，Unicode 和正規表示式
沒有斷言，到處尋找模式，陷阱：沒有斷言（例如 ^、$），正規表示式會到處找到
具象化屬性金鑰，使用具象化金鑰的屬性中的私有資料
不情願比對（正規表示式），量詞
RequireJS，快速且簡陋的模組
保留字，識別碼和變數名稱
作為屬性金鑰，不尋常的屬性金鑰, 語法變更
識別碼，合法識別碼
return 陳述式，switch
在函式宣告中，函式
捨入數字
處理捨入誤差，處理捨入誤差
Math.ceil() 函式，數字函式
Math.floor() 函式，數字函式
Math.round() 函式，透過 Math.floor()、Math.ceil() 和 Math.round() 產生整數, 數字函式

S

鷹架工具，更多工具
範圍
閉包，與誕生範圍保持連接的函數，閉包：函數保持與其誕生範圍的連接
當前範圍，陷阱：無意中共享環境
嚴格模式中的函數，函數必須在範圍的頂層聲明
全局物件，全局物件
全局變數，全局變數
透過 IIFE 導入新範圍，透過 IIFE 導入新範圍
管理環境中的變數，環境：管理變數
範圍和環境鏈，環境：管理變數
變數的範圍，背景：變數的範圍
物件的封裝，封裝
搜尋和比較字串，搜尋和比較
設定器（請參閱存取器）
遮蔽變數，背景：變數的範圍
位移運算子
位元位移運算子，位元位移運算子
將數字轉換為整數，位移運算子
shim，shim 與 polyfill
短路（二元邏輯運算子），二元邏輯運算子，二元邏輯運算子：And (&&) 和 Or (||)
符號（數字的國際表示法），數字的內部表示法
有符號 32 位元整數，有符號 32 位元整數
有符號零，兩個零–區分兩個零
單行註解，註解，註解
原始碼，JavaScript 部署為，JavaScript 的本質
稀疏陣列，稀疏陣列與稠密陣列
正規表示式中的特殊字元，原子：一般，引用文字
堆疊追蹤，堆疊追蹤
標準函式庫，標準函式庫的其他功能
ECMAScript 5 中的新功能，標準函式庫中的新功能
陳述式，宣告和指派變數–偵錯器陳述式
迴圈和條件式主體，迴圈和條件式主體
條件式，條件式
串接 if 陳述式，串接 if 陳述式
if-then-else，if-then-else
條件式陳述式與條件式表達式，條件式陳述式與條件式表達式
偵錯器，偵錯器陳述式
宣告和指派變數，宣告和指派變數
已定義，陳述式
空值，空值陳述式
表達式與，陳述式與表達式
迴圈，迴圈，迴圈和條件式主體
(另請參閱迴圈)
用於迴圈的機制，用於迴圈的機制
switch，switch–switch
throw，throw
try-catch-finally，try-catch-finally
使用不明確表達式作為，使用不明確表達式作為陳述式
with，with 陳述式–棄用的理由
靜態維度（變數），環境：管理變數
靜態語意，背景：靜態與動態
靜態類型，靜態類型與動態類型
嚴格相等，相等運算子
嚴格模式，嚴格模式，開啟嚴格模式–嚴格模式中禁止的功能，廣泛接受的最佳實務
arguments 變數，arguments 的已棄用功能
eval() 函式，eval() 在嚴格模式中較為簡潔，在嚴格模式中使用 eval()
明確變數宣告，需求於 嚴格模式中必須宣告變數
函式於 函式必須宣告於作用域的頂層
屬性的非法操作，設定和刪除不可變的屬性會在嚴格模式中失敗並產生例外
在 ECMAScript 5 中，新功能
無法刪除未限定的識別碼於 未限定的識別碼無法在嚴格模式中刪除
避免忘記使用建構函式的 new，避免忘記 new：嚴格模式
開啟 開啟嚴格模式
使用上的警告，嚴格模式：建議使用，但有注意事項
字串文字
跳脫於 字串文字中的跳脫
多行，在 ECMAScript 5 中，語法變更
引用，字串文字
String() 函式，函式 String
String.fromCharCode() 方法，字串建構函式方法
String.prototype.charAt() 方法，擷取子字串
String.prototype.charCodeAt() 方法，字串建構函式方法, 擷取子字串
String.prototype.concat() 方法，轉換
String.prototype.lastIndexOf() 方法，搜尋和比較
String.prototype.localeCompare() 方法，比較字串, 搜尋和比較, 比較字串
String.prototype.match() 方法，使用正規表示式測試、配對和替換, String.prototype.match：擷取群組或傳回所有配對的子字串
String.prototype.replace() 方法，使用正規表示式測試、配對和替換, String.prototype.replace：搜尋和替換
String.prototype.search() 方法，String.prototype.search：在什麼索引處有配對？
String.prototype.slice() 方法，擷取子字串
String.prototype.split() 方法，擷取子字串
String.prototype.substring() 方法，擷取子字串
String.prototype.toLocaleLowerCase() 方法，轉換
String.prototype.toLocaleUpperCase() 方法，轉換
String.prototype.toLowerCase() 方法，轉換
String.prototype.toUpperCase() 方法，轉換
String.prototype.trim() 方法，轉換
字串，字串, 語法概觀, 原始值, 字串–使用正規表示式測試、配對和替換
字元存取，字元存取
比較，比較字串
在排序陣列時比較，比較字串
比較，演算法
串接，串接字串
串接字串片段陣列，串接：串接字串片段陣列
轉換為布林值，寬鬆相等與，陷阱：寬鬆相等與轉換為布林值不同
轉換日期為，將日期轉換為字串
轉換物件為，陷阱：所有物件皆為真值
轉換為整數，透過 parseInt() 轉換為整數
轉換為數字，轉換為數字
使用 parseFloat()，parseFloat()
轉換值為，轉換為布林值、數字、字串和物件的函式, 轉換為字串
陷阱，轉換無法逆轉，陷阱：轉換無法逆轉
JavaScript 字串與 Unicode，JavaScript 字串與 Unicode
計算字元數，計算字元數
跳脫序列，跳脫序列
透過跳脫序列參照星體平面字元，透過跳脫序列參照星體平面字元
Unicode 正規化，Unicode 正規化
JSON，資料格式
長度屬性，字串實例屬性 length
寬鬆相等與，陷阱：寬鬆相等與字串
方法，字串方法
字串中的數字，寬鬆相等比較與，用例：處理字串中的數字
字串運算子，字串運算子
原型方法，字串原型方法
擷取子字串，擷取子字串
比對並取代字串中的文字，使用正規表示式測試、比對和取代
搜尋和比對字串，搜尋和比對
轉換現有的字串，轉換
字串文字，字串文字
字串文字中的跳脫字元，字串文字中的跳脫字元
String() 函式，String 函式
toString() 方法，轉換為基本型別
基本型別的包裝物件，基本型別的包裝物件
風格指南，現有的風格指南
內建類別的子類化，內建類別的子類化–另一種解決方案：委派
委派作為替代方案，另一種解決方案：委派
障礙 1，具有內部屬性的實例，障礙 1：具有內部屬性的實例
障礙 2，建構函式無法作為函式呼叫，障礙 2：無法作為函式呼叫的建構函式
JSDoc 中的子類化，子類化
supercall，建立 supercall
superconstructor，參照，constructor 屬性的使用案例
代理對，Unicode 編碼，計算字元
switch 陳述式，條件式，switch–switch
SyntaxError 建構函式，錯誤建構函式

T

標籤 (JSDoc)，語法，基本標籤
this 變數，單一物件
和嚴格模式中的函式，this 在非方法函式中為未定義
和嵌套在方法中的函式，方法中的函式
避免作為隱含參數，其他
設定 this 時呼叫函式，設定 this 時呼叫函式：call()、apply() 和 bind()
提取的方法和，提取方法
函數和方法的隱含參數，this 作為函數和方法的隱含參數
提取方法時遺失，陷阱：提取方法時遺失 this
指向全域物件，全域物件
方法中的函數遮蔽，陷阱：方法中的函數遮蔽 this
在方法中使用來指稱目前物件，物件文字
throw 陳述式，switch，throw
時間，日期建構函式
(另請參閱日期)
人類可讀，將日期轉換為字串
時間格式，時間格式（無日期）
時間單位取得器和設定器，時間單位取得器和設定器
UTC（世界協調時間），日期，日期建構函式方法
ToInt32() 函數，位元或運算 (|)
ToInteger() 自訂函數，透過自訂函數 ToInteger() 取得整數
toJSON() 方法，toJSON() 方法
內建 toJSON() 方法，toJSON() 方法
toLocaleString() 方法，Object.prototype.toLocaleString()
工具，更多工具
ToPrimitive() 函數，演算法：ToPrimitive()—將值轉換為基本型別
使用範例，範例：ToPrimitive() 的實際應用
toString() 方法，手動轉換為字串，轉換為基本型別
兩個零和，最佳實務：假裝只有一個零
ToUint32() 函數，位移運算子，陣列索引詳解
轉換方法，陣列，轉換方法
真值和假值，真值和假值
陷阱，所有物件都是真值，陷阱：所有物件都是真值
try-catch-finally 陳述式，例外處理，try-catch-finally
二補數，二進位補數
型別註解 (JSDoc)，語法
型別強制轉換，強制轉換，型別強制轉換–範例：ToPrimitive() 的實際應用
轉換為原始資料型別的函式，轉換為布林值、數字、字串和物件的函式
TypeError 建構函式，錯誤建構函式
typeof 算子，使用 typeof 和 instanceof 分類值，typeof：分類原始資料型別
錯誤，typeof null 回傳物件，使用 typeof 和 instanceof 分類值，陷阱：typeof null
檢查未定義值，檢查未定義
檢查變數是否存在，檢查變數是否存在，使用案例：檢查全域變數是否存在
typeof null 的歷史，typeof null 的歷史
與 isNaN() 一起使用，陷阱：檢查值是否為 NaN
型別（請參閱資料型別）

U

UCS-2，Unicode 編碼
UglifyJS（縮小工具），外部來源程式碼，更多工具
未定義，未定義和 null，原始資料型別，未定義和 null
變更，變更未定義
檢查，使用案例：檢查未定義或 null
檢查未定義或 null，檢查未定義或 null
歷史，未定義和 null 的歷史
遺失函式參數，過多或過少參數
出現，未定義的出現
將物件屬性設定為未定義，刪除屬性
void 0 作為未定義的同義詞，void 用於什麼？
未定義值，命名空間和特殊值
檢查，檢查未定義
遺失函式參數，強制參數、強制執行最小參數個數
未初始化變數，宣告變數
Underscore.js 函式庫，四個語言函式庫
Unicode，Unicode 和 JavaScript–推薦讀物和章節來源
和正規表示式，Unicode 和正規表示式
BOM（位元組順序標記），重要的 Unicode 概念
字元屬性，重要的 Unicode 概念
字元與字形，重要的 Unicode 概念
碼點，重要的 Unicode 概念，碼點
碼元，重要的 Unicode 概念
編碼，Unicode 編碼
跳脫序列，字串文字中的跳脫
字形，重要的 Unicode 概念
歷史，Unicode 歷史
重要概念，重要的 Unicode 概念
JavaScript 正規表示式與，JavaScript 正規表示式與 Unicode
函式庫，函式庫
比對任何碼元與任何碼點，比對任何碼元與任何碼點
JavaScript 原始碼與，JavaScript 原始碼與 Unicode
原始碼外部，原始碼外部
原始碼內部，原始碼內部
JavaScript 字串與，JavaScript 字串與 Unicode
計算字元，計算字元
跳脫序列，跳脫序列
透過跳脫來參照星象平面字元，透過跳脫來參照星象平面字元
Unicode 標準化，Unicode 標準化
標準化，重要的 Unicode 概念
建議閱讀，建議閱讀與章節來源
Unicode 跳脫序列（原始碼），原始碼內部
單元測試工具，更多工具
解開原始型別，封裝與解開原始型別
URIError 建構函式，錯誤建構函式
URI
編碼與解碼，編碼與解碼文字
UTC（世界協調時間），日期，日期建構函式方法
UTF-16，字串建構函式方法，擷取子字串，Unicode 編碼
JavaScript 原始碼內部視為，原始碼內部
將 JavaScript 程式碼轉譯為，透過跳脫來參照星象平面字元
UTF-32、Unicode 編碼
UTF-8、重要的 Unicode 概念、Unicode 編碼

V

V8 (JavaScript 引擎)、JavaScript 歷史里程碑
valueOf() 方法、轉換為原始值
解除原始值包裝、包裝和解除原始值包裝
值、值–布林值、值–範例：ToPrimitive() 的實際應用
使用 typeof 和 instanceof 分類、使用 typeof 和 instanceof 分類值、使用 typeof 和 instanceof 分類值–物件運算子
轉換為物件、將任何值轉換為物件
基本類型、語法的概觀
JavaScript 類型系統、JavaScript 的類型系統
物件、物件、物件
原始值、原始值、原始值
原始值與物件、原始值與物件、原始值與物件
屬性、值
類型強制轉換、類型強制轉換–範例：ToPrimitive() 的實際應用
undefined 和 null、undefined 和 null、undefined 和 null–原始值的包裝物件
變更 undefined 值、變更 undefined
檢查 undefined 或 null、檢查 undefined 或 null
檢查 null、檢查 null
檢查 undefined、檢查 undefined
檢查 undefined 或 null、檢查 undefined 或 null
歷史，未定義和 null 的歷史
null 的出現，null 的出現
未定義的出現，未定義的出現
原生的包裝物件，原生的包裝物件–類型轉換
變數
指定值，語法的概觀
指定值，語法的概觀, 指定
檢查是否存在，檢查變數是否存在
宣告，變數和指定, 語法的概觀
宣告並指定，宣告並指定變數
文件化，文件化變數、參數和實例屬性
變數宣告的提升，函式宣告會提升, 提升
使用 IIFE 模式引入新的範圍，IIFE 模式：引入新的範圍
名稱，識別符號和變數名稱
嚴格模式中需要明確宣告，變數必須在嚴格模式中宣告
範圍和封閉，變數範圍和封閉, 宣告變數–陷阱：無意間共用環境
封閉，封閉, 封閉：函式與其誕生範圍保持連線
環境，環境：管理變數
函式範圍，變數是函式範圍
函式範圍變數，變數是函式範圍
全域物件，全域物件
全域變數，全域變數
提升的變數宣告，變數會提升, 變數宣告會提升
IIFE 應用程式，IIFE 應用程式
IIFE 變體，前置運算子，IIFE 變體：前置運算子
有參數的 IIFE，IIFE 變體：有參數的 IIFE
透過 IIFE 介紹新範圍，透過 IIFE 介紹新範圍
範圍，背景：變數的範圍
靜態與動態（語意），背景：靜態與動態
未宣告的變數在草率模式中會變成全域變數，變數宣告會提升
風格指南，變數
未初始化，未定義的發生
void 運算子，void 運算子
存在的理由，JavaScript 為什麼會有 void 運算子？
使用案例，void 用在哪裡？

W

網路平台
作為原生平台，JavaScript 歷史里程碑
JavaScript 作為其中的一部分，JavaScript 的本質
WebKit，JavaScript 歷史里程碑
WebOS，JavaScript 歷史里程碑
while 迴圈，迴圈
程式碼中的空白，語法
window 物件，跨平台考量
檢查全域變數是否存在，使用案例：檢查全域變數是否存在
在全域範圍中建立東西，使用案例：在全域範圍中建立東西
不透過 window 參照內建全域變數，使用案例：內建函式
window 的使用案例，使用案例：標記全域變數
Windows 8，JavaScript 歷史里程碑
with 陳述式，with 陳述式–不建議使用的理由
不建議使用，with 陳述式不建議使用
不建議使用的理由，不建議使用的理由
避免使用的技巧，避免使用 with 陳述式的技巧
基本資料型別的包裝物件，基本資料型別的包裝物件–類型強制轉換
封裝物件與基本型別的差異，封裝物件與基本型別不同
寬鬆相等性 (==) 無法運作，使用案例：比較封裝實例與基本型別

X

XMLHttprequest，JavaScript 歷史里程碑
XRegExp 函式庫，四種語言函式庫

Y

Yeoman 工具組，更多工具
YUI Compressor（縮小工具），更多工具

Z

零 (0)，正負，兩個零–區分兩個零
下一頁：關於作者