索引
目录
购买本书
（广告，请勿屏蔽。）

索引

关于数字索引的说明

索引条目中的链接显示为该条目出现的章节标题。因为某些章节有多个索引标记，所以一个条目有多个指向同一章节的链接并不罕见。点击任何链接都将直接跳转到文本中出现标记的位置。

符号

! (感叹号)
!= (不等) 运算符，相等运算符，相等运算符：=== 与 ==，宽松不等 (!=)
!== (严格不等) 运算符，相等运算符，相等运算符：=== 与 ==，严格不等 (!==)，普遍接受的最佳实践
检查 NaN，陷阱：检查值是否为 NaN
逻辑非运算符，布尔值和数字运算符，逻辑非 (!)
" " (双引号)
JavaScript 中的最佳实践，普遍接受的最佳实践
用于字符串字面量，字符串，字符串字面量
$ (美元符号)
在替换字符串中，使用正则表达式进行测试、匹配和替换
% (百分号)
%= 复合赋值运算符，复合赋值运算符
求余运算符，运算符，算术运算符，算术运算符
& (和号)
& (按位与) 运算符，布尔值和数字运算符，二进制按位运算符
&& (逻辑与) 运算符，二进制逻辑运算符，布尔值和数字运算符，二进制逻辑运算符：与 (&&) 和或 (||)，逻辑与 (&&)
&= (按位与赋值) 运算符，复合赋值运算符
' ' (单引号)
JavaScript 中的最佳实践，普遍接受的最佳实践
用于字符串字面量，字符串，字符串字面量
* (星号)
*= 复合赋值运算符，复合赋值运算符
乘法运算符，运算符，算术运算符
+ (加号)
++ (递增) 运算符，运算符，算术运算符，递增运算符
+= 复合赋值运算符，复合赋值运算符
+= 运算符，连接字符串，字符串运算符
加法运算符，运算符，算术运算符
字符串连接运算符，字符串运算符，字符串字面量中的转义，连接：加号 (+) 运算符
性能，连接：连接字符串片段数组
, (逗号) 运算符，逗号运算符
- (减号)
-- (递减运算符)，递增运算符
-- (递减) 运算符，运算符，算术运算符
-= 复合赋值运算符，复合赋值运算符
取反运算符，运算符，算术运算符
减法运算符，运算符，算术运算符
. (逗号)，对象字面量和数组字面量中的尾随逗号，语法变化
. (点运算符)，值
使用它调用方法，调用方法
使用它访问属性，值，点运算符 (.): 通过固定键访问属性
使用对象，备忘单：使用对象
/ (斜杠)
/* 和 */ 分隔多行注释，注释
// 分隔单行注释，注释
/= 复合赋值运算符，复合赋值运算符
除法运算符，运算符，算术运算符
0 (零)，正负，两个零–区分两个零
1TBS (一种真正的花括号风格)，1TBS (一种真正的花括号风格)
32 位整数，JavaScript 中的整数
有符号，有符号 32 位整数
通过按位运算符，通过按位运算符实现 32 位整数
64 位精度，JavaScript 数字，数字的内部表示
; (分号)
始终使用，最佳实践，普遍接受的最佳实践
在 JavaScript 代码中，分号，使用分号的规则–陷阱：ASI 可能意外地未被触发
IIFE 的终止分号，通过 IIFE 引入新作用域
< (小于)
< (小于) 运算符，排序运算符，比较字符串
<< (按位左移) 运算符，布尔值和数字运算符，移位运算符，按位移位运算符
<<= (按位左移赋值运算符)，复合赋值运算符
<= (小于等于) 运算符，排序运算符，比较字符串
= (等号)
== (相等) 运算符，相等运算符，相等运算符：=== 与 ==，普通（宽松）相等 (==, !=)
没有有效的用例，== 没有有效的用例
陷阱，陷阱：宽松相等不同于转换为布尔值
=== (严格相等) 运算符，相等运算符，相等运算符：=== 与 ==，搜索值（非破坏性），普遍接受的最佳实践
检查 undefined 或 null 值，检查 null
检查值是否为 NaN，陷阱：检查值是否为 NaN
对象与原始值比较，原始值与对象
赋值 (=) 与相等比较 (===)，语法概述，语法概述
赋值运算符，赋值运算符
设置对象属性，设置属性
> (大于)
> (大于) 运算符，排序运算符，比较字符串
>= (大于等于) 运算符，排序运算符，比较字符串
>> (按位右移) 运算符，布尔值和数字运算符，移位运算符，按位移位运算符
>>= (按位右移赋值运算符)，复合赋值运算符
>>> (按位右移零填充) 运算符，布尔值和数字运算符，移位运算符，按位移位运算符
>>>= (按位右移零填充赋值运算符)，复合赋值运算符
? (问号)
? : (条件) 运算符，条件语句与条件表达式，条件运算符 ( ? : )，比较数字
用括号括起来，语法
嵌套，条件运算符
[ ] (方括号)
访问数组元素，将参数转换为数组
访问字符串中的字符，字符访问
访问字符串中的单个字符，字符串
方括号运算符，异常属性键，方括号运算符 ([]): 通过计算键访问属性，备忘单：使用对象
计算属性键，任意属性键
创建数组和访问数组元素，数组字面量
获取和设置属性，任意属性键
\ (反斜杠)
开头字符转义序列，字符串字面量中的转义
转义字符串中的字符，字符串，字符串字面量中的转义
{ } (花括号)
封闭块，控制流语句和块
在条件和控制流语句中，条件语句
风格，花括号风格
使用它防止 if 语句中的悬挂 else，陷阱：悬挂 else
| (竖线)
按位或运算符，布尔值和数字运算符，二进制按位运算符
将数字转换为整数，按位或 (|)
|= (按位或赋值) 运算符，复合赋值运算符
|| (逻辑或) 运算符，二进制逻辑运算符，布尔值和数字运算符，二进制逻辑运算符：与 (&&) 和或 (||)，逻辑或 (||)，可选参数
模式，提供默认值，模式：提供默认值，默认值
~ (波浪号)
按位非运算符，按位非运算符
“单行注释”)，语法概述
‸ (按位异或) 运算符，布尔值和数字运算符

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.isArray() 方法，陷阱：跨域（框架或窗口），数组构造函数方法
Array.prototype，泛型方法中的缩写，泛型方法
Array.prototype.concat() 方法，连接、切片、拼接（非破坏性）
Array.prototype.every() 方法，检查方法
Array.prototype.filter() 方法，数组迭代方法，转换方法
Array.prototype.forEach() 方法，数组迭代方法，检查方法，检查方法
迭代数组元素，迭代数组
通过迭代跳过空洞，稀疏数组与密集数组
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() 构造函数，优先使用字面量而不是构造函数
泛型调用数组方法，泛型调用方法的示例
连接、切片和拼接，连接、切片、拼接（非破坏性）
连接，拼接字符串片段数组，连接：拼接字符串片段数组
将 arguments 转换为数组，将 arguments 转换为数组
创建字符代码数组，提取子字符串
数组中的空洞，数组中的空洞–从数组中删除空洞
创建，创建空洞
忽略或考虑它们的运算，哪些运算忽略空洞，哪些运算考虑它们？
删除，从数组中删除空洞
稀疏数组与密集数组，稀疏数组与密集数组
索引，数组索引
删除数组元素，删除数组元素
详细介绍，数组索引详解
in 运算符和，in 运算符和索引
迭代，迭代数组
最佳实践，最佳实践：迭代数组
不使用 for-in 循环，最佳实践：不要对数组使用 for-in
使用 for 循环，for
迭代方法，迭代（非破坏性）–归约方法
长度，length
清空数组，清空数组
清空共享数组，清空共享数组
减少数组长度，减少数组长度
增加数组长度，手动增加数组长度
最大长度，最大长度
方法，数组方法
多维，多维数组
概述，概述
属性，数组也可以有属性
原型方法，数组原型方法
ECMAScript 5 中的新增功能，新方法
搜索值，搜索值（非破坏性）
排序和反转元素，排序和反转元素（破坏性）
将字符串拆分为子字符串数组，提取子字符串
在 JavaScript 中过于灵活，怪癖和非正统功能
使用假设的三点运算符 (...) 转换为 arguments，示例，构造函数的 apply()
使用 Array() 构造函数，数组构造函数
避免使用元素初始化数组，使用元素初始化数组（避免！）
创建具有给定长度的空数组，创建具有给定长度的空数组
ASI（自动分号插入），自动分号插入
示例，通过右括号进行 ASI，示例：通过右括号进行 ASI
示例，通过非法标记进行 ASI，示例：通过非法标记进行 ASI
陷阱，ASI 未按预期触发，陷阱：ASI 可能未按预期触发
陷阱，意外拆分语句，陷阱：ASI 可能会意外拆分语句
正则表达式中的断言，断言，正则表达式速查表
后视断言，手动实现，手动实现后视断言
没有断言的正则表达式，陷阱：如果没有断言（例如，^，$），则会在任何地方找到正则表达式
赋值，赋值
赋值给属性，属性：定义与赋值
继承的只读属性，无法赋值给继承的只读属性
复合赋值运算符，复合赋值运算符
使用点运算符赋值给属性，值
赋值运算符 (=)，语法概述，语法概述，赋值运算符
赋值运算符，复合，复合赋值运算符
异步模块定义 (AMD)，模块系统
属性（属性），属性的迭代和检测，属性特性和属性描述符
所有属性共有，属性特性
默认值，默认值
通过属性描述符获取和设置，通过描述符获取和定义属性
通过属性描述符管理，元编程
密封以防止更改，密封
自动分号插入（参见 ASI）

