深入理解JavaScript电子书

作者简介

封面介绍

内容提要

译者简介

要感谢的人：

对本书的赞誉

前言

阅前须知

本书读者对象

未涵盖内容

本书结构

本书使用的JavaScript版本

阅前建议

本书的四部分内容

JavaScript命令行

符号说明

快速查询文档

Safari® Books Online

联系我们

致谢

审稿人

第1部分 JavaScript快速上手

第1章 基础JavaScript

1.1 背景

1.1.1 JavaScript与ECMAScript

1.1.2 JavaScript的影响和本质

1.2 语法

1.2.1 语法概述

1.2.2 语句和表达式

1.2.3 分号

1.2.4 注释

1.3 变量和赋值

1.3.1 赋值

1.3.2 复合赋值运算符

1.3.3 标识符与变量名

1.4 值

1.4.1 原始值和对象

1.4.2 原始值

1.4.3 对象

1.4.4 undefined和null

1.4.5 使用typeof和instanceof对值分类

1.5 布尔值

1.5.1 真值与假值

1.5.2 二元逻辑运算符

1.5.3 等式运算符

1.6 数字

1.7 运算符

1.8 字符串

1.8.1 字符串运算符

1.8.2 字符串方法

1.9 语句

1.9.1 条件语句

1.9.2 循环语句

1.10 函数

1.10.1 函数声明的提升特性

1.10.2 特殊的变量arguments

1.10.3 参数太多或太少

1.10.4 可选参数

1.10.5 强制参数长度

1.10.6 将arguments转换为数组

1.11 异常捕获

1.12 严格模式

1.13 变量作用域和闭包

1.13.1 变量是函数作用域的

1.13.2 变量的提升特性

1.13.3 闭包

1.13.4 IIFE模式：引入一个新的作用域

1.14 对象和构造函数

1.14.1 单一对象

1.14.2 任意属性名

1.14.3 提取方法

1.14.4 方法中的函数

1.14.5 构造函数：对象工厂

1.15 数组

1.15.1 数组字面量

1.15.2 数组方法

1.15.3 遍历数组

1.16 正则表达式

1.16.1 test()方法：匹配吗

1.16.2 exec()方法：匹配以及捕获分组

1.16.3 replace()方法：搜索和替换

1.17 Math

1.18 标准库的其他功能

第2部分 背景

第2章 为什么选择JavaScript

2.1 JavaScript可以自由使用吗

2.2 JavaScript优雅吗

2.3 JavaScript有用吗

2.3.1 图形用户界面

2.3.2 其他技术补充完善JavaScript

2.4 JavaScript有什么好用的工具吗

2.5 JavaScript是否足够快

2.6 JavaScript是广泛使用的吗

2.7 JavaScript有前途吗

2.8 结论

第3章 JavaScript的性质

3.1 古怪和非官方特性

3.2 优雅部分

3.3 影响

第4章 JavaScript是如何创造出来的

第5章 标准化：ECMAScript

第6章 JavaScript的历史里程碑

第3部分 深入JavaScript

第7章 JavaScript的语法

7.1 语法概览

7.2 注释

7.3 表达式与语句

7.3.1 表达式

7.3.2 语句

7.4 控制流语句和块

7.5 使用分号的规则

7.5.1 以块结束的语句后面没有分号

7.5.2 空语句

7.5.3 自动分号插入

7.6 合法标识符

7.7 数字字面量的方法调用

7.8 严格模式

7.8.1 启用严格模式

7.8.2 严格模式：建议与注意事项

7.8.3 严格模式中，变量必须被声明

7.8.4 严格模式下的函数

7.8.5 严格模式中，设置或者删除不可改变的属性会抛出异常

7.8.6 严格模式中的不合格标识符不能删除

7.8.7 严格模式中，eval更加简洁

7.8.8 严格模式中禁用的特性

第8章 值

8.1 JavaScript中的类型体系

8.1.1 JavaScript类型

8.1.2 静态与动态

8.1.3 静态类型与动态类型

8.1.4 静态类型检查和动态类型检查

8.1.5 强制转换

8.2 原始值和对象

8.2.1 原始值

8.2.2 对象

8.3 undefined和null

