代理模式 校对完毕

Author: TooBug

chapter7.markdown

@@ -661,25 +661,23 @@ JavaScript没有类，所以一字一句地说单例的定义并没有什么意
 
 外观模式在做一些重新设计和重构工作时也很有用。当你想用一个不同的实现来替换某个对象的时候，你可能需要花相当长一段时间才能完成（一个复杂的对象），与此同时，一些使用这个新对象的代码也在被同步编写。你可以先想好新对象的API，然后在旧的对象前面使用新的API创建一个外观方法。使用这种方式，当你完全替换掉旧的对象的时候，你只需要修改少量的调用代码，因为新的代码已经是在使用新的API了。
 
-<a name="a16"></a>
 ## 代理模式
 
-在代理设计模式中，一个对象充当了另一个对象的接口的角色。它和外观模式不一样，外观模式带来的方便仅限于将几个方法调用联合起来。而代理对象位于某个对象和它的客户之间，可以保护对对象的访问。
+在代理模式中，一个对象充当了另一个对象的接口的角色。它和外观模式不一样，外观模式带来的方便仅限于将几个方法调用联合起来。而代理对象位于某个对象和它的使用者之间，可以保护对对象的访问。
 
-这个模式看起来开销有点大，但在出于性能考虑时非常有用。代理对象可以作为对象（也叫“真正的主体”）的保护者，让真正的主体对象做尽量少的工作。
+这个模式看起来开销有点大，但在出于性能考虑时非常有用。代理对象可以作为目标对象的保护者，让目标对象做尽量少的工作。
 
-一种示例用法是我们称之为“懒初始化”（延迟初始化）的东西。假设初始化真正的主体是开销很大的，并且正好客户代码将它初始化后并不真正使用它。在这种情况下，代理对象可以作为真正的主体的接口起到帮助作用。代理对象接收到初始化请求，但在真正的主体真正被使用之前都不会将它传递过去。
+一种示例用法是“懒初始化”（延迟初始化）。假设负责初始化的对象是开销很大的，并且正好使用者将它初始化后并不真正使用它。在这种情况下，代理对象可以作为目标对象的接口起到帮助作用。代理对象接收到初始化请求，但在目标对象真正被使用之前都不会将请求传递过去。
 
-图7-2展示了这个场景，当客户代码发出初始化请求时，代理对象回复一切就绪，但并没有将请求传递过去，只有在客户代码真正需要真正的主体做些工作的时候才将两个请求一起传递过去。
+图7-2展示了这个场景，当使用目标对象的代码发出初始化请求时，代理对象回复一切就绪，但并没有将请求传递过去，只有在真正需要目标对象做些工作的时候才将两个请求一起传递过去。
 
-![图7-2 通过代理对象时客户代码与真正的主体的关系](./Figure/chapter7/7-2.jpg)
+![图7-2 通过代理对象时目标对象与使用者的关系](./Figure/chapter7/7-2.jpg)
 
-图7-2 通过代理对象时客户代码与真正的主体的关系
+图7-2 通过代理对象时目标对象与使用者的关系
 
-<a name="a17"></a>
 ### 一个例子
 
-在真正的主体做某件工作开销很大时，代理模式很有用处。在web应用中，开销最大的操作之一就是网络请求，此时尽可能地合并HTTP请求是有意义的。我们来看一个这种场景下应用代理模式的实例。
+在目标对象做某件工作开销很大时，代理模式很有用处。在web应用中，开销最大的操作之一就是网络请求，此时尽可能地合并HTTP请求是有意义的。我们来看一个这种场景下应用代理模式的实例。
 
 #### 一个视频列表（expando）
 
@@ -697,14 +695,14 @@ JavaScript没有类，所以一字一句地说单例的定义并没有什么意
 
 这个应用中最主要的角色是两个对象：
 
-- videos
+- `videos`
 
-	负责对信息区域展开/收起（videos.getInfo()方法）和播放视频的响应（videos.getPlayer()方法）
-- http
+	负责对信息区域展开/收起（`videos.getInfo()`方法）和播放视频的响应（`videos.getPlayer()`方法）
+- `http`
 
-	负责通过http.makeRequest()方法与服务端通讯
+	负责通过`http.makeRequest()`方法与服务端通讯
 
