ja vasc ript语言精髓与编程实践（第2版）_前端开发教程

资源名称：Javaｓｃｒｉｐｔ语言精髓与编程实践(第2版)

内容简介：

《Javaｓｃｒｉｐｔ语言精髓与编程实践(第2版)》详细讲述Javaｓｃｒｉｐｔ作为一种混合式语言的各方面特性，包括过程式、面向对象、函数式和动态语言特性等，在动态函数式语言特性方面有着尤为细致的讲述。《Javaｓｃｒｉｐｔ语言精髓与编程实践(第2版)》的主要努力之一，就是分解出这些语言原子，并重现将它们混合在一起的过程与方法。通过从复杂性到单一语言特性的还原过程，读者可了解到语言的本质，以及“层出不穷的语言特性”背后的真相。

《Javaｓｃｒｉｐｔ语言精髓与编程实践(第2版)》主要的著述目的是基于一种形式上简单的语言来讲述“语言的本质及其应用”。《Javaｓｃｒｉｐｔ语言精髓与编程实践(第2版)》详细讲述了通过框架执行过程来构造一个Javaｓｃｒｉｐｔ扩展框架的方法，并完整地讲述了框架扩展中各种设计取舍，因此可以作为研究计算机程序设计语言时的参考，用以展示现实系统如何实现经典理论中的各种编程范型。

作者简介：

周爱民（Aimingoo），国内软件开发界资深软件工程师、架构师，技术作家。有十余年的软件开发、项目管理、团队建设的经验。著有《Delphi源代码分析》、《大道至简》和《Javaｓｃｒｉｐｔ语言精髓与编程实践》等专著。

资源目录：

第1部分 语言基础

第1章 十年Javaｓｃｒｉｐｔ 3

1.1 网页中的代码 3

1.1.1 新鲜的玩意儿 3

1.1.2 第一段在网页中的代码 4

1.1.3 最初的价值 5

1.2 用Javaｓｃｒｉｐｔ来写浏览器上的应用 7

1.2.1 我要做一个聊天室 7

1.2.2 Flash的一席之地 9

1.2.3 RWC与RIA之争 10

1.3 没有框架与库的语言能怎样发展呢 12

1.3.1 做一个框架 12

1.3.2 重写框架的语言层 15

1.3.3 富浏览器端开发与AJAX 16

1.4 语言的进化 18

1.4.1 Qomo的重生 18

1.4.2 QoBean是对语言的重新组织 18

1.4.3 Javaｓｃｒｉｐｔ作为一门语言的进化 19

1.5 为Javaｓｃｒｉｐｔ正名 22

1.5.1 Javaｓｃｒｉｐｔ 22

1.5.2 Core Javaｓｃｒｉｐｔ 23

1.5.3 SpiderMonkey Javaｓｃｒｉｐｔ 24

1.5.4 ECMAｓｃｒｉｐｔ 24

1.5.5 Jｓｃｒｉｐｔ 25

1.5.6 总述 25

1.6 Javaｓｃｒｉｐｔ的应用环境 26

1.6.1 宿主环境 27

1.6.2 外壳程序 28

1.6.3 运行期环境 29

第2章 Javaｓｃｒｉｐｔ的语法 31

2.1 语法综述 31

2.1.1 标识符所绑定的语义 32

2.1.2 识别语法错误与运行错误 33

2.2 Javaｓｃｒｉｐｔ的语法：变量声明 33

2.2.1 变量的数据类型 34

2.2.1.1 基本数据类型 34

2.2.1.2 值类型与引用类型 35

2.2.2 变量声明 36

2.2.3 变量与直接量 37

2.2.3.1 字符串直接量、转义符 38

2.2.3.2 数值直接量 40

2.2.4 函数声明 41

2.3 Javaｓｃｒｉｐｔ的语法：表达式运算 42

2.3.1 一般表达式运算 43

2.3.2 逻辑运算 44

2.3.3 字符串运算 45

2.3.4 比较运算 46

2.3.4.1 等值检测 46

2.3.4.2 序列检测 48

2.3.5 赋值运算 50

2.3.6 函数调用 51

2.3.7 特殊作用的运算符 51

2.3.8 运算优先级 53

2.4 Javaｓｃｒｉｐｔ的语法：语句 55

2.4.1 表达式语句 56

2.4.1.1 一般表达式语句 57

2.4.1.2 赋值语句与隐式的变量声明 59

2.4.1.3 （显式的）变量声明语句 59

2.4.1.4 函数调用语句 61

2.4.2 分支语句 65

2.4.2.1 条件分支语句（if语句） 65

2.4.2.2 多重分支语句（switch语句） 66

2.4.3 循环语句 68

2.4.4 流程控制：一般子句 70