8.3.1 undefined和null的出现场景

8.3.2 检测undefined和null

8.3.3 undefined和null的历史

8.3.4 修改undefined

8.4 原始值的包装对象

8.4.1 包装对象不同于原始值

8.4.2 原始值的包装与去包装

8.4.3 原始值从包装器借调方法

8.5 强制类型转换

8.5.1 强制类型转换会隐藏bug

8.5.2 转换成布尔值、数字、字符串和对象的函数

8.5.3 算法：ToPrimitive()——将值转换为原始值

第9章 运算符

9.1 运算符和对象

9.2 赋值运算符

复合赋值运算符

9.3 等号运算符：===和==

9.3.1 严格相等（===，!==）

9.3.2 普通（宽松）相等（==，!=）

9.3.3 没有针对==的有效用例

9.4 排序运算符

算法

9.5 加号运算符（+）

算法

9.6 布尔运算符和数字运算符

9.7 特殊运算符

9.7.1 条件运算符（?:）

9.7.2 逗号运算符

9.7.3 void运算符

9.8 通过typeof和instanceof判断值类型

9.8.1 typeof：判断原始值

9.8.2 instanceof：检测对象是否是给定构造函数的实例

9.9 对象运算符

第10章 布尔类型

10.1 转换成布尔值

10.1.1 手动转换为布尔值

10.1.2 真值和假值

10.2 逻辑运算符

10.2.1 二元逻辑运算符：与(&&)和或(||)

10.2.2 逻辑与(&&)

10.2.3 逻辑或(||)

10.2.4 逻辑非(!)

10.3 等号运算符、排序运算符

10.4 Boolean函数

第11章 数字

11.1 数字字面量

11.1.1 说明

11.1.2 在字面量上调用方法

11.2 转换成数字

11.2.1 手动转换为数字

11.2.2 parseFloat()

11.3 特殊的数字值

11.3.1 NaN

11.3.2 Infinity

11.3.3 两个0

11.4 数字的内部表示

特殊的指数

11.5 处理舍入错误

11.6 JavaScript中的整型

11.6.1 整型的范围

11.6.2 将整型表示为浮点数字

11.6.3 安全的整型

11.7 转换成整数

11.7.1 通过Math.floor()，Math.ceil()和Math.round()得到整数

11.7.2 通过定制函数ToInteger()得到整数

11.7.3 通过位运算符得到32位整数

11.7.4 通过parseInt()得到整数

11.8 算术运算符

11.9 位运算符

11.9.1 背景知识

11.9.2 位运算非操作符

11.9.3 二进制位运算符

11.9.4 位运算移位操作符

11.10 Number函数

11.11 Number构造器属性

11.12 Number原型方法

11.12.1 Number.prototype.toFixed（fractionDigits？）

11.12.2 Number.prototype.toPrecision(precision?)

11.12.3 Number.prototype.toString(radix?)

11.12.4 Number.prototype.toExponential(fractionDigits?)

11.13 用于数字的函数

11.14 本章参考资料

第12章 字符串

12.1 字符串字面量

12.2 字符串字面量中的转义字符

12.3 字符访问

12.4 转换为字符串

手动转换为字符串

12.5 字符串比较

12.6 字符串拼接

12.6.1 合并：加号（+）运算符

12.6.2 合并：拼接字符串数组

12.7 字符串函数

12.8 字符串构造器方法

12.9 字符串length属性

12.10 字符串原型方法

12.10.1 提取子字符串

12.10.2 字符串的变换

12.10.3 字符串的检索和比较

12.10.4 支持正则表达式的方法

第13章 语句

13.1 声明和变量赋值

13.2 循环语句和条件语句的主体

13.3 循环

13.3.1 循环的机制

13.3.2 while

13.3.3 do-while

13.3.4 for

13.3.5 for-in

13.3.6 for each-in

13.4 条件语句

13.4.1 if-then-else

13.4.2 switch

13.5 with语句

13.5.1 语法与语义

13.5.2 with语句已被废弃

13.5.3 废弃with的原因

13.6 debugger语句

第14章 异常捕获

14.1 什么是异常捕获

14.2 JavaScript中的异常捕获