-当没有代理对象的时候，videos.getInfo()会为每个视频调用一次http.makeRequest()方法。当我们添加代理对象proxy后，它将位于vidoes和http中间，接手对makeRequest()的调用，并在可能的时候合并请求。
+当没有代理对象的时候，`videos.getInfo()`会为每个视频调用一次`http.makeRequest()`方法。当我们添加代理对象`proxy`后，它将位于`vidoes`和`http`中间，接手对`makeRequest()`的调用，并在可能的时候合并请求。
 
 我们首先看一下没有代理对象的代码，然后添加代理对象来提升应用的响应速度。
 
@@ -730,13 +728,13 @@ HTML代码仅仅是一个链接列表：
 
 #### 事件处理
 
-现在我们来看一下事件处理的逻辑。首先我们定义一个方便的快捷函数$：
+现在我们来看一下事件处理的逻辑。首先我们定义一个方便的快捷函数`$`：
 
 	var $ = function (id) {
 		return document.getElementById(id);
 	};
 
-使用事件代理（第8章有更多关于这个模式的内容），我们将所有id="vids"的条目上的点击事件统一放到一个函数中处理：
+使用事件代理（第八章有更多关于这个模式的内容），我们将所有`id="vids"`的条目上的点击事件统一放到一个函数中处理：
 
 	$('vids').onclick = function (e) {
 		var src, id;
@@ -764,19 +762,19 @@ HTML代码仅仅是一个链接列表：
 		videos.getInfo(id);
 	};
 
-#### videos对象
+#### `videos`对象
 
-videos对象有三个方法：
+`videos`对象有三个方法：
 
-- getPlayer()
+- `getPlayer()`
 
 	返回播放视频需要的HTML代码（跟我们讨论的无关）
-- updateList()
+- `updateList()`
 
-	网络请求的回调函数，接受从服务器返回的数据，然后生成用于视频详细信息的HTML代码。这一部分也没有什么太有趣的事情。
-- getInfo()
+	网络请求的回调函数，接受从服务器返回的数据，然后生成用于视频详细信息的HTML代码。这一部分也没有什么需要关注的事情。
+- `getInfo()`
 
-	这个方法切换视频信息的可视状态，同时也调用http对象的方法，并传递updaetList()作为回调函数。
+	这个方法切换视频信息的可视状态，同时也调用`http`对象的方法，并传递`updaetList()`作为回调函数。
 
 下面是这个对象的代码片段：
 
@@ -803,9 +801,9 @@ videos对象有三个方法：
 		}
 	};
 
-#### http对象
+#### `http`对象
 