2.4.4.1 标签声明 70

2.4.4.2 break子句 71

2.4.4.3 continue子句 73

2.4.4.4 return子句 75

2.4.5 流程控制：异常 75

2.5 面向对象编程的语法概要 77

2.5.1 对象直接量声明与实例创建 78

2.5.1.1 使用构造器创建对象实例 78

2.5.1.2 对象直接量声明 81

2.5.1.3 数组直接量声明 82

2.5.1.4 正则表达式直接量声明 83

2.5.1.5 【ES5】在对象直接量中使用属性读写器 85

2.5.1.6 讨论：初始器与直接量的区别 86

2.5.2 对象成员 87

2.5.2.1 对象成员列举、存取和删除 87

2.5.2.2 属性存取与方法调用 91

2.5.2.3 对象及其成员的检查 92

2.5.2.4 可列举性 94

2.5.3 默认对象的指定 95

2.6 【ES5】严格模式下的语法限制 96

2.6.1 语法限制 97

2.6.2 严格模式的范围 99

2.7 运算符的二义性 100

2.7.1 加号“+”的二义性 102

2.7.2 括号“( )”的二义性 103

2.7.3 冒号“：”与标签的二义性 105

2.7.4 大括号“{ }”的二义性 106

2.7.5 逗号“,”的二义性 109

2.7.6 方括号“[ ]”的二义性 111

第2部分 语言特性及基本应用

第3章 Javaｓｃｒｉｐｔ的非函数式语言特性 117

3.1 概述 117

3.1.1 命令式语言与结构化编程 118

3.1.2 结构化的疑难 120

3.1.3 “面向对象语言”是突破吗 122

3.1.4 更高层次的抽象：接口 125

3.1.5 再论语言的分类 127

3.1.6 Javaｓｃｒｉｐｔ的语源 129

3.2 基本语法的结构化含义 131

3.2.1 基本逻辑与代码分块 131

3.2.2 模块化的层次：语法作用域 134

3.2.2.1 主要的语法作用域及其效果 135

3.2.2.2 语法作用域之间的相关性 138

3.2.3 执行流程及其变更 139

3.2.3.1 级别2：“break ＜label＞”等语法 140

3.2.3.2 级别3：return子句 143

3.2.3.3 级别4：throw语句 144

3.2.3.4 执行流程变更的内涵 145

3.2.4 模块化的效果：变量作用域 147

3.2.4.1 级别1：表达式 148

3.2.4.2 级别2：语句 149

3.2.4.3 级别3：函数（局部） 150

3.2.4.4 级别4：全局 151

3.2.4.5 变量作用域中的次序问题 153

3.2.4.6 变量作用域与变量的生存周期 154

3.2.5 语句的副作用 155

3.3 Javaｓｃｒｉｐｔ中的原型继承 157

3.3.1 空对象（null）与空的对象 158

3.3.2 原型继承的基本性质 159

3.3.3 空的对象是所有对象的基础 159

3.3.4 构造复制？写时复制？还是读遍历？ 160

3.3.5 构造过程：从函数到构造器 162

3.3.6 预定义属性与方法 163

3.3.7 原型链的维护 165

3.3.7.1 两个原型链 165

3.3.7.2 constructor属性的维护 167

3.3.7.3 内部原型链的作用 170

3.3.7.4 【ES5】在SpiderMonkey与ES5中的原型链维护 170

3.3.8 原型继承的实质 172

3.3.8.1 原型修改 172

3.3.8.2 原型继承 173

3.3.8.3 原型继承的实质：从无到有 174

3.3.8.4 如何理解“继承来的成员” 175

3.4 Javaｓｃｒｉｐｔ的对象系统 177

3.4.1 封装 177

3.4.2 多态 179

3.4.3 事件 181

3.4.4 类抄写？或原型继承？ 182

3.4.4.1 类抄写 183

3.4.4.2 原型继承存在的问题 186

3.4.4.3 如何选择继承的方式 186

3.4.5 Javaｓｃｒｉｐｔ中的对象（构造器） 187

3.4.6 不能通过继承得到的效果 190

3.5 【ES5】可定制的对象属性 192

3.5.1 属性描述符 192

3.5.1.1 （一般的）数据属性描述符 193

3.5.1.2 （带读写器的）存取属性描述符 193

3.5.1.3 直接量形式的初始器是语法格式，而非描述符 194

3.5.2 定制对象属性 195

3.5.2.1 属性声明以及获取属性描述符 195

3.5.2.2 新的对象创建方法：Object.create() 197

3.5.3 属性状态维护 198

3.5.3.1 取属性列表 198

3.5.3.2 使用defineProperty来维护属性的性质 199