14.2.1 throw

14.2.2 try-catch-finally

14.2.3 例子

14.3 Error构造器

14.4 栈跟踪

14.5 实现一个自己的异常构造器

第15章 函数

15.1 JavaScript中函数的3种形式

15.2 术语：“形参”和“实参”

15.3 定义函数

15.3.1 函数表达式

15.3.2 函数声明

15.3.3 Function构造器

15.4 函数提升

15.5 函数的名称

15.6 哪个更好，函数声明还是函数表达式

15.7 控制函数调用：call(), apply()和bind()

15.7.1 func.apply(thisValue, argArray)

15.7.2 func.bind(thisValue, arg1, ..., argN)

15.8 参数缺失或者超出时的处理

15.8.1 通过索引访问所有参数：神奇的arguments变量

15.8.2 强制性参数，限制参数数量的最小值

15.8.3 可选参数

15.8.4 模拟参数的引用传递

15.8.5 陷阱：非预期的可选参数

15.9 具名参数

15.9.1 具名参数可作为描述信息

15.9.2 可选的具名参数

15.9.3 在JavaScript中模拟具名参数

第16章 变量：作用域、环境和闭包

16.1 定义变量

16.2 背景知识：静态性和动态性

16.3 背景知识：变量的作用域

16.4 变量以函数为作用域

16.5 变量声明的提前

16.6 通过IIFE引入新的作用域

16.6.1 IIFE变体：前缀运算符

16.6.2 IIFE变体：预内置表达式上下文

16.6.3 IIFE变体：传参的IIFE

16.6.4 IIFE的应用

16.7 全局变量

16.7.1 最佳实践：避免创建全局变量

16.7.2 模块系统可以减少全局变量的引入

16.8 全局对象

16.8.1 跨平台兼容

16.8.2 window的使用场景

16.9 环境：变量的管理

16.10 闭包：使得函数可以维持其创建时所在的作用域

16.10.1 通过环境来控制闭包

16.10.2 陷阱：不经意间的环境共用

第17章 对象与继承

17.1 第1层：单一对象

17.1.1 属性的种类

17.1.2 对象字面量

17.1.3 点运算符（.）：通过固定键值访问属性

17.1.4 特殊的属性键

17.1.5 中括号操作符（[]）：通过计算出的键访问属性

17.2 把任意值转化为对象

17.3 this作为函数和方法的隐式参数

17.3.1 在调用函数时设置this：call()，apply()和bind()

17.3.2 “用于构造函数的apply()”详细阐述了如何配合构造函数使用apply()

17.3.3 用于构造函数的apply()

17.3.4 缺陷：提取方法时丢失this

17.3.5 缺陷：方法中的函数会掩盖this

17.4 第2层：对象间的原型关系

17.4.1 继承

17.4.2 覆写

17.4.3 通过原型在对象间共享数据

17.4.4 获取和设置原型

17.4.5 特殊属性__proto__

17.4.6 设置和删除仅影响自有属性

17.5 遍历和检测属性

17.5.1 列出自有的属性键

17.5.2 列出所有的属性键

17.5.3 检测属性是否存在

17.5.4 示例

17.6 最佳实践：遍历自有属性

17.7 访问器（getter和setter）

17.7.1 通过对象字面量定义访问器

17.7.2 通过属性描述符定义访问器

17.7.3 访问器和继承

17.8 属性特性和属性描述符

17.8.1 属性特性

17.8.2 属性描述符

17.8.3 通过描述符获取和定义属性

17.8.4 复制对象

17.8.5 属性：定义与赋值

17.8.6 继承的只读属性不能被赋值

17.8.7 枚举性：最佳实践

17.9 保护对象

17.9.1 防止扩展

17.9.2 封闭

17.9.3 冻结

17.9.4 缺陷：保护是浅层的

17.10 第3层：构造函数——实例工厂

17.10.1 JavaScript中new操作符的实现

17.10.2 术语：两个原型

17.10.3 实例的constructor属性

17.10.4 instanceof运算符

17.10.5 实现构造函数的小技巧

17.11 原型属性中的数据

17.11.1 对于实例属性，避免使用带初始值的原型属性