-http对象只有一个方法，它向Yahoo!的YQL服务发起一个JSONP请求：
+`http`对象只有一个方法，它向Yahoo!的YQL服务发起一个JSONP请求：
 
 	var http = {
 		makeRequest: function (ids, callback) {
@@ -829,23 +827,23 @@ http对象只有一个方法，它向Yahoo!的YQL服务发起一个JSONP请求
 
 当所有的六个视频都被选中后，将会向服务端发起六个独立的像这样的YQL请求：
 
-select * from music.video.id where ids IN ("2158073")
+	select * from music.video.id where ids IN ("2158073")
 
 #### 代理对象
 
-前面的代码工作得很正常，但我们可以让它工作得更好。proxy对象就在这样的场景中出现，并接管了http和videos对象之间的通讯。它将使用一个简单的逻辑来尝试合并请求：50ms的延迟。videos对象并不直接调用后台接口，而是调用proxy对象的方法。proxy对象在转发这个请求前将会等待一段时间，如果在等待的50ms内有另一个来自videos的调用，则它们将被合并为同一个请求。50ms的延迟对用户来说几乎是无感知的，但是却可以用来合并请求以提升点击“toggle”时的体验，一次展开多个视频。它也可以显著降低服务器的负载，因为web服务器只需要处理更少量的请求。
+前面的代码工作得很好，但我们可以让它工作得更好。`proxy`对象就在这样的场景中出现，并接管了`http`和`videos`对象之间的通讯。它将使用一个简单的逻辑来尝试合并请求：50ms的延迟。`videos`对象并不直接调用后台接口，而是调用`proxy`对象的方法。`proxy`对象在转发这个请求前将会等待一段时间，如果在等待的50ms内有另一个来自`videos`的调用，则它们将被合并为同一个请求。50ms的延迟对用户来说几乎是无感知的，但是却可以用来合并请求以提升点击“toggle”时的体验，一次展开多个视频。它也可以显著降低服务器的负载，因为web服务器只需要处理更少量的请求。
 
 合并后查询两个视频信息的YQL大概是这样：
 
 	select * from music.video.id where ids IN ("2158073", "123456")
 
-在修改后的代码中，唯一的变化是videos.getInfo()现在调用的是proxy.makeRequest()而不是http.makeRequest()，像这样：
+在修改后的代码中，唯一的变化是`videos.getInfo()`现在调用的是`proxy.makeRequest()`而不是`http.makeRequest()`，像这样：
 
 	proxy.makeRequest(id, videos.updateList, videos);
 
-proxy对象创建了一个队列来收集50ms之内接受到的视频ID，然后将这个队列传递给http对象，并提供回调函数，因为videos.updateList()只能处理一次接收到的数据。（译注：指每次传入的回调函数只能处理当次接收到的数据。）
+`proxy`对象创建了一个队列来收集50ms之内接受到的视频ID，然后将这个队列传递给`http`对象，并提供回调函数，因为`videos.updateList()`只能处理一个接收到的视频信息。
 
-下面是proxy对象的代码：
+下面是`proxy`对象的代码：
 
 	var proxy = {
 		ids: [],
@@ -854,13 +852,13 @@ proxy对象创建了一个队列来收集50ms之内接受到的视频ID，然后
 		callback: null,
 		context: null,
 		makeRequest: function (id, callback, context) {
-			// add to the queue
+			// 添加到队列
 			this.ids.push(id);
 			
 			this.callback = callback;
 			this.context  = context;
 			
-			// set up timeout
+			// 设置延时
 			if (!this.timeout) {
 				this.timeout = setTimeout(function () {
 					proxy.flush();
@@ -871,28 +869,28 @@ proxy对象创建了一个队列来收集50ms之内接受到的视频ID，然后
 		
 			http.makeRequest(this.ids, "proxy.handler");
 			
-			// clear timeout and queue
+			// 清除延时和队列
 			this.timeout = null;
 			this.ids = [];
 			
 		},
 		handler: function (data) {
 			var i, max;
 			
-			// single video
+			// 单个视频
 			if (parseInt(data.query.count, 10) === 1) {
 				proxy.callback.call(proxy.context, data.query.results.Video);
 				return;
 			}
 			
-			// multiple videos
+			// 多个视频
 			for (i = 0, max = data.query.results.Video.length; i < max; i += 1) {
 				proxy.callback.call(proxy.context, data.query.results.Video[i]);
 			}
 		}
 	};
 
-了解代理模式后就在只简单地改动一下原来的代码的情况下，将多个web service请求合并为一个。
+使用代理模式可以在只改动一处原来代码的情况下，将多个web service请求合并为一个。
 
 图7-4和7-5展示了使用代理模式将与服务器三次数据交互（不用代理模式时）变为一次交互的过程。
 
@@ -905,9 +903,9 @@ proxy对象创建了一个队列来收集50ms之内接受到的视频ID，然后
 图7-5 通过一个代理对象合并请求，减少与服务器数据交互
 
 
-#### 使用代理对象做缓存
+### 使用代理对象做缓存
 
-在这个例子中，客户对象（videos）已经可以做到不对同一个对象重复发出请求。但现实情况中并不总是这样。这个代理对象还可以通过缓存之前的请求结果到cache属性中来进一步保护真正的主体http对象（图7-6）。然后当videos对象需要对同一个ID的视频请求第二次时，proxy对象可以直接从缓存中取出，从而避免一次网络交互。
+在这个例子中，目标对象的使用者（`videos`）已经可以做到不对同一个对象重复发出请求，但现实情况中并不总是这样。其实这个代理对象还可以通过缓存之前的请求结果到`cache`属性中来进一步保护`http`对象（图7-6）。然后当`videos`对象需要对同一个ID的视频请求第二次时，`proxy`对象可以直接从缓存中取出，从而避免一次网络交互。
 
 ![图7-6 代理缓存](./Figure/chapter7/7-6.jpg)