3.5.3.3 对于继承自原型的属性，修改其值的效果 200

3.5.3.4 重写原型继承来的属性的描述符 201

第4章 Javaｓｃｒｉｐｔ的函数式语言特性 203

4.1 概述 203

4.1.1 从代码风格说起 204

4.1.2 为什么常见的语言不赞同连续求值 204

4.1.3 函数式语言的渊源 206

4.2 函数式语言中的函数 208

4.2.1 函数是运算元 208

4.2.2 在函数内保存数据 209

4.2.3 函数内的运算对函数外无副作用 210

4.3 从运算式语言到函数式语言 211

4.3.1 Javaｓｃｒｉｐｔ中的几种连续运算 212

4.3.1.1 连续赋值 212

4.3.1.2 三元表达式的连用 212

4.3.1.3 一些运算连用 214

4.3.1.4 函数与方法的调用 214

4.3.2 运算式语言 216

4.3.2.1 运算的实质是值运算 216

4.3.2.2 有趣的运算：在IE和J2EE中 218

4.3.3 如何消灭掉语句 220

4.3.3.1 通过表达式消灭分支语句 221

4.3.3.2 通过函数递归消灭循环语句 222

4.3.3.3 其他可以被消灭的语句 223

4.4 函数：对运算式语言的补充和组织 224

4.4.1 函数是必要的补充 224

4.4.2 函数是代码的组织形式 226

4.4.3 重新认识“函数” 227

4.4.3.1 “函数”==“lambda” 228

4.4.3.2 当运算符等义于某个函数时 228

4.4.4 Javaｓｃｒｉｐｔ语言中的函数式编程 230

4.5 Javaｓｃｒｉｐｔ中的函数 231

4.5.1 可变参数与值参数传递 231

4.5.2 非惰性求值 235

4.5.3 函数是第一型 237

4.5.4 函数是一个值 239

4.5.5 可遍历的调用栈 239

4.5.5.1 callee：我是谁 240

4.5.5.2 caller：谁呼（叫）我 242

4.6 闭包 244

4.6.1 闭包与函数实例 244

4.6.1.1 什么是闭包 245

4.6.1.2 什么是函数实例与函数引用 246

4.6.1.3 （在被调用时，）每个函数实例至少拥有一个闭包 248

4.6.2 闭包与调用对象 250

4.6.2.1 “调用对象”的局部变量维护规则 252

4.6.2.2 “全局对象”的变量维护规则 252

4.6.2.3 函数闭包与“调用对象”的生存周期 253

4.6.3 闭包相关的一些特性 255

4.6.3.1 引用与泄漏 256

4.6.3.2 函数实例拥有多个闭包的情况 258

4.6.3.3 语句或语句块中的闭包问题 260

4.6.3.4 闭包中的标识符（变量）特例 262

4.6.3.5 函数对象的闭包及其效果 265

4.6.4 闭包与可见性 266

4.6.4.1 函数闭包带来的可见性效果 266

4.6.4.2 对象闭包带来的可见性效果 269

4.6.4.3 匿名函数的闭包与可见性效果 273

4.7 【ES5】严格模式与闭包 274

4.7.1 严格模式下的执行限制 275

4.7.2 严格模式下的匿名函数递归问题 276

第5章 Javaｓｃｒｉｐｔ的动态语言特性 279

5.1 概述 279

5.1.1 动态数据类型的起源 280

5.1.2 动态执行系统的起源 280

5.1.2.1 编译系统、解释系统与编码 280

5.1.2.2 动态执行 281

5.1.3 脚本系统的起源 282

5.1.4 脚本只是一种表面的表现形式 283

5.2 动态执行 285

5.2.1 动态执行与闭包 285

5.2.1.1 eval使用全局闭包 286

5.2.1.2 eval使用当前函数的闭包 287

5.2.2 动态执行过程中的语句、表达式与值 289

5.2.3 奇特的、甚至是负面的影响 291

5.3 动态方法调用（call、apply与bind） 293

5.3.1 动态方法调用中指定this对象 293

5.3.2 丢失的this引用 295

5.3.3 栈的可见与修改 296

5.3.4 兼容性：低版本中的call()与apply() 298

5.3.5 【ES5】兼容性：ES5中的call()、apply() 301

5.3.6 【ES5】bind()方法与函数的延迟调用 302

5.4 重写 303

5.4.1 原型重写 304

5.4.2 构造器重写 305

5.4.2.1 语法声明与语句含义不一致的问题 307

5.4.2.2 对象检测的麻烦 310

5.4.2.3 构造器的原型（prototype属性）不受重写影响 311

5.4.2.4 “内部对象系统”不受影响 312

5.4.2.5 让用户对象系统影响内部对象系统 313

