Merge pull request #154 from todoubaba/architecture

Polish architecture.jade (round 2)

public/docs/ts/latest/guide/architecture.jade

@@ -7,7 +7,7 @@ block includes
   Angular is a framework for building client applications in HTML and
   either JavaScript or a language like TypeScript that compiles to JavaScript.
 
-  Angular是一个用HTML和JavaScript或者一个可以编译成JavaScript的语言（例如Dart或者TypeScript），来构建客户端应用的框架。
+  Angular 是一个用 HTML 和 JavaScript 或者一个可以编译成 JavaScript 的语言（例如 Dart 或者 TypeScript ），来构建客户端应用的框架。
 
 block angular-parts
   :marked
@@ -20,7 +20,7 @@ block angular-parts
   writing *component* classes to manage those templates, adding application logic in *services*,
   and boxing components and services in *modules*.
 
-  我们是这样写Angular应用的：用带Angular扩展语法的HTML写*模板*，
+  我们是这样写 Angular 应用的：用 Angular 扩展语法编写 HTML *模板*，
   用*组件*类管理这些模板，用*服务*添加应用逻辑，
   用*模块*打包发布组件与服务。
 
@@ -29,12 +29,12 @@ block angular-parts
   responding to user interactions according to the instructions you've provided.
 
   然后，我们通过*引导*_根模块_来启动该应用。
-  Angular在浏览器中接管、展现应用的内容，并根据我们提供的操作指令响应用户的交互。
+  Angular 在浏览器中接管、展现应用的内容，并根据我们提供的操作指令响应用户的交互。
 
   Of course, there is more to it than this.
   You'll learn the details in the pages that follow. For now, focus on the big picture.
 
-  当然，这只是冰山一角。在以后的页面中，我们还会学到更多细节知识。不过，目前我们还是先关注全景图吧。
+  当然，这只是冰山一角。后面我们将学习更多的细节。不过，目前我们还是先关注全景图吧。
 
 figure
   img(src="/resources/images/devguide/architecture/overview2.png" alt="overview" style="margin-left:-40px;" width="700")
@@ -42,48 +42,48 @@ figure
 :marked
   The architecture diagram identifies the eight main building blocks of an Angular application:
 