B

正则表达式中的反向引用，原子：组
最佳实践（编码风格），普遍接受的最佳实践
二元逻辑运算符，二元逻辑运算符，二元逻辑运算符：与 (&&) 和或 (||)
二进制数，输入和输出，输入和输出二进制数
数字的二进制表示，数字的内部表示
bind() 方法, 提取方法, func.bind(thisValue, arg1, ..., argN)
通过以下方式创建构造函数, 手动模拟构造函数的 apply()
防止 this 被遮蔽, 解决方法 2：bind()
按位运算符, 布尔值和数字的运算符, JavaScript 中的整数, 按位运算符
二进制, 二进制按位运算符
按位移位运算符, 按位移位运算符
将数字转换为整数, 通过按位运算符实现 32 位整数–我应该使用按位运算符强制转换为整数吗？
块级作用域, 变量是函数作用域的
通过 IIFE 模拟, 通过 IIFE 引入新的作用域
块
用以下内容替换语句, 控制流语句和块
分号 (;) 终止, 分号
以以下内容结尾的语句，没有分号, 以块结尾的语句后没有分号
将 for 用作循环体, 循环和条件语句的循环体
BOM（字节顺序标记）, 重要的 Unicode 概念
Boolean() 函数, 转换为布尔值、数字、字符串和对象的函数, 手动转换为布尔值
布尔值, 布尔值, 语法概述, 原始值, 布尔值–相等运算符、排序运算符
转换为布尔值和宽松相等, 陷阱：宽松相等与转换为布尔值不同
将值转换为布尔值, 转换为布尔值、数字、字符串和对象的函数, 转换为布尔值, 手动转换为布尔值
将 Boolean() 作为构造函数调用, 手动转换为布尔值
逻辑非 (!) 运算符, 逻辑非 (!)
布尔值的运算符, 布尔值和数字的运算符
真值和假值, 真值和假值
布尔值的包装对象, 原始值的包装对象
拆箱, 包装和拆箱原始值
Bower（包管理器）, 包管理器
大括号样式, 大括号样式
方括号运算符 ([]), 不常见的属性键, 备忘单：使用对象
通过以下方式访问属性, 方括号运算符 ([]): 通过计算键访问属性
通过以下方式调用方法, 通过方括号运算符调用方法
通过以下方式删除属性, 通过方括号运算符删除属性
通过以下方式设置属性, 通过方括号运算符设置属性
循环中的 break 语句, 循环, 与循环一起使用的机制
浏览器作为操作系统, JavaScript 历史里程碑
Browserify, 包管理器
浏览器
用于输入 JavaScript 的控制台, JavaScript 命令行
全局对象，window, 跨平台注意事项
javascript: URL 和, void 的用途是什么？
旧版浏览器，使用技巧, 使用旧版浏览器的技巧
浏览器的包管理器, 包管理器
构建工具, 更多工具
字节顺序标记 (BOM), 重要的 Unicode 概念