5.4.2.6 构造器重写对直接量声明的影响 314

5.4.2.7 构造绑定 315

5.4.2.8 内置构造器重写的概述 317

5.4.3 对象成员的重写 318

5.4.3.1 成员重写的检测 318

5.4.3.2 成员重写的删除 319

5.4.4 宿主对重写的限制 321

5.4.5 引擎对重写的限制 323

5.4.5.1 this的重写 323

5.4.5.2 语句语法中的重写 324

5.4.5.3 结构化异常处理中的重写 326

5.5 包装类：面向对象的妥协 327

5.5.1 显式包装元数据 328

5.5.2 隐式包装的过程与检测方法 329

5.5.3 包装值类型数据的必要性与问题 332

5.5.4 其他直接量与相应的构造器 333

5.5.4.1 函数特例 333

5.5.4.2 正则表达式特例 334

5.6 关联数组：对象与数组的动态特性 335

5.6.1 关联数组是对象系统的基础 336

5.6.2 用关联数组实现的索引数组 336

5.6.3 干净的对象 339

5.7 类型转换 342

5.7.1 宿主环境下的特殊类型系统 343

5.7.2 值运算：类型转换的基础 345

5.7.3 隐式转换 346

5.7.3.1 运算导致的类型转换 346

5.7.3.2 语句（语义）导致的类型转换 348

5.7.4 值类型之间的转换 348

5.7.4.1 undefined的转换 349

5.7.4.2 number的转换 349

5.7.4.3 boolean的转换 350

5.7.4.4 string的转换 351

5.7.4.5 值类型数据的显式转换 351

5.7.5 从引用到值：深入探究valueOf()方法 353

5.7.6 到字符串类型的显式转换 355

5.7.6.1 重写toString()方法 356

5.7.6.2 从数值到字符串的显式转换 357

5.7.6.3 其他类型的显式转换 358

5.7.6.4 序列化 358

第3部分 编程实践

第6章 元语言：QoBean核心技术与实现 363

6.1 QoBean语言层的基本特性 363

6.1.1 QoBean语言层概要 363

6.1.1.1 如何使用QoBean 364

6.1.1.2 QoBean中的面向对象（OOP） 365

6.1.1.3 QoBean中的接口（Interface） 367

6.1.1.4 QoBean中的切面（Aspect） 369

6.1.2 Qomo的体系结构及其与QoBean的关系 373

6.2 QoBean的元语言特性 374

6.2.1 QoBean如何理解元语言 374

6.2.2 算法与数据结构 375

6.2.2.1 引用类型与值类型的数据 376

6.2.2.2 函数调用 376

6.2.2.3 源起 377

6.2.2.4 小结 377

6.2.3 代码组织形式 379

6.2.3.1 块，以及基于块的编织 379

6.2.3.2 更强的编织 381

6.2.3.3 逻辑代码块：局部、全局，以及闭包 382

6.2.3.4 逻辑的属主 384

6.2.4 对“如何组织对象”的补充 385

6.2.4.1 原子，与原子联结的友类、友函数 386

6.2.4.2 对象唯一化 387

6.2.5 综述 390

6.3 基于元语言实现的语言特性 391

6.3.1 基于元语言的类继承框架 391

6.3.1.1 类注册过程 392

6.3.1.2 示例：实现MetaClass与MetaObject的约定 393

6.3.1.3 完整的Qomo语法实现 396

6.3.1.4 类类型树的建立 400

6.3.2 多投事件 401

6.3.3 其他语言特性的实现 403

6.4 基于元语言实现的DSL 405

6.4.1 DSL的基本设计 405

6.4.2 DSL的基本实现 406

6.4.3 DSL的基本应用 409

6.4.4 一些修补 410

6.4.5 基于严格模式的一些修补 412

第7章 一般性的动态函数式语言技巧 415

7.1 消除代码的全局变量名占用 415

7.2 一次性的构造器 417

7.3 对象充当识别器 418

7.4 识别new运算进行的构造器调用 420

7.5 使用直接量及其包装类快速调用对象方法 421

7.6 三天前是星期几 422

7.7 使用对象的值含义来构造复杂对象 423

7.8 控制字符串替换过程的基本模式 426

7.9 实现二叉树 427

7.10 将函数封装为方法 429

7.11 使用with语句来替代函数参数传递 431

7.12 使用对象闭包来重置重写 432

7.13 构造函数参数 434

7.14 使用更复杂的表达式来消减if语句 437

7.15 利用钩子函数来扩展功能 439

7.16 安全的字符串 441

附录A 术语表 443

附录B 主要引擎的特性差异列表 447

附录C 附图 449

附录D 参考书目 453

附录E 本书各版次主要修改 455

资源截图：