17.11.2 避免非多态的原型属性

17.11.3 多态的原型属性

17.12 保持数据私有性

17.12.1 构造函数环境中的私有数据（Crockford私有模式）

17.12.2 使用标记的键的属性保存私有数据

17.12.3 使用具体化键的属性保存私有数据

17.12.4 通过IIFE保持全局数据私有

17.13 第4层：构造函数之间的继承

17.13.1 继承实例属性

17.13.2 继承原型属性

17.13.3 确保instanceof正常工作

17.13.4 覆写方法

17.13.5 父调用

17.13.6 避免硬编码父构造函数的名字

17.13.7 示例：构造函数继承

17.13.8 示例：内建构造函数的继承层次结构

17.13.9 反模式：原型是父构造函数的实例

17.14 所有对象的方法

17.14.1 转换为原始值

17.14.2 Object.prototype.toLocaleString()

17.14.3 原型式继承和属性

17.15 泛型方法：借用原型方法

17.15.1 通过字面量访问Object.prototype和Array.prototype

17.15.2 调用泛型方法的例子

17.15.3 类似数组的对象和泛型方法

17.15.4 所有泛型方法列表

17.16 缺陷：Object作为Map使用

17.16.1 缺陷1：继承影响读取属性

17.16.2 缺陷2：覆写会影响调用方法

17.16.3 缺陷3：特殊属性__proto__

17.16.4 字典模式：没有原型的对象更适合用作映射

17.16.5 最佳实践

17.17 备忘录：对象的使用

第18章 数组

18.1 概述

18.1.1 数组是映射，不是元组

18.1.2 数组也可以具有属性

18.2 创建数组

18.2.1 数组构造函数

18.2.2 多维数组

18.3 数组索引

18.3.1 操作符in与索引

18.3.2 删除数组元素

18.3.3 数组索引的细节

18.4 长度

18.4.1 手动增加数组的长度

18.4.2 减少数组的长度

18.4.3 最大长度

18.5 数组中的“空缺”

18.5.1 创建空缺

18.5.2 稀疏数组和密集数组

18.5.3 哪些操作会忽略空缺，而哪些不会

18.5.4 移除数组中的空缺

18.6 数组构造函数

18.7 数组原型方法

18.8 添加和删除元素（破坏性地）

18.9 排序和颠倒元素顺序（破坏性地）

18.9.1 比较数字

18.9.2 比较字符串

18.9.3 比较对象

18.10 合并、切分和连接（非破坏性地）

18.11 值的查找（非破坏性地）

18.12 迭代（非破坏性地）

18.12.1 检测方法

18.12.2 转化方法

18.12.3 归约函数

18.13 缺陷：类数组对象

18.14 最佳实践：遍历数组

第19章 正则表达式

19.1 正则表达式语法

19.1.1 原子：常规

19.1.2 原子：字符类

19.1.3 原子：分组

19.1.4 量词

19.1.5 断言

19.1.6 析取（或）

19.2 Unicode和正则表达式

19.3 创建正则表达式

19.3.1 字面量与构造函数

19.3.2 标识

19.3.3 正则表达式的实例属性

19.3.4 几个创建正则表达式的例子

19.4 RegExp.prototype.test：是否存在匹配

19.5 String.prototype.search：匹配位置的索引

19.6 RegExp.prototype.exec：捕获分组

19.6.1 首次匹配（不设置标识/g）

19.6.2 全部匹配（设置标识/g）

19.7 String.prototype.match：捕获分组或返回所有匹配的子字符串

19.8 String.prototype.replace：查找和替换

19.8.1 Replacement为字符串的情况

19.8.2 当Replacement为函数时

19.9 标识/g的一些问题

19.10 提示与技巧

19.10.1 引用文本

19.10.2 陷阱：缺少断言（例如^、$）的正则表达式可以在任意位置匹配

19.10.3 匹配一切或什么都不匹配

19.10.4 手动实现逆向查找

19.11 正则表达式备忘单

第20章 Date

20.1 Date构造函数

20.2 Date构造函数方法

20.3 Date原型方法

20.3.1 时间单位的getter和setter方法

20.3.2 各种各样的getter和setter方法