C 语言

call() 方法（参见 Function.prototype.call() 方法）
回调和提取的方法, 回调和提取的方法
大小写
将字符串转换为小写, 转换
将字符串转换为大写, 转换
switch 语句中的 case 子句, 条件语句, switch
catch 子句
在 try-catch 语句中, 异常处理, constructor 属性的用例
在 try-catch-finally 语句中, try-catch-finally
正则表达式中的字符类转义, 原子：常规
正则表达式中的字符类, 原子：字符类
字符转义序列, 字符串字面量中的转义
正则表达式中的字符转义, 原子：常规
字符属性, 重要的 Unicode 概念
字符
在字符串中访问, 字符访问
和字素簇, 重要的 Unicode 概念
Chrome 操作系统, JavaScript 历史里程碑
CJS（CommonJS 模块）, 模块系统
类，文档化（JSDoc）
子类化, 子类化
类，文档化（JSDoc）, 语法, 文档化类
通过构造函数定义类, 通过构造函数定义类
通过对象字面量定义类, 通过对象字面量定义类
通过带有 @constructs 方法的对象字面量定义类
带有 @constructs 方法的对象字面量, 通过带有 @constructs 方法的对象字面量定义类
Closure Compiler, 更多工具
闭包, 闭包, 闭包：函数与其诞生作用域保持连接
避免用于私有数据, 面向对象
定义, 闭包：函数与其诞生作用域保持连接
通过环境处理, 通过环境处理闭包
无意中共享环境, 陷阱：无意中共享环境
代码点, 重要的 Unicode 概念, 代码点
使用正则表达式匹配任何代码点, 匹配任何代码单元和任何代码点
代码风格指南, 元代码风格指南–结论
可接受的技巧, 可接受的技巧
大括号样式, 大括号样式
普遍接受的最佳实践, 普遍接受的最佳实践
不推荐的技巧示例, 不要耍小聪明
现有的风格指南, 现有的风格指南
一般技巧, 一般技巧
易于阅读的代码, 代码应该易于理解
编写一致的代码, 代码应该一致
其他技巧, 其他
优先使用字面量而不是构造函数, 优先使用字面量而不是构造函数
语法, 有争议的规则
紧凑的空格, 语法
使用变量, 变量
代码单元, 重要的 Unicode 概念
使用正则表达式匹配任何代码单元, 匹配任何代码单元和任何代码点
强制转换, 强制转换, 类型强制转换
（另见类型强制转换）
关于强制转换的技巧, 其他
逗号运算符, 陷阱：ASI 可能意外地没有被触发, 逗号运算符
命令行, JavaScript 命令行
与命令行的交互, 命令行交互
对象和数组字面量中的尾随逗号, 语法变化
注释, 语法概述, 语法概述, 代码应该易于理解
JSDoc, JSDoc：生成 API 文档, 语法
单行和多行注释，语法, 注释, 注释
CommonJS 模块 (CJS), 模块系统
比较运算符, 排序运算符
比较字符串, 比较字符串
复合赋值运算符, 复合赋值运算符
源代码压缩, JavaScript 的本质
连接数组, 连接、切片、合并（非破坏性）
连接字符串, 字符串运算符, 连接字符串
String.prototype.concat() 方法, 转换
条件运算符 (? :), 条件语句与条件表达式, 条件运算符 ( ? : ), 比较数字
嵌套, 条件运算符
放在括号中, 语法
条件语句, 语法概述, 条件语句, 语法概述
条件语句的循环体, 循环和条件语句的循环体
链接 if 语句, 链接 if 语句
if-then-else, if-then-else
控制台 API, 控制台 API
检查和计数方法, 检查和计数
调试帮助, 用于调试的语言机制
日志记录方法, 简单日志记录
性能分析和计时方法, 性能分析和计时
跨引擎的标准化, 控制台 API 跨引擎的标准化程度如何？
构造函数, 第三层：构造函数——实例的工厂
实例的 constructor 属性, 实例的 constructor 属性
最佳实践, 最佳实践
用例, constructor 属性的用例
构造函数, 构造函数：对象的工厂, JavaScript 中函数的三个角色, 第三层：构造函数——实例的工厂–将全局数据附加到方法, 构造函数
构造函数的 apply() 方法, 构造函数的 apply()
手动模拟，手动模拟构造函数的 apply()
内置，子类化，子类化内置对象–另一种解决方案：委托
类与，在 JSDoc 中，记录类
原型属性中的数据，原型属性中的数据
在严格模式下，非方法函数中的 this 为 undefined
之间的继承，第 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 中的新增功能，新增方法
时间单位获取器和设置器，时间单位获取器和设置器
各种获取器和设置器，各种获取器和设置器
toJSON() 方法，toJSON() 方法
将日期字符串转换为日期对象，JSON.parse(text, reviver?)
debugger 语句，debugger 语句，调试的语言机制
调试，语言机制，调试的语言机制
默认值
对于可选参数，可选参数
对于属性特性，默认值
使用 || 运算符提供，模式：提供默认值，默认值
定义属性，属性：定义与赋值
委托，另一种解决方案：委托
delete 运算符，单个对象，对象运算符，删除属性
删除数组元素，删除数组元素
返回值，delete 的返回值
数字的非规范化表示，特殊指数
密集数组，稀疏数组与密集数组
破坏性和非破坏性数组方法，数组原型方法
字典模式，dict 模式：没有原型的对象是更好的映射，数组是映射，而不是元组
JavaScript 资源目录，JavaScript 资源目录
除以零，错误：除以零
区分带符号的零，区分两个零
do-while 循环，循环，do-while
文档
在 JavaScript 中查找文档，快速查找文档
使用 JSDoc 生成 API 文档，JSDoc：生成 API 文档–其他有用的标签
编写文档的技巧，代码应该易于理解
Dojo 工具包，JavaScript 历史里程碑
DOM（文档对象模型），JavaScript 历史里程碑
用于 DOM 操作的 jQuery，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 中的定义
Eich，Brendan，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 历史里程碑
正则表达式中的标志，标志，正则表达式速查表
标志 /g 的问题，标志 /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() 方法）
冻结对象，冻结
函数声明，函数
定义函数，函数声明
提升，函数声明会被提升，提升
与函数表达式的比较，哪个更好：函数声明还是函数表达式？
函数表达式，方法内部的函数，函数表达式
用作语句的歧义表达式，将歧义表达式用作语句
使用函数表达式定义函数，函数
函数声明与函数表达式的比较，哪个更好：函数声明还是函数表达式？
IIFE（立即执行函数表达式），IIFE 模式：引入新的作用域，立即执行函数表达式
（另请参阅 IIFE）
命名函数表达式，命名函数表达式
函数的名称，函数的名称
Function() 构造函数，Function 构造函数，使用 new Function() 计算代码
函数作用域变量，变量是函数作用域的
Function.prototype.apply() 方法，Function.prototype.apply(thisValue, argArray)，Function.prototype.bind(thisValue, arg1?, ..., argN?)
将数组破坏性地追加到另一个数组，添加和删除元素（破坏性）
数组中的空洞，转换为 undefined 元素，Function.prototype.apply()
Function.prototype.call() 方法，更好地控制函数调用：call()、apply() 和 bind()，Function.prototype.call(thisValue, arg1?, arg2?, ...)
函数，函数–在 JavaScript 中模拟命名参数
调用，语法概述
在设置 this 的同时调用，在设置 this 的同时调用函数：call()、apply() 和 bind()
闭包，闭包
构造函数，构造函数：对象的工厂
定义，语法概述，语法概述，定义函数
使用函数声明，函数声明
使用函数表达式，函数表达式
使用 Function() 构造函数，Function 构造函数
定义和调用，函数
文档化（JSDoc），记录函数和方法
为每个函数启用严格模式，严格模式
函数声明与函数表达式的比较，哪个更好：函数声明还是函数表达式？
处理缺少或多余的参数，处理缺少或多余的参数
arguments 变量，按索引获取所有参数：特殊变量 arguments
提升，提升
隐式返回 undefined 值，undefined 的出现
在严格模式下，函数必须在作用域的顶层声明
在方法内部，方法内部的函数
强制参数，强制最小参数个数，强制参数，强制最小参数个数
更好地控制函数调用，更好地控制函数调用：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
类数组对象和泛型方法，类数组对象和泛型方法
示例，泛型调用方法的示例
列表，所有泛型方法的列表
getter 和 setter（请参阅访问器）
全局数据，保持私有，通过 IIFE 保持全局数据私有
使用 IIFE 将全局数据附加到单例对象，将私有全局数据附加到单例对象
通过 IIFE 附加到方法，将全局数据附加到方法
对构造函数的所有内容保持私有，将全局数据保持为所有构造函数的私有数据
全局对象，全局对象
跨平台注意事项，跨平台注意事项
window 的用例，用例：标记全局变量
全局作用域，全局变量
在其中创建事物，使用 window，用例：在全局作用域中创建事物
其中的非构造函数，非构造函数
对数字进行分类和解析，对数字进行分类和解析
文本编码和解码，文本编码和解码
其中的其他变量，命名空间和特殊值
全局变量，标识符和变量名，全局变量，构造函数–命名空间和特殊值
避免创建，最佳实践：避免创建全局变量
检查是否存在，用例：检查全局变量是否存在
通过赋值给未声明的变量来创建，变量声明被提升
通过使用模块消除，模块系统导致更少的全局变量
风格检查器和，用例：风格检查器
字形，重要的 Unicode 概念
字素簇，重要的 Unicode 概念
贪婪匹配（正则表达式），量词
正则表达式中的组，原子：组
捕获组或返回所有匹配的子字符串，String.prototype.match：捕获组或返回所有匹配的子字符串
在匹配时捕获组，RegExp.prototype.exec：捕获组
Grunt，更多工具
Gulp，更多工具

