无忧 月影出书啦《JavaScript王者归来》

首先恭喜月影，当然希望好书大卖！

原文提供了样章下载1.1M，pdf格式的。

如果大家想下载可以访问源地址：

http://bbs.51js.com/viewthread.php?tid=74643&extra=&page=1

下面是来自无忧的关于《JavaScript王者归来》一书的介绍

《JavaScript王者归来》正在审稿中，预计春节前后出版~

《JavaScript王者归来》在线购买

先放出目录和样章

请大家PP，最好能帮俺写写书评，谢谢了

书名中的“王者”，并不是指我这个作者，而是指你们——偶然地停下来，饶有兴趣地翻动这本书的每一位读者。正是你们对JavaScript和Web开发的浓厚兴趣和热情，使得Web领域发生了和正在发生着翻天覆地的变化，也使得我有信心和毅力去完成这样一本厚厚的书。所以，这本书，是献给你们的，现在的和将来的JavaScript王者们！

这是一本什么样的书呢？作为作者，我很希望它能成为一本带着神奇力量的魔法书，能够将你对技术的兴趣，转化为神奇的魔力，帮助你在Web应用中写出不可思议的奇迹般的漂亮代码。当然，也许这只是我的一个美好的愿望，但是如果你是带着兴趣和热情来读这本书，并且愿意和我一起探寻JavaScript王国的奥秘，那么，这本书中一定有着能让你着迷的东西。

JavaScript是一位美丽而又难以捉摸的丛林女神，她干净利落而又变化多端，她的美丽能够带给你喜悦和幸福感，她的善变，却又让你深深地陷入困惑之中。有时候，你本能地想逃避她，内心里又离不开她。你觉得她单纯，可是你看不透她，你觉得她难以捉摸，可是她却偏偏又有着简单乖巧的一面。这样的一种语言，是充满魅力的魔法精灵，难道你就不想看清她的真面目，读懂她，让她帮助你创造出激动人心的神迹吗？来吧，翻开这本书，你的愿望能够实现。