-  这个架构图展现了Angular应用中的8个主要构造块：
+  这个架构图展现了 Angular 应用中的 8 个主要构造块：
 
   * [Modules](#modules)
 
-  * [模块(Modules)](#modules)
+    [模块 (module)](#modules)
 
   * [Components](#components)
 
-  * [组件(Components)](#components)
+    [组件 (component)](#components)
 
   * [Templates](#templates)
 
-  * [模板(Templates)](#templates)
+    [模板 (template)](#templates)
 
   * [Metadata](#metadata)
 
-  * [元数据(Metadata)](#metadata)
+    [元数据 (metadata)](#metadata)
 
   * [Data binding](#data-binding)
 
-  * [数据绑定(Data Binding)](#data-binding)
+    [数据绑定 (data binding)](#data-binding)
 
   * [Directives](#directives)
 
-  * [指令(Directives)](#directives)
+    [指令 (directive)](#directives)
 
   * [Services](#services)
 
-  * [服务(Services)](#services)
+    [服务 (service)](#services)
 
   * [Dependency injection](#dependency-injection)
 
-  * [依赖注入(Dependency Injection)](#dependency-injection)
+    [依赖注入 (dependency injection)](#dependency-injection)
 
   Learn these building blocks, and you're on your way.
 
-  掌握这些构造块，我们就可以开始使用Angular 2编写应用程序了。
+  掌握了这些构造块，你就可以下山了！
 
 .l-sub-section
   p The code referenced on this page is available as a <live-example></live-example>.
 
-  p 本章所引用的代码可以从这个<live-example>在线例子</live-example>。
+  p 本章所引用的代码见<live-example>在线例子</live-example>。
 
 .l-main-section
 :marked
@@ -96,30 +96,30 @@ figure
 :marked
   Angular apps are modular and Angular has its own modularity system called _Angular modules_ or _NgModules_.
 
-  Angular应用是模块化的，并且Angular有自己的模块系统，它被称为_Angular模块_或_NgModules_。
+  Angular 应用是模块化的，并且 Angular 有自己的模块系统，它被称为 _Angular 模块_或 _NgModules_。
 
   _Angular modules_ are a big deal.
   This page introduces modules; the [Angular modules](ngmodule.html) page covers them in depth.
 
-  _Angular模块_很重要。
+  _Angular 模块_很重要。
-  这里我们只做一个简介，在[Angular模块](ngmodule.html)中会做深入讲解。
+  这里只是简单介绍，在 [Angular 模块](ngmodule.html)中会做深入讲解。
 
 <br class="l-clear-both"><br>
 :marked
   Every Angular app has at least one Angular module class, [the _root module_](appmodule.html "AppModule: the root module"),
   conventionally named `AppModule`.
 
-  每个Angular应用至少有一个模块（_根模块_），习惯上命名为`AppModule`。
+  每个 Angular 应用至少有一个模块（[_根模块_](appmodule.html "AppModule: 根模块")），习惯上命名为`AppModule`。
 
   While the _root module_ may be the only module in a small application, most apps have many more
   _feature modules_, each a cohesive block of code dedicated to an application domain,
   a workflow, or a closely related set of capabilities. 
 
-  _根模块_在一些小型应用中可能是唯一的模块，不过大多数应用会有很多_特性模块_，每个模块都是一个内聚的代码块专注于某个应用领域、工作流或紧密相关的功能。
+  _根模块_在一些小型应用中可能是唯一的模块，大多数应用会有很多_特性模块_，每个模块都是一个内聚的代码块专注于某个应用领域、工作流或紧密相关的功能。
 
   An Angular module, whether a _root_ or _feature_, is a class with an `@NgModule` decorator.
 
-  Angular模块（无论是_根模块_还是_特性模块_）都是一个带有`@NgModule`装饰器的类。
+  Angular 模块（无论是_根模块_还是_特性模块_）都是一个带有`@NgModule`装饰器的类。
 
 .l-sub-section
   :marked
@@ -129,9 +129,9 @@ figure
     <a href="https://medium.com/google-developers/exploring-es7-decorators-76ecb65fb841#.x5c2ndtx0" target="_blank">
     Learn more</a> about decorators on the web.
 
-    装饰器是用来修饰JavaScript类的函数。
+    装饰器是用来修饰 JavaScript 类的函数。
-    Angular有很多装饰器，它们负责把元数据附加到类上，以了解那些类的设计意图以及它们应如何工作。
+    Angular 有很多装饰器，它们负责把元数据附加到类上，以了解那些类的设计意图以及它们应如何工作。
-    点此<a href="https://medium.com/google-developers/exploring-es7-decorators-76ecb65fb841#.x5c2ndtx0" target="_blank">学习更多知识</a>。
+    关于装饰器的<a href="https://medium.com/google-developers/exploring-es7-decorators-76ecb65fb841#.x5c2ndtx0" target="_blank">更多信息</a>。
 
 :marked
   `NgModule` is a decorator function that takes a single metadata object whose properties describe the module. 
@@ -142,30 +142,30 @@ figure
   * `declarations` - the _view classes_ that belong to this module.
   Angular has three kinds of view classes: [components](#components), [directives](#directives), and [pipes](pipes.html).
 
-  * `declarations`（声明） - 本模块中拥有的视图类。
+    `declarations` - 声明本模块中拥有的_视图类_。
-  Angular有三种视图类：[组件](#components)、[指令](#directives)和[管道](pipes.html)。
+  Angular 有三种视图类：[组件](#components)、[指令](#directives)和[管道](pipes.html)。
 
   * `exports` - the subset of declarations that should be visible and usable in the component [templates](#templates) of other modules.
 
-  * `exports` - 声明（declarations）的子集，可用于其它模块的组件[模板](#templates)。
+    `exports` - declarations 的子集，可用于其它模块的组件[模板](#templates)。
 
   * `imports` - other modules whose exported classes are needed by component templates declared in _this_ module.
 
-  * `imports` - _本_模块声明的组件模板需的类所在的其它模块。
+    `imports` - _本_模块声明的组件模板需要的类所在的其它模块。
 
   * `providers` - creators of [services](#services) that this module contributes to
   the global collection of services; they become accessible in all parts of the app.
 
-  * `providers` - [服务](#services)的创建者，并加入到全局服务表中，可用于应用任何部分。
+    `providers` - [服务](#services)的创建者，并加入到全局服务列表中，可用于应用任何部分。
 
   * `bootstrap` - the main application view, called the _root component_,
   that hosts all other app views. Only the _root module_ should set this `bootstrap` property.
 
-  * `bootstrap` - 指定应用的主视图（称为_根组件_），它是所有其它视图的宿主。只有_根模块_才能设置`bootstrap`属性。
+    `bootstrap` - 指定应用的主视图（称为_根组件_），它是所有其它视图的宿主。只有_根模块_才能设置`bootstrap`属性。
 
   Here's a simple root module:
 
-  下面是一个最简单的根模块：
+  下面是一个简单的根模块：
 
 +makeExample('app/mini-app.ts', 'module', 'app/app.module.ts')(format='.')
 
@@ -181,32 +181,32 @@ figure
   During development you're likely to bootstrap the `AppModule` in a `main.ts` file like this one.
 
   我们通过_引导_根模块来启动应用。
-  在开发期间，你通常在一个`main.ts`文件中来引导`AppModule`，就像这样：
+  在开发期间，你通常在一个`main.ts`文件中引导`AppModule`，就像这样：
 
 +makeExample('app/main.ts', '', 'app/main.ts')(format='.')
 
 :marked
   ### Angular modules vs. JavaScript modules
 
-  ### Angular模块 vs. JavaScript模块
+  ### Angular 模块 vs. JavaScript 模块
 
   The Angular module &mdash; a class decorated with `@NgModule` &mdash; is a fundamental feature of Angular.
 
-  Angular模块（一个用`@NgModule`装饰的类）是Angular的基础特性。
+  Angular 模块（一个用`@NgModule`装饰的类）是 Angular 的基础特性。
 
   JavaScript also has its own module system for managing collections of JavaScript objects.
   It's completely different and unrelated to the Angular module system.
 
-  JavaScript有自己的模块系统，用来管理一组JavaScript对象。
+  JavaScript 也有自己的模块系统，用来管理一组 JavaScript 对象。
-  它与Angular的模块体系完全不同且完全无关。
+  它与 Angular 的模块系统完全不同且完全无关。
 
   In JavaScript each _file_ is a module and all objects defined in the file belong to that module.
   The module declares some objects to be public by marking them with the `export` key word. 
   Other JavaScript modules use *import statements* to access public objects from other modules.
 
-  JavaScript中，每个_文件_是一个模块，文件中定义的所有对象都从属于那个模块。
+  JavaScript 中，每个_文件_是一个模块，文件中定义的所有对象都从属于那个模块。
   通过`export`关键字，模块可以把它的某些对象声明为公共的。
-  其它JavaScript模块可以使用*import语句*来访问这些公共对象。
+  其它 JavaScript 模块可以使用*import 语句*来访问这些公共对象。
 
 +makeExample('app/app.module.ts', 'imports', '')(format='.')
 +makeExample('app/app.module.ts', 'export', '')(format='.')
@@ -215,7 +215,7 @@ figure
   :marked
     <a href="http://exploringjs.com/es6/ch_modules.html" target="_blank">Learn more about the JavaScript module system on the web.</a>
 
-    <a href="http://exploringjs.com/es6/ch_modules.html" target="_blank">可到其它网站深入学习关于JavaScript模块的知识。</a>
+    <a href="http://exploringjs.com/es6/ch_modules.html" target="_blank">学习更多关于 JavaScript 模块的知识。</a>
 
 :marked
   These are two different and _complementary_ module systems. Use them both to write your apps.
@@ -224,59 +224,60 @@ figure
 
   ### Angular libraries
 
-  ### Angular模块库
+  ### Angular 模块库
 figure
   img(src="/resources/images/devguide/architecture/library-module.png" alt="Component" align="left" style="width:240px; margin-left:-40px;margin-right:10px" )
 
 :marked
   Angular ships as a collection of JavaScript modules. You can think of them as library modules. 
 
-  Angular发布了一组JavaScript模块。我们可以把它们看做库模块。
+  Angular 提供了一组 JavaScript 模块。可以把它们看做库模块。
 
   Each Angular library name begins with the `!{_at_angular}` prefix.
 
-  每个Angular库的名字都带有`!{_at_angular}`前缀。
+  每个 Angular 库的名字都带有`!{_at_angular}`前缀。
 
   You install them with the **npm** package manager and import parts of them with JavaScript `import` statements.
 
-  我们可以用**npm**包管理工具安装它们，用JavaScript的`import`语句导入其中某些部件。
+  用 **npm** 包管理工具安装它们，用 JavaScript 的`import`语句导入其中某些部件。
 <br class="l-clear-both"><br>
 :marked
   For example, import Angular's `Component` decorator from the `@angular/core` library like this:
 
-  例如，我们从`@angular/core`库中导入`Component`装饰器，就像这样：
+  例如，象下面这样，从`@angular/core`库中导入`Component`装饰器：
 +makeExample('app/app.component.ts', 'import', '')(format='.')
 
 :marked
   You also import Angular _modules_ from Angular _libraries_ using JavaScript import statements:
 
-  我们还可以使用JavaScript的导入语句从Angular_库_中导入Angular的_某些模块_。
+  还可以使用 JavaScript 的导入语句从 Angular _库_中导入 Angular _模块_。
 
 +makeExample('app/mini-app.ts', 'import-browser-module', '')(format='.')
 
 :marked
   In the example of the simple root module above, the application module needs material from within that `BrowserModule`. To access that material, add it to the `@NgModule` metadata `imports` like this.
 
-  在上面这个根模块的例子中，应用模块需要`BrowserModule`的某些素材。要访问这些素材，我们就得把它加入`@NgModule`元数据的`imports`中去，就像这样：
+  在上面那个简单的根模块的例子中，应用模块需要`BrowserModule`的某些素材。
+  要访问这些素材，就得把它加入`@NgModule`元数据的`imports`中，就像这样：
 
 +makeExample('app/mini-app.ts', 'ngmodule-imports', '')(format='.')
 
 :marked
   In this way you're using both the Angular and JavaScript module systems _together_.
 
-  种情况下，你同时使用了Angular和JavaScript的模块化系统。
+  这种情况下，你同时使用了 Angular 和 JavaScript 的模块化系统。
 
   It's easy to confuse the two systems because they share the common vocabulary of "imports" and "exports".
   Hang in there. The confusion yields to clarity with time and experience.
 
-  这两个系统比较容易混淆，因为它们共享相同的词汇“imports”和“exports”。
+  这两个系统比较容易混淆，因为它们共享相同的词汇 “imports” 和 “exports”。
   先放一放，随着时间和经验的增长，自然就会澄清了。
 
 .l-sub-section
   :marked
     Learn more from the [Angular modules](ngmodule.html) page.
 
-    要了解更多，参见[Angular模块](ngmodule.html)页。
+    更多信息，见 [Angular 模块](ngmodule.html)。
 
 .l-hr
 
@@ -301,21 +302,21 @@ figure
 
   * The app root with the navigation links.
 
-  * 带有导航链接的应用根组件。
+    带有导航链接的应用根组件。
 
   * The list of heroes.
 
-  * 英雄列表。
+    英雄列表。
 
   * The hero editor.
 
-  * 英雄编辑器。
+    英雄编辑器。
 
   You define a component's application logic&mdash;what it does to support the view&mdash;inside a class.
   The class interacts with the view through an API of properties and methods.
 
-  我们在类中定义组件的应用逻辑(用来为视图提供支持)。
+  我们在类中定义组件的应用逻辑，为视图提供支持。
-  组件通过一些由属性和方法组成的API与视图交互。
+  组件通过一些由属性和方法组成的 API 与视图交互。
 
   <a id="component-code"></a>
   For example, this `HeroListComponent` has a `heroes` property that returns !{_an} !{_array} of heroes
@@ -331,7 +332,7 @@ figure
   Angular creates, updates, and destroys components as the user moves through the application.
   Your app can take action at each moment in this lifecycle through optional [lifecycle hooks](lifecycle-hooks.html), like `ngOnInit()` declared above.
 
-  当用户在这个应用中漫游时，Angular会创建、更新和销毁组件。
+  当用户在这个应用中漫游时， Angular 会创建、更新和销毁组件。
   应用可以通过[生命周期钩子](lifecycle-hooks.html)在组件生命周期的各个时间点上插入自己的操作，例如上面声明的`ngOnInit()`。
 
 .l-hr
@@ -348,19 +349,20 @@ figure
   You define a component's view with its companion **template**. A template is a form of HTML
   that tells Angular how to render the component.
 
-  我们通过组件的自带的**模板**来定义组件视图。模板以HTML形式存在，告诉Angular如何渲染组件(视图)。
+  我们通过组件的自带的**模板**来定义组件视图。模板以 HTML 形式存在，告诉 Angular 如何渲染组件。
 
   A template looks like regular HTML, except for a few differences. Here is a
   template for our `HeroListComponent`:
 
-  多数情况下，模板看起来很像标准HTML……当然也有一点不同的地方。下面是`HeroListComponent`组件的一个模板。
+  多数情况下，模板看起来很像标准 HTML，当然也有一点不同的地方。下面是`HeroListComponent`组件的一个模板：
 
 +makeExample('app/hero-list.component.html')
 
 :marked
   Although this template uses typical HTML elements like `<h2>` and  `<p>`, it also has some differences. Code like `*ngFor`, `{{hero.name}}`, `(click)`, `[hero]`, and `<hero-detail>` uses Angular's [template syntax](template-syntax.html).
 
-  模板除了可以使用典型的HTML元素（`<h2>`和`<p>`），它还能使用其它元素。例如(template-syntax.html)中使用了Angular的[模板语法]`*ngFor`、`{{hero.name}}`、`(click)`、`[hero]`和`<hero-detail>`。
+  模板除了可以使用像`<h2>`和`<p>`这样的典型的 HTML 元素，还能使用其它元素。
+  例如，像`*ngFor`、`{{hero.name}}`、`(click)`、`[hero]`和`<hero-detail>`这样的代码使用了 Angular 的[模板语法](template-syntax.html)。
 
   In the last line of the template, the `<hero-detail>` tag is a custom element that represents a new component, `HeroDetailComponent`.
 
@@ -372,7 +374,7 @@ figure
   The `HeroDetailComponent` is a **child** of the `HeroListComponent`.
 
   `HeroDetailComponent`跟以前见到过的`HeroListComponent`是*不同*的组件。
-  `HeroDetailComponent`(未展示代码)用于展现一个特定英雄的情况，这个英雄是用户从`HeroListComponent`列表中选择的。
+  `HeroDetailComponent`（代码未显示）用于展现一个特定英雄的情况，这个英雄是用户从`HeroListComponent`列表中选择的。
   `HeroDetailComponent`是`HeroListComponent`的*子组件*。
 
 figure
@@ -380,8 +382,8 @@ figure
 :marked
   Notice how `<hero-detail>` rests comfortably among native HTML elements. Custom components mix seamlessly with native HTML in the same layouts.
 
-  注意：`<hero-detail>`竟如此和谐的出现在那些原生HTML元素中。
+  注意到了吗？`<hero-detail>`舒适地躺在原生 HTML 元素之间。
-  自定义组件和原生HTML在同一布局中融合得天衣无缝。
+  自定义组件和原生 HTML 在同一布局中融合得天衣无缝。
 
 <br class="l-clear-both">
 
@@ -398,27 +400,27 @@ figure
 
 :marked
 <p style="padding-top:10px">Metadata tells Angular how to process a class.</p>
-<p style="padding-top:10px">元数据告诉Angular如何处理一个类。</p>
+<p style="padding-top:10px">元数据告诉 Angular 如何处理一个类。</p>
 <br class="l-clear-both">
 :marked
   [Looking back at the code](#component-code) for `HeroListComponent`, you can see that it's just a class.
   There is no evidence of a framework, no "Angular" in it at all.
 
   [回头看看](#component-code)`HeroListComponent`就会明白：它只是一个类。
-  一点框架的痕迹也没有，里面完全没有出现"Angular"的字样。
+  一点框架的痕迹也没有，里面完全没有出现 "Angular" 的字样。
 
   In fact, `HeroListComponent` really is *just a class*. It's not a component until you *tell Angular about it*.
 
-  实际上，`HeroListComponent`真的*只是一个类*。直到我们*告诉Angular*它是一个组件。
+  实际上，`HeroListComponent`真的*只是一个类*。直到我们*告诉 Angular* 它是一个组件。
 
   To tell Angular that `HeroListComponent` is a component, attach **metadata** to the class.
 
-  只要把**元数据**附加到这个类，就相当于告诉Angular：`HeroListComponent`是个组件。
+  要告诉 Angular `HeroListComponent`是个组件，只要把**元数据**附加到这个类。
 
   In !{_Lang}, you attach metadata by using !{_a} **!{_decorator}**.
   Here's some metadata for `HeroListComponent`:
 
-  在!{_Lang}中，我们用**装饰器(!{_decorator})**来附加元数据。
+  在!{_Lang} 中，我们用**装饰器 (!{_decorator}) **来附加元数据。
   下面就是`HeroListComponent`的一些元数据。
 
 +makeExcerpt('app/hero-list.component.ts', 'metadata')
@@ -434,7 +436,7 @@ block ts-decorator
     The `@Component` decorator takes a required configuration object with the
     information Angular needs to create and present the component and its view.
 
-    `@Component`!{_decoratorCn}能接受一个配置对象，Angular会基于这些信息创建和展示组件及其视图。
+    `@Component`!{_decoratorCn}能接受一个配置对象， Angular 会基于这些信息创建和展示组件及其视图。
 
     Here are a few of the possible `@Component` configuration options:
 
@@ -443,26 +445,26 @@ block ts-decorator
 :marked
   - `moduleId`: sets the source of the base address (`module.id`) for module-relative URLs such as the `templateUrl`.
 
-  - `moduleId`: 为与模块相关的URL（如`templateUrl`）提供基地址
+    `moduleId`: 为与模块相关的 URL（例如`templateUrl`）提供基地址。
 
   - `selector`: CSS selector that tells Angular to create and insert an instance of this component
   where it finds a `<hero-list>` tag in *parent* HTML.
   For example, if an app's  HTML contains `<hero-list></hero-list>`, then
   Angular inserts an instance of the `HeroListComponent` view between those tags.
 
-  - `selector`： CSS选择器，它告诉Angular在*父级*HTML中查找`<hero-list>`标签，创建并插入该组件。
+    `selector`： CSS 选择器，它告诉 Angular 在*父级* HTML 中查找`<hero-list>`标签，创建并插入该组件。
-  例如，如果应用的HTML包含`<hero-list></hero-list>`，Angular就会把`HeroListComponent`的一个实例插入到这个标签中。
+  例如，如果应用的 HTML 包含`<hero-list></hero-list>`， Angular 就会把`HeroListComponent`的一个实例插入到这个标签中。
 
   - `templateUrl`: module-relative address of this component's HTML template, shown [above](#templates).
 
-  - `templateUrl`：组件HTML模板的模块相对地址，[如前所示](#templates)。
+    `templateUrl`：组件 HTML 模板的模块相对地址，[如前所示](#templates)。
 
   - `providers`: !{_array} of **dependency injection providers** for services that the component requires.
   This is one way to tell Angular that the component's constructor requires a `HeroService`
   so it can get the list of heroes to display. 
 
-  - `providers` - 组件所需服务的*依赖注入提供商*数组。
+    `providers` - 组件所需服务的*依赖注入提供商*数组。
-  这是在告诉Angular：该组件的构造函数需要一个`HeroService`服务，这样组件就可以从服务中获得英雄数据。
+  这是在告诉 Angular：该组件的构造函数需要一个`HeroService`服务，这样组件就可以从服务中获得英雄数据。
 
 figure
   img(src="/resources/images/devguide/architecture/template-metadata-component.png" alt="元数据" align="left" style="height:200px; margin-left:-40px;margin-right:10px" )
@@ -470,7 +472,7 @@ figure
 :marked
   The metadata in the `@Component` tells Angular where to get the major building blocks you specify for the component.
 
-  `@Component`里面的元数据会告诉Angular如何取得你为组件指定的元数据。
+  `@Component`里面的元数据会告诉 Angular 从哪里获取你为组件指定的主要的构建块。
 
   The template, metadata, and component together describe a view.
 
@@ -479,7 +481,7 @@ figure
   Apply other metadata !{_decorator}s in a similar fashion to guide Angular behavior.
   `@Injectable`, `@Input`, and `@Output` are a few of the more popular !{_decorator}s.
 
-  我们也会沿用类似的风格，用其它元数据!{_decoratorCn}来指导Angular的行为。
+  其它元数据!{_decoratorCn}用类似的方式来指导 Angular 的行为。
   例如`@Injectable`、`@Input`和`@Output`等是一些最常用的!{_decoratorCn}。
 
 <br class="l-clear-both">
@@ -487,7 +489,7 @@ figure
   The architectural takeaway is that you must add metadata to your code
   so that Angular knows what to do.
 
-  这种架构处理方式是：你向代码中添加元数据，以便Angular知道该怎么做。
+  这种架构处理方式是：你向代码中添加元数据，以便 Angular 知道该怎么做。
 
 .l-hr
 
@@ -501,8 +503,8 @@ figure
   into actions and value updates. Writing such push/pull logic by hand is tedious, error-prone, and a nightmare to
   read as any experienced jQuery programmer can attest.
 
-  如果没有框架，我们就得自己把数据值推送到HTML控件中，并把用户的反馈转换成动作和值更新。
+  如果没有框架，我们就得自己把数据值推送到 HTML 控件中，并把用户的反馈转换成动作和值更新。
-  如果手工写代码来实现这些推/拉逻辑，肯定会枯燥乏味、容易出错，读起来简直是噩梦 —— 写过jQuery的程序员大概都对此深有体会。
+  如果手工写代码来实现这些推/拉逻辑，肯定会枯燥乏味、容易出错，读起来简直是噩梦 —— 写过 jQuery 的程序员大概都对此深有体会。
 
 figure
   img(src="/resources/images/devguide/architecture/databinding.png" alt="数据绑定" style="width:220px; float:left; margin-left:-40px;margin-right:20px" )
@@ -511,37 +513,40 @@ figure
   a mechanism for coordinating parts of a template with parts of a component.
   Add binding markup to the template HTML to tell Angular how to connect both sides.
 
-  Angular支持**数据绑定**，一种让模板的各部分与组件的各部分相互合作的机制。
+  Angular 支持**数据绑定**，一种让模板的各部分与组件的各部分相互合作的机制。
-  我们往模板HTML中添加绑定标记，来告诉Angular如何连接两者。
+  我们往模板 HTML 中添加绑定标记，来告诉 Angular 如何把二者联系起来。
 
   As the diagram shows, there are four forms of data binding syntax. Each form has a direction &mdash; to the DOM, from the DOM, or in both directions.
 
-  如图所示，数据绑定的语法有四种形式。每种形式都有一个方向 —— 绑定到DOM、绑定自DOM以及双向绑定。
+  如图所示，数据绑定的语法有四种形式。每种形式都有一个方向 —— 绑定到 DOM 、绑定自 DOM 以及双向绑定。
 
 <br class="l-clear-both">
 :marked
   The `HeroListComponent` [example](#templates) template has three forms:
 
+  `HeroListComponent`[示例](#templates)模板中有三种形式：
 +makeExcerpt('app/hero-list.component.1.html', 'binding')
 
 :marked
   * The `{{hero.name}}` [*interpolation*](displaying-data.html#interpolation)
   displays the component's `hero.name` property value within the `<li>` tags.
 
-  * `{{hero.name}}`[*插值表达式*](displaying-data.html#interpolation)：在`<li>`标签中显示了组件的`hero.name`属性的值。
+    `{{hero.name}}`[*插值表达式*](displaying-data.html#interpolation)在`<li>`标签中显示组件的`hero.name`属性的值。
 
   * The `[hero]` [*property binding*](template-syntax.html#property-binding) passes the value of `selectedHero` from
   the parent `HeroListComponent` to the `hero` property of the child `HeroDetailComponent`.
 
-  * `[hero]`[*属性绑定*](template-syntax.html#property-binding)：把父组件`HeroListComponent`的`selectedHero`的值传到子组件`HeroDetailComponent`的`hero`属性中。
+    `[hero]`[*属性绑定*](template-syntax.html#property-binding)把父组件`HeroListComponent`的`selectedHero`的值传到子组件`HeroDetailComponent`的`hero`属性中。
 
   * The `(click)` [*event binding*](user-input.html#click) calls the component's `selectHero` method when the user clicks a hero's name.
 
+    `(click)` [*事件绑定*](user-input.html#click)在用户点击英雄的名字时调用组件的`selectHero`方法。
+
   **Two-way data binding** is an important fourth form
   that combines property and event binding in a single notation, using the `ngModel` directive.
   Here's an example from the `HeroDetailComponent` template:
 
-  **双向数据绑定**：这是很重要的第四种绑定形式，它使用`ngModel`指令组合了属性绑定和事件绑定的功能。
+  **双向数据绑定**是重要的第四种绑定形式，它使用`ngModel`指令组合了属性绑定和事件绑定的功能。
   下面是`HeroDetailComponent`模板的范例：
 
 +makeExcerpt('app/hero-detail.component.html', 'ngModel')
@@ -551,12 +556,12 @@ figure
   The user's changes also flow back to the component, resetting the property to the latest value,
   as with event binding.
 
-  在双向绑定中，数据属性值通过属性绑定从组件传到输入框。用户的修改通过事件绑传回到组件，把属性值设置为最新的值。
+  在双向绑定中，数据属性值通过属性绑定从组件流到输入框。用户的修改通过事件绑定流回组件，把属性值设置为最新的值。
 
   Angular processes *all* data bindings once per JavaScript event cycle,
   from the root of the application component tree through all child components.
 
-  Angular在每个JavaScript事件周期中一次性处理*所有的*数据绑定，它会从组件树的根部开始，递归处理全部子组件。
+  Angular 在每个 JavaScript 事件循环中处理*所有的*数据绑定，它会从组件树的根部开始，递归处理全部子组件。
 
 figure
   img(src="/resources/images/devguide/architecture/component-databinding.png" alt="数据绑定" style="float:left; width:300px; margin-left:-40px;margin-right:10px" )
@@ -564,7 +569,7 @@ figure
   Data binding plays an important role in communication
   between a template and its component.
 
-  数据绑定在模板与对应组件的交互中扮演了一个很重要的角色。
+  数据绑定在模板与对应组件的交互中扮演了重要的角色。
 <br class="l-clear-both">
 figure
   img(src="/resources/images/devguide/architecture/parent-child-binding.png" alt="父/子绑定" style="float:left; width:300px; margin-left:-40px;margin-right:10px" )
@@ -580,7 +585,7 @@ figure
 :marked
   ## Directives
 
-  ## 指令（directive)
+  ## 指令 (directive)
 
 figure
   img(src="/resources/images/devguide/architecture/directive.png" alt="父与子" style="float:left; width:150px; margin-left:-40px;margin-right:10px" )
@@ -588,12 +593,12 @@ figure
   Angular templates are *dynamic*. When Angular renders them, it transforms the DOM
   according to the instructions given by **directives**.
 
-  Angular模板是*动态的*。当Angular渲染它们时，它会根据**指令**提供的操作对DOM进行转换。
+  Angular 模板是*动态的*。当 Angular 渲染它们时，它会根据**指令**提供的操作对 DOM 进行转换。
 
   A directive is a class with directive metadata. In !{_Lang}, apply the `@Directive` !{_decorator}
   to attach metadata to the class.
 
-  指令是一个带有“指令元数据”的类。在!{_Lang}中，要通过`@Directive`!{_decoratorCn}把元数据附加到类上。
+  指令是一个带有“指令元数据”的类。在 !{_Lang} 中，要通过`@Directive`!{_decoratorCn}把元数据附加到类上。
 <br class="l-clear-both">
 :marked
   A component is a *directive-with-a-template*;
@@ -606,36 +611,37 @@ figure
     While **a component is technically a directive**,
     components are so distinctive and central to Angular applications that this architectural overview  separates components from directives.
 
-    虽然**严格来说组件就是一个指令**，但是组件非常独特，并在Angular中位于中心地位，所以在架构概览中，我们把组件从指令中独立了出来。
+    虽然**严格来说组件就是一个指令**，但是组件非常独特，并在 Angular 中位于中心地位，所以在架构概览中，我们把组件从指令中独立了出来。
 
 :marked
   Two *other* kinds of directives exist: _structural_ and _attribute_ directives.
 
-  有两种*其它*类型的指令，我们称之为_结构型_指令和_属性(attribute)型_指令。
+  还有两种*其它*类型的指令：_结构型_指令和_属性 (attribute) 型_指令。
 
   They tend to appear within an element tag as attributes do,
   sometimes by name but more often as the target of an assignment or a binding.
 
-  它们往往像属性(attribute)一样出现在元素标签中，偶尔会以名字的形式出现但多数时候还是作为赋值目标或绑定目标出现。
+  它们往往像属性 (attribute) 一样出现在元素标签中，
+  偶尔会以名字的形式出现，但多数时候还是作为赋值目标或绑定目标出现。
 
   **Structural** directives alter layout by adding, removing, and replacing elements in DOM.
 
-  **结构型指令**通过在DOM中添加、移除和替换元素来修改布局。
+  **结构型**指令通过在 DOM 中添加、移除和替换元素来修改布局。
 
   The [example template](#templates) uses two built-in structural directives:
 
-  我们在[范例模板](#templates)中用到了两个内置的结构型指令。
+  下面的[范例模板](#templates)中用到了两个内置的结构型指令：
 
 +makeExcerpt('app/hero-list.component.1.html', 'structural')
 
 :marked
   * [`*ngFor`](displaying-data.html#ngFor) tells Angular to stamp out one `<li>` per hero in the `heroes` list.
 
-  * [`*ngFor`](displaying-data.html#ngFor)告诉Angular为`heroes`列表中的每个英雄生成一个`<li>`标签。
+    [`*ngFor`](displaying-data.html#ngFor)告诉 Angular 为`heroes`列表中的每个英雄生成一个`<li>`标签。
 
   * [`*ngIf`](displaying-data.html#ngIf) includes the `HeroDetail` component only if a selected hero exists.
 
-  * [`*ngIf`](displaying-data.html#ngIf)表示只有在选择的英雄存在时，才会包含`HeroDetail`组件。
+    [`*ngIf`](displaying-data.html#ngIf)表示只有在选择的英雄存在时，才会包含`HeroDetail`组件。
 
 block dart-bool
   //- N/A
@@ -644,14 +650,16 @@ block dart-bool
   **Attribute** directives alter the appearance or behavior of an existing element.
   In templates they look like regular HTML attributes, hence the name.
 
-  **属性型指令** 修改一个现有元素的外观或行为。在模板中，它们看起来就像是标准的HTML属性，故名。
+  **属性型** 指令修改一个现有元素的外观或行为。
+  在模板中，它们看起来就像是标准的 HTML 属性，故名。
 
   The `ngModel` directive, which implements two-way data binding, is
   an example of an attribute directive. `ngModel` modifies the behavior of
   an existing element (typically an `<input>`)
   by setting its display value property and responding to change events.
 
-  `ngModel`指令就是属性型指令的一个例子，它实现了双向数据绑定。它修改了现有元素(一般是`<input>`)的行为：设置其显示属性值，并响应change事件。
+  `ngModel`指令就是属性型指令的一个例子，它实现了双向数据绑定。
+  `ngModel`修改现有元素（一般是`<input>`）的行为：设置其显示属性值，并响应 change 事件。
 
 +makeExcerpt('app/hero-detail.component.html', 'ngModel')
 :marked
@@ -660,8 +668,8 @@ block dart-bool
   or modify aspects of DOM elements and components
   (for example, [ngStyle](template-syntax.html#ngStyle) and [ngClass](template-syntax.html#ngClass)).
 
-  Angular还有少量指令，它们或者修改结构布局(如[ngSwitch](template-syntax.html#ngSwitch))，或者修改DOM元素和组件的各个方面
+  Angular 还有少量指令，它们或者修改结构布局（例如 [ngSwitch](template-syntax.html#ngSwitch)），
-  (如[ngStyle](template-syntax.html#ngStyle)和[ngClass](template-syntax.html#ngClass))。
+  或者修改 DOM 元素和组件的各个方面（例如 [ngStyle](template-syntax.html#ngStyle)和 [ngClass](template-syntax.html#ngClass)）。
 
   Of course, you can also write your own directives. Components such as
   `HeroListComponent` are one kind of custom directive.
@@ -681,7 +689,7 @@ figure
 :marked
   _Service_ is a broad category encompassing any value, function, or feature that your application needs.
 
-  *服务*分为很多种，包括：值、函数，以及应用所需的特性。
+  *服务*是一个广义范畴，包括：值、函数，或应用所需的特性。
 
   Almost anything can be a service.
   A service is typically a class with a narrow, well-defined purpose. It should do something specific and do it well.
@@ -696,37 +704,37 @@ figure
 
   * logging service
 
-  * 日志服务
+    日志服务
 
   * data service
 
-  * 数据服务
+    数据服务
 
   * message bus
 
-  * 消息总线
+    消息总线
 
   * tax calculator
 
-  * 税款计算器
+    税款计算器
 
   * application configuration
 
-  * 应用程序配置
+    应用程序配置
 
   There is nothing specifically _Angular_ about services. Angular has no definition of a service.
   There is no service base class, and no place to register a service.
 
-  服务没有什么特别属于*Angular*的特性。Angular对于服务也没有什么定义。
+  服务没有什么特别属于 *Angular* 的特性。 Angular 对于服务也没有什么定义。
-  它甚至都没有定义服务的基类（Base Class），也没有地方注册一个服务。
+  它甚至都没有定义服务的基类，也没有地方注册一个服务。
 
   Yet services are fundamental to any Angular application. Components are big consumers of services.
 
-  即便如此，服务仍然是任何Angular应用的基础。组件就是最大的*服务*消费者。
+  即便如此，服务仍然是任何 Angular 应用的基础。组件就是最大的*服务*消费者。
 
   Here's an example of a service class that logs to the browser console:
 
-  这里是一个服务类的范例，用于把日志记录到浏览器的控制台：
+  下面是一个服务类的范例，用于把日志记录到浏览器的控制台：
 
 +makeExcerpt('app/logger.service.ts', 'class')
 
@@ -734,8 +742,8 @@ figure
   Here's a `HeroService` that fetches heroes and returns them in a resolved !{_PromiseLinked}.
   The `HeroService` depends on the `Logger` service and another `BackendService` that handles the server communication grunt work.
 
-  下面是`HeroService`类，用于获取英雄数据，并通过一个已解析的[承诺（Promise）](http://exploringjs.com/es6/ch_promises.html)返回它们。
+  下面是`HeroService`类，用于获取英雄数据，并通过一个已解析的[承诺 (Promise)](http://exploringjs.com/es6/ch_promises.html) 返回它们。
-  `HeroService`还依赖于`Logger`服务和另一个用来处理服务器通讯工作的`BackendService`服务。
+  `HeroService`还依赖于`Logger`服务和另一个用于处理服务器通讯的`BackendService`服务。
 
 +makeExcerpt('app/hero.service.ts', 'class')
 
@@ -748,7 +756,7 @@ figure
   validate user input, or log directly to the console.
   They delegate such tasks to services.
 
-  我们倾向于让组件保持精简。组件本身不从服务器获得数据、不进行验证输入，也不直接往控制台写日志。
+  组件类应保持精简。组件本身不从服务器获得数据、不进行验证输入，也不直接往控制台写日志。
   它们把这些任务委托给服务。
 
   A component's job is to enable the user experience and nothing more. It mediates between the view (rendered by the template)
@@ -756,19 +764,19 @@ figure
   A good component presents properties and methods for data binding.
   It delegates everything nontrivial to services.
 
-  组件的任务就是提供用户体验，仅此而已。它介于视图(由模板渲染)和应用逻辑(通常包括_模型（model）_的观念)之间。
+  组件的任务就是提供用户体验，仅此而已。它介于视图（由模板渲染）和应用逻辑（通常包括_模型_的某些概念）之间。
-  设计良好的组件为数据绑定提供属性和方法，把那些其它对它们不重要的事情都委托给服务。
+  设计良好的组件为数据绑定提供属性和方法，把其它琐事都委托给服务。
 
   Angular doesn't *enforce* these principles.
   It won't complain if you write a "kitchen sink" component with 3000 lines.
 
-  Angular不会*强制要求*我们遵循这些原则。
+  Angular 不会*强制要求*我们遵循这些原则。
-  即使我们花3000行代码写了一个“厨房洗碗槽”组件，它也不会抱怨什么。
+  即使我们花 3000 行代码写了一个“厨房洗碗槽”组件，它也不会抱怨什么。
 
   Angular does help you *follow* these principles by making it easy to factor your
   application logic into services and make those services available to components through *dependency injection*.
 
-  Angular帮助我们*追随*这些原则 —— 它让我们能轻易地把应用逻辑拆分到服务，并通过*依赖注入*来在组件中使用这些服务。
+  Angular 帮助我们*遵循*这些原则 —— 它让我们能轻易地把应用逻辑拆分到服务，并通过*依赖注入*来在组件中使用这些服务。
 
 .l-hr
 
@@ -785,15 +793,15 @@ figure
   Angular uses dependency injection to provide new components with the services they need.
 
   “依赖注入”是提供类的新实例的一种方式，还负责处理好类所需的全部依赖。大多数依赖都是服务。
-  Angular也使用依赖注入提供我们需要的组件以及这些组件所需的服务。
+  Angular 使用依赖注入来提供新组件以及组件所需的服务。
 
 <br class="l-clear-both">
 :marked
   Angular can tell which services a component needs by looking at the types of its constructor parameters.
   For example, the constructor of your `HeroListComponent` needs a `HeroService`:
 
-  Angular通过查看构造函数的参数类型得知组件需要哪些服务。
+  Angular 通过查看构造函数的参数类型得知组件需要哪些服务。
-  例如，`HeroListComponent`组件的构造函数需要一个`HeroService`：
+  例如，`HeroListComponent`组件的构造函数需要一个`HeroService`服务：
 
 +makeExcerpt('app/hero-list.component.ts (constructor)', 'ctor')
 
@@ -801,7 +809,7 @@ figure
   When Angular creates a component, it first asks an **injector** for
   the services that the component requires.
 
-  当Angular创建组件时，会首先为组件所需的服务找一个**注入器（Injector）**。
+  当 Angular 创建组件时，会首先为组件所需的服务请求一个**注入器 (injector)**。
 
   An injector maintains a container of service instances that it has previously created.
   If a requested service instance is not in the container, the injector makes one and adds it to the container
@@ -811,8 +819,8 @@ figure
   This is *dependency injection*.
 
   注入器维护了一个服务实例的容器，存放着以前创建的实例。
-  如果所请求的服务实例不在容器中，注入器就会创建一个服务实例，并且添加到容器中，然后把这个服务返回给Angular。
+  如果所请求的服务实例不在容器中，注入器就会创建一个服务实例，并且添加到容器中，然后把这个服务返回给 Angular。
-  当所有请求的服务都被解析完并返回时，Angular会以这些服务为参数去调用组件的构造函数。
+  当所有请求的服务都被解析完并返回时，Angular 会以这些服务为参数去调用组件的构造函数。
   这就是*依赖注入* 。
 
   The process of `HeroService` injection looks a bit like this:
@@ -829,17 +837,17 @@ figure
   In brief, you must have previously registered a **provider** of the `HeroService` with the injector.
   A provider is something that can create or return a service, typically the service class itself.
 
-  简单的说，必须在要求注入`HeroService`之前，在注入器中注册`HeroService`的**提供商Provider**。
+  简单的说，必须在要求注入`HeroService`之前，在注入器中注册`HeroService`的**提供商 Provider**。
-  提供商用于创建并返回一个服务，通常是这个“服务类”本身。
+  提供商用于创建并返回一个服务，通常是服务类本身。
 
   You can register providers in modules or in components.
 
-  我们可以在模块上或组件上注册提供商。
+  我们可以在模块或组件中注册提供商。
 
   In general, add providers to the [root module](#module) so that
   the same instance of a service is available everywhere.
 
-  我们通常会把提供商添加到[根模块](#module)上，以便在任何地方使用服务的同一个实例。
+  通常会把提供商添加到[根模块](#module)上，以便在任何地方使用服务的同一个实例。
 
 +makeExample('app/app.module.ts', 'providers', 'app/app.module.ts (module providers)')(format='.')
 
@@ -854,7 +862,7 @@ figure
   Registering at a component level means you get a new instance of the
   service with each new instance of that component.
 
-  把它注册在组件级表示该组件的每一个新实例都会有一个(在该组件注册的)服务的新实例。
+  把它注册在组件级表示该组件的每一个新实例都会有一个服务的新实例。
 
   <!-- We've vastly oversimplified dependency injection for this overview.
   The full story is in the [dependency injection](dependency-injection.html) page. -->
@@ -868,27 +876,27 @@ figure
 
   * Dependency injection is wired into the Angular framework and used everywhere.
 
-  * 依赖注入渗透在整个Angular框架中，并且被到处使用。
+    依赖注入渗透在整个 Angular 框架中，被到处使用。
 
   * The *injector* is the main mechanism.
 
-  * **注入器（Injector）**是本机制的核心。
+    **注入器 (injector)** 是本机制的核心。
 
     * An injector maintains a *container* of service instances that it created.
 
-    * 注入器负责维护一个*容器*，用于存放它创建过的服务实例。
+      注入器负责维护一个*容器*，用于存放它创建过的服务实例。
 
     * An injector can create a new service instance from a *provider*.
 
-    * 注入器能使用*提供商*创建一个新的服务实例。
+      注入器能使用*提供商*创建一个新的服务实例。
 
   * A *provider* is a recipe for creating a service.
 
-  * *提供商*是一个用于创建服务的“配方”。
+    *提供商*是一个用于创建服务的配方。
 
   * Register *providers* with injectors.
 
-  * 把*提供商*注册到注入器。
+    把*提供商*注册到注入器。
 
 .l-hr
 
@@ -900,63 +908,63 @@ figure
 
   You've learned the basics about the eight main building blocks of an Angular application:
 
-  我们学到的这些只是关于Angular应用程序的八个主要构造块的基础知识：
+  我们学到的这些只是关于 Angular 应用程序的八个主要构造块的基础知识：
 
   * [Modules](#modules)
 
-  * [模块](#modules)
+    [模块](#modules)
 
   * [Components](#components)
 
-  * [组件](#components)
+    [组件](#components)
 
   * [Templates](#templates)
 
-  * [模板](#templates)
+    [模板](#templates)
 
   * [Metadata](#metadata)
 
-  * [元数据](#metadata)
+    [元数据](#metadata)
 
   * [Data binding](#data-binding)
 
-  * [数据绑定](#data-binding)
+    [数据绑定](#data-binding)
 
   * [Directives](#directives)
 
-  * [指令](#directives)
+    [指令](#directives)
 
   * [Services](#services)
 
-  * [服务](#services)
+    [服务](#services)
 
   * [Dependency injection](#dependency-injection)
 
-  * [依赖注入](#dependency-injection)
+    [依赖注入](#dependency-injection)
 
   That's a foundation for everything else in an Angular application,
   and it's more than enough to get going.
   But it doesn't include everything you need to know.
 
-  这是Angular应用程序中所有其它东西的基础，要使用Angular 2，以这些作为开端就绰绰有余了。
+  这是 Angular 应用程序中所有其它东西的基础，要使用 Angular，以这些作为开端就绰绰有余了。
   但它仍然没有包含我们需要知道的全部。
 
   Here is a brief, alphabetical list of other important Angular features and services.
   Most of them are covered in this documentation (or soon will be).
 
-  这里是一个简短的、按字母排序的列表，列出了其它重要的Angular特性和服务。
+  这里是一个简短的、按字母排序的列表，列出了其它重要的 Angular 特性和服务。
-  它们大多数已经(或即将)包括在这份开发文档中：
+  它们大多数已经（或即将）包括在这份开发文档中：
 
   > [**Animations**](animations.html): Animate component behavior
   without deep knowledge of animation techniques or CSS with Angular's animation library.
 
-  > [**动画**](animations.html)：用Angular的动画库让组件动起来，而不需要对动画技术或CSS有深入的了解。
+  > [**动画**](animations.html)：用 Angular 的动画库让组件动起来，而不需要对动画技术或 CSS 有深入的了解。
 
   > **Change detection**: The change detection documentation will cover how Angular decides that a component property value has changed,
   when to update the screen, and how it uses **zones** to intercept asynchronous activity and run its change detection strategies.
 
-  > **变更检测**：变更检测文档会告诉你Angular是如何决定组件的属性值变化，什么时候该更新到屏幕，
+  > **变更检测**：变更检测文档会告诉你 Angular 是如何决定组件的属性值变化，什么时候该更新到屏幕，
-  以及它是如何利用**zones**来拦截异步活动并执行变更检测策略。
+  以及它是如何利用**区域 (zone)** 来拦截异步活动并执行变更检测策略。
 
   > **Events**: The events documentation will cover how to use components and services to raise events with mechanisms for
   publishing and subscribing to events.
@@ -965,11 +973,11 @@ figure
 
   > [**Forms**](forms.html): Support complex data entry scenarios with HTML-based validation and dirty checking.
 
-  > [**表单**](forms.html)：通过基于HTML的验证和脏检查机制支持复杂的数据输入场景。
+  > [**表单**](forms.html)：通过基于 HTML 的验证和脏检查机制支持复杂的数据输入场景。
 
   > [**HTTP**](server-communication.html): Communicate with a server to get data, save data, and invoke server-side actions with an HTTP client.
 
-  > [**HTTP**](server-communication.html)：通过这个HTTP客户端，可以与服务器通讯，以获得数据、保存数据和触发服务端动作。
+  > [**HTTP**](server-communication.html)：通过 HTTP 客户端，可以与服务器通讯，以获得数据、保存数据和触发服务端动作。
 
   > [**Lifecycle hooks**](lifecycle-hooks.html): Tap into key moments in the lifetime of a component, from its creation to its destruction,
   by implementing the lifecycle hook interfaces.
@@ -997,4 +1005,4 @@ code-example().
   > [**Testing**](testing.html): Run unit tests on your application parts as they interact with the Angular framework
   using the _Angular Testing Platform_.
 
-  > [**测试**](testing.html)：使用Angular测试工具运行单元测试，在你的应用与Angular框架交互时进行测试。
+  > [**测试**](testing.html)：使用 _Angular 测试平台_，在你的应用部件与 Angular 框架交互时进行单元测试。