H

十六进制转义序列（字符串字面量），字符串字面量中的转义，内部源代码
十六进制数字字面量，数字字面量
高代理码位，Unicode 编码
提升，提升
函数声明，函数声明被提升，哪个更好：函数声明还是函数表达式？
变量声明，函数声明被提升，变量作用域和闭包，变量被提升，变量声明被提升
数组中的空洞，删除数组元素，数组中的空洞–从数组中移除空洞
创建，创建空洞
忽略或考虑它们的运算，哪些运算忽略空洞，哪些运算考虑它们？
移除，从数组中移除空洞
稀疏数组与密集数组，稀疏数组与密集数组
宿主对象，进行超调用
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 变体：前缀运算符
使用 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：检查对象是否是给定构造函数的实例
跨域，陷阱：跨域（框架或窗口）
陷阱，不是 Object 实例的对象，陷阱：不是 Object 实例的对象
整数，数字，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–最大长度
字符串，字符串，字符串实例属性 length
词法（静态）维度（变量），环境：管理变量
词法作用域，背景：变量的作用域
词法语义，背景：静态与动态
库，其他补充 JavaScript 的技术，四个语言库–JavaScript 资源目录
JavaScript 资源目录，JavaScript 资源目录
ECMAScript 国际化 API，ECMAScript 国际化 API
在 JavaScript 中处理 Unicode，库
垫片与 polyfill，垫片与 Polyfill
字符串的换行符，字符串字面量中的转义
行终止符，JavaScript 正则表达式和 Unicode
代码风格检查工具，更多工具
字面量，优先于构造函数，优先使用字面量而不是构造函数
Lo-Dash 库，四个语言库
日志记录方法，控制台 API，简单日志记录
逻辑运算符，布尔值和数字的运算符，二元逻辑运算符：与（&&）和或（||）
缩写 if 语句，缩写 if 语句
逻辑非（!），逻辑非（!）
后行断言，手动实现，手动实现后行断言
循环，循环，循环和条件的循环体–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 开发者网络 (MDN)，快速查找文档
多维数组，多维数组
多行注释，注释，注释