书名：JavaScript王者归来
作者：月影
清华大学出版社
[目录]
第一部分 概论        19
第一章 从零开始        19
1.1为什么选择JavaScript?        19
1.1.1 用户的偏好：B/S模式        19
1.1.2 在什么情况下用JavaScript        20
1.1.3 对JavaScript的一些误解        20
1.1.4 警惕！脚本诱惑        22
1.1.5 隐藏在简单表象下的复杂度        22
1.1.6 令人迷惑的选择：锦上添花还是雪中送炭        23
1.1.7回到问题上来        23
1.2 JavaScript的应用范围        24
1.2.1客户端的JavaScript        24
1.2.2服务器端的JavaScript        25
1.2.3其他环境中的JavaScript        26
1.3 JavaScript的版本        26
1.3.1 浏览器中的JavaScript版本        26
1.3.2 其他版本        27
1.4 一些值得留意的特性        27
1.4.1 小把戏：神奇的魔法代码        27
1.4.2 为客户端服务        30
1.4.3 数据交互        32
1.4.4 表面上的禁忌        32
1.5 安全性和执行效率        35
1.5.1 数据安全：永远的敏感话题        35
1.5.2 实战！攻击与防范        35
1.5.3 不容马虎：时刻关注性能        38
1.6 一个例子——JavaScript编写的计算器        40
1.6.1 从需求分析开始：什么是计算器？        40
1.6.2 系统设计：如何实现计算器？        41
1.6.3 系统实现：计算器的最终实现        46
1.6.4 持续改进：迭代的软件开发过程        55
1.7 学习和使用JavaScript的几点建议        56
1.7.1 像程序员一样地思考        57
1.7.2 吝惜你的代码        59
1.7.3 学会在环境中调试        59
1.7.4 警惕小缺陷        59
1.7.5 思考先于实践        60
1.7.6 时刻回头        60
1.8 关于本书的其余部分        60
第二章 浏览器中的JavaScript        61
2.1 嵌入网页的可执行内容        61
2.1.1 在什么地方装载代码        61
2.1.2 代码的Script标签        63
2.1.3 我的代码什么时候被执行        63
2.1.4 拿来主义：引入外部文件        65
2.2 赏心悦目的特效        69
2.2.1 生命在于运动        69
2.2.2 换一种风格        69
2.2.3 我的地盘我做主        70
2.3 与用户交互        73
2.3.1 悄悄地告诉你        73
2.3.2 填错了哦        77
2.4 绕开脚本陷阱        77
2.4.1 现实并不总是完美的        77
2.4.2 不能完全相信你所见到的        78
2.5 总结        78
第三章 开发环境和调试方法        79
3.1 我能用什么来编写脚本        79
3.1.1 适合编写JavaScript的文本编辑器        79
3.2 来自浏览器的支持        82
3.2.1 主流浏览器        82
3.2.2 非主流浏览器        82
3.3 集成开发环境        83
3.3.1 什么是集成开发环境        83
3.3.2 我需要集成开发环境吗        83
3.3.3 适合JavaScript的集成开发环境        83
3.4 调试工具：提升开发效率的利器        84
3.4.1 什么是调试        84
3.4.2 原始的调试方法        84
3.4.3 适合JavaScript的调试工具        87
3.5 定位代码和调用堆栈        89
3.5.1 Step by Step：单步和断点        89
3.5.2 监视内存        89
3.5.3 追踪问题的源头：查看调用堆栈        90
3.5.4 遇到麻烦了：为什么我跟踪不到代码        91
3.6 浏览器捕获异常        91
3.6.1 异常处理机制        91
3.6.2 异常的种类        93
3.6.3 应该在什么时候“吃掉”异常        94
3.7 总结        94
第二部分 JavaScript核心        95
第四章 语言结构        95
4.1基本文法        95
4.1.1 字符集        95
4.1.2 大小写敏感        96
4.1.3 分隔符        97
4.1.4 词、句子和段落        97
4.1.5 分号        98
4.1.6 标记        99
4.1.7 注释        99
4.1.8 保留字        99
4.2常量和变量        100
4.2.1 常量和变量        100
4.2.2 变量的标识符        101
4.2.4 变量的声明        101
4.2.5 变量的作用域        102
4.3表达式和运算符        106
4.3.1 表达式        106
4.3.2 运算符概述        106
4.3.3 算术运算符        108
4.3.4 关系运算符        109
4.3.5 逻辑运算符        111
4.3.6 位运算符        112
4.3.7 赋值运算符        113
4.3.8 其他运算符        114
4.4控制语句        118
4.4.1 表达式语句        118
4.4.2 语句块        119
4.4.3 条件语句        119
4.4.4 循环语句        123
4.4.5 跳转语句        126
4.4.6 异常处理语句        129
4.4.7 其他语句        130
4.5总结        131
第五章 数据类型        132
5.1基本数据类型        132
5.1.1数值        133
5.1.2字符串        134
5.1.3布尔型        136
5.2数组和对象        137
5.2.1数组        137
5.2.2对象        138
5.3函数类型        141
5.3.1函数        141
5.4null和undefined        143
5.4.1 null        143
5.4.2 undefined        143
5.5正则表达式        144
5.5.1正则表达式常量        144
5.5.2正则表达式对象        144
5.6值类型和引用类型        144
5.6.1什么是值和值的引用        144
5.6.2使用值和使用引用        145
5.7类型识别与类型转换        148
5.7.1运行时类型识别        148
5.7.2类型的自动转换        150
5.7.3强制类型转换        151
5.7.4高级用法        154
5.8警惕数值陷阱        155
5.8.1困惑：浮点数的精度问题        155
5.8.2误差的修正        156
5.9总结        157
第六章 函数        158
6.1函数定义和函数调用        158
6.1.1 函数的定义        158
6.1.2 函数的调用        161
6.2函数的参数        162
6.2.1 形参与实参        162
6.2.2 Arguments对象        164
6.2.3 参数类型匹配        168
6.3函数的调用者和所有者        171
6.3.1 函数的调用者        171
6.3.2 函数的所有者        171
6.3.3 动态调用：外来的所有者        173
6.4函数常量和闭包        175
6.4.1 匿名的函数        175
6.4.2 函数引用        175
6.4.3 函数参数和函数返回值        176
6.4.4 高级用法        177
6.5高级抽象： Function类型和函数模版        179
6.5.1 动态创建函数        179
6.5.2 模式：函数工厂        180
6.6总结        183
第七章 对象        183
7.1什么是对象        184
7.2对象的属性和方法        184
7.2.1 对象的内置属性        184
7.2.2 为对象添加和删除属性        186
7.2.3 反射机制：枚举对象属性        188
7.3对象的构造        188
7.3.1 构造函数        188
7.3.2 缺省构造和拷贝构造        190
7.3.3 对象常量        192
7.4对象的销毁和存储单元回收        192
7.5 JavaScript内置对象        193
7.5.1 Math对象        193
7.5.2 Date对象        194
7.5.3 Error对象        196
7.5.4 其他内置对象        196
7.5.5 特殊的对象：全局对象与调用对象        196
7.6总结        197
第八章 集合        197
8.1数组和数组元素        198
8.1.1 数组的构造        198
8.1.2 数组常量        199
8.1.3 数组元素        199
8.2数组对象和方法        199
8.2.1 查找元素        199
8.2.2 添加和删除元素        200
8.2.3 集合操作        201
8.3哈希表        202
8.2.1什么是哈希表        203
8.2.2 哈希表的构造        203
8.2.3 实现HashTable类型        203
8.4高级用法        206
8.4.1 集合操作和闭包        206
8.5总结        210
第九章 字符串        211
9.1字符串的构造        211
9.1.1 字符串常量        211
9.1.2 转义序列        211
9.1.3 字符串构造函数        212
9.2字符串的使用        212
9.2.1 比较字符串        212
9.2.2 抽取和检索子串        212
9.2.3 连接拆分        213
9.2.4 模式匹配        214
9.2.5 其他方法        216
9.3字符串与字符数组        216
9.4字符串与文本处理        216
9.4.1 JavaScript棋谱阅读器（一）        217
9.5总结        221
第十章 正则表达式        222
10.1什么是正则表达式        222
10.1.1 正则表达式的概念        222
10.1.2 JavaScript中的正则表达式        222
10.2正则表达式的规则        223
10.2.1直接量字符        223
10.2.2 字符类和布尔操作        224
10.2.3 重复        224
10.2.4 选择、分组和引用        224
10.2.5 指定匹配的位置        225
10.2.6标志        225
10.3模式匹配        226
10.3.1 用于模式匹配的String方法        226
10.3.2 用于模式匹配的RegExp方法        229
10.4正则表达式包装对象        231
10.4.1 RegExp对象        231
10.4.2 RegExp的实例属性        233
10.5强大的正则表达式        233
10.5.1 分析正则表达式的局部        233
10.5.2 一个例子——强大的在线编辑器        233
10.5.3 构造新的文法        236
10.6高级用法        238
10. 7 用正则表达式处理文本        239
10.7.1 计价公式编辑器        239
10.7.2 同步滚动歌词播放器        243
10. 8 总结        247
第三部分 浏览器与DOM        248
第十一章 浏览器对象        248
11.1 Window对象        248
11.1.1 Window对象概览        248
11.1.2 Window对象的生命周期        249
11.1.3 Window属性和方法        251
11.2 Document对象        253
11.2.1 Document对象概览        253
11.2.2 动态生成的文档        254
11.2.3 Document对象的基本信息        257
11.2.4 Document对象的外观属性        258
11.2.5 子对象接口        260
11.3 对话框和状态栏        262
11.3.1 简单对话框        263
11.3.2其他类型的对话框        264
11.3.3 状态栏        274
11.4 框架        274
11.4.1 多框架应用        274
11.4.2 框架之间的关系        275
11.4.3 框架的命名        276
11.4.4 子框架中的JavaScript        276
11.4.5 框架的应用——多页签显示        277
11.5 表单和表单对象        279
11.5.1 Form对象        279
11.5.2客户端表单校验        282
11.5.3通用的客户端表单校验组件        287
11.6 其他内置对象        296
11.6.1 Navigator对象        296
11.6.2 Screen对象        297
11.6.3 Location对象        299
11.6.4 History对象        301
11.7 总结        301
第十二章 文档对象模型        301
12.1 什么是DOM        302
12.1.1 把文档表示为树        302
12.1.2 树的节点        302
12.1.3 DOM对象的通用属性和方法        304
12.1.4 HTML结构和DOM对象的关系        304
12.2 DOM与浏览器实现        306
12.2.1 DOM HTML API        306
12.2.2 DOM的级别和特性        309
12.2.3 DOM的一致性        309
12.2.4 差异性：浏览器的DOM方言        310
12.3一组“盒子”：DOM元素        310
12.3.1嵌套的“盒子”        311
12.3.2“盒子”和“盒子”内容的分类        311
12.4创建和删除节点        312
12.4.1 构造全新的节点        312
12.4.2 平面展开：通过文档元素直接创建        314
12.4.3 回收空间：删除不用的节点        316
12.5访问和操纵 DOM节点        316
12.5.1 打开每一个盒子：遍历节点        317
12.5.2 弄清层级关系：父子与兄弟        318
12.5.3 搜索特定节点        319
12.5.4 克隆节点        322
12.5.5移动节点        324
12.5.6 小技巧        327
12.6读写数据        329
12.6.1 添加、修改和删除属性        330
12.7外观与行为        331
12.7.1 DOM样式属性        331
12.7.2 显示与隐藏        331
12.7.3 改变颜色和大小        332
12.7.4 改变位置        334
12.7.5 编辑控制        335
12.7.6 改变样式        337
12.8 XML DOM        338
12.8.1 什么是XML DOM        339
12.8.2 如何使用XML DOM        339
12.9总结        341
第十三章 事件处理        342
13.1 什么是事件        342
13.1.1 消息与事件响应        342
13.1.2 浏览器的事件驱动机制        343
13.2 基本事件处理        344
13.2.1 事件和事件类型        344
13.2.2 事件的绑定        345
13.2.3 直接调用事件处理函数        345
13.2.4 事件处理函数的返回值        347
13.2.5 带参数的事件响应        347
13.2.6“this”关键字        348
13.3标准事件模型        349
13.3.1 起泡和捕捉：浏览器的事件传播        349
13.3.2 事件处理函数的注册        350
13.3.3 把对象注册为事件处理程序        351
13.3.4 事件模块和事件类型        351
13.3.5 Event接口        352
13.3.6 混合事件模型        354
13.3.7 合成事件        354
13.4浏览器的事件处理模型实现        355
13.4.1 Internet Explorer 事件模型        355
13.4.2 Netscape 4 事件模型        357
13.5回调与用户自定义事件        360
13.5.1 事件处理模式        361
13.5.2 用户事件接口的定义        363
13.5.3 事件代理和事件注册        363
13.5.4 标准模式：事件分派和接收        367
13.6一个例子——增强数据表格        370
13.6.1 什么是增强数据表格        370
13.6.2 固定表头        371
13.6.3 可变列宽        373
13.6.4 标记列        375
13.6.5 小技巧：将代码添加到样式表        377
13.7总结        378
第十四章 级联样式表        379
14.1什么是级联样式表        379
14.1.1 CSS样式和样式表        379
14.1.2 CSS的标准化        379
14.1.3 浏览器支持的CSS        383
14.2 JavaScript与CSS        383
14.2.1 CSS和DOM        383
14.2.2 CSS和IE        385
14.2.3浏览器的CSS兼容性        386
14.3 总结        386
第十五章 脚本化数据存储        386
15.1什么是cookie        387
15.1.1 浏览器和客户端cookie        387
15.1.2 cookie的属性        388
15.2 cookie的客户端存取        388
15.2.1 cookie的存储        388
15.2.2 cookie的读取        389
15.3 cookie的限制        389
15.4 cookie示例        389
15.5 cookie对象封装        392
15.5什么是userData        394
15.5.1 浏览器和客户端userData        394
15.5.2 userData的声明        394
15.5.3 userData的属性和方法        395
15.6 userData的客户端存取        395
15.6.1 userData的存储和读取        395
15.6.2 userData的安全性        396
15.7 userData的限制        396
15.8 userData与cookie的对比        396
15.9 userData示例        396
15.10总结        400
第四部分 数据交互        400
第十六章 同步和异步        400
16.1什么是同步和异步        401
16.2超时设定和时间间隔        401
16.3定时器使用——侦听与拦截        403
16.3.1 标准模式：监视器        403
16.3.2 应当注意的问题        405
16.4一个例子——漂亮的Web时钟        406
16.4.1什么是Web时钟？        406
16.4.2 最简单的Web时钟        407
16.4.3 Web时钟的设计        408
16.4.4 完整的Web时钟源代码        408
16.5总结        412
第十七章XML DOM和XML HTTP        412
17.1 什么是XML DOM对象        413
17.1.1 XML DOM简介        413
17.1.2 浏览器支持的XML DOM接口        414
17.2 XMLDOM的版本兼容性        418
17.2.1 XMLDOM的跨浏览器应用        418
17.3 错误处理        423
17.3.1 ParseError对象        423
17.3.2 包含错误信息的文档        424
17.4 XML DOM操作XML文档        424
17.4.1 访问节点        424
17.4.2 创建新节点        425
17.4.3移动和修改节点        426
17.4.4 读写节点属性和读写数据        428
17.4.5 保存文档        428
17.5 一个例子——JavaScript棋谱阅读器（二）        428
17.5.1 用XML描述棋谱        428
17.5.2 将XML棋谱转换为SGF棋谱        429
17.6 什么是XML HTTP对象        430
17.6.1 XML HTTP 对象简介        431
17.6.2 浏览器支持的XML HTTP对象        431
17.7发送请求        431
17.7.1 建立连接        432
17.7.2发送请求        432
17.8 读取和设定HTTP头        432
17.8.1 什么是HTTP头        432
17.9 服务器应答        433
17.9.1 同步和异步应答        433
17.9.2 ResponseText 和ResponseXML        435
17.10 总结        435
第十八章 Ajax简介        436
18.1什么是Ajax        436
18.1.1 Ajax并不神秘        436
18.1.2 Ajax的应用场景        436
18.1.3 Ajax的竞争对手：其他替代技术        437
18.2 Ajax初探：我的第一个Ajax程序        438
18.2.1 从常规应用开始        438
18.2.2 讨厌的页面刷新        439
18.2.3 无刷新解决方案        440
18.2.4 异步工作        441
18.3 Ajax原理剖析        442
18.3.1 XmlHttp实时通信        442
18.3.2 数据动态显示        445
18.3.3 发挥XML的能力        448
18.3.4 JavaScript绑定一切        448
18.3.5 应用背后的标准        448
18.4 Ajax范例——实时聊天工具        449
18.4.1什么是实时聊天工具        449
18.4.2需求分析：实时聊天功能的实现要点        450
18.4.3系统实现：实时聊天功能的实现        450
18.4.4小结        451
18.5 总结        451
第十九章 标准和兼容性        452
19.1标准化组织        452
19.1.1 W3C和 DOM标准        452
19.1.2 ECMA 和 JavaScript标准        452
19.1.3 互联网标准        452
19.2平台和浏览器的兼容性        453
19.2.1 最小公分母法        453
19.2.2 防御性编码        453
19.2.3 客户端探测器        453
19.2.4 特性检测        454
19.2.5 实现标准        454
19.3语言版本的兼容性        455
19.3.1 language属性        455
19.3.2 版本测试        455
19.4如何实现跨浏览器应用        456
19.4.1 取舍：划定支持范围        456
19.4.2 基础模块设计：独立兼容性检测        457
19.4.3 划分运行级别        458
19.4.4 给出正确的信息        458
19.4.5 充分的应用测试        459
19.4.6 靠近标准和就近原则        460
19.5展望未来        460
19.6总结        461
第二十章 信息安全        461
20.1用户的隐私信息        461
20.1.1 Web应用中的隐私信息        461
20.2禁止和受限制的操作        462
20.2.1 受限制的属性        462
20.2.2 受限制的操作        463
20.2.3 脚本安全级别        464
20.2.4 脚本调试        464
20.3警惕幕后的攻击者        465
20.3.1 攻击的手段        465
20.3.2 隐匿的数据流        466
20.3.3 页面伪装        466
20.3.4 发现蛛丝马迹        466
20.3.5 防范的手段        467
20.4同源策略        468
20.4.1 什么是同源策略        468
20.4.2 同源策略的利弊        469
20.4.3 突破同源策略        469
20.5安全区和签名脚本        470
20.5.1 可配置的安全策略方案        470
20.5.2 Internet Explorer的安全区        470
20.5.3 Netscape的签名脚本        470
20.6代码本身的安全：加密和混淆        470
20.6.1 为什么要加密和混淆        470
20.6.2 客户端的加密技术        471
20.6.3 代码混淆原理        472
20.6.4 JavaScript代码混淆工具        472
20.6.5 加密和混淆的结合使用        475
20.7总结        476
第五部分 超越JavaScript        477
第二十一章 面向对象        477
21.1什么是面向对象        477
21.1.1 类和对象        478
21.1.2 公有和私有：属性的封装        479
21.1.3 属性和方法的类型        480
21.2神奇的prototype        482
21.2.1 什么是prototype        482
21.2.2 prototype使用技巧        484
21.2.3 prototype的实质        492
21.2.4 prototype的价值与局限性        494
21.3继承与多态        495
21.3.1 什么是继承        495
21.3.2 实现继承的方法        496
21.3.3 单继承与多重继承        505
21.3.4 接口        507
21.3.5 多态        508
21.4构造与析构        510
21.4.1构造函数        510
21.4.2多重构造        511
21.4.3析构        512
21.5疑团！“this”迷宫        513
21.5.1 无数个陷阱：令人困扰的“this”谜团        513
21.5.2 偷梁换柱：不好的使用习惯        517
21.5.3 异步调用：谁动了我的“this”        518
21.5.4 揭开真相：JavaScript的“this”本质        518
21.5.5 困难不再：利用闭包修正“this”引用        518
21.6包装对象        519
21.6.1 区分值和引用        520
21.6.2 装箱与拆箱        521
21.7元类，类的模板        523
21.7.1 什么是元类        523
21.7.2 元类：构造类的类        523
21.7.3 为什么要用元类        525
21.7.4 类工厂        526
21.8谁才是造物主        526
21.8.1 万物适用的准则        526
21.8.2 抽象的极致        527
21.8.3 返璞归真，同源架构        529
21.9总结        530
第二十二章 闭包与函数式编程        530
22.1动态语言与闭包        530
22.1.1动态语言        530
22.1.2语法域和执行域        531
22.1.2 JavaScript的闭包        532
22.2闭包的特点与形式        533
22.2.1 闭包的内在：自治的领域        533
22.2.2 访问外部环境        535
22.2.3 闭包和面向对象        536
22.2.4 其他形式的闭包        537
22.3闭包使用的注意事项        538
22.3.1 不适合使用闭包的场合        538
22.4函数式编程        539
22.4.1 什么是函数式编程        539
22.4.3 函数式编程的优点        545
22.4.4 函数式编程的缺点        547
22.5闭包与面向对象        547
22.5.1  私有域        548
22.5.2  名字空间管理        549
22.5.3  友元        550
22.6 Python风格        551
22.6.1 最简约代码        552
22.6.2 轻量级重用        552
22.6.3 模块管理        557
22.7 总结        558
第二十三章 模块级管理        558
23.1模块化管理        558
23.1.1 模块化：代码的重用        559
23.1.2 JavaScript的模块管理        559
23.2开放封闭原则和面向接口        561
23.2.1 开放封闭原则        561
23.2.2 面向接口        561
23.3名字空间管理        562
23.3.1 什么是名字空间        562
23.3.2 为什么要用名字空间        562
23.3.3 JavaScript的名字空间管理        562
23.4调用依赖        565
23.4.1 模块的依赖性        566
23.4.2 模块依赖的管理        566
23.5用代码管理代码        567
23.5.1 运行时环境的管理        567
23.5.2 托管代码        567
23.5.3 完整的代码管理容器        568
23.6总结        571
第二十四章 动态构建        571
24.1让代码去写代码        572
24.1.1 脚本的动态解析        572
24.1.2 语法扩展：创造属于自己的语言        572
24.2 “发明”语法        573
24.2.1 正则表达式和语法解析        574
24.2.2 一个简单的语法解析器实现        577
24.3 实现自己的方言——LispScript        580
24.3.1 从JavaScript到Lisp        580
24.3.2 最初的工作        580
24.3.3 公理，表达式        582
24.3.4 七条基本公设        582
24.3.5 函数文法        586
24.3.6 定义新函数        588
24.3.7一个惊喜——_eval        590
24.3.8其他的扩展        591
24.3.9小结        591
24.3.10运行环境和代码容器        592
24.4 总结        595
第二十五章 执行效率        595
25.1为什么要讨论执行效率        595
25.1.1 来自客户的抱怨：JavaScript能有多慢        595
25.1.2 代码慢下来是谁的错        598
25.2封闭的代价        599
25.2.1 过度封装的性能问题        599
25.2.2 信息隐藏的利弊        602
25.2.3构造对象的开销        604
25.3盒子里的流火        606
25.3.1 DOM的内存开销        606
25.3.2 浏览器的内存管理        607
25.3.3 看清一个事实：内存泄漏的存在        608
25.3.4 注意：及时关闭你的“盒子”        608
25.3.5 一些误会的澄清        609
25.4 动态：魔鬼与天使        610
25.4.1 动态解析的性能分析        610
25.4.2开发效率与执行效率：永远的困难选择        612
25.4.3 优美与适用：学会经受魔鬼的诱惑        612
25.4.4 扮演客户眼中的天使        613
25.5 让代码轻舞飞扬        613
25.5.1 简单就是美：为代码瘦身        613
25.5.2 最完美的运用是不用        614
25.5.3 高度抽象是为了简化问题        614
25.5.4 逻辑和表达同样重要        615
25.5.5 保持代码的严谨        616
25.5.6 漂亮的书写风格：让阅读者心情愉快        616
25.6 总结        617
第二十六章 应用框架        617
26.1应用框架概览        617
26.1.1 什么是应用框架        618
26.1.2 应用框架的组成部分        618
26.2为什么要设计应用框架        620
26.2.1 应用框架的适用范围        620
26.2.2 应用框架的利弊        620
26.3如何设计应用框架        621
26.3.1 把握设计的目标        621
26.3.2 应用框架的设计准则        622
26.3.3 什么样的应用框架才是成熟的应用框架        622
26.3.4 应用框架的设计方法        623
26.3.5 实战！设计一个简单的应用框架        623
26.4框架的实际应用        639
26.5已存在的应用框架        647
26.5.1 Prototype        647
26.5.2 JQuery        649
26.5.3 Dojo        650
26.5.4 JSVM2        653
26.5.5 其他框架        654
26.6 总结        656