20.3.3 将日期转换成字符串

20.4 日期和时间格式

20.4.1 日期格式（无时间）

20.4.2 时间格式（无日期）

20.4.3 日期时间格式

20.5 时间值：从1970-01-01开始的毫秒数

将日期转换为数字

第21章 Math

21.1 Math属性

21.2 数值函数

21.3 三角函数

21.4 其他函数

第22章 JSON

22.1 背景

22.1.1 数据格式

22.1.2 历史

22.1.3 语法

22.2 JSON.stringify(value, replacer?, space?)

22.2.1 被JSON.stringify()忽略的数据

22.2.2 toJSON()方法

22.3 JSON.parse(text, reviver?)

22.4 通过节点访问函数转换数据

22.4.1 JSON.stringify()

22.4.2 JSON.parse()

第23章 标准全局变量

23.1 构造器

23.2 Error构造器

23.3 非构造器函数

23.3.1 文字的编码和解码

23.3.2 数值归类与数值转换

23.4 通过eval()和new Function()来动态执行JavaScript代码

23.4.1 使用eval()执行代码

23.4.2 通过new Function()执行代码

23.4.3 eval()与new Function()比较

23.4.4 最佳实践

23.4.5 结论

23.5 Console API

23.5.1 Console API在各引擎的标准程度如何

23.5.2 简单的日志记录

23.5.3 检查和计数

23.5.4 格式化的日志

23.5.5 性能和时间

23.6 名称空间和特殊值

第24章 编码和JavaScript

24.1 Unicode历史

24.2 Unicode中的重要概念

24.3 码位

24.4 Unicode编码

24.5 JavaScript源码和Unicode

24.5.1 内部源码转化

24.5.2 源码外部转化

24.6 JavaScript字符串和Unicode

24.6.1 转义序列

24.6.2 通过转义引用星际平面的字符

24.6.3 字符长度计算

24.6.4 Unicode正常化

24.7 JavaScript正则表达式和Unicode

24.7.1 匹配任意的码元以及任意的码位

24.7.2 库

24.7.3 推荐阅读的章节资源

第25章 ECMAScript 5的新特性

25.1 新特性

25.2 语法的改变

25.3 标准库的新功能

25.3.1 元编程

25.3.2 新方法

25.3.3 JSON

25.4 兼容旧浏览器的小贴士

第4部分 技巧、工具和类库

第26章 元编程风格指南

26.1 现有风格指南

26.2 通用技巧

26.2.1 代码应该具有一致性

26.2.2 代码应该易于理解

26.3 普遍认可的最佳实践

26.3.1 括号风格

26.3.2 推荐字面量而不是构造函数

26.3.3 不要自作聪明

26.3.4 可接受的技巧

26.4 具有争议的规则

26.4.1 语法

26.4.2 变量

26.4.3 面向对象

26.4.4 其他

26.5 结论

第27章 调试的语言机制

第28章 子类化内置构造函数

28.1 术语

28.2 障碍1：具有内部属性的实例

28.2.1 障碍1的解决方法

28.2.2 注意

28.3 障碍2：内置的构造函数不能作为方法调用

障碍2的解决方案

28.4 另一种解决方案：委托

第29章 JSDoc：生成API文档

29.1 JSDoc基础

29.1.1 语法

29.1.2 命名类型

29.2 基础的标签

29.3 文档记录函数和方法

29.4 行内类型信息（“行内文档注释”）

29.5 文档记录变量、参数和实例属性

29.6 文档记录类

29.6.1 通过构造函数定义类

29.6.2 通过对象字面量定义类

29.6.3 通过带有@constructs方法的对象字面量定义类

29.6.4 子类

29.7 其他有用的标签

第30章 类库

30.1 shim和polyfill

30.2 四个语言类库

30.3 ECMAScript的国际化API

30.3.1 ECMAScript的国际化API，第1版

30.3.2 它是怎么样的标准呢

30.3.3 我们可以用它做什么

30.3.4 延伸阅读

30.4 JavaScript资源目录

第31章 模块系统和包管理器

31.1 模块系统

31.2 包管理器

31.3 简单粗暴的模块实现

第32章 其他工具

第33章 接下来该做什么