N

命名访问器属性，属性的种类
命名数据属性，属性的种类
命名函数表达式，命名函数表达式，函数的名称
命名参数，命名参数–在 JavaScript 中模拟命名参数
作为描述，命名参数作为描述
可选的，可选的命名参数
可选参数作为，可选参数
在 JavaScript 中模拟，在 JavaScript 中模拟命名参数
NaN（非数字），数字，NaN，命名空间和特殊值
通过严格相等比较，陷阱：NaN
isNaN() 函数，数字函数
陷阱，检查值是否为 NaN，陷阱：检查值是否为 NaN
网景，JavaScript 的诞生
new 运算符，构造函数：对象的工厂，JavaScript 中函数的三种角色，第三层：构造函数——实例的工厂，JavaScript 中实现的 new 运算符
防止在使用构造函数时忘记 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 中的整数
内部表示，数字的内部表示
特殊指数，特殊指数
在数字字面量上调用方法，在数字字面量上调用方法
数字字面量，数字字面量
指数，指数
在字面量上调用方法，在字面量上调用方法
排序运算符，排序运算符
原型方法，Number 原型方法
特殊数字值，特殊数字值
Infinity，Infinity
NaN，NaN
两个零，两个零–区分两个零
包装对象，原始值的包装对象

O

对象字面量，对象，优雅的部分，对象字面量，备忘单：使用对象
通过空对象字面量访问 Object.prototype，通过字面量访问 Object.prototype 和 Array.prototype
歧义表达式或语句，使用歧义表达式作为语句
比 Object() 构造函数更好的选择，将任何值转换为对象
通过对象字面量定义类 (JSDoc)，通过对象字面量定义类
通过对象字面量定义访问器，通过对象字面量定义访问器
使用 eval() 求值，使用 eval() 求值对象字面量
尾随逗号，语法变化
Object() 函数，转换为布尔值、数字、字符串和对象的函数
将值转换为对象，将任何值转换为对象
作为构造函数调用，将任何值转换为对象
Object，全局变量作为元编程功能的命名空间，命名空间和特殊值
JavaScript 中的面向对象编程 (OOP)，对象和继承–备忘单：使用对象
第一层，单个对象，对象和继承–第二层：对象之间的原型关系
第二层，对象之间的原型关系，第二层：对象之间的原型关系–第三层：构造函数——实例的工厂
第三层，构造函数，实例的工厂，第三层：构造函数——实例的工厂–将全局数据附加到方法
第四层，构造函数之间的继承，第四层：构造函数之间的继承–备忘单：使用对象
风格指南，面向对象
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 实例的对象
运算符和，运算符和对象
用于的运算符，对象运算符
原始值与，原始值与对象，原始值与对象
属性特性和属性描述符，属性特性和属性描述符
保护，保护对象，备忘单：使用对象，元编程
陷阱，保护是浅层的，陷阱：保护是浅层的
通过原型共享数据，通过原型在对象之间共享数据
单个，单个对象，第一层：单个对象
用作映射
无原型对象的优点，无原型对象
最佳实践，最佳实践
字典模式，无原型对象，字典模式：无原型对象是更好的映射
中的陷阱，陷阱：将对象用作映射
与原始值相比，原始值与对象
原始值的包装对象，原始值的包装对象–类型强制转换
反码，按位非运算符
运算符，运算符–对象运算符
+（加）运算符，加法运算符 (+)
，（逗号）运算符，逗号运算符
？：（条件）运算符，条件运算符 ( ? : )
和对象，运算符和对象
算术运算符，运算符
赋值运算符，赋值运算符
二元逻辑运算符，二元逻辑运算符，布尔值和数字的运算符，二元逻辑运算符：与 (&&) 和或 (||)
将操作数强制转换为所需类型，类型强制转换
复合赋值运算符，复合赋值运算符
相等运算符，相等运算符，相等运算符：=== 与 ==–排序运算符
用于布尔值和数字，布尔值和数字的运算符
用于对象，对象运算符
用于字符串，字符串运算符
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 中的新功能，元编程
不存在或未定义，undefined 的出现
用作映射的对象，陷阱：将对象用作映射
检查属性是否存在，检查属性是否存在
收集属性键，收集属性键
获取属性值，获取属性值
继承和读取属性，陷阱 1：继承会影响读取属性
对象的属性，对象，单个对象，对象
可变性，对象
原始值的属性，原始值，原始值
值的属性，值，值
属性作为对象中的条目，第 1 层：单个对象
保留字作为属性键，语法变化
设置，设置属性
具有标记键的属性中的私有数据，具有标记键的属性中的私有数据
具有具体化键的属性中的私有数据，具有具体化键的属性中的私有数据
属性特性（参见特性）
属性描述符，属性特性和属性描述符，属性描述符
通过属性描述符定义访问器，通过属性描述符定义访问器
属性描述符的函数，通过描述符获取和定义属性
通过描述符获取和定义属性，备忘单：使用对象
通过属性描述符管理属性特性，元编程
使用属性描述符复制对象，复制对象
proto 属性，特殊属性 __proto__，陷阱 3：特殊属性 __proto__
原型属性，公共属性
原型属性中的数据，原型属性中的数据
继承原型属性，继承原型属性
非多态，避免，避免非多态原型属性
多态，多态原型属性
具有实例属性初始值的原型属性，避免，避免具有实例属性初始值的原型属性
prototype 属性，构造函数：对象的工厂
与原型关系对比，术语：两种原型
对象之间的原型关系，第 2 层：对象之间的原型关系–第 3 层：构造函数—实例的工厂
更改原型链中任何位置的属性，更改原型链中任何位置的属性
检查对象是否是另一个对象的原型，检查一个对象是否是另一个对象的原型
使用给定原型创建新对象，使用给定原型创建新对象
删除继承的属性，删除继承的属性
查找定义属性的对象，查找定义属性的对象
获取和设置原型，获取和设置原型
属性的继承，继承
覆盖属性，覆盖
读取原型，读取对象的原型
设置属性，设置属性
设置和删除仅影响自身属性，设置和删除仅影响自身属性
特殊属性 proto，特殊属性 __proto__
原型与 prototype 属性对比，术语：两种原型
公共属性（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 引入新的作用域
在环境中管理变量，环境：管理变量
作用域和环境链，环境：管理变量
变量的作用域，背景：变量的作用域
对象的密封，密封
搜索和比较字符串，搜索和比较
设置器（参见访问器）
变量遮蔽，背景：变量的作用域
移位运算符
按位移位运算符，按位移位运算符
将数字转换为整数，移位运算符
垫片，垫片与 Polyfill
短路求值（二元逻辑运算符），二元逻辑运算符，二元逻辑运算符：与（&&）和或（||）
符号（数字的国际表示法），数字的内部表示
有符号 32 位整数，有符号 32 位整数
带符号的零，两个零–区分两个零
单行注释，注释，注释
源代码，JavaScript 部署为，JavaScript 的本质
稀疏数组，稀疏数组与密集数组
正则表达式中的特殊字符，原子：通用，引用文本
堆栈跟踪，堆栈跟踪
标准库，标准库的其他功能
ECMAScript 5 中的新功能，标准库中的新功能
语句，声明和赋值变量–debugger 语句
循环和条件语句的主体，循环和条件语句的主体
条件语句，条件语句
链接 if 语句，链接 if 语句
if-then-else，if-then-else
条件语句与条件表达式，条件语句与条件表达式
debugger，debugger 语句
声明和赋值变量，声明和赋值变量
已定义，语句
空语句，空语句
表达式与语句，表达式与语句
循环，循环，循环和条件语句的主体
（另请参阅循环）
与循环一起使用的机制，与循环一起使用的机制
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 构造函数方法
String.prototype.charAt() 方法，提取子字符串
String.prototype.charCodeAt() 方法，String 构造函数方法，提取子字符串
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 属性，字符串实例属性 length
宽松相等和，陷阱：宽松相等和字符串
方法，字符串方法
字符串中的数字，宽松相等比较和，用例：处理字符串中的数字
运算符，字符串运算符
原型方法，字符串原型方法
提取子字符串，提取子字符串
匹配和替换字符串中的文本，使用正则表达式测试、匹配和替换
搜索和比较字符串，搜索和比较
转换现有字符串，转换
字符串字面量，字符串字面量
转义，字符串字面量中的转义
String() 函数，String 函数
toString() 方法，转换为原始值
包装对象，原始值的包装对象
风格指南，现有风格指南
子类化内置对象，子类化内置对象–另一种解决方案：委托
委托作为替代方案，另一种解决方案：委托
障碍 1，具有内部属性的实例，障碍 1：具有内部属性的实例
障碍 2，构造函数不能作为函数调用，障碍 2：不能作为函数调用的构造函数
JSDoc 中的子类化，子类化
超级调用，进行超级调用
超级构造函数，引用，constructor 属性的用例
代理对，Unicode 编码，计算字符数
switch 语句，条件语句，switch–switch
SyntaxError 构造函数，错误构造函数

