。
964 |
965 | 
966 |
967 | 图7-8 游戏涉及的对象
968 |
969 | 玩家对象是通过Player()构造函数来创建的，有自己的points和name属性。原型上的play()方法负责给自己加一分然后通知中介者：
970 |
971 | function Player(name) {
972 | this.points = 0;
973 | this.name = name;
974 | }
975 | Player.prototype.play = function () {
976 | this.points += 1;
977 | mediator.played();
978 | };
979 |
980 | scoreboard对象（计分板）有一个update()方法，它会在每次玩家玩完后被中介者调用。计分析根本不知道玩家的任何信息，也不保存分数，它只负责显示中介者给过来的分数：
981 |
982 | var scoreboard = {
983 |
984 | // HTML element to be updated
985 | element: document.getElementById('results'),
986 |
987 | // update the score display
988 | update: function (score) {
989 |
990 | var i, msg = '';
991 | for (i in score) {
992 |
993 | if (score.hasOwnProperty(i)) {
994 | msg += '' + i + '<\/strong>: ';
995 | msg += score[i];
996 | msg += '<\/p>';
997 | }
998 | }
999 | this.element.innerHTML = msg;
1000 | }
1001 | };
1002 |
1003 | 现在我们来看一下mediator对象（中介者）。在游戏初始化的时候，在setup()方法中创建游戏者，然后放后players属性以便后续使用。played()方法会被游戏者在每轮玩完后调用，它更新score哈希然表然后将它传给scoreboard用于显示。最后一个方法是keypress()，负责处理键盘事件，决定是哪位玩家玩的，并且通知它：
1004 |
1005 | var mediator = {
1006 |
1007 | // all the players
1008 | players: {},
1009 |
1010 | // initialization
1011 | setup: function () {
1012 | var players = this.players;
1013 | players.home = new Player('Home');
1014 | players.guest = new Player('Guest');
1015 |
1016 | },
1017 |
1018 | // someone plays, update the score
1019 | played: function () {
1020 | var players = this.players,
1021 | score = {
1022 | Home: players.home.points,
1023 | Guest: players.guest.points
1024 | };
1025 |
1026 | scoreboard.update(score);
1027 | },
1028 |
1029 | // handle user interactions
1030 | keypress: function (e) {
1031 | e = e || window.event; // IE
1032 | if (e.which === 49) { // key "1"
1033 | mediator.players.home.play();
1034 | return;
1035 | }
1036 | if (e.which === 48) { // key "0"
1037 | mediator.players.guest.play();
1038 | return;
1039 | }
1040 | }
1041 | };
1042 |
1043 | 最后一件事是初始化和结束游戏：
1044 |
1045 | // go!
1046 | mediator.setup();
1047 | window.onkeypress = mediator.keypress;
1048 |
1049 | // game over in 30 seconds
1050 | setTimeout(function () {
1051 | window.onkeypress = null;
1052 | alert('Game over!');
1053 | }, 30000);
1054 |
1055 |
1056 |
1057 | ## 观察者模式
1058 |
1059 | 观察者模式被广泛地应用于JavaScript客户端编程中。所有的浏览器事件（mouseover，keypress等）都是使用观察者模式的例子。这种模式的另一个名字叫“自定义事件”，意思是这些事件是被编写出来的，和浏览器触发的事件相对。它还有另外一个名字叫“订阅者/发布者”模式。
1060 |
1061 | 使用这个模式的最主要目的就是促进代码触解耦。在观察者模式中，一个对象订阅另一个对象的指定活动并得到通知，而不是调用另一个对象的方法。订阅者也被叫作观察者，被观察的对象叫作发布者或者被观察者（译注：subject，不知道如何翻译，第一次的时候译为“主体”，第二次译时觉得不妥，还是直接叫被观察者好了）。当一个特定的事件发生的时候，发布者会通知（调用）所有的订阅者，同时还可能以事件对象的形式传递一些消息。
1062 |
1063 |
1064 | ### 例1：杂志订阅
1065 |
1066 | 为了理解观察者模式的实现方式，我们来看一个具体的例子。我们假设有一个发布者paper，它发行一份日报和一份月刊。无论是日报还是月刊发行，有一个名叫joe的订阅者都会收到通知。
1067 |
1068 | paper对象有一个subscribers属性，它是一个数组，用来保存所有的订阅者。订阅的过程就仅仅是将订阅者放到这个数组中而已。当一个事件发生时，paper遍历这个订阅者列表，然后通知它们。通知的意思也就是调用订阅者对象的一个方法。因此，在订阅过程中，订阅者需要提供一个方法给paper对象的subscribe()。
1069 |
1070 | paper对象也可以提供unsubscribe()方法，它可以将订阅者从数组中移除。paper对象的最后一个重要的方法是publish()，它负责调用订阅者的方法。总结一下，一个发布者对象需要有这些成员：
1071 |
1072 | - subscribers
1073 |
1074 | 一个数组
1075 | - subscribe()
1076 |
1077 | 将订阅者加入数组
1078 | - unsubscribe()
1079 |
1080 | 从数组中移除订阅者
1081 | - publish()
1082 |
1083 | 遍历订阅者并调用它们订阅时提供的方法
1084 |
1085 | 所有三个方法都需要一个type参数，因为一个发布者可能触发好几种事件（比如同时发布杂志和报纸），而订阅者可以选择性地订阅其中的一种或几种。
1086 |
1087 | 因为这些成员对任何对象来说都是通用的，因此将它们作为独立对象的一部分提取出来是有意义的。然后，我们可以（通过混元模式）将它们复制到任何一个对象中，将这些对象转换为订阅者。
1088 |
1089 | 下面是这些发布者通用功能的一个示例实现，它定义了上面列出来的所有成员，还有一个辅助的visitSubscribers()方法：
1090 |
1091 | var publisher = {
1092 | subscribers: {
1093 | any: [] // event type: subscribers
1094 | },
1095 | subscribe: function (fn, type) {
1096 | type = type || 'any';
1097 | if (typeof this.subscribers[type] === "undefined") {
1098 | this.subscribers[type] = [];
1099 | }
1100 | this.subscribers[type].push(fn);
1101 | },
1102 | unsubscribe: function (fn, type) {
1103 | this.visitSubscribers('unsubscribe', fn, type);
1104 | },
1105 | publish: function (publication, type) {
1106 | this.visitSubscribers('publish', publication, type);
1107 | },
1108 | visitSubscribers: function (action, arg, type) {
1109 | var pubtype = type || 'any',
1110 | subscribers = this.subscribers[pubtype],
1111 | i,
1112 | max = subscribers.length;
1113 |
1114 | for (i = 0; i < max; i += 1) {
1115 | if (action === 'publish') {
1116 | subscribers[i](arg);
1117 | } else {
1118 | if (subscribers[i] === arg) {
1119 | subscribers.splice(i, 1);
1120 | }
1121 | }
1122 | }
1123 | }
1124 | };
1125 |
1126 | 下面这个函数接受一个对象作为参数，并通过复制通用的发布者的方法将这个对象墨迹成发布者：
1127 |
1128 | function makePublisher(o) {
1129 | var i;
1130 | for (i in publisher) {
1131 | if (publisher.hasOwnProperty(i) && typeof publisher[i] === "function") {
1132 | o[i] = publisher[i];
1133 | }
1134 | }
1135 | o.subscribers = {any: []};
1136 | }
1137 |
1138 | 现在我们来实现paper对象，它能做的事情就是发布日报和月刊：
1139 |
1140 | var paper = {
1141 | daily: function () {
1142 | this.publish("big news today");
1143 | },
1144 | monthly: function () {
1145 | this.publish("interesting analysis", "monthly");
1146 | }
1147 | };
1148 |
1149 | 将paper对象变成发布者：
1150 |
1151 | makePublisher(paper);
1152 |
1153 | 现在我们有了一个发布者，让我们再来看一下订阅者对象joe，它有两个方法：
1154 |
1155 | var joe = {
1156 | drinkCoffee: function (paper) {
1157 | console.log('Just read ' + paper);
1158 | },
1159 | sundayPreNap: function (monthly) {
1160 | console.log('About to fall asleep reading this ' + monthly);
1161 | }
1162 | };
1163 |
1164 | 现在让joe来订阅paper：
1165 |
1166 | paper.subscribe(joe.drinkCoffee);
1167 | paper.subscribe(joe.sundayPreNap, 'monthly');
1168 |
1169 | 如你所见，joe提供了一个当默认的any事件发生时被调用的方法，还提供了另一个当monthly事件发生时被调用的方法。现在让我们来触发一些事件：
1170 |
1171 | paper.daily();
1172 | paper.daily();
1173 | paper.daily();
1174 | paper.monthly();
1175 |
1176 | 这些发布行为都会调用joe的对应方法，控制台中输出的结果是：
1177 |
1178 | Just read big news today
1179 | Just read big news today
1180 | Just read big news today
1181 | About to fall asleep reading this interesting analysis
1182 |
1183 | 这里值得称道的地方就是paper对象并没有硬编码写上joe，而joe也同样没有硬编码写上paper。这里也没有知道所有事情的中介者对象。所有涉及到的对象都是松耦合的，而且在不修改代码的前提下，我们可以给paper添加更多的订阅者，同时joe也可以在任何时候取消订阅。
1184 |
1185 | 让我们更进一步，将joe也变成一个发布者。（毕竟，在博客和微博上，任何人都可以是发布者。）这样，joe变成发布者之后就可以在Twitter上更新状态：
1186 |
1187 | makePublisher(joe);
1188 | joe.tweet = function (msg) {
1189 | this.publish(msg);
1190 | };
1191 |
1192 | 现在假设paper的公关部门准备通过Twitter收集读者反馈，于是它订阅了joe，提供了一个方法readTweets()：
1193 |
1194 | paper.readTweets = function (tweet) {
1195 | alert('Call big meeting! Someone ' + tweet);
1196 | };
1197 | joe.subscribe(paper.readTweets);
1198 |
1199 | 这样每当joe发出消息时，paper就会弹出警告窗口：
1200 |
1201 | joe.tweet("hated the paper today");
1202 |
1203 | 结果是一个警告窗口：“Call big meeting! Someone hated the paper today”。
1204 |
1205 | 你可以在看到完整的源代码，并且在控制台中运行这个实例。
1206 |
1207 |
1208 | ### 例2：按键游戏
1209 |
1210 | 我们来看另一个例子。我们将实现一个和中介者模式的示例一样的按钮游戏，但这次使用观察者模式。为了让它看起来更高档，我们允许接受无限个玩家，而不限于2个。我们仍然保留用来产生玩家的Player()构造函数，也保留scoreboard对象。只有mediator会变成game对象。
1211 |
1212 | 在中介者模式中，mediator对象知道所有涉及到的对象，并且调用它们的方法。而观察者模式中的game对象不是这样，它会让对象来订阅它们感兴趣的事件。比如，scoreboard会订阅game对象的scorechange事件。
1213 |
1214 | 首先我们重新看一下通用的publisher对象，并且将它的接口做一点小修改以更贴近浏览器的情况：
1215 |
1216 | - 将publish()，subscribe()，unsubscribe()分别改为fire()，on()，remove()
1217 | - 事件的type每次都会被用到，所以把它变成三个方法的第一个参数
1218 | - 可以给订阅者的方法额外加一个context参数，以便回调方法可以用this指向它自己所属的对象
1219 |
1220 | 新的publisher对象是这样：
1221 |
1222 | var publisher = {
1223 | subscribers: {
1224 | any: []
1225 | },
1226 | on: function (type, fn, context) {
1227 | type = type || 'any';
1228 | fn = typeof fn === "function" ? fn : context[fn];
1229 |
1230 | if (typeof this.subscribers[type] === "undefined") {
1231 | this.subscribers[type] = [];
1232 | }
1233 | this.subscribers[type].push({fn: fn, context: context || this});
1234 | },
1235 | remove: function (type, fn, context) {
1236 | this.visitSubscribers('unsubscribe', type, fn, context);
1237 | },
1238 | fire: function (type, publication) {
1239 | this.visitSubscribers('publish', type, publication);
1240 | },
1241 | visitSubscribers: function (action, type, arg, context) {
1242 | var pubtype = type || 'any',
1243 | subscribers = this.subscribers[pubtype],
1244 | i,
1245 | max = subscribers ? subscribers.length : 0;
1246 |
1247 | for (i = 0; i < max; i += 1) {
1248 | if (action === 'publish') {
1249 | subscribers[i].fn.call(subscribers[i].context, arg);
1250 | } else {
1251 | if (subscribers[i].fn === arg && subscribers[i].context === context) {
1252 | subscribers.splice(i, 1);
1253 | }
1254 | }
1255 | }
1256 | }
1257 | };
1258 |
1259 |
1260 | 新的Player()构造函数是这样：
1261 |
1262 | function Player(name, key) {
1263 | this.points = 0;
1264 | this.name = name;
1265 | this.key = key;
1266 | this.fire('newplayer', this);
1267 | }
1268 |
1269 | Player.prototype.play = function () {
1270 | this.points += 1;
1271 | this.fire('play', this);
1272 | };
1273 |
1274 | 变动的部分是这个构造函数接受key，代表这个玩家在键盘上用来按之后得分的按键。（这些键预先被硬编码过。）每次创建一个新玩家的时候，一个newplayer事件也会被触发。类似的，每次有一个玩家玩的时候，会触发play事件。
1275 |
1276 | scoreboard对象和原来一样，它只是简单地将当前分数显示出来。
1277 |
1278 | game对象会关注所有的玩家，这样它就可以给出分数并且触发scorechange事件。它也会订阅浏览吕中所有的keypress事件，这样它就会知道按钮对应的玩家：
1279 |
1280 | var game = {
1281 |
1282 | keys: {},
1283 |
1284 | addPlayer: function (player) {
1285 | var key = player.key.toString().charCodeAt(0);
1286 | this.keys[key] = player;
1287 | },
1288 |
1289 | handleKeypress: function (e) {
1290 | e = e || window.event; // IE
1291 | if (game.keys[e.which]) {
1292 | game.keys[e.which].play();
1293 | }
1294 | },
1295 |
1296 | handlePlay: function (player) {
1297 | var i,
1298 | players = this.keys,
1299 | score = {};
1300 |
1301 | for (i in players) {
1302 | if (players.hasOwnProperty(i)) {
1303 | score[players[i].name] = players[i].points;
1304 | }
1305 | }
1306 | this.fire('scorechange', score);
1307 | }
1308 | };
1309 |
1310 | 用于将任意对象转变为订阅者的makePublisher()还是和之前一样。game对象会变成发布者（这样它才可以触发scorechange事件），Player.prototype也会变成发布者，以使得每个玩家对象可以触发play和newplayer事件：
1311 |
1312 | makePublisher(Player.prototype);
1313 | makePublisher(game);
1314 |
1315 | game对象订阅play和newplayer事件（以及浏览器的keypress事件），scoreboard订阅scorechange事件：
1316 |
1317 | Player.prototype.on("newplayer", "addPlayer", game);
1318 | Player.prototype.on("play", "handlePlay", game);
1319 | game.on("scorechange", scoreboard.update, scoreboard);
1320 | window.onkeypress = game.handleKeypress;
1321 |
1322 | 如你所见，on()方法允许订阅者通过函数（scoreboard.update）或者是字符串（"addPlayer"）来指定回调函数。当有提供context（如game）时，才能通过字符串来指定回调函数。
1323 |
1324 | 初始化的最后一点工作就是动态地创建玩家对象（以及它们对象的按键），用户想要多少个就可以创建多少个：
1325 |
1326 | var playername, key;
1327 | while (1) {
1328 | playername = prompt("Add player (name)");
1329 | if (!playername) {
1330 | break;
1331 | }
1332 | while (1) {
1333 | key = prompt("Key for " + playername + "?");
1334 | if (key) {
1335 | break;
1336 | }
1337 | }
1338 | new Player(playername, key);
1339 | }
1340 |
1341 | 这就是游戏的全部。你可以在看到完整的源代码并且试玩一下。
1342 |
1343 | 值得注意的是，在中介者模式中，mediator对象必须知道所有的对象，然后在适当的时机去调用对应的方法。而这个例子中，game对象会显得笨一些（译注：指知道的信息少一些），游戏依赖于对象去观察特写的事件然后触发相应的动作：如scoreboard观察scorechange事件。这使得对象之间的耦合更松了（对象间知道彼此的信息越少越好），而代价则是弄清事件和订阅者之间的对应关系会更困难一些。在这个例子中，所有的订阅行为都发生在代码中的同一个地方，而随着应用规模的境长，on()可能会被在各个地方调用（如在每个对象的初始化代码中）。这使得调试更困难一些，因为没有一个集中的地方来看这些代码并理解正在发生什么事情。在观察者模式中，你将不再能看到那种从开头一直跟到结尾的顺序执行方式。
1344 |
1345 |
1346 | ## 小结
1347 |
1348 | 在这章中你学习到了若干种流行的设计模式，并且也知道了如何在JavaScript中实现它们。我们讨论过的设计模式有：
1349 |
1350 | - 单例模式
1351 |
1352 | 只创建类的唯一一个实例。我们看了好几种可以不通过构造函数和类Java语法达成单例的方法。从另一方面来说，JavaScript中所有的对象都是单例。有时候开发者说的单例是指通过模块化模式创建的对象。
1353 | - 工厂模式
1354 |
1355 | 一种在运行时通过指定字符串来创建指定类型对象的方法。
1356 | - 遍历模式
1357 |
1358 | 通过提供API来实现复杂的自定义数据结构中的遍历和导航。
1359 | - 装饰模式
1360 |
1361 | 在运行时通过从预先定义好的装饰器对象来给被装饰对象动态添加功能。
1362 | - 策略模式
1363 |
1364 | 保持接口一致的情况下选择最好的策略来完成特写类型的任务。
1365 | - 外观模式
1366 |
1367 | 通过包装通用的（或者设计得很差的）方法来提供一个更方便的API。
1368 | - 代理模式
1369 |
1370 | 包装一个对象以控制对它的访问，通过合并操作或者是只在真正需要时执行来尽量避免开销太大的操作。
1371 | - 中介者模式
1372 |
1373 | 通过让对象不彼此沟通，只通过一个中介者对象沟通的方法来促进解耦。
1374 | - 观察者模式
1375 |
1376 | 通过创建“可被观察的对象”使它在某个事件发生时通知订阅者的方式来解耦。（也叫“订阅者/发布者”或者“自定义事件”。）
--------------------------------------------------------------------------------
/chapter8.markdown:
--------------------------------------------------------------------------------
1 | # DOM和浏览器中的模式
2 |
3 | 在本书的前面几章中，我们主要关注了JavaScript核心（ECMAScript），并没有涉及太多关于在浏览器中使用JavaScript的内容。在本章，我们将探索一些在浏览器环境中的模式，因为这是最常见的JavaScript程序环境。浏览器脚本编程也是大部分不喜欢JavaScript的人对这门语言的认知。这当然是可以理解，因为在浏览器中有非常多不一致的宿主对象和DOM实现。很明显，任何能够减轻客户端脚本编程的痛楚的最佳初中都是大有益处的。
4 |
5 | 在本章中，你会看到一些零散的模式，包括DOM编程、事件处理、远程脚本、页面脚本的加载策略以及将JavaScript部署到生产环境的步骤。
6 |
7 | 但首先，让我们来简要讨论一下如何做客户端脚本编程。
8 |
9 | ## 分离
10 |
11 | 在web应用开发中主要关注的有三种东西：
12 |
13 | - 内容
14 |
15 | 即HTML文档
16 | - 表现
17 |
18 | 指定文档样式的CSS
19 | - 行为
20 |
21 | JavaScript，用来处理用户交互和页面的动态变化
22 |
23 | 尽可能地将这三者分离可以加强应用在各种用户代理（译注：user agent，即为用户读取页面并呈现的软件，一般指浏览器）的可到达性（译注：delivery，指可被用户代理接受并理解的程度），比如图形浏览器、纯文本浏览器、用于残障人士的辅助技术、移动设备等等。分离常常是和渐进增强的思想一起实现的，我们从一个给最简单的用户代理的最基础的体验（纯HTML）开始，当用户代理的兼容性提升时再添加更多的可以为体验加分的东西。如果浏览器支持CSS，那么用户会看到文档更好的呈现。如果浏览器支持JavaScript，那文档会更像一个应用，提供更多的特性来增强用户体验。
24 |
25 | 在实践中，分离意味者：
26 |
27 | - 在关掉CSS的情况下测试页面，看页面是否仍然可用，内容是否可以呈现和阅读
28 | - 在关掉JavaScript的情况下测试页面，确保页面仍然可以完成它的主要功能，所有的链接都可以正常工作（没有href="#"的链接），表单仍然可以正常填写和提交
29 | - 不要使用内联的事件处理（如onclick）或者是内联的style属性，因为它们不属于内容层
30 | - 使用语义化的HTML元素，比如头部和列表等
31 |
32 | JavaScript（行为）层的地位不应该很显赫，也就是说它不应该成为页面正常工作必须的东西，不应该使得用户在使用不支持的浏览器操作时存在障碍。它只应该被用来增强页面。
33 |
34 | 通常比较优雅的用来处理浏览器差异的方法是特性检测。它的思想是你不应该使用浏览器类型检测来决定代码的逻辑，而是应该检测在当前环境中你需要使用的某个方法或者是属性是否存在。浏览器检测一般认为是一种“反模式”（译注：anitpattern，指不好的模式）。虽然有的情况下不可避免要使用，但它应该是最后考虑的选择，并且应该只在特性检测没有办法给出明确答案（或者造成明显性能问题）的时候使用：
35 |
36 | // antipattern
37 | if (navigator.userAgent.indexOf('MSIE') !== −1) {
38 | document.attachEvent('onclick', console.log);
39 | }
40 |
41 | // better
42 | if (document.attachEvent) {
43 | document.attachEvent('onclick', console.log);
44 | }
45 |
46 | // or even more specific
47 | if (typeof document.attachEvent !== "undefined") {
48 | document.attachEvent('onclick', console.log);
49 | }
50 |
51 | 分离也有助于开发、维护，减少升级一个现有应用的难度，因为当出现问题的时候，你知道去看哪一块。当出现一个JavaScript错误的时候，你不需要去看HTML或者是CSS就能修复它。
52 |
53 | ## DOM编程
54 |
55 | 操作页面的DOM树是在客户端JavaScript编程中最普遍的动作。这也是导致开发者头疼的最主要原因（这也导致了JavaScript名声不好），因为DOM方法在不同的浏览器中实现得有很多差异。这也是为什么使用一个抽象了浏览器差异的JavaScript库能显著提高开发速度的原因。
56 |
57 | 我们来看一些在访问和修改DOM树时推荐的模式，主要考虑点是性能方面。
58 |
59 | ### DOM访问
60 |
61 | DOM操作性能不好，这是影响JavaScript性能的最主要原因。性能不好是因为浏览器的DOM实现通常是和JavaScript引擎分离的。从浏览器的角度来讲，这样做是很有意义的，因为有可能一个JavaScript应用根本不需要DOM，而除了JavaScript之外的其它语言（如IE的VBScript）也可以用来操作页面中的DOM。
62 |
63 | 一个原则就是DOM访问的次数应该被减少到最低，这意味者：
64 |
65 | - 避免在环境中访问DOM
66 | - 将DOM引用赋给本地变量，然后操作本地变量
67 | - 当可能的时候使用selectors API
68 | - 遍历HTML collections时缓存length（见第2章）
69 |
70 | 看下面例子中的第二个（better）循环，尽管它看起来更长一些，但却要快上几十上百倍（取决于具体浏览器）：
71 |
72 | // antipattern
73 | for (var i = 0; i < 100; i += 1) {
74 | document.getElementById("result").innerHTML += i + ", ";
75 | }
76 |
77 | // better - update a local variable var i, content = "";
78 | for (i = 0; i < 100; i += 1) {
79 | content += i + ",";
80 | }
81 | document.getElementById("result").innerHTML += content;
82 |
83 | 在下一个代码片段中，第二个例子（使用了本地变量style）更好，尽管它需要多写一行代码，还需要多定义一个变量：
84 |
85 | // antipattern
86 | var padding = document.getElementById("result").style.padding,
87 | margin = document.getElementById("result").style.margin;
88 |
89 | // better
90 | var style = document.getElementById("result").style,
91 | padding = style.padding,
92 | margin = style.margin;
93 |
94 | 使用selectors API是指使用这个方法：
95 |
96 | document.querySelector("ul .selected");
97 | document.querySelectorAll("#widget .class");
98 |
99 | 这两个方法接受一个CSS选择器字符串，返回匹配这个选择器的DOM列表（译注：querySelector只返回第一个匹配的DOM）。selectors API在现代浏览器（以及IE8+）可用，它总是会比你使用其它DOM方法来做同样的选择要快。主流的JavaScript库的最近版本都已经使用了这个API，所以你有理由去检查你的项目，确保使用的是最新版本。
100 |
101 | 给你经常访问的元素加上一个id属性也是有好处的，因为document.getElementById(myid)是找到一个DOM元素最容易也是最快的方法。
102 |
103 | ### DOM操作
104 |
105 | 除了访问DOM元素之外，你可能经常需要改变它们、删除其中的一些或者是添加新的元素。更新DOM会导致浏览器重绘（repaint）屏幕，也经常导致重排(reflow)（重新计算元素的位置），这些操作代价是很高的。
106 |
107 | 再说一次，通用的原则仍然是尽量少地更新DOM，这意味着我们可以将变化集中到一起，然后在“活动的”（live）文档树之外去执行这些变化。
108 |
109 | 当你需要添加一棵相对较大的子树的时候，你应该在完成这棵树的构建之后再放到文档树中。为了达到这个目的，你可以使用文档碎片（document fragment）来包含你的节点。
110 |
111 | 不要这样添加节点：
112 |
113 | // antipattern
114 | // appending nodes as they are created
115 |
116 | var p, t;
117 |
118 | p = document.createElement('p');
119 | t = document.createTextNode('first paragraph');
120 | p.appendChild(t);
121 | document.body.appendChild(p);
122 |
123 | p = document.createElement('p');
124 | t = document.createTextNode('second paragraph');
125 | p.appendChild(t);
126 | document.body.appendChild(p);
127 |
128 | 一个更好的版本是创建一个文档碎片，然后“离线地”（译注：即不在文档树中）更新它，当它准备好之后再将它加入文档树中。当你将文档碎片添加到DOM树中时，碎片的内容将会被添加进去，而不是碎片本身。这个特性非常好用。所以当有好几个没有被包裹在同一个父元素的节点时，文档碎片是一个很好的包裹方式。
129 |
130 | 下面是使用文档碎片的例子：
131 |
132 | var p, t, frag;
133 |
134 | frag = document.createDocumentFragment();
135 |
136 | p = document.createElement('p');
137 | t = document.createTextNode('first paragraph');
138 | p.appendChild(t);
139 | frag.appendChild(p);
140 |
141 | p = document.createElement('p');
142 | t = document.createTextNode('second paragraph');
143 | p.appendChild(t);
144 | frag.appendChild(p);
145 |
146 | document.body.appendChild(frag);
147 |
148 | 这个例子和前面例子中每段更新一次相比，文档树只被更新了一下，只导致一次重排/重绘。
149 |
150 | 当你添加新的节点到文档中时，文档碎片很有用。当你需要更新已有的节点时，你也可以将这些变化集中。你可以将你要修改的子树的父节点克隆一份，然后对克隆的这份做修改，完成之后再去替换原来的元素。
151 |
152 | var oldnode = document.getElementById('result'),
153 | clone = oldnode.cloneNode(true);
154 |
155 | // work with the clone...
156 |
157 | // when you're done:
158 | oldnode.parentNode.replaceChild(clone, oldnode);
159 |
160 | ## 事件
161 |
162 | 在浏览器脚本编程中，另一块充满兼容性问题并且带来很多不愉快的区域就是浏览器事件，比如click，mouseover等等。同样的，一个JavaScript库可以解决支持IE（9以下）和W3C标准实现的双倍工作量。
163 |
164 | 我们来看一下一些主要的点，因为你在做一些简单的页面或者快速开发的时候可能不会使用已有的库，当然，也有可能你正在写你自己的库。
165 |
166 | ### 事件处理
167 |
168 | 麻烦是从给元素绑定事件开始的。假设你有一个按钮，点击它的时候增加计数器的值。你可以添加一个内联的onclick属性，这在所有的浏览器中都能正常工作，但是会违反分离和渐进增强的思想。所以你应该尽力在JavaScript中来做绑定，而不是在标签中。
169 |
170 | 假设你有下面的标签：
171 |
172 |
173 |
174 | 你可以将一个函数赋给节点的onclick属性，但你只能这样做一次：
175 |
176 | // suboptimal solution
177 | var b = document.getElementById('clickme'),
178 | count = 0;
179 | b.onclick = function () {
180 | count += 1;
181 | b.innerHTML = "Click me: " + count;
182 | };
183 |
184 | 如果你希望在按钮点击的时候执行好几个函数，那么在维持松耦合的情况下就不能用这种方法来做绑定。从技术上讲，你可以检测onclick是否已经包含一个函数，如果已经包含，就将它加到你自己的函数中，然后替换onclick的值为你的新函数。但是一个更干净的解决方案是使用addEventListener()方法。这个方法在IE8及以下版本中不存在，在这些浏览器需要使用attachEvent()。
185 |
186 | 当我们回头看条件初始化模式（第4章）时，会发现一个示例实现是一个很好的解决跨浏览器事件监听的套件。现在我们不讨论细节，只看一下如何给我们的按钮绑定事件：
187 |
188 | var b = document.getElementById('clickme');
189 | if (document.addEventListener) { // W3C
190 | b.addEventListener('click', myHandler, false);
191 | } else if (document.attachEvent) { // IE
192 | b.attachEvent('onclick', myHandler);
193 | } else { // last resort
194 | b.onclick = myHandler;
195 | }
196 |
197 | 现在当按钮被点击时，myHandler会被执行。让我们来让这个函数实现增加按钮文字“Click me: 0”中的数字的功能。为了更有趣一点，我们假设有好几个按钮，一个myHandler()函数来处理所有的按钮点击。如果我们可以从每次点击的事件对象中获取节点和节点对应的计数器值，那为每个按钮保持一个引用和计数器就显得不高效了。
198 |
199 | 我们先看一下解决方案，稍后再来做些评论：
200 |
201 | function myHandler(e) {
202 |
203 | var src, parts;
204 |
205 | // get event and source element
206 | e = e || window.event;
207 | src = e.target || e.srcElement;
208 |
209 | // actual work: update label
210 | parts = src.innerHTML.split(": ");
211 | parts[1] = parseInt(parts[1], 10) + 1;
212 | src.innerHTML = parts[0] + ": " + parts[1];
213 |
214 | // no bubble
215 | if (typeof e.stopPropagation === "function") {
216 | e.stopPropagation();
217 | }
218 | if (typeof e.cancelBubble !== "undefined") {
219 | e.cancelBubble = true;
220 | }
221 |
222 | // prevent default action
223 | if (typeof e.preventDefault === "function") {
224 | e.preventDefault();
225 | }
226 | if (typeof e.returnValue !== "undefined") {
227 | e.returnValue = false;
228 | }
229 |
230 | }
231 |
232 | 一个在线的例子可以在找到。
233 |
234 | 在这个事件处理函数中，有四个部分：
235 |
236 | - 首先，我们需要访问事件对象，它包含事件的一些信息以及触发这个事件的页面元素。事件对象会被传到事件处理回调函数中，但是使用onclick属性时需要使用全局属性window.event来获取。
237 | - 第二部分是真正用于更新文字的部分
238 | - 接下来是阻止事件冒泡。在这个例子中它不是必须的，但通常情况下，如果你不阻止的话，事件会一直冒泡到文档根元素甚至window对象。同样的，我们也需要用两种方法来阻止冒泡：W3C标准方式（stopPropagation()）和IE的方式（使用cancelBubble）
239 | - 最后，如果需要的话，阻止默认行为。有一些事件（点击链接、提交表单）有默认的行为，但你可以使用preventDefault()（IE是通过设置returnValue的值为false的方式）来阻止这些默认行为。
240 |
241 | 如你所见，这里涉及到了很多重复性的工作，所以使用第7章讨论过的外观模式创建自己的事件处理套件是很有意义的。
242 |
243 | ### 事件委托
244 |
245 | 事件委托是通过事件冒泡来实现的，它可以减少分散到各个节点上的事件处理函数的数量。如果有10个按钮在一个div元素中，你可以给div绑定一个事件处理函数，而不是给每个按钮都绑定一个。
246 |
247 | 我们来的睦一个实例，三个按钮放在一个div元素中（图8-1）。你可以在看到这个事件委托的实例。
248 |
249 | 
250 |
251 | 图8-1 事件委托示例：三个在点击时增加计数器值的按钮
252 |
253 | 结构是这样的：
254 |
255 |
256 |
257 |
258 |
259 |
260 |
261 | 你可以给包裹按钮的div绑定一个事件处理函数，而不是给每个按钮绑定一个。然后你可以使用和前面的示例中一样的myHandler()函数，但需要修改一个小地方：你需要将你不感兴趣的点击排除掉。在这个例子中，你只关注按钮上的点击，而在同一个div中产生的其它的点击应该被忽略掉。
262 |
263 | myHandler()的改变就是检查事件来源的nodeName是不是“button”:
264 |
265 | // ...
266 | // get event and source element
267 | e = e || window.event;
268 | src = e.target || e.srcElement;
269 |
270 | if (src.nodeName.toLowerCase() !== "button") {
271 | return;
272 | }
273 | // ...
274 |
275 | 事件委托的坏处是筛选容器中感兴趣的事件使得代码看起来更多了，但好处是性能的提升和更干净的代码，这个好处明显大于坏处，因此这是一种强烈推荐的模式。
276 |
277 | 主流的JavaScript库通过提供方便的API的方式使得使用事件委托变得很容易。比如YUI3中有Y.delegate()方法，它允许你指定一个用来匹配包裹容器的CSS选择器和一个用于匹配你感兴趣的节点的CSS选择器。这很方便，因为如果事件发生在你不关心的元素上时，你的事件处理回调函数不会被调用。在这种情况下，绑定一个事件处理函数很简单：
278 |
279 | Y.delegate('click', myHandler, "#click-wrap", "button");
280 |
281 | 感谢YUI抽象了浏览器的差异，已经处理好了事件的来源，使得回调函数更简单了：
282 |
283 | function myHandler(e) {
284 |
285 | var src = e.currentTarget,
286 | parts;
287 |
288 | parts = src.get('innerHTML').split(": ");
289 | parts[1] = parseInt(parts[1], 10) + 1;
290 | src.set('innerHTML', parts[0] + ": " + parts[1]);
291 |
292 | e.halt();
293 | }
294 |
295 | 你可以在看到实例。
296 |
297 | ## 长时间运行的脚本
298 |
299 | 你可能注意到过，有时候浏览器会提示脚本运行时间过长，询问用户是否要停止执行。这种情况你当然不希望发生在自己的应用中，不管它有多复杂。
300 |
301 | 同时，如果脚本运行时间太长的话，浏览器的UI将变得没有响应，用户不能点击任何东西。这是一种很差的用户体验，应该尽量避免。
302 |
303 | 在JavaScript中没有线程，但你可以在浏览器中使用setTimeout来模拟，或者在现代浏览器中使用web workers。
304 |
305 | ### setTimeout()
306 |
307 | 它的思想是将一大堆工作分解成为一小段一小段，然后每隔1毫秒运行一段。使用1毫秒的延迟会导致整个任务完成得更慢，但是用户界面会保持可响应状态，用户会觉得浏览器没有失控，觉得更舒服。
308 |
309 | > 1毫秒（甚至0毫秒）的延迟执行命令在实际运行的时候会延迟更多，这取决于浏览器和操作系统。设定0毫秒的延迟并不意味着马上执行，而是指“尽快执行”。比如，在IE中，最短的延迟是15毫秒。
310 |
311 | ### Web Workers
312 |
313 | 现代浏览器为长时间运行的脚本提供了另一种解决方案：web workers。web workers在浏览器内部提供了后台线程支持，你可以将计算量很大的部分放到一个单独的文件中，比如my_web_worker.js，然后从主程序（页面）中这样调用它：
314 |
315 | var ww = new Worker('my_web_worker.js');
316 | ww.onmessage = function (event) {
317 | document.body.innerHTML +=
318 | "message from the background thread: " + event.data + "
";
319 | };
320 |
321 | 下面展示了一个做1亿次简单的数学运算的web worker：
322 |
323 | var end = 1e8, tmp = 1;
324 |
325 | postMessage('hello there');
326 |
327 | while (end) {
328 | end -= 1;
329 | tmp += end;
330 | if (end === 5e7) { // 5e7 is the half of 1e8
331 | postMessage('halfway there, `tmp` is now ' + tmp);
332 | }
333 | }
334 |
335 | postMessage('all done');
336 |
337 | web worker使用postMessage()来和调用它的程序通讯，调用者通过onmessage事件来接受更新。onmessage事件处理函数接受一个事件对象作为参数，这个对象含有一个由web worker传过来data属性。类似的，调用者（在这个例子中）也可以使用ww.postMessage()来给web worker传递数据，web worker可以通过一个onmessage事件处理函数来接受这些数据。
338 |
339 | 上面的例子会在浏览器中打印出：
340 |
341 | message from the background thread: hello there
342 | message from the background thread: halfway there, `tmp` is now 3749999975000001 message from the background thread: all done
343 |
344 | ## 远程脚本编程
345 |
346 | 现代web应用经常会使用远程脚本编程和服务器通讯，而不刷新当前页面。这使得web应用更灵活，更像桌面程序。我们来看一下几种用JavaScript和服务器通讯的方法。
347 |
348 | ### XMLHttpRequest
349 |
350 | 现在，XMLHttpRequest是一个特别的对象（构造函数），绝大多数浏览器都可以用，它使得我们可以从JavaScript来发送HTTP请求。发送一个请求有以下三步：
351 |
352 | 1. 初始化一个XMLHttpRequest对象（简称XHR）
353 | 2. 提供一个回调函数，供请求对象状态改变时调用
354 | 3. 发送请求
355 |
356 | 第一步很简单：
357 |
358 | var xhr = new XMLHttpRequest();
359 |
360 | 但是在IE7之前的版本中，XHR的功能是使用ActiveX对象实现的，所以需要做一下兼容处理。
361 |
362 | 第二步是给readystatechange事件提供一个回调函数：
363 |
364 | xhr.onreadystatechange = handleResponse;
365 |
366 | 最后一步是使用open()和send()两个方法触发请求。open()方法用于初始化HTTP请求的方法（如GET，POST）和URL。send()方法用于传递POST的数据，如果是GET方法，则是一个空字符串。open()方法的最后一个参数用于指定这个请求是不是异步的。异步是指浏览器在等待响应的时候不会阻塞，这明显是更好的用户体验，因此除非必须要同步，否则异步参数应该使用true：
367 |
368 | xhr.open("GET", "page.html", true);
369 | xhr.send();
370 |
371 | 下面是一个完整的示例，它获取新页面的内容，然后将当前页面的内容替换掉（可以在看到示例）：
372 |
373 | var i, xhr, activeXids = [
374 | 'MSXML2.XMLHTTP.3.0',
375 | 'MSXML2.XMLHTTP',
376 | 'Microsoft.XMLHTTP'
377 | ];
378 |
379 | if (typeof XMLHttpRequest === "function") { // native XHR
380 | xhr = new XMLHttpRequest();
381 | } else { // IE before 7
382 | for (i = 0; i < activeXids.length; i += 1) {
383 | try {
384 | xhr = new ActiveXObject(activeXids[i]);
385 | break;
386 | } catch (e) {}
387 | }
388 | }
389 |
390 | xhr.onreadystatechange = function () {
391 | if (xhr.readyState !== 4) {
392 | return false;
393 | }
394 | if (xhr.status !== 200) {
395 | alert("Error, status code: " + xhr.status);
396 | return false;
397 | }
398 | document.body.innerHTML += "" + xhr.responseText + "<\/pre>"; };
399 |
400 | xhr.open("GET", "page.html", true);
401 | xhr.send("");
402 |
403 | 代码中的一些说明：
404 |
405 | - 因为IE6及以下版本中，创建XHR对象有一点复杂，所以我们通过一个数组列出ActiveX的名字，然后遍历这个数组，使用try-catch块来尝试创建对象。
406 | - 回调函数会检查xhr对象的readyState属性。这个属性有0到4一共5个值，4代表“complete”（完成）。如果状态还没有完成，我们就继续等待下一次readystatechange事件。
407 | - 回调函数也会检查xhr对象的status属性。这个属性和HTTP状态码对应，比如200（OK）或者是404（Not found）。我们只对状态码200感兴趣，而将其它所有的都报为错误（为了简化示例，否则需要检查其它不代表出错的状态码）。
408 | - 上面的代码会在每次创建XHR对象时检查一遍支持情况。你可以使用前面提到过的模式（如条件初始化）来重写上面的代码，使得只需要做一次检查。
409 |
410 | ### JSONP
411 |
412 | JSONP（JSON with padding）是另一种发起远程请求的方式。与XHR不同，它不受浏览器同源策略的限制，所以考虑到加载第三方站点的安全影响的问题，使用它时应该很谨慎。
413 |
414 | 一个XHR请求的返回可以是任何类型的文档：
415 |
416 | - XML文档（过去很常用）
417 | - HTML片段（很常用）
418 | - JSON数据（轻量、方便）
419 | - 简单的文本文件及其它
420 |
421 | 使用JSONP的话，数据经常是被包裹在一个函数中的JSON，函数名称在请求的时候提供。
422 |
423 | JSONP的请求URL通常是像这样：
424 |
425 | http://example.org/getdata.php?callback=myHandler
426 |
427 | getdata.php可以是任何类型的页面或者脚本。callback参数指定用来处理响应的JavaScript函数。
428 |
429 | 这个URL会被放到一个动态生成的\元素中，像这样：
430 |
431 | var script = document.createElement("script");
432 | script.src = url;
433 | document.body.appendChild(script);
434 |
435 | 服务器返回一些作为参数传递给回调函数的JSON数据。最终的结果实际上是页面中多了一个新的脚本，这个脚本的内容就是一个函数调用，如：
436 |
437 | myHandler({"hello": "world"});
438 |
439 | （译注：原文这里说得不是太明白。JSONP的返回内容如上面的代码片段，它的工作原理是在页面中动态插入一个脚本，这个脚本的内容是函数调用+JSON数据，其中要调用的函数是在页面中已经定义好的，数据以参数的形式存在。一般情况下数据由服务端动态生成，而函数由页面生成，为了使返回的脚本能调用到正确的函数，在请求的时候一般会带上callback参数以便后台动态返回处理函数的名字。）
440 |
441 | #### JSONP示例：井字棋
442 |
443 | 我们来看一个使用JSONP的井字棋游戏示例，玩家就是客户端（浏览器）和服务器。它们两者都会产生1到9之间的随机数，我们使用JSONP去取服务器产生的数字（图8-2）。
444 |
445 | 你可以在玩这个游戏。
446 |
447 | 
448 |
449 | 图8-2 使用JSONP的井字棋游戏
450 |
451 | 界面上有两个按钮：一个用于开始新游戏，一个用于取服务器下的棋（客户端下的棋会在一定数量的延时之后自动进行）：
452 |
453 |
454 |
455 |
456 | 界面上包含9个单元格，每个都有对应的id，比如：
457 |
458 | | |
459 | |
460 | |
461 | ...
462 |
463 | 整个游戏是在一个全局对象ttt中实现：
464 |
465 | var ttt = {
466 | // cells played so far
467 | played: [],
468 |
469 | // shorthand
470 | get: function (id) {
471 | return document.getElementById(id);
472 | },
473 |
474 | // handle clicks
475 | setup: function () {
476 | this.get('new').onclick = this.newGame;
477 | this.get('server').onclick = this.remoteRequest;
478 | },
479 |
480 | // clean the board
481 | newGame: function () {
482 | var tds = document.getElementsByTagName("td"),
483 | max = tds.length,
484 | i;
485 | for (i = 0; i < max; i += 1) {
486 | tds[i].innerHTML = " ";
487 | }
488 | ttt.played = [];
489 | },
490 |
491 | // make a request
492 | remoteRequest: function () {
493 | var script = document.createElement("script");
494 | script.src = "server.php?callback=ttt.serverPlay&played=" + ttt.played.join(',');
495 | document.body.appendChild(script);
496 | },
497 |
498 | // callback, server's turn to play
499 | serverPlay: function (data) {
500 | if (data.error) {
501 | alert(data.error);
502 | return;
503 | }
504 |
505 | data = parseInt(data, 10);
506 | this.played.push(data);
507 |
508 | this.get('cell-' + data).innerHTML = 'X<\/span>';
509 |
510 | setTimeout(function () {
511 | ttt.clientPlay();
512 | }, 300); // as if thinking hard
513 | },
514 |
515 | // client's turn to play
516 | clientPlay: function () {
517 | var data = 5;
518 |
519 | if (this.played.length === 9) {
520 | alert("Game over");
521 | return;
522 | }
523 |
524 | // keep coming up with random numbers 1-9
525 | // until one not taken cell is found
526 | while (this.get('cell-' + data).innerHTML !== " ") {
527 | data = Math.ceil(Math.random() * 9);
528 | }
529 | this.get('cell-' + data).innerHTML = 'O';
530 | this.played.push(data);
531 | }
532 | };
533 |
534 | ttt对象维护着一个已经填过的单元格的列表ttt.played，并且将它发送给服务器，这样服务器就可以返回一个没有玩过的数字。如果有错误发生，服务器会像这样响应：
535 |
536 | ttt.serverPlay({"error": "Error description here"});
537 |
538 | 如你所见，JSONP中的回调函数必须是公开的并且全局可访问的函数，它并不一定要是全局函数，也可以是一个全局对象的方法。如果没有错误发生，服务器将会返回一个函数调用，像这样：
539 |
540 | ttt.serverPlay(3);
541 |
542 | 这里的3是指3号单元格是服务器要下棋的位置。在这种情况下，数据非常简单，甚至都不需要使用JSON格式，只需要一个简单的值就可以了。
543 |
544 | ### 框架（frame）和图片信标(image beacon)
545 |
546 | 另外一种做远程脚本编程的方式是使用框架。你可以使用JavaScript来创建框架并改变它的src URL。新的URL可以包含数据和函数调用来更新调用者，也就是框架之外的父页面。
547 |
548 | 远程脚本编程中最最简单的情况是你只需要传递一点数据给服务器，而并不需要服务器的响应内容。在这种情况下，你可以创建一个新的图片，然后将它的src指向服务器的脚本：
549 |
550 | new Image().src = "http://example.org/some/page.php";
551 |
552 | 这种模式叫作图片信标，当你想发送一些数据给服务器记录时很有用，比如做访问统计。因为信标的响应对你来说完全是没有用的，所以通常的做法（不推荐）是让服务器返回一个1x1的GIF图片。更好的做法是让服务器返回一个“204 No Content”HTTP响应。这意味着返回给客户端的响应只有响应头（header）而没有响应体（body）。
553 |
554 | ## 部署JavaScript
555 |
556 | 在生产环境中使用JavaScript时，有不少性能方面的考虑。我们来讨论一下最重要的一些。如果需要了解所有的细节，可以参见O'Reilly出社的《高性能网站建设指南》和《高性能网站建设进阶指南》。
557 |
558 | ### 合并脚本
559 |
560 | 创建高性能网站的第一个原则就是尽量减少外部引用的组件（译注：这里指文件），因为HTTP请求的代价是比较大的。具体就JavaScript而言，可以通过合并外部脚本来显著提高页面加载速度。
561 |
562 | 我们假设你的页面正在使用jQuery库，这是一个.js文件。然后你使用了一些jQuery插件，这些插件也是单独的文件。这样的话在你还一行代码都没有写的时候就已经有了四五个文件了。把这些文件合并起来是很有意义的，尤其是其中的一些体积很小（2-3kb）时，这种情况下，HTTP协议中的开销会比下载本身还大。合并脚本的意思就是简单地创建一个新的js文件，然后把每个文件的内容粘贴进去。
563 |
564 | 当然，合并的操作应该放在代码部署到生产环境之前，而不是在开发环境中，因为这会使调试变得困难。
565 |
566 | 合并脚本的不便之处是：
567 |
568 | - 在部署前多了一步操作，但这很容易使用命令行自动化工具来做，比如使用Linux/Unix的cat：
569 |
570 | $ cat jquery.js jquery.quickselect.js jquery.limit.js > all.js
571 | - 失去一些缓存上的便利——当你对某个文件做了一点小修改之后，会使得整个合并后的代码缓存失效。所以比较好的方法是为大的项目设定一个发布计划，或者是将代码合并为两个文件：一个包含可能会经常变更的代码，另一个包含那些不会轻易变更的“核心”。
572 | - 你需要处理合并后文件的命名或者是版本问题，比如使用一个时间戳all_20100426.js或者是使用文件内容的hash值。
573 |
574 | 这就是主要的不便之处，但它带来的好处却是远远大于这些麻烦的。
575 |
576 | ### 压缩代码
577 |
578 | 第二章中，我们讨论过代码压缩。部署之前进行代码压缩也是一个很重要的步骤。
579 |
580 | 从用户的角度来想，完全没有必要下载代码中的注释，因为这些注释根本不影响代码运行。
581 |
582 | 压缩代码带来的好处多少取决于代码中注释和空白的数量，也取决于你使用的压缩工具。平均来说，压缩可以减少50%左右的体积。
583 |
584 | 服务端脚本压缩也是应该要做的事情。配置启用gzip压缩是一个一次性的工作，能带来立杆见影的速度提升。即使你正在使用共享的空间，供应商并没有提供那么多服务器配置的空间，大部分的供应商也会允许使用.htaccess配置文件。所以可以将这些加入到站点根目录的.htaccess文件中：
585 |
586 | AddOutputFilterByType DEFLATE text/html text/css text/plain text/xml application/javascript application/json
587 |
588 | 平均下来压缩会节省70%的文件体积。将代码压缩和服务端压缩合计起来，你可以期望你的用户只下载你写出来的未压缩文件体积的15%。
589 |
590 | ### 缓存头
591 |
592 | 与流行的观点相反，文件在浏览器缓存中的时间并没有那么久。你可以尽你自己的努力，通过使用Expires头来增加非首次访问时命中缓存的概率：
593 |
594 | 这也是一个在.htaccess中做的一次性配置工作：
595 |
596 | ExpiresActive On
597 | ExpiresByType application/x-javascript "access plus 10 years"
598 |
599 | 它的弊端是当你想更改这个文件时，你需要给它重命名，如果你已经处理好了合并的文件命名规则，那你就已经处理好这里的命名问题了。
600 |
601 | ### 使用CDN
602 |
603 | CDN是指“文件分发网络”（Content Delivery Network）。这是一项收费（有时候还相当昂贵）的托管服务，它将你的文件分发到世界上各个不同的数据中心，但代码中的URL却都是一样的，这样可以使用户更快地访问。
604 |
605 | 即使你没有CDN的预算，你仍然有一些可以免费使用的东西：
606 |
607 | - Google托管了很多流行的开源库，你可以免费使用，并从它的CDN中得到速度提升（译注：鉴于Google在国内的尴尬处境，不建议使用）
608 | - 微软托管了jQuery和自家的Ajax库
609 | - 雅虎在自己的CDN上托管了YUI库
610 |
611 | ## 加载策略
612 |
613 | 怎样在页面上引入脚本，这第一眼看起来是一个简单的问题——使用\元素，然后要么写内联的JavaScript代码或者是在src属性中指定一个独立的文件：
614 |
615 | // option 1
616 |
618 | // option 2
619 |
620 |
621 | 但是，当你的目标是要构建一个高性能的web应用的时候，有些模式和考虑点还是应该知道的。
622 |
623 | 作为题外话，来看一些比较常见的开发者会用在\元素上的属性：
624 |
625 | - language="JavaScript"
626 |
627 | 还有一些不同大小写形式的“JavaScript”，有的时候还会带上一个版本号。language属性不应该被使用，因为默认的语言就是JavaScript。版本号也不像想象中工作得那么好，这应该是一个设计上的错误。
628 | - type="text/javascript"
629 |
630 | 这个属性是HTML4和XHTML1标准所要求的，但它不应该存在，因为浏览器会假设它就是JavaScript。HTML5不再要求这个属性。除非是要强制通过难，否则没有任何使用type的理由。
631 | - defer
632 |
633 | （或者是HTML5中更好的async）是一种指定浏览器在下载外部脚本时不阻塞页面其它部分的方法，但还没有被广泛支持。关于阻塞的更多内容会在后面提及。
634 |
635 | ### \元素的位置
636 |
637 | script元素会阻塞页面的下载。浏览器会同时下载好几个组件（文件），但遇到一个外部脚本的时候，会停止其它的下载，直到脚本文件被下载、解析、执行完毕。这会严重影响页面的加载时间，尤其是当这样的事件在页面加载时发生多次的时候。
638 |
639 | 为了尽量减小阻塞带来的影响，你可以将script元素放到页面的尾部，在\之前，这样就没有可以被脚本阻塞的元素了。此时，页面中的其它组件（文件）已经被下载完毕并呈现给用户了。
640 |
641 | 最坏的“反模式”是在文档的头部使用独立的文件：
642 |
643 |
644 |
645 |
646 | My App
647 |
648 |
649 |
650 |
651 |
652 |
653 |
654 | ...
655 |
656 |
657 |
658 | 一个更好的选择是将所有的文件合并起来：
659 |
660 |
661 |
662 |
663 | My App
664 |
665 |
666 |
667 | ...
668 |
669 |
670 |
671 | 最好的选择是将合并后的脚本放到页面的尾部：
672 |
673 |
674 |
675 |
676 | My App
677 |
678 |
679 | ...
680 |
681 |
682 |
683 |
684 | ### HTTP分块
685 |
686 | HTTP协议支持“分块编码”。它允许将页面分成一块一块发送。所以如果你有一个很复杂的页面，你不需要将那些每个站都多多少少会有的（静态）头部信息也等到所有的服务端工作都完成后再开始发送。
687 |
688 | 一个简单的策略是在组装页面其余部分的时候将页面\的内容作为第一块发送。也就是像这样子：
689 |
690 |
691 |
692 |
693 | My App
694 |
695 |
696 |
697 | ...
698 |
699 |
700 |
701 |
702 | 这种情况下可以做一个简单的发动，将JavaScript移回\，随着第一块一起发送。
703 |
704 | 这样的话可以让服务器在拿到head区内容后就开始下载脚本文件，而此时页面的其它部分在服务端还尚未就绪：
705 |
706 |
707 |
708 |
709 | My App
710 |
711 |
712 |
713 |
714 | ...
715 |
716 |
717 |
718 | 一个更好的办法是使用第三块内容，让它在页面尾部，只包含脚本。如果有一些每个页面都用到的静态的头部，也可以将这部分随和一块一起发送：
719 |
720 |
721 |
722 | My App
723 |
724 |
728 |
729 |
730 | ... The full body of the page ...
731 |
732 |
733 |
734 |
735 |
736 |
737 |
738 | 这种方法很适合使用渐进增强思想的网站（关键业务不依赖JavaScript）。当HTML的第二块发送完毕的时候，浏览器已经有了一个加载、显示完毕并且可用的页面，就像禁用JavaScript时的情况。当JavaScript随着第三块到达时，它会进一步增强页面，为页面锦上添花。
739 |
740 | ### 动态\元素实现非阻塞下载
741 |
742 | 前面已经说到过，JavaScript会阻塞后面文件的下载，但有一些模式可以防止阻塞：
743 |
744 | - 使用XHR加载脚本，然后作为一个字符串使用eval()来执行。这种方法受同源策略的限制，而且引入了eval()这种“反模式”。
745 | - 使用defer和async属性，但有浏览器兼容性问题
746 | - 使用动态\元素
747 |
748 | 最后一种是一个很好并且实际可行的模式。和介绍JSONP时所做的一样，创建一个新的script元素，设置它的src属性，然后将它放到页面上。
749 |
750 | 这是一个异步加载JavaScript，不阻塞其它文件下载的示例：
751 |
752 | var script = document.createElement("script");
753 | script.src = "all_20100426.js";
754 | document.documentElement.firstChild.appendChild(script);
755 |
756 | 这种模式的缺点是，在这之后加载的脚本不能依赖这个脚本。因为这个脚本是异步加载的，所以无法保证它什么时候会被加载进来，如果要依赖的话，很可能会访问到（因还未加载完毕导致的）未定义的对象。
757 |
758 | 如果要解决这个问题，可以让内联的脚本不立即执行，而是作为一个函数放到一个数组中。当依赖的脚本加载完毕后，再执行数组中的所有函数。所以一共有三个步骤。
759 |
760 | 首先，创建一个数组用来存储所有的内联代码，定义的位置尽量靠前：
761 |
762 | var mynamespace = {
763 | inline_scripts: []
764 | };
765 |
766 | 然后你需要将这些单独的内联脚本包裹进一个函数中，然后将每个函数放到inline_scripts数组中，也就是这样：
767 |
768 | // was:
769 | //
770 |
771 | // becomes:
772 |
777 |
778 | 最后一步是使用异步加载的脚本遍历这个数组，然后执行函数：
779 |
780 | var i, scripts = mynamespace.inline_scripts, max = scripts.length;
781 | for (i = 0; i < max; max += 1) {
782 | scripts[i]();
783 | }
784 |
785 | #### 插入\元素
786 |
787 | 通常脚本是插入到文档的中的，但其实你可以插入任何元素中，包括body（像JSONP示例中那样）。
788 |
789 | 在前面的例子中，我们使用documentElement来插到\中，因为documentElement就是\，它的第一个子元素是\：
790 |
791 | document.documentElement.firstChild.appendChild(script);
792 |
793 | 通常也会这样写：
794 |
795 | document.getElementsByTagName("head")[0].appendChild(script);
796 |
797 | 当你能控制结构的时候，这样做没有问题，但是如果你在写挂件（widget）或者是广告时，你并不知道托管它的是一个什么样的页面。甚至可能页面上连\和\都没有，尽管document.body在绝大多数没有\标签的时候也可以工作：
798 |
799 | document.body.appendChild(script);
800 |
801 | 可以肯定页面上一定存在的一个标签是你正在运行的脚本所处的位置——script标签。（对内联或者外部文件来说）如果没有script标签，那么代码就不会运行。可以利用这一事实，在页面的第一个script标签上使用insertBefore()：
802 |
803 | var first_script = document.getElementsByTagName('script')[0];
804 | first_script.parentNode.insertBefore(script, first_script);
805 |
806 | frist_script是页面中一定存在的一个script标签，script是你创建的新的script元素。
807 |
808 | ### 延迟加载
809 |
810 | 所谓的延迟加载是指在页面的load事件之后再加载外部文件。通常，将一个大的合并后的文件分成两部分是有好处的：
811 |
812 | - 一部分是页面初始化和绑定UI元素的事件处理函数必须的
813 | - 第二部分是只在用户交互或者其它条件下才会用到的
814 |
815 | 目标就是逐步加载页面，让用户尽快可以进行一些操作。剩余的部分可以在用户可以看到页面的时候再在后台加载。
816 |
817 | 加载第二部分JavaScript的方法也是使用动态script元素，将它加在head或者body中：
818 |
819 | .. The full body of the page ...
820 |
821 |
822 |
823 |
830 |
831 |
726 | ...
727 |