T

标签（JSDoc），语法，基本标签
this 变量，单个对象
和严格模式下的函数，非方法函数中的 this 为 undefined
和嵌套在方法中的函数，方法内部的函数
避免作为隐式参数，其他
在设置 this 时调用函数，在设置 this 时调用函数：call()、apply() 和 bind()
提取方法和，提取方法
函数和方法的隐式参数，this 作为函数和方法的隐式参数
提取方法时丢失，陷阱：提取方法时丢失 this
指向全局对象，全局对象
被方法中的函数遮蔽，陷阱：方法内部的函数遮蔽 this
在方法中使用以引用当前对象，对象字面量
throw 语句，switch，throw
时间，Date 构造函数
（另见日期）
人类可读的，将日期转换为字符串
时间格式，时间格式（无日期）
时间单位获取器和设置器，时间单位获取器和设置器
UTC（协调世界时），日期，Date 构造函数方法
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 返回 object，使用 typeof 和 instanceof 对值进行分类，陷阱：typeof null
检查 undefined 值，检查 undefined
检查变量是否存在，检查变量是否存在，用例：检查全局变量是否存在
typeof null 的历史，typeof null 的历史
与 isNaN() 一起使用，陷阱：检查值是否为 NaN
类型（参见数据类型）

U

UCS-2，Unicode 编码
UglifyJS（压缩工具），外部源代码，更多工具
undefined，undefined 和 null，原始值，undefined 和 null
更改，更改 undefined
检查，用例：检查 undefined 或 null
检查 undefined 或 null，检查 undefined 或 null
历史，undefined 和 null 的历史
缺少函数参数，参数过多或过少
出现次数，undefined 的出现次数
将对象属性设置为，删除属性
void 0 作为同义词，void 的用途是什么？
undefined 值，命名空间和特殊值
检查，检查 undefined
缺少函数参数，强制参数，强制最小参数个数
未初始化的变量，声明变量
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（协调世界时），日期，Date 构造函数方法
UTF-16，String 构造函数方法，提取子字符串，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
历史，undefined 和 null 的历史
null 的出现，null 的出现
undefined 的出现，undefined 的出现
原始值的包装对象，原始值的包装对象–类型强制转换
变量
赋值，语法概述
赋值，语法概述，赋值
检查是否存在，检查变量是否存在
声明，变量和赋值，语法概述
声明和赋值，声明和赋值变量
文档化，变量、参数和实例属性的文档化
变量声明的提升，函数声明被提升，提升
使用 IIFE 模式引入新的作用域，IIFE 模式：引入新的作用域
名称，标识符和变量名
严格模式下需要显式声明，变量必须在严格模式下声明
作用域和闭包，变量作用域和闭包，声明变量–陷阱：无意中共享环境
闭包，闭包，闭包：函数与其诞生作用域保持连接
环境，环境：管理变量
函数作用域，变量是函数作用域的
函数作用域变量，变量是函数作用域的
全局对象，全局对象
全局变量，全局变量
提升的变量声明，变量被提升，变量声明被提升
IIFE 应用，IIFE 应用
IIFE 变体，前缀运算符，IIFE 变体：前缀运算符
带参数的 IIFE，IIFE 变体：带参数的 IIFE
通过 IIFE 引入新的作用域，通过 IIFE 引入新的作用域
作用域，背景：变量的作用域
静态与动态（语义），背景：静态与动态
未声明的变量在松散模式下变为全局变量，变量声明被提升
风格指南，变量
未初始化，undefined 的出现
void 运算符，void 运算符
存在的原因，为什么 JavaScript 有 void 运算符？
用例，void 的用途是什么？

W

Web 平台
作为原生平台，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)，正数和负数，两个零–区分两个零
下一页：关于作者