From a2d6add5fe69893f585524a2bc5f890a8ebe69c1 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Sun, 8 May 2016 21:00:15 +0800
Subject: [PATCH 01/12] =?UTF-8?q?=E7=BF=BB=E8=AF=91=E4=BA=86=E5=A4=A7?=
 =?UTF-8?q?=E9=83=A8=E5=88=86=E2=80=9C=E6=A8=A1=E6=9D=BF=E8=AF=AD=E6=B3=95?=
 =?UTF-8?q?=E2=80=9D=E7=AB=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 public/docs/_includes/_side-nav.jade          |   1 -
 .../ts/latest/guide/dependency-injection.jade |   5 +-
 .../docs/ts/latest/guide/template-syntax.jade | 683 +++++++++++++++++-
 3 files changed, 669 insertions(+), 20 deletions(-)

diff --git a/public/docs/_includes/_side-nav.jade b/public/docs/_includes/_side-nav.jade
index 6e9bd4797a..2abdb30872 100644
--- a/public/docs/_includes/_side-nav.jade
+++ b/public/docs/_includes/_side-nav.jade
@@ -104,7 +104,6 @@ nav.side-nav.l-pinned-left.l-layer-4.l-offset-nav
             li(class="nav-list-item #{item.class}"): a(href="#{item.href}" title="#{item.tooltip}") #{item.navTitle}
 
     .nav-blocks
-      a(class="nav-title #{isApiReferenceSelected()}" href="#{reference[0].href}" title="#{reference[0].tooltip}") API Reference
       a(class="nav-title #{isApiReferenceSelected()}" href="#{reference[0].href}" title="#{reference[0].tooltip}") API参考
 
 script.
diff --git a/public/docs/ts/latest/guide/dependency-injection.jade b/public/docs/ts/latest/guide/dependency-injection.jade
index 06f8a72215..28683976de 100644
--- a/public/docs/ts/latest/guide/dependency-injection.jade
+++ b/public/docs/ts/latest/guide/dependency-injection.jade
@@ -9,7 +9,7 @@ include ../_util-fns
 
   **依赖注入** 是一个很重要的程序设计模式。
   Angular有自己的依赖注入框架，离开了它，我们几乎没法构建Angular应用。
-  它使用的是如此广泛，以至于几乎每个人都会把它简称为 _DI_ 。
+  它使用得非常广泛，以至于几乎每个人都会把它简称为 _DI_ 。
   
   In this chapter we'll learn what DI is and why we want it.
   Then we'll learn [how to use it](#angular-di) in an Angular app.
@@ -1401,5 +1401,4 @@ p.
     在`forwardRef()`方法的帮助下，我们实际上也可以先定义组件。
     它的原理解释在[这个博客中](http://blog.thoughtram.io/angular/2015/09/03/forward-references-in-angular-2.html)。
     但是为什么要先给自己找麻烦呢？
-    还是通过在独立的文件中定义组件和服务，完全消除此问题吧。
-    
\ No newline at end of file
+    还是通过在独立的文件中定义组件和服务，完全避免此问题吧。
diff --git a/public/docs/ts/latest/guide/template-syntax.jade b/public/docs/ts/latest/guide/template-syntax.jade
index 8933106cb7..81351ccc7f 100644
--- a/public/docs/ts/latest/guide/template-syntax.jade
+++ b/public/docs/ts/latest/guide/template-syntax.jade
@@ -3,67 +3,104 @@ include ../_util-fns
 // #docregion intro
 :marked
   Our Angular application manages what the user sees and does through the interaction of a Component class instance (the *component*) and its user-facing template.
+  
+  我们的Angular应用管理着用户之所见，并通过组件类的实例以及组件面向用户的模板来与用户交互。
 
   Many of us are familiar with the component/template duality from our experience with model-view-controller (MVC) or model-view-viewmodel (MVVM). In Angular,  the component plays the part of the controller/viewmodel, and the template represents the view.
+  
+  从使用模型-视图-控制器(MVC)或模型-视图-视图模型(MVVM)的经验中，很多用户都熟悉了组件/模板这两个概念。
+  在Angular中，组件扮演着控制器部分或视图模型部分，模板则用来表示视图部分。
 
   Let’s find out what it takes to write a template for our view. We’ll cover these basic elements of template syntax:
+  
+  我们来看看写视图的模板都需要什么。我们将覆盖模板语法中的下列基本元素：
 
   * [HTML](#html)
   * [Interpolation](#interpolation)
+  * [插值表达式](#interpolation)
   * [Template expressions](#template-expressions)
+  * [模板表达式](#template-expressions)
   * [Template statements](#template-statements)
+  * [模板语句](#template-statements)
   * [Binding syntax](#binding-syntax)
+  * [绑定语法](#binding-syntax)
   * [Property binding](#property-binding)
+  * [属性绑定](#property-binding)
   * [Attribute, class, and style bindings](#other-bindings)
+  * [元素属性、class和style绑定](#other-bindings)
   * [Event binding](#event-binding)
+  * [事件绑定](#event-binding)
   * [Two-way data binding with `NgModel`](#ngModel)
+  * [使用`NgModel`进行双向数据绑定](#ngModel)
   * [Built-in directives](#directives)
+  * [内置指令](#directives)
     * [NgClass](#ngClass)
     * [NgStyle](#ngStyle)
     * [NgIf](#ngIf)
     * [NgSwitch](#ngSwitch)
     * [NgFor](#ngFor)
   * [* and &lt;template>](#star-template)
+  * [* 和 &lt;模板>](#star-template)
   * [Template reference variables](#ref-vars)
+  * [模板引用变量](#ref-vars)
   * [Input and output properties](#inputs-outputs)
+  * [输入输出属性](#inputs-outputs)
   * [Template expression operators](#expression-operators)
+  * [模板表达式操作符](#expression-operators)
     * [pipe](#pipe)
     * ["safe navigation operator" (?.)](#safe-navigation-operator)
+    * ["安全导航操作符" (?.)](#safe-navigation-operator)
 // #enddocregion intro
 .l-sub-section
   :marked
     The [live example](/resources/live-examples/template-syntax/ts/plnkr.html)
     demonstrates all of the syntax and code snippets described in this chapter.
 
+    这个[鲜活范例](/resources/live-examples/template-syntax/ts/plnkr.html)演示了本章中描述的所有语法和代码片段。
 // #docregion html-1
 .l-main-section
 :marked
   ## HTML
   HTML is the language of the Angular template. Our [QuickStart](../quickstart.html) application had a template that was pure HTML:
+  
+  HTML是Angular模板的“语言”。我们的[QuickStart](../quickstart.html)应用就有一个模板是纯HTML的：
 // #enddocregion html-1
 
 +makeExample('template-syntax/ts/app/app.component.html', 'my-first-app')(format=".")
 // #docregion html-2
 :marked
   Almost all HTML syntax is valid template syntax. The `<script>` element is a notable exception; it is forbidden, eliminating the risk of script injection attacks. (In practice, `<script>` is simply ignored.)
+  
+  几乎所有的HTML语法都是有效的模板语法。但值得注意的是`<script>`元素是个例外，它被禁用了，以阻止脚本注入攻击的风险。（在实践中，`<script>`只是被简单的忽略了。）
 
   Some legal HTML doesn’t make much sense in a template. The `<html>`, `<body>`, and `<base>` elements have no useful role in our repertoire. Pretty much everything else is fair game.
+  
+  在模板中，有些合法的HTML不会被用户感知。`<html>`、`<body>`和`<base>`元素在我们的舞台上中并没有扮演有用的角色。对所有其它的元素则一视同仁。
 
   We can extend the HTML vocabulary of our templates with components and directives that appear as new elements and attributes. And we are about to learn how to get and set DOM values dynamically through data binding.
+  
+  我们可以通过组件和指令来扩展模板中的HTML词汇。它们看上去就是新元素和Attribute。我们即将学习如何通过数据绑定来动态获取/设置DOM的值。
 
   Let’s turn to the first form of data binding &mdash; interpolation &mdash; to see how much richer template HTML can be.
+  
+  我们拿数据绑定的第一种形式 —— 插值表达式 —— 来看看模板的HTML可以有多丰富。
 // #enddocregion html-2
 
 // #docregion interpolation-1
 .l-main-section
 :marked
   ## Interpolation
+  ## 插值表达式
   We met the double-curly braces of interpolation, `{{` and `}}`, early in our Angular education.
+  
+  在以前的Angular教程中，我们遇到过由双花括号括起来的插值表达式，`{{`和`}}`。
 // #enddocregion interpolation-1
 +makeExample('template-syntax/ts/app/app.component.html', 'first-interpolation')(format=".")
 // #docregion interpolation-2
 :marked
   We use interpolation to weave calculated strings into the text between HTML element tags and within attribute assignments.
+  
+  我们使用插值表达式来把计算所得的字符串插入HTML元素标签内的文本以及对标签Attribute进行赋值。
 // #enddocregion interpolation-2
 
 +makeExample('template-syntax/ts/app/app.component.html', 'title+image')(format=".")
@@ -72,27 +109,42 @@ include ../_util-fns
   The material between the braces is often the name of a component property. Angular replaces that name with the
   string value of the corresponding component property. In this example, Angular evaluates the `title` and `heroImageUrl` properties
   and "fills in the blanks", displaying first a bold application title and then a heroic image.
+  
+  在括号之间的“素材”，通常是组件属性的名字。Angular会使用组件中这个名字属性的字符串值，替换这个名字。
+  在这个例子中，Angualr计算`title`和`heroImageUrl`属性的值，并把它们填在空白处。首先显示一个粗体的应用标题，然后显示英雄的图片。
 
   More generally, the material between the braces is a **template expression** that Angular first **evaluates**
   and then **converts to a string**. The following interpolation illustrates the point by adding the two numbers within braces:
+  
+  更一般化的说法是：括号间的素材是一个 **模板表达式** ，Angular首先 **对它求值** 然后把它 **转换成字符串** 。下列插值表达式通过把括号中的两个数字相加说明了这一点：
 // #enddocregion interpolation-3
 +makeExample('template-syntax/ts/app/app.component.html', 'sum-1')(format=".")
 // #docregion interpolation-4
 :marked
   The expression can invoke methods of the host component, as we do here with `getVal()`:
+  
+  这个表达式可以调用所属组件的方法，就像下面用的`getVal()`：
 // #enddocregion interpolation-4
 +makeExample('template-syntax/ts/app/app.component.html', 'sum-2')(format=".")
 // #docregion interpolation-5
 :marked
   Angular evaluates all expressions in double curly braces, converts the expression results to strings, and concatenates them with neighboring literal strings. Finally,
   it assigns this composite interpolated result to an **element or directive property**.
+  
+  Angular求值所有双花括号中的表达式，把表达式的结果转换成字符串，并且把它们跟相邻的字符串字面量连接起来。最后，它把这个组合出的插值结果赋给一个 **元素或指令的属性** 。
 
   We appear to be inserting the result between element tags and assigning to attributes.
   It's convenient to think so, and we rarely suffer for this mistake.
   But it is not literally true. Interpolation is a special syntax that Angular converts into a
   [property binding](#property-binding), as we'll explain below.
+  
+  表面上看，我们在元素标签之间插入了结果或者对标签的Attribute进行了赋值。
+  这样思考很方便，并且很少给我们带来错误。
+  但严格来讲，这是不对的。插值表达式是一个特殊的语法，Angular把它转换成了一个[属性绑定](#property-binding)，我们后面将会解释这一点。
 
   But first, let's take a closer look at template expressions and statements.
+  
+  但是，让我们先仔细审视下模板表达式和模板语句。
 // #enddocregion interpolation-5
 
 // #docregion template-expressions-1
@@ -100,13 +152,20 @@ include ../_util-fns
 .l-main-section
 :marked
   ## Template expressions
+  ## 模板表达式
   A template **expression** produces a value.
   Angular executes the expression and assigns it to a property of a binding target;
   the target might be an HTML element, a component, or a directive.
+  
+  模板 **表达式** 产生一个值。
+  Angular执行这个表达式，并且把它赋值给绑定目标的一个属性（property），这个绑定目标可能是一个HTML元素、一个组件或一个指令。
 
   We put a template expression within the interpolation braces when we wrote `{{1 + 1}}`.
   We’ll see template expressions again in the [property binding](#property-binding) section,
   appearing in quotes to the right of the `=` symbol as in `[property]="expression"`.
+  
+  当我们写`{{1 + 1}}`时，我们往插值表达式的括号中放进了一个模板表达式。
+  我们会在[属性绑定](#property-binding)中再次看到模板表达式，它出现在`=`右侧的引号中，看起来像这样：`[property]="expression"`。
 // #enddocregion template-expressions-1
 
 // #docregion template-expressions-2
@@ -115,85 +174,143 @@ include ../_util-fns
   Many JavaScript expressions are legal template expressions, but not all.
   JavaScript expressions that have or promote side effects are prohibited,
   including:
+  
+  我们用来写模板表达式的是一种看起来很像JavaScript的语言。
+  很多JavaScript表达式也是合法的模板表达式，但不是全部。
+  JavaScript中那些具有或引发副作用的表达式是被禁止的，包括：
 
   * assignments (`=`, `+=`, `-=`)
+  * 赋值 (`=`, `+=`, `-=`)
   * the `new` operator
+  * `new`运算符
   * chaining expressions with `;` or `,`
+  * 使用`;`或`,`的链式表达式
   * increment and decrement operators (`++` and `--`)
+  * 自增或自减操作符(`++`和`--`)
 
   Other notable differences from JavaScript syntax include:
+  
+  其它和JavaScript语法的显著不同点包括：
 
   * no support for the bitwise operators `|` and `&`
+  * 不支持位运算 `|` 和 `&`
   * new [template expression operators](#expression-operators), such as `|` and `?.`
+  * 具有新的 [模板表达式运算符](#expression-operators)，比如`|`和`?.`
 // #enddocregion template-expressions-2
 
 // #docregion template-expressions-context
 - var lang = current.path[1]
 - var details = lang === 'dart' ? 'template expressions can’t refer to static properties, nor to top-level variables or functions, such as <code>window</code> or <code>document</code> from <code>dart:html</code>. They can’t directly call <code>print</code> or functions imported from <code>dart:math</code>. They are restricted to referencing members of the expression context.' : 'template expressions cannot refer to anything in the global namespace. They can’t refer to <code>window</code> or <code>document</code>. They can’t call <code>console.log</code> or <code>Math.max</code>. They are restricted to referencing members of the expression context.'
+- var detailsCn = lang === 'dart' ? '模板表达式不能引用静态属性或顶级变量或函数，比如<code>window</code> 或 来自于 <code>dart:html</code>的<code>document</code>。它们不能直接调用<code>print</code>或从<code>dart:math</code>的函数。它们被局限于只能引用来自表达式上下文中的可引用成员' : '模板表达式不能引用全局命名空间中的任何东西。它们不能引用<code>window</code>或<code>document</code>。它们不能调用<code>console.log</code>或<code>Math.max</code>。它们被局限于只能访问来自表达式上下文中的成员。'
 :marked
   <a id="expression-context"></a>
   ### Expression context
+  ### 表达式上下文
 
   Perhaps more surprising, !{details}
+  
+  你可能会感到惊讶，!{detailsCn}
 
   The *expression context* is typically the **component instance**, which is
   the source of binding values.
+  
+  典型的 *表达式上下文* 就是 **这个组件的实例** ，它是绑定值的源。
 
   When we see *title* wrapped in double-curly braces, <code>{{title}}</code>,
   we know that `title` is a property of the data-bound component.
   When we see *isUnchanged* in `[disabled]="isUnchanged"`,
   we know we are referring to that component's `isUnchanged` property.
+  
+  当看到包裹在双花括号中的 *title* （<code>{{title}}</code>）时，我们就知道`title`是这个数据绑定组件中的一个属性。
+  当看到`[disabled]="isUnchanged"`中的 *isUnchanged* 时，我们就知道我们正在引用该组件的`isUnchanged`属性。
 
   The component itself is usually the expression *context*, in which case
   the template expression usually references that component.
+  
+  组件本身通常就是表达式的 *上下文* ，这种情况下，模板表达式通常会引用那个组件。
 
   The expression context can include objects other than the component.
   A [template reference variable](#ref-vars) is one such alternative context object.
+  
+  表达式的上下文也可能包含组件之外的对象。
+  [template reference variable](#ref-vars)就是另外的上下文对象之一。
 // #enddocregion template-expressions-context
 
 // #docregion template-expressions-guidelines
 :marked
   <a id="no-side-effects"></a>
   ### Expression guidelines
+  ### 表达式指南
   Template expressions can make or break an application.
   Please follow these guidelines:
+  
+  模板表达式能成就或毁掉一个应用。请遵循下列指南：
 
   * [No visible side effects](#no-visible-side-effects)
+  * [没有可见的副作用](#no-visible-side-effects)
   * [Quick execution](#quick-execution)
+  * [执行迅速](#quick-execution)
   * [Simplicity](#simplicity)
+  * [非常简单](#simplicity)
   * [Idempotence](#idempotence)
+  * [幂等性](#idempotence)
 
   The only exceptions to these guidelines should be in specific circumstances that you thoroughly understand.
+  
+  这些指南中唯一的例外是：当你彻底理解了模板表达式之后，仍然觉得这个场景很特殊，那也可以不遵循它。
 
   #### No visible side effects
+  #### 没有可见的副作用
 
   A template expression should not change any application state other than the value of the
   target property.
+  
+  模板表达式除了目标属性的值以外，不应该改变应用的任何状态。
 
   This rule is essential to Angular's "unidirectional data flow" policy.
   We should never worry that reading a component value might change some other displayed value.
   The view should be stable throughout a single rendering pass.
+  
+  这条规则是Angular的“单向数据流”策略的基础。
+  我们永远不该担心读取一个模板值可能改变另外的显示值。
+  只要经过一遍渲染，视图就应该趋于稳定。
 
   #### Quick execution
+  #### 执行迅速
   Angular executes template expressions more often than we think.
   They can be called after every keypress or mouse move.
   Expressions should finish quickly or the user experience may drag, especially on slower devices.
   Consider caching values computed from other values when the computation is expensive.
+  
+  Angular执行模板表达式比我们想象的频繁。
+  它们可能在每一次按键或鼠标移动后被调用。表达式应该快速结束，否则用户就会感到拖沓，特别是在较慢的设备上。
+  当计算比较昂贵时，要考虑缓存那些从其它值计算而得出的值。
 
   #### Simplicity
+  #### 非常简单
   Although it's possible to write quite complex template expressions, we really shouldn't.
+  
+  虽然确实可能写出相当复杂的模板表达式，但我们真的不应该那样。
 
   A property name or method call should be the norm.
   An occasional Boolean negation (`!`) is OK.
   Otherwise, confine application and business logic to the component itself,
   where it will be easier to develop and test.
+  
+  一个属性名或方法调用属于常态。偶尔的逻辑取反(`!`)也还凑合。
+  其他情况下，组件会自己界定应用逻辑和业务逻辑，它将让开发和测试变得更容易。
 
   #### Idempotence
+  #### 幂等性
   An [idempotent](https://en.wikipedia.org/wiki/Idempotence) expression is ideal because
   it is free of side effects and improves Angular's change detection performance.
 
+  一个[幂等的](https://en.wikipedia.org/wiki/Idempotence)表达式更加理想，因为它没有副作用，而且能提升Angular变更检测的性能。
+  
   In Angular terms, an idempotent expression always returns *exactly the same thing* until
   one of its dependent values changes.
+  
+  用Angular的术语说，一个幂等的表达式应该总是返回 *完全相同的东西* ，直到它所依赖的值中的一个变化了。
 // #enddocregion template-expressions-guidelines
 // #docregion template-expressions-guidelines-2
 :marked
@@ -201,6 +318,10 @@ include ../_util-fns
   If an idempotent expression returns a string or a number, it returns the same string or number
   when called twice in a row. If the expression returns an object (including a `Date` or `Array`),
   it returns the same object *reference* when called twice in a row.
+  
+  在单独的一次消息循环中，被依赖的值应该不变。
+  如果一个幂等的表达式返回了一个字符串或数字，连续调用它两次，也应该返回相同的字符串或数字。
+  如果表达式返回一个对象（包括`Date`或`Array`），连续调用它两次，也应该返回同一个对象的 *引用* 。
 // #enddocregion template-expressions-guidelines-2
 
 // #docregion template-statements-1
@@ -208,60 +329,97 @@ include ../_util-fns
 .l-main-section
 :marked
   ## Template statements
+  ## 模板语句
 
   A template **statement** responds to an **event** raised by a binding target
   such as an element, component, or directive.
+  
+  模板 **语句** 用来响应由绑定目标（如HTML元素、组件或指令）触发的 **事件** 对象。
 
   We’ll see template statements in the [event binding](#event-binding) section,
   appearing in quotes to the right of the `=` symbol as in `(event)="statement"`.
+  
+  我们将在[事件绑定](#event-binding)一节看到模板语句，它出现在`=`号右侧的引号中，就像这样：`(event)="statement"`。
 
   A template statement *has a side effect*.
   It's how we update application state from user input.
   There would be no point to responding to an event otherwise.
+  
+  模板语句 *有副作用* 。
+  这个副作用就是我们从用户的输入更新应用状态的方式。
+  除此之外，我们将没办法响应一个事件。
 
 .l-sub-section
   :marked
     Responding to events is the other side of Angular's "unidirectional data flow".
     We're free to change anything, anywhere, during this turn of the event loop.
+    
+    响应事件是Angular中“单向数据流”的另一面。
+    在事件循环的这一回合中，我们可以随意改变任何地方的任何东西。
 // #enddocregion template-statements-1
 // #docregion template-statements-2
 :marked
   Like template expressions, template *statements* use a language that looks like JavaScript.
   The template statement parser is different than the template expression parser and
   specifically supports both basic assignment (`=`) and chaining expressions with semicolons (`;`) and commas (`,`).
+  
+  和模板表达式一样，模板 *语句* 也是一个一个看起来很像JavaScript的语言。
+  模板语句解析器和模板表达式解析器不同，它的特别之处在于它既支持支持基本赋值（`=`）又支持使用分号（`;`）和逗号（`,`）把表达式串起来。
 
   However, certain JavaScript syntax is not allowed:
+  
+  但无论如何，某些JavaScript语法仍然是不允许的：
   * the `new` operator
+  * `new`运算符
   * increment and decrement operators, `++` and `--`
+  * 自增和自减运算符：`++`和`--`
   * operator assignment, such as `+=` and `-=`
+  * 操作并赋值，比如`+=`和`-=`
   * the bitwise operators `|` and `&`
+  * 位操作符`|`和`&`
   * the [template expression operators](#expression-operators)
+  * [模板表达式运算符](#expression-operators)
 // #enddocregion template-statements-2
 
 // #docregion template-statements-3
 - var lang = current.path[1]
 - var details = lang === 'dart' ? 'Template statements can’t refer to static properties on the class, nor to top-level variables or functions, such as <code>window</code> or <code>document</code> from <code>dart:html</code>. They can’t directly call <code>print</code> or functions imported from <code>dart:math</code>.' : 'Template statements cannot refer to anything in the global namespace. They can’t refer to <code>window</code> or <code>document</code>. They can’t call <code>console.log</code> or <code>Math.max</code>.'
+- var detailsCn = lang === 'dart' ? '模板语句不能引用静态属性或顶级变量或函数，比如<code>window</code> 或 来自于 <code>dart:html</code>的<code>document</code>。它们不能直接调用<code>print</code>或从<code>dart:math</code>的函数。' : '模板语句不能引用全局命名空间中的任何东西。它们不能引用<code>window</code>或<code>document</code>。它们不能调用<code>console.log</code>或<code>Math.max</code>。'
 :marked
   ### Statement context
+  ### 语句上下文
 
   As with expressions, statements can refer only to what's in the statement context — typically the
   **component instance** to which we're binding the event.
   !{details}
+  
+  和表达式中一样，语句只能引用语句上下文中 —— 典型的就是我们正在绑定事件的那个 **组件的实例** —— 中的内容。
 
   The *onSave* in `(click)="onSave()"` is sure to be a method of the data-bound component instance.
+  
+  `(click)="onSave()"`中的 *onSave* 就是数据绑定组件实例中的一个方法。
 
   The statement context may include an object other than the component.
   A [template reference variable](#ref-vars) is one such alternative context object.
   We'll frequently see the reserved `$event` symbol in event binding statements,
   representing the "message" or "payload" of the raised event.
+  
+  语句上下文可以包含组件之外的对象。
+  [模板引用对象](#ref-vars)就是这些候选上下文对象中的一个。
+  在事件绑定语句中，我们将频繁的看到保留的`$event`符号，代表来自所触发事件的“消息”或“有效载荷”。
 
   ### Statement guidelines
+  ### 语句指南
 
   As with expressions, avoid writing complex template statements.
   A method call or simple property assignment should be the norm.
+  
+  和表达式一样，要避免写复杂的模板语句。单一函数调用或者单一属性访问应该是常态。
 
   Now that we have a feel for template expressions and statements,
   we’re ready to learn about the varieties of data binding syntax beyond interpolation.
+  
+  现在，我们对模板表达式和语句有了一点感觉，是时候学习除了插值表达式之外多种多样的数据绑定语法了。
 // #enddocregion template-statements-3
 
 // #docregion binding-syntax-1
@@ -269,16 +427,27 @@ include ../_util-fns
 :marked
   <a id="binding-syntax"></a>
   ## Binding syntax: An overview
+  ## 绑定语法：概览
   Data binding is a mechanism for coordinating what users see with application data values.
   While we could push values to and pull values from HTML,
   the application is easier to write, read, and maintain if we turn these chores over to a binding framework.
   We simply declare bindings between binding sources and target HTML elements and let the framework do the work.
+  
+  数据绑定是一种机制，用来协调用户所见与应用数据的值。
+  虽然我们能往HTML推送值或者从HTML拉取值，但如果我们能把这些琐事放进数据绑定框架，应用就会更容易写、读以及维护。
+  我们只要简单的在绑定源和目标HTML元素之间建立绑定，框架就会完成这项工作。
 
   Angular provides many kinds of data binding, and we’ll discuss each of them in this chapter.
   First we'll take a high-level view of Angular data binding and its syntax.
+  
+  Angular提供很多种数据绑定，我们将在本章中逐一讨论它们。
+  首先，我们来看看Angular数据绑定的高层视角及其语法。
 
   We can group all bindings into three categories by the direction in which data flows.
   Each category has its distinctive syntax:
+  
+  根据数据流的方向，我们可以把所有绑定归为三类。
+  每一类都有它独特的语法：
 table
   tr
     th Data direction
@@ -297,54 +466,108 @@ table
       Attribute<br>
       Class<br>
       Style
-    tr
-      td One-way<br>from view target<br>to data source
-      td
-        code-example(format="" ).
-          (target) = "statement"
-          on-target = "statement"
-      td Event
-    tr
-      td Two-way
-      td
-        code-example(format="" ).
-          [(target)] = "expression"
-          bindon-target = "expression"
-      td Two-way
+  tr
+    td One-way<br>from view target<br>to data source
+    td
+      code-example(format="" ).
+        (target) = "statement"
+        on-target = "statement"
+    td Event
+  tr
+    td Two-way
+    td
+      code-example(format="" ).
+        [(target)] = "expression"
+        bindon-target = "expression"
+    td Two-way
+
+table
+  tr
+    th 数据流方向
+    th 语法
+    th 绑定类型
+  tr
+    td 单向<br>从数据源<br>到目标视图
+    td
+      code-example(format="" ).
+        {{expression}}
+        [target] = "expression"
+        bind-target = "expression"
+    td.
+      插值表达式<br>
+      属性<br>
+      Attribute<br>
+      类Class<br>
+      风格Style
+  tr
+    td 单向<br>从目标视图<br>到数据源
+    td
+      code-example(format="" ).
+        (target) = "statement"
+        on-target = "statement"
+    td 事件
+  tr
+    td 双向
+    td
+      code-example(format="" ).
+        [(target)] = "expression"
+        bindon-target = "expression"
+    td 双向
 
 :marked
   Binding types other than interpolation have a **target name** to the left of the equal sign,
   either surrounded by punctuation (`[]`, `()`) or preceded by a prefix (`bind-`, `on-`, `bindon-`).
+  
+  除了插值表达式之外的绑定类型，在等号左边都有一个 **目标名** ，无论是包在括号中（`[]`、`()`）还是带有前缀（`bind-`、`on-`、`bindon-`）。
 
   What is that target? Before we can answer that question, we must challenge ourselves to look at template HTML in a new way.
+  
+  什么是“目标”？在回答这个问题之前，我们必须挑战自我，尝试用另一种方式来审视模板中的HTML。
 
   ### A new mental model
+  ### 一个新的思维模型
 
   With all the power of data binding and our ability to extend the HTML vocabulary
   with custom markup, it is tempting to think of template HTML as *HTML Plus*.
+  
+  借助数据绑定的威力和我们的能力来使用自定义语言扩展HTML词汇，它误导我们把模板HTML当做 *HTML+* 。
 
   Well, it *is* HTML Plus.
   But it’s also significantly different than the HTML we’re used to.
   We really need a new mental model.
+  
+  也对，它 *是* HTML+ 。
+  但它也跟我们用过的那些HTML有着显著的不同。
+  我们需要一种新的思维模型。
 
   In the normal course of HTML development, we create a visual structure with HTML elements, and
   we modify those elements by setting element attributes with string constants.
+  
+  在通常的HTML开发过程中，我们使用HTML元素创建一个视觉结构，并且通过把字符串常量设置给元素的Attribute来修改那些元素。
 // #enddocregion binding-syntax-1
 
 +makeExample('template-syntax/ts/app/app.component.html', 'img+button')(format=".")
 // #docregion binding-syntax-2
 :marked
   We still create a structure and initialize attribute values this way in Angular templates.
+  
+  我们还创建了一个结构，并且在Angular模板中用这种方式初始化Attribute值。
 
   Then we learn to create new elements with components that encapsulate HTML
   and drop them into our templates as if they were native HTML elements.
+  
+  然后，我们学着通过包含HTML的组件创建新元素，然后，如果把它扔进我们的模板，就像它是原生的HTML元素一样。
 // #enddocregion binding-syntax-2
 +makeExample('template-syntax/ts/app/app.component.html', 'hero-detail-1')(format=".")
 // #docregion binding-syntax-3
 :marked
   That’s HTML Plus.
+  
+  这就是HTML+。
 
   Now we start to learn about data binding. The first binding we meet might look like this:
+  
+  现在我们开始学习数据绑定。我们碰到的第一种数据绑定看起来是这样的：
 // #enddocregion binding-syntax-3
 
 +makeExample('template-syntax/ts/app/app.component.html', 'disabled-button-1')(format=".")
@@ -353,82 +576,140 @@ table
   We’ll get to that peculiar bracket notation in a moment. Looking beyond it,
   our intuition tells us that we’re binding to the button's `disabled` attribute and setting
   it to the current value of the component’s `isUnchanged` property.
+  
+  我们首先会注意到这个怪异的括号注解。接下来，直觉告诉我们，我们正在绑定到这个按钮的`disabled` Attribute。
+  并且把它设置为组件的`isUnchanged`属性（property）的当前值。
 
   Our intuition is wrong! Our everyday HTML mental model is misleading us.
   In fact, once we start data binding, we are no longer working with HTML *attributes*. We aren't setting attributes.
   We are setting the *properties* of DOM elements, components, and directives.
+  
+  但我们的直觉是错的！以前的思维模型在误导我们。
+  实际上，一旦我们开始数据绑定，我们就不再跟Attribute一起玩儿了。我们不是在设置Attribute。
+  我们在设置DOM元素、组件和指令的属性。
 // #enddocregion binding-syntax-4
 
 // #docregion binding-syntax-attribute-vs-property
 .l-sub-section
   :marked
     ### HTML attribute vs. DOM property
+    ### HTML的Attribute vs. DOM的Property
 
     The distinction between an HTML attribute and a DOM property is crucial to understanding how Angular binding works.
+    
+    要想理解Angular绑定如何工作，清楚HTML Attribute和DOM Property之间的区别是至关重要的。
 
     **Attributes are defined by HTML. Properties are defined by the DOM (Document Object Model).**
+    
+    **Attribute是由HTML定义的。Property是由DOM（Document Object Model）定义的。**
 
     * A few HTML attributes have 1:1 mapping to properties. `id` is one example.
+    
+    * 少量HTML Attribute和Property之间有着1:1的映射。`id`就是一个例子。
 
     * Some HTML attributes don't have corresponding properties. `colspan` is one example.
+    
+    * 一些HTML Attribute没有对应的Property。`colspan`就是一个例子。
 
     * Some DOM properties don't have corresponding attributes. `textContent` is one example.
+    
+    * 一些DOM Property没有对应的Attribute。`textContent`就是一个例子。
 
     * Many HTML attributes appear to map to properties ... but not in the way we might think!
+    
+    * 许多HTML Attribute看起来映射到了Property…… 但却不是我们自以为的那样！
 
     That last category can be especially confusing ... until we understand this general rule:
+    
+    尤其最后一种更让人困惑…… 除非我们能理解这个普遍原则：
 
     **Attributes *initialize* DOM properties and then they are done.
     Property values can change; attribute values can't.**
+    
+    **Attribute *初始化* DOM Property，然后它们的任务就完成了。Property的值可以改变；Attribute的值不能改变。**
 
     For example, when the browser renders `<input type="text" value="Bob">`, it creates a
     corresponding DOM node with a `value` property *initialized* to "Bob".
+    
+    例如，当浏览器渲染`<input type="text" value="Bob">`时，它创建了一个对应的DOM节点，它的`value`Property被 *初始化为* “Bob”。
 
     When the user enters "Sally" into the input box, the DOM element `value` *property* becomes "Sally".
     But the HTML `value` *attribute* remains unchanged as we discover if we ask the input element
     about that attribute: `input.getAttribute('value') // returns "Bob"`
 
+    当用户在输入框中输入 “Sally” 时，DOM元素的`value` *Property* 变成了“Sally”。
+    但是这个HTML`value` *Attribute* 保持不变。
+    如果我们通过`input.getAttribute('value') // returns "Bob"`获取这个input元素的Attribute，就会明白这一点。
+
     The HTML attribute `value` specifies the *initial* value; the DOM `value` property is the *current* value.
+    
+    HTML Attribute `value`指定了初始值；DOM的`value`Property 是 *当前* 值。
 
     The `disabled` attribute is another peculiar example. A button's `disabled` *property* is
     `false` by default so the button is enabled.
     When we add the `disabled` *attribute*, its presence alone initializes the  button's `disabled` *property* to `true`
     so the button is disabled.
+    
+    `disabled` Attribute是另一个古怪的例子。按钮的`disabled` *Property* 是`false`，因为默认情况下按钮是可用的。
+    当我们添加`disabled` *Attribute* 时，它只要出现就表示按钮的`disabled` *Property* 是`true`，于是按钮就被禁用了。
 
     Adding and removing the `disabled` *attribute* disables and enables the button. The value of the *attribute* is irrelevant,
     which is why we cannot enable a button by writing `<button disabled="false">Still Disabled</button>`.
+    
+    添加或删除`disabled` *Attribute* 会禁用或启用这个按钮。但 *Attribute* 的值无关紧要，这就是我们为什么没法通过
+    `<button disabled="false">仍被禁用</button>`这种写法来启用一个按钮的原因。
 
     Setting the button's `disabled` *property*  (say, with an Angular binding) disables or enables the button.
     The value of the *property* matters.
+    
+    设置按钮的`disabled` *Property* （比如，通过Angular绑定）可以禁用或启用这个按钮。
+    这就是 *Property* 的价值。
 
     **The HTML attribute and the DOM property are not the same thing, even when they have the same name.**
+    
+    **就算名字相同，HTML Attribute和DOM Property也不是同一样东西。**
 // #enddocregion binding-syntax-attribute-vs-property
 
 // #docregion binding-syntax-5
 :marked
   This is so important, we’ll say it again.
+  
+  这句话很重要，我们得再强调一次：
 
   **Template binding works with *properties* and *events*, not *attributes*.**
+  
+  **模板绑定是用 *Property* 和 *事件* 来工作的，而不是 *Attribute* 。**
 // #enddocregion binding-syntax-5
 
 // #docregion binding-syntax-world-without-attributes
 .callout.is-helpful
   header A world without attributes
+  header 一个没有Attribute的世界
   :marked
     In the world of Angular 2, the only role of attributes is to initialize element and directive state.
     When we data bind, we're dealing exclusively with element and directive properties and events.
     Attributes effectively disappear.
+    
+    在Angular 2的世界中，Attribute唯一的作用是用来初始化元素和指令的状态。
+    当进行数据绑定时，我们只是在与元素和指令的属性和事件打交道，而Attribute就完全靠边站了。
 // #enddocregion binding-syntax-world-without-attributes
 // #docregion binding-syntax-targets
 :marked
   With this model firmly in mind, let's learn about binding targets.
+  
+  请把这个模型牢牢的印在脑子里，接下来我们学习什么是“绑定目标”。
 
   ### Binding targets
+  ### 绑定目标
   The **target of a data binding** is something in the DOM.
   Depending on the binding type, the target can be an
   (element | component | directive) property, an
   (element | component | directive) event, or (rarely) an attribute name.
   The following table summarizes:
+  
+  **数据绑定的目标** 是DOM中的某些东西。
+  这个目标可能是（元素|组件|指令）的属性、（元素|组件|指令）的事件，或（极少数情况下）一个Attribute名。
+  下面是的汇总表：
 // #enddocregion binding-syntax-targets
 
 // If you update this table, UPDATE it in Dart & JS, too.
@@ -481,60 +762,134 @@ table
       +makeExample('template-syntax/ts/app/app.component.html', 'style-binding-syntax-1')(format=".")
 </div>
 
+table
+  tr
+    th 绑定类型
+    th 目标
+    th 范例
+  tr
+    td 属性
+    td.
+      元素&nbsp;属性<br>
+      组件&nbsp;属性<br>
+      指令&nbsp;属性
+    td
+      +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-syntax-1')(format=".")
+  tr
+    td 事件
+    td.
+      元素&nbsp;事件<br>
+      组件&nbsp;事件<br>
+      指令&nbsp;事件
+    td
+      +makeExample('template-syntax/ts/app/app.component.html', 'event-binding-syntax-1')(format=".")
+  tr
+    td 双向
+    td.
+      事件和属性
+    td
+      +makeExample('template-syntax/ts/app/app.component.html', '2-way-binding-syntax-1')(format=".")
+  tr
+    td Attribute
+    td.
+      Attribute(例外情况)
+    td
+      +makeExample('template-syntax/ts/app/app.component.html', 'attribute-binding-syntax-1')(format=".")
+  tr
+    td 类
+    td.
+      <code>class</code>属性
+    td
+      +makeExample('template-syntax/ts/app/app.component.html', 'class-binding-syntax-1')(format=".")
+  tr
+    td 样式
+    td.
+      <code>style</code>属性
+    td
+      +makeExample('template-syntax/ts/app/app.component.html', 'style-binding-syntax-1')(format=".")
+</div>
+
 // #docregion binding-syntax-end
 :marked
   Let’s descend from the architectural clouds and look at each of these binding types in concrete detail.
+  
+  让我们从云端视角降下来，看看每种绑定类型的具体情况。
 // #enddocregion binding-syntax-end
 
 // #docregion property-binding-1
 .l-main-section
 :marked
   ## Property binding
+  ## 属性绑定
   We write a template **property binding** when we want to set a property of a view element to the value of
   a [template expression](#template-expressions).
+  
+  当想把一个视图元素的属性设置为[模板表达式](#template-expressions)时，我们就要写模板的 **属性绑定** 。
 
   The most common property binding sets an element property to a component property value. An example is
   binding the `src` property of an image element to a component’s `heroImageUrl` property:
+  
+  这种最常用的属性绑定把元素的属性设置为组件中属性的值。
+  下面这个例子中，把image元素的`src`属性绑定到组件的`heroImageUrl`属性上：
 // #enddocregion property-binding-1
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-1')(format=".")
 // #docregion property-binding-2
 :marked
   Another example is disabling a button when the component says that it `isUnchanged`:
+  
+  另一个例子是当组件说它`isUnchanged`时禁用一个按钮：
 // #enddocregion property-binding-2
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-2')(format=".")
 // #docregion property-binding-3
 :marked
   Another is setting a property of a directive:
+  
+  另一个例子是设置指令的属性：
 // #enddocregion property-binding-3
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-3')(format=".")
 // #docregion property-binding-4
 :marked
   Yet another is setting the model property of a custom component (a great way
   for parent and child components to communicate):
+  
+  还有另一个例子是设置一个自定义组件的模型属性（这是父子组件之间通讯的重要途径）：
 // #enddocregion property-binding-4
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-4')(format=".")
 // #docregion property-binding-5
 :marked
   ### One-way *in*
+  ### 单向 *输入*
   People often describe property binding as *one-way data binding* because it flows a value in one direction,
   from a component’s data property into a target element property.
+  
+  人们经常把属性绑定描述成 *单向数据绑定* ，因为值的流动是单向的，从组件中的属性数据，流动到目标元素的属性。
 
   We cannot use property binding to pull values *out* of the target element.
   We can't bind to a property of the target element to read it. We can only set it.
+  
+  我们不能使用属性绑定来从目标元素拉取值，也不能绑定到目标元素的属性来读取它。我们只能设置它。
 // #enddocregion property-binding-5
 
 // #docregion property-binding-6
 .l-sub-section
   :marked
     Nor can we use property binding to *call* a method on the target element.
+    
+    我们也不能使用属性绑定来 *调用* 目标元素上的方法。
 
     If the element raises events we can listen to them with an [event binding](#event-binding).
+    
+    如果这个元素触发了事件，我们可以通过[事件绑定](#event-binding)来监听它们。
 
     If we must read a target element property or call one of its methods,
     we'll need a different technique.
     See the API reference for
     [viewChild](../api/core/ViewChild-var.html) and
     [contentChild](../api/core/ContentChild-var.html).
+    
+    如果我们不得不读取目标元素上的属性或调用它的某个方法，我们得用另一种技术。
+    参见API参考中的[viewChild](../api/core/ViewChild-var.html)和
+    [contentChild](../api/core/ContentChild-var.html)。
 // #enddocregion property-binding-6
 
 // TODO (global): once we have api docs everywhere, change /docs/ts/latest/ to ../
@@ -542,22 +897,31 @@ table
 // #docregion property-binding-7
 :marked
   ### Binding target
+  ### 绑定目标
   An element property between enclosing square brackets identifies the target property. The target property in the following code is the image element’s `src` property.
+  
+  包裹在方括号中的元素属性名用于标记目标属性。下列代码中的目标属性是image元素的`src`属性。
 
 // #enddocregion property-binding-7
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-1')(format=".")
 // #docregion property-binding-8
 :marked
   Some people prefer the `bind-` prefix alternative, known as the *canonical form*:
+  
+  有些人喜欢用`bind-`前缀的可选形式，称之为 *规范形式* ：
 // #enddocregion property-binding-8
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-5')(format=".")
 // #docregion property-binding-9
 :marked
   The target name is always the name of a property, even when it appears to be the name of something else. We see `src` and may think it’s the name of an attribute. No. It’s the name of an image element property.
+  
+  目标名总是属性的名字。即使它看起来和别的名字一样。我们看到`src`时，可能会把它当做Attribute。不！它不是！它是image元素的属性名。
 
   Element properties may be the more common targets,
   but Angular looks first to see if the name is a property of a known directive,
   as it is in the following example:
+  
+  元素属性可能是最常见的绑定目标，但Angular会先去看这个名字是否一个已知指令的属性，就像下列范例中一样：
 // #enddocregion property-binding-9
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-3')(format=".")
 
@@ -567,57 +931,99 @@ table
     Technically, Angular is matching the name to a directive [input](#inputs-outputs),
     one of the property names listed in the directive’s `inputs` array or a property decorated with `@Input()`.
     Such inputs map to the directive’s own properties.
+    
+    从技术的角度看，Angular正在匹配一个[input](#inputs-outputs)指令的名字。这个名字是指令的`inputs`数组中所列的名字之一，或者是一个带有`@Input()`装饰器的属性。
+    这个inputs被映射到了指令自己的属性。
 :marked
   If the name fails to match a property of a known directive or element, Angular reports an “unknown directive” error.
+  
+  如果名字没有匹配上一个已知指令或元素的属性，Angular会报告一个“未知指令”的错误。
 
   ### Avoid side effects
+  ### 消除副作用
   As we've already discussed, evaluation of a template expression should have no visible side effects. The expression language itself does its part to keep us safe. We can’t assign a value to anything in a property binding expression nor use the increment and decrement operators.
+  
+  正如我们曾讨论过的，计算模板表达式不能有可见的副作用。表达式语言本身可以提供一部分安全保障。我们不能在属性绑定表达式中对任何东西赋值，也不能使用自增、自减运算符。
 
   Of course, our expression might invoke a property or method that has side effects. Angular has no way of knowing that or stopping us.
+  
+  当然，我们的表达式也可能会调用一个具有副作用的属性或方法。但Angular没法知道这一点，也没法防止我们误用。
 
   The expression could call something like `getFoo()`. Only we know what `getFoo()` does.
   If `getFoo()` changes something and we happen to be binding to that something, we risk an unpleasant experience. Angular may or may not display the changed value. Angular may detect the change and throw a warning error. Our general advice: stick to data properties and to methods that return values and do no more.
+  
+  表达式中可以调用像`getFoo()`这样的方法。只有我们才知道`getFoo()`干了什么。
+  如果`getFoo()`改变了什么，而我们把它绑定在什么地方，我们就可能把自己坑了。Angular可能显示也可能不显示变化后的值。Angular可能检测到变化，并抛出一个警告型错误。
+  我们具有普遍性的建议是：盯紧数据源的属性和方法，确保它们只返回值而不做别的。
 
   ### Return the proper type
+  ### 返回恰当的类型
   The template expression should evaluate to the type of value expected by the target property.
   Return a string if the target property expects a string.
   Return a number if the target property expects a number.
   Return an object if the target property expects an object.
+  
+  模板表达式应该返回一个目标属性所需类型的值。
+  如果目标属性想要个字符串，就返回字符串。
+  如果目标属性想要个数字，就返回数字。
+  如果目标属性想要个对象，就返回对象。
 
   The `hero` property of the `HeroDetail` component expects a `Hero` object, which is exactly what we’re sending in the property binding:
+  
+  `HeroDetail`组件的`hero`属性想要一个`Hero`对象，那我们就要在属性绑定中精确的给它一个`Hero`对象：
 // #enddocregion property-binding-10
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-4')(format=".")
 // #docregion property-binding-11
 :marked
   ### Remember the brackets
+  ### 别忘了括号
   The brackets tell Angular to evaluate the template expression.
   If we forget the brackets, Angular treats the string as a constant and *initializes the target property* with that string.
   It does *not* evaluate the string!
+  
+  括号会告诉Angular计算模板表达式。
+  如果我们忘了括号，Angular就把这个表达式当做一个字符串常量看待，并且用它 *初始化目标属性* 。
+  它 *不会* 计算这个字符串。
 
   Don't make the following mistake:
+  
+  不要出现这样的失误：
 // #enddocregion property-binding-11
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-6')(format=".")
 // #docregion property-binding-12
 a(id="one-time-initialization")
 :marked
   ### One-time string initialization
+  ### 一次性字符串初始化
   We *should* omit the brackets when all of the following are true:
+  当下列条件满足时，我们不应该带括号：
   * The target property accepts a string value.
+  * 目标属性接受字符串值。
   * The string is a fixed value that we can bake into the template.
+  * 我们想合并到模板中的字符串是一个固定值。
   * This initial value never changes.
+  * 这个初始值永不改变。
 
   We routinely initialize attributes this way in standard HTML, and it works
   just as well for directive and component property initialization.
   The following example initializes the `prefix` property of the `HeroDetailComponent` to a fixed string,
   not a template expression. Angular sets it and forgets it.
+  
+  我们像在标准HTML中一样用这种方式初始化Attribute，它在初始化指令和组件的属性时也同样工作得很好。
+  下面这个例子把`HeroDetailComponent`的`prefix`属性初始化成了一个固定的字符串，而不是模板表达式。Angular设置它，然后忘记它。
 // #enddocregion property-binding-12
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-7')(format=".")
 // #docregion property-binding-13
 :marked
   The `[hero]` binding, on the other hand, remains a live binding to the component's `currentHero` property.
+  
+  作为对比，这个`[hero]`绑定就保持了到组件的`currentHero`属性的活绑定，它会一直随着更新。
 
   ### Property binding or interpolation?
+  ### 属性绑定还是插值表达式？
   We often have a choice between interpolation and property binding. The following binding pairs do the same thing:
+  
+  我们通常得在插值表达式和属性绑定之间做出选择。下列这几对绑定做的事情完全相同：
 // #enddocregion property-binding-13
 +makeExample('template-syntax/ts/app/app.component.html', 'property-binding-vs-interpolation')(format=".")
 // #docregion property-binding-14
@@ -625,11 +1031,18 @@ a(id="one-time-initialization")
   Interpolation is a convenient alternative for property binding in many cases.
   In fact, Angular  translates those interpolations into the corresponding property bindings
   before rendering the view.
+  
+  在多数情况下，插值表达式是一个更方便的选择。实际上，在渲染视图之前，Angular把这些插值表达式翻译成了对应的属性绑定形式。
 
   There is no technical reason to prefer one form to the other.
   We lean toward readability, which tends to favor interpolation.
   We suggest establishing coding style rules for the organization and choosing the form that
   both conforms to the rules and feels most natural for the task at hand.
+  
+  没有技术上的理由能决定哪种形式更好。
+  我们倾向于可读性，所以倾向于插值表达式。
+  我们建议建立组织级的代码风格规定，然后选择一种形式，既能遵循规则，又能让手头儿的任务做起来更自然。
+  
 // #enddocregion property-binding-14
 
 // #docregion other-bindings-1
@@ -637,20 +1050,32 @@ a(id="one-time-initialization")
 :marked
   <a id="other-bindings"></a>
   ## Attribute, class, and style bindings
+  ## Attribute、class和style绑定
   The template syntax provides specialized one-way bindings for scenarios less well suited to property binding.
+  
+  模板语法为那些不太适合使用属性绑定的场景提供了专门的单向数据绑定形式。
 
   ### Attribute binding
+  ### Attribute绑定
   We can set the value of an attribute directly with an **attribute binding**.
+  
+  我们可以通过 **Attribute绑定** 来直接设置Attribute的值。
 // #enddocregion other-bindings-1
 // #docregion other-bindings-2
 .l-sub-section
   :marked
     This is the only exception to the rule that a binding sets a target property. This is the only binding that creates and sets an attribute.
+    
+    这是“绑定到目标属性”这条规则中唯一的例外。这是唯一的一个能创建和设置Attribute的绑定形式。
 
 :marked
   We have stressed throughout this chapter that setting an element property with a property binding is always preferred to setting the attribute with a string. Why does Angular offer attribute binding?
+  
+  在本章中，我们通篇都在说通过属性绑定来设置元素的属性总是好于用字符串设置Attribute。为什么Angular还提供了Attribute绑定呢？
 
   **We must use attribute binding when there is no element property to bind.**
+  
+  **因为当元素没有属性可绑的时候，我们不得不使用Attribute绑定。**
 
   Consider the [ARIA](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA),
   [SVG](https://developer.mozilla.org/en-US/docs/Web/SVG), and
@@ -658,32 +1083,56 @@ a(id="one-time-initialization")
   They do not correspond to element properties, and they do not set element properties.
   There are no property targets to bind to.
 
+  考虑[ARIA](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA),
+  [SVG](https://developer.mozilla.org/en-US/docs/Web/SVG)和
+  table中的colspan/rowspan等Attribute。它们是纯粹的Attribute。
+  它们没有对应的属性可供绑定。
+
   We become painfully aware of this fact when we try to write something like this:
+  
+  如果我们想写出类似下面这样的东西，这一现状会令我们痛苦：
 code-example(language="html").
   &lt;tr>&lt;td colspan="{{1 + 1}}">Three-Four&lt;/td>&lt;/tr>
 :marked
   We get this error:
+  
+  我们会得到这个错误：
 code-example(format="", language="html").
   Template parse errors:
   Can't bind to 'colspan' since it isn't a known native property
+  
+  模板解析错误：不能绑定到'colspan'，因为它不是已知的原生属性
 :marked
   As the message says, the `<td>` element does not have a `colspan` property.
   It has the "colspan" *attribute*, but
   interpolation and property binding can set only *properties*, not attributes.
+  
+  正如消息中所说，`<td>`元素没有`colspan`属性。
+  但是插值表达式和属性绑定只能设置 *属性* ，而不是Attribute。
 
   We need attribute bindings to create and bind to such attributes.
+  
+  我们需要Attribute绑定来创建和绑定到这样的Attribute。
 
   Attribute binding syntax resembles property binding.
   Instead of an element property between brackets, we start with the prefix **`attr`**,
   followed by a dot (`.`) and the name of the attribute. We then set the attribute
   value, using an expression that resolves to a string.
+  
+  Attribute绑定在语法上类似于属性绑定。
+  但括号中的部分不是一个元素的属性名，而是由一个 **`attr`** 前缀，紧跟着一个点（`.`），再跟着Attribute的名字组成。
+  我们可以通过一个能求值为字符串的表达式来设置Attribute的值。
 
   Here we bind `[attr.colspan]` to a calculated value:
+  
+  这个例子中，我们把`[attr.colspan]`绑定成一个通过计算得到的值：
 // #enddocregion other-bindings-2
 +makeExample('template-syntax/ts/app/app.component.html', 'attrib-binding-colspan')(format=".")
 // #docregion other-bindings-3
 :marked
   Here's how the table renders:
+  
+  这里是table渲染出来的样子：
   <table border="1px">
     <tr><td colspan="2">One-Two</td></tr>
     <tr><td>Five</td><td>Six</td></tr>
@@ -691,26 +1140,38 @@ code-example(format="", language="html").
 
   One of the primary use cases for attribute binding
   is to set ARIA attributes, as in this example:
+  
+  Attribute绑定的主要用例之一是设置ARIA Attribute（（译注：ARIA指可访问性，用于给残障人士访问互联网提供便利）），就像这个例子中一样：
 // #enddocregion other-bindings-3
 +makeExample('template-syntax/ts/app/app.component.html', 'attrib-binding-aria')(format=".")
 // #docregion other-bindings-class-1
 :marked
   ### Class binding
+  ### 类绑定
 
   We can add and remove CSS class names from an element’s `class` attribute with
   a **class binding**.
+  
+  借助 **类绑定** ，我们可以从元素的`class` Attribute上添加和移除CSS类名。
 
   Class binding syntax resembles property binding.
   Instead of an element property between brackets, we start with the prefix `class`,
   optionally followed by a dot (`.`) and the name of a CSS class: `[class.class-name]`.
+  
+  类绑定在语法上类似于属性绑定。但括号中的部分不是一个元素的属性名，而是包括一个 **`class`** 前缀，紧跟着一个点（`.`），再跟着CSS类的名字组成。
+  其中，后两部分是可选的。形如：`[class.class-name]`。
 
   The following examples show how to add and remove the application's "special" class
   with class bindings.  Here's how we set the attribute without binding:
+  
+  下列例子示范了如何通过类绑定来添加和移除应用的"special"类。不用绑定直接设置Attribute时是这样的：
 // #enddocregion other-bindings-class-1
 +makeExample('template-syntax/ts/app/app.component.html', 'class-binding-1')(format=".")
 // #docregion other-bindings-class-2
 :marked
   We can replace that with a binding to a string of the desired class names; this is an all-or-nothing, replacement binding.
+  
+  我们可以把它改写为一个绑定到所需类名的绑定；这是一个或者全有或者全无的替换型绑定（译注：即，当badCurly有值时class这个Attribute设置的内容会被完全覆盖）。
 // #enddocregion other-bindings-class-2
 +makeExample('template-syntax/ts/app/app.component.html', 'class-binding-2')(format=".")
 // #docregion other-bindings-class-3
@@ -718,6 +1179,9 @@ code-example(format="", language="html").
   Finally, we can bind to a specific class name.
   Angular adds the class when the template expression evaluates to something truthy.
   It removes the class when the expression is falsey.
+  
+  最后，我们可以绑定到一个特定的类名。
+  当模板表达式的求值结果是真值时，Angular会添加这个类，反之则移除它。
 // #enddocregion other-bindings-class-3
 +makeExample('template-syntax/ts/app/app.component.html', 'class-binding-3')(format=".")
 
@@ -726,23 +1190,33 @@ code-example(format="", language="html").
   :marked
     While this is a fine way to toggle a single class name,
     we generally prefer the [NgClass directive](#ngClass) for managing multiple class names at the same time.
+    
+    虽然这是一个切换单一类名的好办法，但我们通常更喜欢使用[NgClass指令](#ngClass)来同时管理多个类名。
 // #enddocregion other-bindings-class-4
 
 // #docregion other-bindings-style-1
 :marked
   ### Style binding
+  ### 样式绑定
 
   We can set inline styles with a **style binding**.
+  
+  通过 **样式绑定** ，我们可以设置内联样式。
 
   Style binding syntax resembles property binding.
   Instead of an element property between brackets, we start with the prefix `style`,
   followed by a dot (`.`) and the name of a CSS style property: `[style.style-property]`.
+  
+  样式绑定在语法上类似于属性绑定。但括号中的部分不是一个元素的属性名，而是包括一个 **`style`** 前缀，紧跟着一个点（`.`），再跟着CSS样式的属性名。
+  形如：`[style.style-property]`。
 
 // #enddocregion other-bindings-style-1
 +makeExample('template-syntax/ts/app/app.component.html', 'style-binding-1')(format=".")
 // #docregion other-bindings-style-2
 :marked
   Some style binding styles have unit extension. Here we conditionally set the font size in  “em” and “%” units .
+  
+  有些样式绑定中的样式带有单位。在这里，我们根据条件用“em”和“%”来设置字体大小的单位。
 // #enddocregion other-bindings-style-2
 +makeExample('template-syntax/ts/app/app.component.html', 'style-binding-2')(format=".")
 
@@ -751,68 +1225,104 @@ code-example(format="", language="html").
   :marked
     While this is a fine way to set a single style,
     we generally prefer the [NgStyle directive](#ngStyle) when setting several inline styles at the same time.
+    
+    虽然这是一个设置单一样式的好办法，但我们通常更喜欢使用[NgStyle指令](#ngStyle)来同时设置多个内联样式。
 // #enddocregion other-bindings-style-3
 
 // #docregion event-binding-1
 .l-main-section
 :marked
   ## Event binding
+  ## 事件绑定
   The bindings we’ve met so far flow data in one direction: *from the component to an element*.
+  
+  我们前面遇到过的那些绑定的数据流都是单向的：*从组件到元素* 。
 
   Users don’t just stare at the screen. They enter text into input boxes. They pick items from lists.
   They click buttons. Such user actions may result in a flow of data in the opposite direction:
   *from an element to the component*.
+  
+  用户不会只盯着屏幕看。他们会在输入框中输入文本。他们会从列表中选取条目。
+  他们会点击按钮。这类用户动作可能导致反向的数据流： *从元素到组件* 。
 
   The only way to know about a user action is to listen for certain events such as
   keystrokes, mouse movements, clicks, and touches.
   We declare our interest in user actions through Angular event binding.
+  
+  知道用户动作的唯一方式是监听正确的事件，比如击键、鼠标移动、点击和触屏。
+  我们可以通过Angular事件绑定来定义我们对哪些用户动作感兴趣。
 
   Event binding syntax consists of a **target event** within parentheses on the left of an equal sign, and a quoted
   [template statement](#template-statements) on the right.
   The following event binding listens for the button’s click event, calling
   the component's `onSave()` method whenever a click occurs:
+  
+  事件绑定语法由等号左侧带圆括号的 **目标事件** ，和右侧一个引号中的[模板语句](#template-statements)组成。
+  下列事件绑定监听按钮的点击事件。无论什么时候，发生点击时，都会调用组件的`onSave()`方法。
 // #enddocregion event-binding-1
 +makeExample('template-syntax/ts/app/app.component.html', 'event-binding-1')(format=".")
 // #docregion event-binding-2
 :marked
   ### Target event
+  ### 目标事件
   A **name between enclosing parentheses** &mdash; for example, `(click)` &mdash;
   identifies the target event. In the following example, the target is the button’s click event.
+  
+  **圆括号中的名称** —— 比如`(click)` —— 标记出目标事件。在下面这个例子中，目标是按钮的click事件。
 // #enddocregion event-binding-2
 +makeExample('template-syntax/ts/app/app.component.html', 'event-binding-1')(format=".")
 // #docregion event-binding-3
 :marked
   Some people prefer the `on-` prefix alternative, known as the *canonical form*:
+  
+  有些人更喜欢带`on-`前缀的可选形式，称之为 *规范形式* ：
 // #enddocregion event-binding-3
 +makeExample('template-syntax/ts/app/app.component.html', 'event-binding-2')(format=".")
 // #docregion event-binding-4
 :marked
   Element events may be the more common targets, but Angular looks first to see if the name matches an event property
   of a known directive, as it does in the following example:
+  
+  元素事件可能是更常见的目标，但Angular会先看这个名字是否能匹配上已知指令的事件属性，就像下面这个例子：
 // #enddocregion event-binding-4
 +makeExample('template-syntax/ts/app/app.component.html', 'event-binding-3')(format=".")
 // #docregion event-binding-5
 :marked
   If the name fails to match an element event or an output property of a known directive,
   Angular reports an “unknown directive” error.
+  
+  如果这个名字没能匹配到元素事件或已知指令的输出型属性，Angular就会报“未知指令”错误。
 
   ### $event and event handling statements
+  ### $event和事件处理语句
   In an event binding, Angular sets up an event handler for the target event.
+  
+  在事件绑定中，Angular会为目标事件设置事件处理器。
 
   When the event is raised, the handler executes the template statement.
   The template statement typically involves a receiver that wants to do something
   in response to the event, such as take a value from the HTML control and store it
   in a model.
+  
+  当事件发生时，这个处理器会执行模板语句。
+  典型的模板语句会让那些想在这个事件的响应过程中做点什么的接收器参与进来，例如从一个HTML控件中取得一个值，并存入一个模型。
 
   The binding conveys information about the event, including data values, through
   an **event object named `$event`**.
+  
+  这种绑定会通过一个 **名叫`$event`的事件对象** 表达关于此事件的信息（包括数据值）。
 
   The shape of the event object is determined by the target event itself.
   If the target event is a native DOM element event, the `$event` is a
   [DOM event object]( https://developer.mozilla.org/en-US/docs/Web/Events),
   with properties such as `target` and `target.value`.
+  
+  事件对象的形态取决于它是哪个目标事件。如果目标事件是一个原生DOM元素事件，
+  `$event`就是一个[DOM事件对象]( https://developer.mozilla.org/en-US/docs/Web/Events)，它有像`target`和`target.value`这样的属性。
 
   Consider this example:
+  
+  考虑这个范例：
 // #enddocregion event-binding-5
 +makeExample('template-syntax/ts/app/app.component.html', 'without-NgModel')(format=".")
 // #docregion event-binding-6
@@ -820,25 +1330,44 @@ code-example(format="", language="html").
   We’re binding the input box `value` to a `firstName` property, and we’re listening for changes by binding to the input box’s `input` event.
   When the user makes changes, the `input` event is raised, and the binding executes the statement within a context that includes the DOM event object, `$event`.
 
+  我们在把输入框的`value`绑定到`firstName`属性，并且我们正在通过绑定到输入框的`input`事件来监听更改。
+  当用户造成更改时，`input`事件被触发，并且在一个包含了DOM事件对象 —— `$event`的上下文中执行这条语句。
+
   To update the `firstName` property, we must get the changed text by following
   the path `$event.target.value`.
+  
+  要更改`firstName`属性，我们必须通过路径`$event.target.value`来获取更改后的值。
 
   If the event belongs to a directive (remember: components are directives), `$event` has whatever shape the directive chose to produce.
+  
+  如果这个事件属于指令（记住：组件是指令的一种），`$event`可以具有指令想生成的任何形态。
 
   <a id="eventemitter"></a>
   <a id="custom-event"></a>
   ### Custom events with EventEmitter
+  ### 使用EventEmitter实现自定义事件
 
   Directives typically raise custom events with an Angular [EventEmitter](../api/core/EventEmitter-class.html).
   A directive creates an `EventEmitter` and exposes it as a property.
   The directive calls `EventEmitter.emit(payload)` to fire an event, passing in a message payload that can be anything.
   Parent directives listen for the event by binding to this property and accessing the payload through the `$event` object.
+  
+  典型的指令使用Angular的[EventEmitter](../api/core/EventEmitter-class.html)来触发自定义事件。
+  指令创建一个`EventEmitter`实例，并且把它作为一个属性暴露出来。
+  指令调用`EventEmitter.emit(payload)`来触发事件，传进去的消息载荷可以是任何东西。
+  父指令通过绑定到这个属性来监听这个事件，并且通过`$event`对象来访问这个载荷。
 
   Consider a `HeroDetailComponent` that presents hero information and responds to user actions.
   Although the `HeroDetailComponent` has a delete button it doesn't know how to delete the hero itself.
   The best it can do is raise an event reporting the user's delete request.
+  
+  考虑一个`HeroDetailComponent`，它展示英雄的信息，并响应用户的动作。
+  虽然`HeroDetailComponent`有一个删除按钮，但它自己并不知道该如何删除这个英雄。
+  最好的做法是触发一个事件来代表用户“要求删除”。
 
   Here are the pertinent excerpts from that `HeroDetailComponent`:
+  
+  这里是来自`HeroDetailComponent`的相关摘要：
 // #enddocregion event-binding-6
 +makeExample('template-syntax/ts/app/hero-detail.component.ts',
 'template-1', 'HeroDetailComponent.ts (template)')(format=".")
@@ -850,8 +1379,13 @@ code-example(format="", language="html").
   The component defines a `deleteRequest` property that returns an `EventEmitter`.
   When the user clicks *delete*, the component invokes the `delete()` method
   which tells the `EventEmitter` to emit a `Hero` object.
+  
+  组件定义了一个`deleteRequest`属性，它是一个`EventEmitter`。
+  当用户点击 *删除* 时，组件会调用`delete()`方法，这个方法告诉`EventEmitter`，发出一个`Hero`对象。
 
   Now imagine a hosting parent component that binds to the `HeroDetailComponent`'s `deleteRequest` event.
+  
+  现在，想象作为宿主的父组件绑定到了`HeroDetailComponent`的`deleteRequest`事件。
 // #enddocregion event-binding-7
 
 +makeExample('template-syntax/ts/app/app.component.html',
@@ -860,15 +1394,25 @@ code-example(format="", language="html").
 :marked
   When the `deleteRequest` event fires, Angular calls the parent component's `deleteHero` method,
   passing the *hero-to-delete* (emitted by `HeroDetail`) in the `$event` variable.
+  
+  当`deleteRequest`事件触发时，Angular调用父组件的`deleteHero`方法，在`$event`变量中传入 *要删除的英雄* （来自`HeroDetail`）。
 
   ### Template statements have side effects
+  ### 模板语句有副作用
   The `deleteHero` method has a side effect: It deletes a hero.
   Template statement side effects are not just OK, they are expected.
+  
+  `deleteHero`方法有一个副作用：它删除了一个英雄。
+  模板语句的副作用不仅没问题，而且正是我们所期待的。
 
   Deleting the hero updates the model, perhaps triggering other changes
   including queries and saves to a remote server.
   These changes percolate through the system and are ultimately displayed in this and other views.
   It's all good.
+  
+  删除这个英雄会更新模型，还可能触发其它修改，包括向远端服务器的查询和保存。
+  这些变更通过系统进行扩散，并最终显示到当前以及其它视图中。
+  这都是好事。
 // #enddocregion event-binding-8
 
 //
@@ -903,9 +1447,14 @@ code-example(format="", language="html").
 :marked
   <a id="ngModel"></a>
   ## Two-way binding with NgModel
+  ## 使用NgModel进行双向数据绑定
   When developing data entry forms, we often want to both display a data property and update that property when the user makes changes.
+  
+  当开发数据输入表单时，我们通常希望既显示数据的属性，也在用户修改时更新那个属性。
 
   The `[(NgModel)]` two-way data binding syntax makes that easy. Here's an example:
+  
+  `[(NgModel)]`双向数据绑定语法让它变得简单，这里是例子：
 // #enddocregion ngModel-1
 +makeExample('template-syntax/ts/app/app.component.html', 'NgModel-1')(format=".")
 // #docregion ngModel-2
@@ -913,19 +1462,30 @@ code-example(format="", language="html").
   header
     :marked
        <span style="font-family:consolas; monospace">[()]</span> = banana in a box
+       
+       <span style="font-family:consolas; monospace">[()]</span> = 盒子里的香蕉
   :marked
     To remember that the parentheses go inside the brackets, visualize a *banana in a box*.
+    
+    要记住“方括号中的圆括号”这种语法，就把它想象成 *盒子里的香蕉* 吧，是不是很形象？
 :marked
   Alternatively, we can use the canonical prefix form:
+  
+  另外，我们也可以使用规范前缀格式：
 // #enddocregion ngModel-2
 +makeExample('template-syntax/ts/app/app.component.html', 'NgModel-2')(format=".")
 // #docregion ngModel-3
 :marked
   There’s a story behind this construction, a story that builds on the property and event binding techniques we learned previously.
+  
+  在这个构造函数背后还有一个故事，一个关于如何构建我们以前学过的属性绑定和事件绑定技术的故事。
 
   ### Inside [(ngModel)]
+  ### [(ngModel)]内幕
   We could have achieved the same result with separate bindings to
   the `<input>` element's  `value` property and `input` event.
+  
+  通过分别绑定到`<input>`元素的`value`属性和`input`事件，我们能达到同样的效果。
 // #enddocregion ngModel-3
 +makeExample('template-syntax/ts/app/app.component.html', 'without-NgModel')(format=".")
 // #docregion ngModel-4
@@ -933,8 +1493,14 @@ code-example(format="", language="html").
   That’s cumbersome. Who can remember which element property to set and what event reports user changes?
   How do we extract the currently displayed text from the input box so we can update the data property?
   Who wants to look that up each time?
+  
+  这样很笨拙。谁能记住哪个元素属性用于设置，哪个用于汇报用户更改？
+  我们如何从输入框中提取出当前显示的文本，以便更新数据属性？
+  谁想每次都去查一遍？
 
   That `ngModel` directive hides these onerous details behind its own  `ngModel` input and `ngModelChange` output properties.
+  
+  `ngModel`指令通过它自己的`ngModel`输入属性和`ngModelChange`输出属性隐藏了这些繁琐的细节。
 // #enddocregion ngModel-4
 +makeExample('template-syntax/ts/app/app.component.html', 'NgModel-3')(format=".")
 // #docregion ngModel-5
@@ -947,11 +1513,18 @@ code-example(format="", language="html").
     We can't apply `[(ngModel)]` to our custom components until we write a suitable *value accessor*,
     a technique that is out of scope for this chapter.
 
+    `ngModel`输入属性设置元素的值属性，而`ngModelChange`输出属性监听元素值的变化。
+    细节由每种元素自行实现，`NgModel`指令只和元素一起工作，比如输入框，它由[ControlValueAccessor](../api/common/ControlValueAccessor-interface.html)提供支持。
+    除非写一个合适的 *值访问器* ，否则我们不能把`[(ngModel)]`用在我们自己的自定义组件上。但 *值访问器* 技术超出了本章的范围。
 :marked
   Separate `ngModel` bindings is an improvement. We can do better.
+  
+  把`ngModel`绑定分离开是一个提升，但我们还能做得更好。
 
   We shouldn't have to mention the data property twice. Angular should be able to capture the component’s data property and set it
   with a single declaration &mdash; which it can with the `[( )]` syntax:
+  
+  我们不该两次引用这个数据属性。Angular应该能捕获组件的数据属性，并且把它设置为一个简单的定义 —— 那就用`[( )]`语法吧：
 // #enddocregion ngModel-5
 +makeExample('template-syntax/ts/app/app.component.html', 'NgModel-1')(format=".")
 
@@ -962,26 +1535,40 @@ code-example(format="", language="html").
     into an `x` input property for property binding and an `xChange` output property for event binding.
     Angular constructs the event property binding's template statement by appending `=$event`
     to the literal string of the template expression.
+    
+    `[(ngModel)]`是一个更通用的模式中的具体例子，在这里，Angular把`[(x)]`语法去掉语法糖，变成了一个供属性绑定用的输入属性`x`，和一个供事件绑定用的输出属性`xChange`。
+    Angular通过在模板表达式的原始字符串后面追加上`=$event`，来构建出供事件绑定用的模板语句。
   code-example(format="." ).
     [(x)]="hero.name" &lt;==> [x]="hero.name" (xChange)="hero.name=$event"
 
   :marked
     We can write a two-way binding directive of our own to exploit this behavior.
+    
+    利用这一行为，我们也可以自己写出具有双向绑定功能的指令。
 
 :marked
   Is `[(ngModel)]` all we need? Is there ever a reason to fall back to its expanded form?
+  
+  `[(ngModel)]`就是我们所需的一切吗？有没有什么理由需要回落到它的展开形式？
 
   The `[( )]` syntax can only _set_ a data-bound property.
   If we need to do something more or something different, we need to write the expanded form ourselves.
 
+  `[( )]`语法只能 _设置_ 一个数据绑定属性。
+  如果需要做更多或不同的事情，我们得自己写它的展开形式。
+  
   Let's try something silly like forcing the input value to uppercase:
+  
+  来做点幼稚的事情吧，比如强制让输入值变成大写形式：
 // #enddocregion ngModel-6
 +makeExample('template-syntax/ts/app/app.component.html', 'NgModel-4')(format=".")
 // #docregion ngModel-7
 :marked
   Here are all variations in action, including the uppercase version:
+  
+  下面是实际操作中的所有变体形式，包括这个大写版本：
 figure.image-display
-    img(src='/resources/images/devguide/template-syntax/ng-model-anim.gif' alt="NgModel variations")
+    img(src='/resources/images/devguide/template-syntax/ng-model-anim.gif' alt="NgModel变体")
 // #enddocregion ngModel-7
 
 // #docregion directives-1
@@ -989,14 +1576,22 @@ figure.image-display
 :marked
   <a id="directives"></a>
   ## Built-in directives
+  ## 内建指令
 
   Earlier versions of Angular included over seventy built-in directives.
   The community contributed many more, and countless private directives
   have been created for internal applications.
+  
+  前一个版本的Angular包含了超过70个内建指令。
+  社区贡献了更多，还有为内部应用而创建的无数私有指令。
 
   We don’t need many of those directives in Angular 2.
   Quite often we can achieve the same results with the more capable and expressive Angular 2 binding system.
   Why create a directive to handle a click when we can write a simple binding such as this?
+  
+  在Angular 2中我们不需要那么多指令。
+  使用更强大、更富有表现力的Angular 2绑定系统，我们其实可以达到同样的效果。
+  如果我们能用一个这样的简单绑定达到目的，为什么还需要创建一个指令来处理点击事件？
 // #enddocregion directives-1
 +makeExample('template-syntax/ts/app/app.component.html', 'event-binding-1')(format=".")
 // #docregion directives-2
@@ -1004,8 +1599,14 @@ figure.image-display
   We still benefit from directives that simplify complex tasks.
   Angular still ships with built-in directives; just not as many.
   We'll write our own directives, just not as many.
+  
+  我们仍然可以从简化复杂任务的指令中获益。
+  Angular发布时仍然带有内建指令，只是没那么多了。
+  我们仍会写自己的指令，只是没那么多了。
 
   This segment reviews some of the most frequently used built-in directives.
+  
+  下面这部分要检阅一下那些最常用的内建指令。
 // #enddocregion directives-2
 
 // #docregion directives-ngClass-1
@@ -1017,24 +1618,37 @@ figure.image-display
   We typically control how elements appear
   by adding and removing CSS classes dynamically.
   We can bind to `NgClass` to add or remove several classes simultaneously.
+  
+  我们经常用动态添加或删除CSS类的方式来控制元素如何显示。
+  通过绑定到`NgClass`，我们可以同时添加或移除多个类。
 
   A [class binding](#class-binding) is a good way to add or remove a *single* class.
+  
+  [类绑定](#class-binding)是添加或删除 *单个* 类的最佳途径。
 // #enddocregion directives-ngClass-1
 +makeExample('template-syntax/ts/app/app.component.html', 'class-binding-3a')(format=".")
 // #docregion directives-ngClass-2
 :marked
   The `NgClass` directive may be the better choice
   when we want to add or remove *many* CSS classes at the same time.
+  
+  当我们想要同时添加或移除 *多个* CSS类时，`NgClass`指令可能是更好的选择。
 
   A good way to apply `NgClass` is by binding it to a key:value control object. Each key of the object is a CSS class name; its value is `true` if the class should be added, `false` if it should be removed.
+  
+  绑定到一个 key:value 形式的控制对象，是应用`NgClass`的好途径之一。这个对象中的每个key都是一个CSS类名，如果它的value是`true`，这个类就会被加上，否则就会被移除。
 
   Consider a component method such as `setClasses` that manages the state of three CSS classes:
+  
+  考虑一个像`setClasses`这样的组件方法，用于管理三个CSS类的状态。
 // #enddocregion directives-ngClass-2
 +makeExample('template-syntax/ts/app/app.component.ts', 'setClasses')(format=".")
 // #docregion directives-ngClass-3
 :marked
   Now we can add an `NgClass` property binding that calls `setClasses`
   and sets the element's classes accordingly:
+  
+  现在，我们可以添加一个`NgClass`属性绑定，它会调用`setClasses`，并据此设置元素的类：
 // #enddocregion directives-ngClass-3
 +makeExample('template-syntax/ts/app/app.component.html', 'NgClass-1')(format=".")
 
@@ -1045,25 +1659,39 @@ figure.image-display
   ### NgStyle
   We can set inline styles dynamically, based on the state of the component.
   Binding to `NgStyle` lets us set many inline styles simultaneously.
+  
+  我们可以基于组件的状态动态设置内联样式。
+  绑定到`NgStyle`可以让我们同时设置很多内联样式。
 
   A [style binding](#style-binding) is an easy way to set a *single* style value.
+  
+  [样式绑定](#style-binding)是设置 *单一* 样式值的简单方式。
 // #enddocregion directives-ngStyle-1
 +makeExample('template-syntax/ts/app/app.component.html', 'NgStyle-1')(format=".")
 // #docregion directives-ngStyle-2
 :marked
   The `NgStyle` directive may be the better choice
   when we want to set *many* inline styles at the same time.
+  
+  如果我们要同时设置 *多个* 内联样式，`NgStyle`指令可能是更好的选择。
 
   We apply `NgStyle` by binding it to a key:value control object.
   Each key of the object is a style name; its value is whatever is appropriate for that style.
+  
+  我们通过把它绑定到一个 key:value 控制对象的形式使用`NgStyle`。
+  对象的每个key是样式名；它的取值就是能用于这个样式的任何值。
 
   Consider a component method such as `setStyles` that returns an object defining three styles:
+  
+  考虑一个类似于`setStyles`的组件方法，它返回一个定义三个样式的对象：
 // #enddocregion directives-ngStyle-2
 +makeExample('template-syntax/ts/app/app.component.ts', 'setStyles')(format=".")
 // #docregion directives-ngStyle-3
 :marked
   Now we just add an `NgStyle` property binding that calls `setStyles`
   and sets the element's styles accordingly:
+  
+  现在我们添加一个`NgStyle`属性绑定，让它调用`setStyles`，并且据此设置元素的样式：
 // #enddocregion directives-ngStyle-3
 +makeExample('template-syntax/ts/app/app.component.html', 'NgStyle-2')(format=".")
 
@@ -1073,6 +1701,8 @@ figure.image-display
 :marked
   ### NgIf
   We can add an element subtree (an element and its children) to the DOM  by binding an `NgIf` directive to a truthy expression.
+  
+  通过把`NgIf`指令绑定到一个真值表达式，我们可以把一个元素的子树（元素及其子元素）添加到DOM上。
 // #enddocregion directives-ngIf-1
 +makeExample('template-syntax/ts/app/app.component.html', 'NgIf-1')(format=".")
 
@@ -1081,35 +1711,56 @@ figure.image-display
   :marked
     Don't forget the asterisk (`*`) in front of `ngIf`.
     For more information, see [\* and &lt;template>](#star-template).
+    
+    不要忘记了`ngIf`前面的星号（`*`）。
+    要了解更多，参见[\* 和 &lt;模板>](#star-template)。
 // #enddocregion directives-ngIf-2
 // #docregion directives-ngIf-3
 :marked
   Binding to a falsey expression removes the element subtree from the DOM.
+  
+  绑定到一个假值表达式将从DOM中移除元素的子树。
 // #enddocregion directives-ngIf-3
 +makeExample('template-syntax/ts/app/app.component.html', 'NgIf-2')(format=".")
 
 // #docregion directives-ngIf-4
 :marked
   #### Visibility and NgIf are not the same
+  #### 可见性和NgIf不是一回事
   We can show and hide an element subtree (the element and its children) with a
   [class](#class-binding) or [style](#style-binding) binding:
+  
+  我们可以通过[类绑定](#class-binding)或[样式绑定](#style-binding)来显示和隐藏一个元素的子树（元素及其子元素）。
 // #enddocregion directives-ngIf-4
 +makeExample('template-syntax/ts/app/app.component.html', 'NgIf-3')(format=".")
 // #docregion directives-ngIf-5
 :marked
   Hiding a subtree is quite different from excluding a subtree with `NgIf`.
+  
+  隐藏一个子树和用`NgIf`排除一个子树是截然不同的。
 
   When we hide the element subtree, it remains in the DOM.
   Components in the subtree are preserved, along with their state.
   Angular may continue to check for changes even to invisible properties.
   The subtree may tie up substantial memory and computing resources.
+  
+  当我们隐藏一个子树时，它仍然留在DOM中。
+  子树中的组件及其状态仍然保留着。
+  即使对于不可见属性，Angular也会继续检查变更。
+  子树可能占用相当可观的内存和运算资源。
 
   When `NgIf` is `false`, Angular physically removes the element subtree from the DOM.
   It destroys components in the subtree, along with their state, potentially freeing up substantial resources and
   resulting in better performance for the user.
+  
+  当`NfIf`是`false`时，Angular从DOM中实际移除了这个元素的子树。
+  它销毁了子树中的组件及其状态，也潜在的释放了可观的资源，最终让用户体验到更好的性能。
 
   The show/hide technique is probably fine for small element trees.
   We should be wary when hiding large trees; `NgIf` may be the safer choice. Always measure before leaping to conclusions.
+  
+  显示/隐藏技术用在小型元素树上可能还不错。
+  但在隐藏大树时我们得小心；`NgIf`可能是更安全的选择。但要记住：永远得先测量，再下结论。
 // #enddocregion directives-ngIf-5
 
 // #docregion directives-ngSwitch-1
@@ -1120,7 +1771,7 @@ figure.image-display
   We bind to `NgSwitch` when we want to display *one* element tree (an element and its children)
   from a *set* of possible element trees, based on some condition.
   Angular puts only the *selected* element tree into the DOM.
-
+  
   Here’s an example:
 // #enddocregion directives-ngSwitch-1
 +makeExample('template-syntax/ts/app/app.component.html', 'NgSwitch')(format=".")

From 48e03ae748c0d68292380c4af2361faab5f6b497 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 09:58:40 +0800
Subject: [PATCH 02/12] =?UTF-8?q?=E5=AE=8C=E6=88=90=E4=BA=86=E6=A8=A1?=
 =?UTF-8?q?=E6=9D=BF=E8=AF=AD=E6=B3=95=E7=AB=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../docs/ts/latest/guide/template-syntax.jade | 314 +++++++++++++++++-
 1 file changed, 312 insertions(+), 2 deletions(-)

diff --git a/public/docs/ts/latest/guide/template-syntax.jade b/public/docs/ts/latest/guide/template-syntax.jade
index 81351ccc7f..655efd11ed 100644
--- a/public/docs/ts/latest/guide/template-syntax.jade
+++ b/public/docs/ts/latest/guide/template-syntax.jade
@@ -1713,7 +1713,7 @@ figure.image-display
     For more information, see [\* and &lt;template>](#star-template).
     
     不要忘记了`ngIf`前面的星号（`*`）。
-    要了解更多，参见[\* 和 &lt;模板>](#star-template)。
+    要了解更多，参见[\*与&lt;template>](#star-template)。
 // #enddocregion directives-ngIf-2
 // #docregion directives-ngIf-3
 :marked
@@ -1772,40 +1772,71 @@ figure.image-display
   from a *set* of possible element trees, based on some condition.
   Angular puts only the *selected* element tree into the DOM.
   
+  当需要从 *一组* 可能的元素树中根据条件显示 *一个* 时，我们就把它绑定到`NgSwitch`。
+  Angular将只把 *选中的* 元素树放进DOM中。
+  
   Here’s an example:
+  
+  下面是例子：
 // #enddocregion directives-ngSwitch-1
 +makeExample('template-syntax/ts/app/app.component.html', 'NgSwitch')(format=".")
 // #docregion directives-ngSwitch-2
 :marked
   We bind the parent `NgSwitch` directive to an expression returning a *switch value*.
   The value is a string in this example, but it can be a value of any type.
+  
+  我们把作为父指令的`NgSwitch`绑定到一个能返回 *开关值* 的表达式。
+  本例中，这个值是字符串，但它也可能是任何类型的值。
 
   In this example, the parent `NgSwitch` directive controls a set of child `<span>` elements.
   A `<span>` is either pegged to a *match value* expression or marked as the default.
+  
+  这个例子中，父指令`NgSwitch`控制一组`<span>`子元素。
+  每个`<span>`或者挂在一个 *匹配值* 表达式上，或者被标记为默认情况。
 
   **At any particular moment, at most one of these *spans* is in the DOM.**
+  
+  **任何时候，这些 *span* 中最多只有一个会出现在DOM中。**
 
   If the *span*’s *match value* equals the switch value, Angular adds the `<span>` to the DOM.
   If none of the *spans* is a match, Angular adds the default *span* to the DOM.
   Angular removes and destroys all other *spans*.
+  
+  如果这个 *span* 的 *匹配值* 与 *开关值* 相等，Angular就把这个`<span>`添加到DOM中。
+  如果没有任何 *span* 匹配上，Angular就把默认的 *span* 添加到DOM中。
+  Angular会移除并销毁所有其它的 *span* 。
 .l-sub-section
   :marked
     We could substitute any element for the *span* in this example.
     That element could be a `<div>` with a vast subtree of its own elements.
     Only the matching `<div>` and its subtree would appear in the DOM;
     the others would be removed.
+    
+    我们可以用任何其它元素代替本例中的 *span* 。
+    那个元素可以是一个带有巨大子树的`<div>`。
+    只有匹配的`<div>`和它的子树会显示在DOM中，其它的则会被移除。
 :marked
   Three collaborating directives are at work here:
+  
+  这里有三个相互合作的指令：
   1. `ngSwitch`: bound to an expression that returns the switch value
+  1. `ngSwitch`：绑定到一个返回开关值的表达式
   1. `ngSwitchWhen`: bound to an expression returning a match value
+  1. `ngSwitchWhen`：绑定到一个返回匹配值的表达式
   1. `ngSwitchDefault`: a marker attribute on the default element
+  1. `ngSwitchDefault`：用于标记出默认元素的Attribute
 
 .alert.is-critical
   :marked
     **Do *not*** put the asterisk (`*`) in front of `ngSwitch`. Use the property binding instead.
+    
+    **不要** 在`ngSwitch`的前面放星号（`*`），而应该用属性绑定。
 
     **Do** put the asterisk (`*`) in front of `ngSwitchWhen` and `ngSwitchDefault`.
     For more information, see [\* and &lt;template>](#star-template).
+    
+    把星号（`*`） **放在** `ngSwitchWhen`和`ngSwitchDefault`的前面。
+    要了解更多信息，参见[\*与&lt;template>](#star-template)。
 // #enddocregion directives-ngSwitch-2
 
 // #docregion directives-ngFor-1
@@ -1814,16 +1845,25 @@ figure.image-display
 :marked
   ### NgFor
   `NgFor` is a _repeater_ directive &mdash; a way to customize data display.
+  
+  `NgFor`是一个 _重复器_ 指令 —— 自定义数据显示的一种方式。
 
   Our goal is to present a list of items. We define a block of HTML that defines how a single item should be displayed.
   We tell Angular to use that block as a template for rendering each item in the list.
+  
+  我们的目标是展示一个多个条目组成的列表。我们定义了一个HTML块儿，它规定单个条目应该如何显示。
+  我们告诉Angular把这个块儿当做模板，用于在列表中渲染每个条目。
 
   Here is an example of `NgFor` applied to a simple `<div>`:
+  
+  这里是一个例子，它把`NgFor`应用在一个简单的`<div>`上：
 // #enddocregion directives-ngFor-1
 +makeExample('template-syntax/ts/app/app.component.html', 'NgFor-1')(format=".")
 // #docregion directives-ngFor-2
 :marked
   We can also apply an `NgFor` to a component element, as in this example:
+  
+  我们也可以把`NgFor`应用在一个组件元素上，就像这个例子中一样：
 // #enddocregion directives-ngFor-2
 +makeExample('template-syntax/ts/app/app.component.html', 'NgFor-2')(format=".")
 
@@ -1832,54 +1872,84 @@ figure.image-display
   :marked
     Don't forget the asterisk (`*`) in front of `ngFor`.
     For more information, see [\* and &lt;template>](#star-template).
+    
+    不要忘了`ngFor`前面的星号（`*`）。
+    要了解更多，参见[\*与&lt;template>](#star-template)
 :marked
   The text assigned to `*ngFor` is the instruction that guides the repeater process.
+  
+  赋值给`*ngFor`的文本是一个用于指导重复器如何工作的“操作指南”。
 // #enddocregion directives-ngFor-3
 
 // #docregion directives-ngFor-4
 <a id="ngForMicrosyntax"></a>
 :marked
   #### NgFor microsyntax
+  #### NgFor微语法
   The string assigned to `*ngFor` is not a [template expression](#template-expressions).
   It’s a *microsyntax* &mdash; a little language of its own that Angular interprets. In this example, the string "let hero of heroes" means:
+  
+  赋值给`*ngFor`的字符串并不是一个[模板表达式](#template-expressions)。
+  它是一个 *微语法* —— 由Angular自己解释的小语言。在这个例子中，字符串`let hero of heroes`的含义是：
 
   >*Take each hero in the `heroes` array, store it in the local `hero` variable, and make it available to the templated HTML
   for each iteration.*
+  
+  >*取出`heroes`数组中的每个英雄，把它存在一个局部变量`hero`中，并且在每个迭代中让它对模板HTML可用*
 
   Angular translates this instruction into a new set of elements and bindings.
+  Angular把这份“操作指南”翻译成一组“元素和绑定”。
 // #enddocregion directives-ngFor-4
 // #docregion directives-ngFor-5
 :marked
   In the two previous examples, the `ngFor` directive iterates over the `heroes` array returned by the parent component’s `heroes` property,
   stamping out instances of the element to which it is applied.
   Angular creates a fresh instance of the template for each hero in the array.
+  
+  在前面的两个范例中，`ngFor`指令在`heroes`变量上进行迭代（它是由父组件的`heroes`属性返回的），以其应用到的元素为模板“冲压”出很多实例。
+  Angular为数组中的每个英雄创建了此模板的一个全新实例。
 
   The `let` keyword before "hero" creates a template input variable called `hero`.
+  
+  "hero"前面的`let`关键字创建了一个名叫`hero`的模板输入变量。
 
 .alert.is-critical
   :marked
      A template input variable is **not** the same as a [template reference variable](#ref-vars)!
+     
+     模板输入变量和[模板引用变量](#ref-vars)不是一回事儿！
 
 :marked
   We use this variable within the template to access a hero’s properties,
   as we’re doing in the interpolation.
   We can also pass the variable in a binding to a component element,
   as we're doing with `hero-detail`.
+  
+  我们在模板中使用这个变量来访问英雄的属性，就像在插值表达式中所做的那样。
+  我们也可以把这个变量传给组件元素上的一个绑定，就像我们对`hero-detail`所做的那样。
 // #enddocregion directives-ngFor-5
 
 // #docregion directives-ngFor-6
 :marked
   #### NgFor with index
+  #### 带索引的NgFor
   The `ngFor` directive supports an optional `index` that increases from 0 to the length of the array for each iteration.
   We can capture the index in a template input variable and use it in our template.
+  
+  `ngFor`指令支持一个可选的`index`，它在迭代过程中会从0增长到（当前数组的长度-1）。
+  我们可以通过模板输入变量来捕获这个index，并把它用在模板中。
 
   The next example captures the index in a variable named `i`, using it to stamp out rows like "1 - Hercules Son of Zeus".
+  
+  下一个例子把index捕获到了一个名叫`i`的变量中，使用它“冲压出”像"1 - Hercules Son of Zeus"这样的条目。
 // #enddocregion directives-ngFor-6
 +makeExample('template-syntax/ts/app/app.component.html', 'NgFor-3')(format=".")
 // #docregion directives-ngFor-7
 .l-sub-section
   :marked
     Learn about other special *index-like* values such as `last`, `even`, and `odd` in the [NgFor API reference](../api/common/NgFor-directive.html).
+    
+    要学习更多的 *类似于index* 的值，例如`last`、`even`和`odd`，请参阅[NgFor API 参考](../api/common/NgFor-directive.html)。
 // #enddocregion directives-ngFor-7
 
 // #docregion directives-ngForTrackBy-1
@@ -1887,22 +1957,38 @@ figure.image-display
   #### NgForTrackBy
   The `ngFor` directive has the potential to perform poorly, especially with large lists.
   A small change to one item, an item removed, or an item added can trigger a cascade of DOM manipulations.
+  
+  `ngFor`指令有时候会性能较差，特别是在大型列表中。
+  对一个条目的一点小更改、移除或添加，都会导致级联的DOM操作。
 
   For example, we could refresh the list of heroes by re-querying the server.
   The refreshed list probably contains most, if not all, of the previously displayed heroes.
+  
+  例如，我们可以通过重新从服务器查询来刷新英雄列表。
+  刷新后的列表可能包含很多（如果不是全部的话）以前显示过的英雄。
 
   *We* know this because the `id` of each hero hasn't changed.
   But Angular sees only a fresh list of new object references.
   It has no choice but to tear down the old list, discard those DOM elements, and re-build a new list with new DOM elements.
+  
+  *我们*知道这一点，是因为每个英雄的`id`没有变化。
+  但在Angular看来，它只是一个由新的对象引用构成的新列表，
+  所以它没有选择，只能清理老列表、舍弃那些DOM元素，并且用新的DOM元素来重建一个新列表。
 
   Angular can avoid this churn if we give it a *tracking* function that tells it what we know:
   that two objects with the same `hero.id` are the same *hero*. Here is such a function:
+  
+  如果我们给它一个 *追踪* 函数，Angular就可以避免这种折腾。追踪函数告诉Angular：我们知道两个具有相同`hero.id`的对象其实是同一个英雄。
+  下面就是这样一个函数：
 // #enddocregion directives-ngForTrackBy-1
 +makeExample('template-syntax/ts/app/app.component.ts', 'trackByHeroes')(format=".")
 // #docregion directives-ngForTrackBy-2
 :marked
   Now set the `NgForTrackBy` directive to that *tracking* function.
   Angular offers a variety of equivalent syntax choices including these two:
+  
+  现在，把`NgForTrackBy`指令设置为那个 *追踪* 函数。
+  Angular从语法上提供了等价的可选变体，比如这两个：
 // #enddocregion directives-ngForTrackBy-2
 +makeExample('template-syntax/ts/app/app.component.html', 'NgForTrackBy-2')(format=".")
 // #docregion directives-ngForTrackBy-3
@@ -1911,8 +1997,15 @@ figure.image-display
   Angular may have to update the DOM element if the same-hero *properties* have changed.
   But if the properties haven't changed &mdash; and most of the time they will not have changed &mdash;
   Angular can leave those DOM elements alone. The list UI will be smoother and more responsive.
+  
+  *追踪* 函数不会排除所有DOM更改。
+  如果用来判断是否同一个英雄的 *属性* 变化了，Angular就可能不得不更新DOM元素。
+  但是如果这个属性没有变化 —— 而且大多数时候它们不会变化 —— 
+  Angular就能留下这些DOM元素。列表界面就会更加平滑，提供更好的响应。
 
   Here is an illustration of the `NgForTrackBy` effect.
+  
+  这里是关于`NgForTrackBy`效果的一个插图。
 figure.image-display
   img(src='/resources/images/devguide/template-syntax/ng-for-track-by-anim.gif' alt="NgForTrackBy")
 // #enddocregion directives-ngForTrackBy-3
@@ -1923,92 +2016,137 @@ figure.image-display
 .l-main-section
 :marked
   ## * and &lt;template&gt;
+  ## *与&lt;template*&gt;
   When we reviewed the `NgFor`, `NgIf`, and `NgSwitch` built-in directives, we called out an oddity of the syntax: the asterisk (`*`) that appears before the directive names.
+  
+  当我们审视`NgFor`、`NgIf`和`NgSwitch`内置指令时，我们使用了古怪的语法：出现在指令名称前面的星号（`*`）。
 
   The `*` is a bit of syntactic sugar that makes it easier to read and write directives that modify HTML layout
   with the help of templates.
   `NgFor`, `NgIf`, and `NgSwitch` all add and remove element subtrees that are wrapped in `<template>` tags.
+  
+  `*`是一种语法糖，它让那些借助模板的帮助来修改HTML布局的指令更易于读写。
+  `NgFor`、`NgIf`和`NgSwitch`都会添加或移除包裹在`<template>`标签中的元素子树。
 
   We didn't see the `<template>` tags because the `*` prefix syntax allowed us to skip those tags and
   focus directly on the HTML element that we are including, excluding, or repeating.
+  
+  我们没有看到`<template>`标签，那是因为这种`*`前缀语法让我们忽略了这个标签，而把注意力直接聚焦在所要包含、排除或重复的那些HTML元素上。
 
   In this section we go under the hood and see how
   Angular strips away the `*` and expands the HTML into the `<template>` tags for us.
+  
+  在这一节，我们将掀开引擎盖儿，看看Angular是怎样替我们扒掉这个`*`，并且把这段HTML展开到`<template>`标签中的。
 // #enddocregion star-template
 
 // #docregion star-template-ngIf-1
 :marked
   ### Expanding `*ngIf`
+  ### 展开`*ngIf`
   We can do what Angular does ourselves and expand the `*` prefix syntax to template syntax. Here's some code with `*ngIf`:
+  
+  我们可以像Angular一样，自己把`*`前缀语法展开成template语法，这里是`*ngIf`的一些代码：
 // #enddocregion star-template-ngIf-1
 +makeExample('template-syntax/ts/app/app.component.html', 'Template-1')(format=".")
 // #docregion star-template-ngIf-2a
 :marked
   The `currentHero` is referenced twice, first as the true/false condition for `NgIf` and
   again as the actual hero passed into the `HeroDetailComponent`.
+  
+  `currentHero`被引用了两次，第一次是作为`NgIf`的真/假条件，第二次作为实际的hero值传给了`HeroDetailComponent`。
 
   The first expansion step transports the `ngIf` (without the `*` prefix) and its contents
   into an expression assigned to a `template` directive.
+  
+  展开的第一步是把`ngIf`（没有`*`前缀）和它的内容传给一个表达式，再赋值给`template`指令。
 // #enddocregion star-template-ngIf-2a
 +makeExample('template-syntax/ts/app/app.component.html', 'Template-2a')(format=".")
 // #docregion star-template-ngIf-2
 :marked
   The next (and final) step unfolds the HTML into a `<template>` tag and `[ngIf]` [property binding](#property-binding):
+  
+  下一步，也就是最后一步，是把HTML包裹进`<template>`标签和一个`[ngIf]`[属性绑定](#property-binding)中：
 // #enddocregion star-template-ngIf-2
 +makeExample('template-syntax/ts/app/app.component.html', 'Template-2')(format=".")
 // #docregion star-template-ngIf-3
 :marked
   Notice that the `[hero]="currentHero"` binding remains on the child `<hero-detail>`
   element inside the template.
+  
+  注意，`[hero]="currengHero"`绑定留在了模板中的子元素`<hero-detail>`上。
 // #enddocregion star-template-ngIf-3
 
 // #docregion star-template-ngIf-4
 .callout.is-critical
   header Remember the brackets!
+  header 别忘了括号！
   :marked
     Don’t make the mistake of writing `ngIf="currentHero"`!
     That syntax assigns the *string* value "currentHero" to `ngIf`.
     In JavaScript a non-empty string is a truthy value, so `ngIf` would always be
     `true` and Angular would always display the `hero-detail`
     … even when there is no `currentHero`!
+    
+    不要误写为`ngIf="currentHero"`！
+    这种语法会把一个字符串"currentHero"赋值给`ngIf`。
+    在JavaScript中，非空的字符串是真值，所以`ngIf`总会是`true`，而Angular将永远显示`hero-detail` …… 即使根本没有`currentHero`！
 // #enddocregion star-template-ngIf-4
 
 // #docregion star-template-ngSwitch-1
 :marked
   ### Expanding `*ngSwitch`
+  ### 展开`*ngSwitch`
   A similar transformation applies to `*ngSwitch`. We can de-sugar the syntax ourselves.
   Here's an example, first with `*ngSwitchWhen` and `*ngSwitchDefault` and then again with `<template>` tags:
+  
+  类似的转换也作用于`*ngSwitch`上。我们可以自己解开这个语法糖。
+  这里是一个例子，首先是`*ngSwitchWhen`和`*ngSwitchDefault`，然后再解出`<template>`标签：
 // #enddocregion star-template-ngSwitch-1
 +makeExample('template-syntax/ts/app/app.component.html', 'NgSwitch-expanded')(format=".")
 // #docregion star-template-ngSwitch-2
 :marked
   The `*ngSwitchWhen` and `*ngSwitchDefault` expand in exactly the same manner as `*ngIf`,
   wrapping their former elements in `<template>` tags.
+  
+  `*ngSwitchWhen`和`*ngSwitchDefault`用和`*ngIf`完全相同的方式展开，把它们以前的元素包裹在`<template>`标签中。
 
   Now we can see why the `ngSwitch` itself is not prefixed with an asterisk (*).
   It does not define content. It's job is to control a collection of templates.
+  
+  现在，我们应该明白为什么`ngSwitch`本身不能用星号（*）前缀的原因了吧？
+  它没有定义内容，它的工作是控制一组模板。
 
   In this case, it governs two sets of `NgSwitchWhen` and `NgSwitchDefault` directives.
   We should expect it to display the values of the selected template twice,
   once for the (*) prefixed version and once for the expanded template version.
   That's exactly what we see in this example:
+  
+  这种情况下，它管理两组`NgSwitchWhen`和`NgSwitchDefault`指令。
+  我们期待它应该显示所选模板的值两次，一次是（*）前缀的版本，一次是展开模板后的版本。
+  这正是我们在这个例子中看到的：
 figure.image-display
     img(src='/resources/images/devguide/template-syntax/ng-switch-anim.gif' alt="NgSwitch")
 // #enddocregion star-template-ngSwitch-2
 // #docregion star-template-ngFor-1
 :marked
   ### Expanding `*ngFor`
+  ### 展开`*ngFor`
   The `*ngFor` undergoes a similar transformation. We begin with an `*ngFor` example:
+  `*ngFor`经历了同样的转换。我们从一个`*ngFor`的例子开始：
 // #enddocregion star-template-ngFor-1
 +makeExample('template-syntax/ts/app/app.component.html', 'Template-3a')(format=".")
 // #docregion star-template-ngFor-2
 :marked
   Here's the same example after transporting the `ngFor` to the `template` directive:
+  
+  这里是在把`ngFor`传进`template`指令后的同一个例子：
 // #enddocregion star-template-ngFor-2
 +makeExample('template-syntax/ts/app/app.component.html', 'Template-3')(format=".")
 // #docregion star-template-ngFor-3
 :marked
   And here it is expanded further into a `<template>` tag wrapping the original `<hero-detail>` element:
+  
+  这里，它被进一步扩展成了包裹着原始`<hero-detail>`元素的`<template>`标签：
 // #enddocregion star-template-ngFor-3
 +makeExample('template-syntax/ts/app/app.component.html', 'Template-4')(format=".")
 // #docregion star-template-ngFor-4
@@ -2016,6 +2154,10 @@ figure.image-display
   The `NgFor` code is a bit more complex than `NgIf` because a repeater has more moving parts to configure.
   In this case, we have to remember to create and assign the `NgForOf` directive that identifies the list and the `NgForTrackBy` directive.
   Using the `*ngFor` syntax is much easier than writing out this expanded HTML ourselves.
+  
+  `NgFor`的代码相对`NgIf`更复杂一点，因为一个重复器有更多可配置的活动部分。
+  这种情况下，我们不得不记着创建并对用于标记列表的`NgForOf`指令和`NgForTrackBy`指令赋值。
+  使用`*ngFor`语法比直接写这些展开后的HTML本身要简单多了。
 // #enddocregion star-template-ngFor-4
 
 // #docregion ref-vars
@@ -2023,65 +2165,99 @@ figure.image-display
 .l-main-section
 :marked
   ## Template reference variables
+  ## 模板引用变量
 
   A **template reference variable** is a reference to an DOM element or directive within a template.
+  
+  **模板引用变量** 是模板中对DOM元素或指令的引用。
 
   It can be used with native DOM elements but also with Angular 2 components - in fact, it will work with any custom web component.
+  
+  它能被用作原生DOM元素，但也能用于Angular 2组件 —— 实际上，它可以和任何自定义Web组件协同工作。
 
 :marked
   ### Referencing a template reference variable
+  ### 引用一个模板引用变量
 
   We can reference a template reference variable on the same element, on a sibling element, or on
   any child elements.
+  
+  我们可以在同一元素、兄弟元素或任何子元素中引用模板引用变量。
 
   Here are two other examples of creating and consuming a Template reference variable:
+  
+  这里是关于创建和消费模板引用变量的另外两个例子：
 // #enddocregion ref-vars
 +makeExample('template-syntax/ts/app/app.component.html', 'ref-phone')(format=".")
 // #docregion ref-vars-value
 :marked
   The hash (`#`) prefix to "phone" means that we're defining a `phone` variable.
+  
+  "phone"的(`#`)前缀意味着我们将要定义一个`phone`变量。
 .l-sub-section
   :marked
     Folks who don't like using the `#` character can use its canonical alternative,
     the `ref-` prefix. For example, we can declare the our `phone` variable using
     either `#phone` or `ref-phone`.
+    
+    有些人不喜欢使用`#`字符，而是使用它的古典形式：`ref-`前缀。例如，我们既能用`#phone`，也能用`ref-phone`来定义我们的`phone`变量。
 
 :marked
   ### How a variable gets its value
+  ### 如何获取变量的值
 
   Angular sets the variable's value to the element on which it was defined.
   We defined these variables on the `input` elements.
   We’re passing those `input` element objects across to the
   button elements, where they're used in arguments to the `call` methods in the event bindings.
+  
+  Angular把这种变量的值设置为它所定义在的那个元素。
+  我们在这个`input`元素上定义了这些变量。
+  我们把那些`input`元素对象传给button元素，在这里，它们被当做参数传给了在事件绑定中的`call`方法。
 // #enddocregion ref-vars-value
 
 // #docregion ref-vars-form-1
 :marked
   ### NgForm and template reference variables
+  ### NgForm和模板引用变量
   Let's look at one final example: a form, the poster child for template reference variables.
+  
+  让我们看看最后一个例子：一个表单，使用模板引用变量的典范。
 
   The HTML for a form can be quite involved, as we saw in the [Forms](forms.html) chapter.
   The following is a *simplified* example &mdash; and it's not simple at all.
+  
+  正如我们在[表单](forms.html)一章中所见过的，此表单的HTML可以做得相当复杂。
+  下面是一个 *简化过的* 范例 —— 虽然仍然不那么简单。
 // #enddocregion ref-vars-form-1
 +makeExample('template-syntax/ts/app/app.component.html', 'ref-form')(format=".")
 // #docregion ref-vars-form-2
 :marked
   A template reference variable, `theForm`, appears three times in this example, separated
   by a large amount of HTML.
+  
+  模板引用变量`theForm`在这个例子中出现了三次，中间隔着一大段儿HTML。
 // #enddocregion ref-vars-form-2
 +makeExample('template-syntax/ts/app/app.component.html', 'ref-form-a')(format=".")
 // #docregion ref-vars-form-3
 :marked
   What is the value of `theForm`?
+  
+  `theForm`变量的值是什么？
 
   It would be the [HTMLFormElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement)
   if Angular hadn't taken it over.
   It's actually `ngForm`, a reference to the Angular built-in `NgForm` directive that wraps the native `HTMLFormElement`
   and endows it with additional superpowers such as the ability to
   track the validity of user input.
+  
+  如果Angular没有捕获它，那它可能是个[HTMLFormElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement)。
+  但实际上它是个`ngForm`，一个对Angular内建指令`NgForm`的引用。它包装了原生的`HTMLFormElement`并赋予它额外的“超能力”，比如跟踪用户输入的有效性。
 
   This explains how we can disable the submit button by checking `theForm.form.valid`
   and pass an object with rich information to the parent component's `onSubmit` method.
+  
+  这解释了我们该如何通过检查`theForm.form.valid`来禁用提交按钮，以及如何把一个信息量有点大的对象传给父组件的`onSubmit`方法。
 // #enddocregion ref-vars-form-3
 
 // #docregion inputs-outputs-1
@@ -2089,43 +2265,70 @@ figure.image-display
 .l-main-section
 :marked
   ## Input and output properties
+  ## 输入与输出属性
   So far, we’ve focused mainly on binding to component members within template expressions and statements
   that appear on the *right side of the binding declaration*.
   A member in that position is a data binding **source**.
+  
+  迄今为止，我们主要聚焦在绑定声明的右侧，学习如何在模板表达式和模板语句中绑定到组件成员上。
+  当一个成员出现在这个位置上，则称之为数据绑定的 **源** 。
 
   This section concentrates on binding to **targets**, which are directive
   properties on the *left side of the binding declaration*.
   These directive properties must be declared as **inputs** or **outputs**.
+  
+  这一节则专注于绑定到的 **目标** ，它位于 *绑定声明中的左侧* 。
+  这些指令的属性必须被声明成 **输入** 或 **输出** 。
 
 .alert.is-important
   :marked
     Remember: All **components** are **directives**.
+    
+    记住：所有 **组件** 皆为 **指令** 。
 :marked
 .l-sub-section
   :marked
     We're drawing a sharp distinction between a data binding **target** and a data binding **source**.
+    
+    我们要重点突出下绑定 **目标** 和绑定 **源** 的区别。
 
     The *target* of a binding is to the *left* of the `=`.
     The *source* is on the *right* of the `=`.
+    
+    绑定的 *目标* 是在`=` *左侧* 的部分， *源* 则是在`=` *右侧* 的部分。
 
     The *target* of a binding is the property or event inside the binding punctuation: `[]`, `()` or `[()]`.
     The *source* is either inside quotes (`" "`) or within an interpolation (`{}`).
+    
+    绑定的 *目标* 是绑定符：`[]`、`()`或`[()]`中的属性或事件名， *源* 则是引号（`" "`）中的部分或插值符号（`{}`）中的部分。
 
     Every member of a **source** directive is automatically available for binding.
     We don't have to do anything special to access a directive member in a template expression or statement.
+    
+    **源** 指令中的每个成员都会自动在绑定中可用。
+    我们不需要特别做什么，就能在模板表达式或语句中访问指令的成员。
 
     We have *limited* access to members of a **target** directive.
     We can only bind to properties that are explicitly identified as *inputs* and *outputs*.
+    
+    访问 **目标** 指令中的成员则 *受到限制* 。
+    我们只能绑定到那些显式标记为 *输入* 或 *输出* 的属性。
 :marked
   In the following example, `iconUrl` and `onSave` are members of a component
   that are referenced within quoted syntax to the right of the `=`.
+  
+  在下列范例中，`iconUrl`和`onSave`是组件的成员，他们在`=`右侧引号中的语法中被引用了。
 // #enddocregion inputs-outputs-1
 +makeExample('template-syntax/ts/app/app.component.html', 'io-1')(format=".")
 // #docregion inputs-outputs-2
 :marked
   They are *neither inputs nor outputs* of the component. They are data sources for their bindings.
+  
+  它们既不是组件的 *输入* 也不是 *输出* 。它们是绑定的数据源。
 
   Now look at `HeroDetailComponent` when it is the **target of a binding**.
+  
+  现在，看看`HeroDetailComponent`，它是 **绑定的目标** 。
 // #enddocregion inputs-outputs-2
 +makeExample('template-syntax/ts/app/app.component.html', 'io-2')(format=".")
 // #docregion inputs-outputs-3
@@ -2133,12 +2336,21 @@ figure.image-display
   Both `HeroDetailComponent.hero` and `HeroDetailComponent.deleteRequest` are on the **left side** of binding declarations.
   `HeroDetailComponent.hero` is inside brackets; it is the target of a property binding.
   `HeroDetailComponent.deleteRequest` is inside parentheses; it is the target of an event binding.
+  
+  `HeroDetailComponent.hero`和`HeroDetailComponent.deleteRequest`都在绑定声明的 **左侧** 。
+  `HeroDetailComponent.hero`在方括号中，它是一个属性绑定的目标。
+  `HeroDetailComponent.deleteRequest`在圆括号中，它是一个事件绑定的目标。
 
   ### Declaring input and output properties
+  ### 声明输入和输出属性
   Target properties must be explicitly marked as inputs or outputs.
+  
+  目标属性必须被显式的标记成输入或输出。
 
   When we peek inside `HeroDetailComponent`, we see that these properties are marked
   with decorators as input and output properties.
+  
+  当我们深入`HeroDetailComponent`内部，我们看到这些属性被装饰器标记成了输入和输出属性。
 // #enddocregion inputs-outputs-3
 +makeExample('template-syntax/ts/app/hero-detail.component.ts', 'input-output-1')(format=".")
 
@@ -2147,39 +2359,58 @@ figure.image-display
   :marked
     Alternatively, we can identify members in the `inputs` and `outputs` arrays
     of the directive metadata, as in this example:
+    
+    另外，我们还可以在指令元数据的`inputs`或`outputs`数组中标记出这些成员。比如这个例子：
   +makeExample('template-syntax/ts/app/hero-detail.component.ts', 'input-output-2')(format=".")
   <br>
   :marked
     We can specify an input/output property either with a decorator or in a metadata array.
     Don't do both!
+    
+    我们既可以通过装饰器，又可以通过元数据数组来指定输入/输出属性。但别同时用！
 // #docregion inputs-outputs-4
 :marked
   ### Input or output?
+  ### 输入或输出？
 
   *Input* properties usually receive data values.
   *Output* properties expose event producers, such as `EventEmitter` objects.
+  
+  *输入* 属性通常接收数据值。
+  *输出* 属性暴露事件生产者，比如`EventEmitter`对象。
 
   The terms _input_ and _output_ reflect the perspective of the target directive.
+  
+  _输入_ 和 _输出_ 这两个词是从目标指令的视角来说的。
 figure.image-display
-    img(src='/resources/images/devguide/template-syntax/input-output.png' alt="Inputs and outputs")
+    img(src='/resources/images/devguide/template-syntax/input-output.png' alt="输入和输出")
 :marked
   `HeroDetailComponent.hero` is an **input** property from the perspective of `HeroDetailComponent`
   because data flows *into* that property from a template binding expression.
+  
+  `HeroDetailComponent.hero`是一个相对于`HeroDetailComponent`视角的 **输入** 属性，因为数据流从模板绑定表达式流向那个属性。
 
   `HeroDetailComponent.deleteRequest` is an **output** property from the perspective of `HeroDetailComponent`
   because events stream *out* of that property and toward the handler in a template binding statement.
+  
+  `HeroDetailComponent.deleteRequest`是一个相对于`HeroDetailComponent`视角的 **输出** 属性，因为事件流来自这个属性，并且被模板绑定语句所处理。
 // #enddocregion inputs-outputs-4
 
 // #docregion inputs-outputs-5
 :marked
   ### Aliasing input/output properties
+  ### 输入/输出属性的别名
 
   Sometimes we want the public name of an input/output property to be different from the internal name.
+  
+  有时我们需要让输入/输出属性的公开名字不同于内部名字。
 
   This is frequently the case with [attribute directives](attribute-directives.html).
   Directive consumers expect to bind to the name of the directive.
   For example, when we apply a directive with a `myClick` selector to a `<div>` tag,
   we expect to bind to an event property that is also called `myClick`.
+  
+  这是使用[Attribute指令](attribute-directives.html)时的常见情况。
 // #enddocregion inputs-outputs-5
 +makeExample('template-syntax/ts/app/app.component.html', 'my-click')(format=".")
 // #docregion inputs-outputs-6
@@ -2187,13 +2418,22 @@ figure.image-display
   However, the directive name is often a poor choice for the name of a property within the directive class.
   The directive name rarely describes what the property does.
   The `myClick` directive name is not a good name for a property that emits click messages.
+  
+  无论如何，在指令类中，直接用指令名作为属性名通常都不是好的选择。
+  指令名很少能描述这个属性是干嘛的。
+  `myClick`这个指令名对于用来发出click消息的属性就算不上一个好名字。
 
   Fortunately, we can have a public name for the property that meets conventional expectations,
   while using a different name internally.
   In the example immediately above, we are actually binding *through the* `myClick` *alias* to
   the directive's own `clicks` property.
+  
+  幸运的是，我们有一个约定俗成的公开名字，同时在内部使用一个不同的名字。
+  在紧上面这个例子中，我们实际上是把`myClick`这个别名指向了指令自己的`clicks`属性。
 
   We can specify the alias for the property name by passing it into the input/output decorator like this:
+  
+  通过把别名传进@Input/@Output装饰器，我们可以为属性指定别名，就像这样：
 // #enddocregion inputs-outputs-6
 
 +makeExample('template-syntax/ts/app/my-click.directive.ts', 'my-click-output-1')(format=".")
@@ -2203,6 +2443,9 @@ figure.image-display
     We can also alias property names in the `inputs` and `outputs` arrays.
     We write a colon-delimited (`:`) string with
     the directive property name on the *left* and the public alias on the *right*:
+    
+    我们也能在`inputs`和`outputs`数组中为属性指定别名。
+    我们可以写一个冒号（`:`）分隔的字符串， *左侧* 是指令中的属性名， *右侧* 则是公开的别名。
   +makeExample('template-syntax/ts/app/my-click.directive.ts', 'my-click-output-2')(format=".")
 
 // #docregion expression-operators
@@ -2210,36 +2453,55 @@ figure.image-display
 .l-main-section
 :marked
   ## Template expression operators
+  ## 模板表达式操作符
   The template expression language employs a subset of JavaScript syntax supplemented with a few special operators
   for specific scenarios. We'll cover two of these operators: _pipe_ and _safe navigation operator_.
+  
+  模板表达式语言使用了JavaScript语法的一个子集，并补充了几个用于特定场景的特殊操作符。
+  这里我们讲其中的两个： _管道_ 和 _安全导航操作符_ 。
 // #enddocregion expression-operators
 
 // #docregion expression-operators-pipe-1
 :marked
   <a id="pipe"></a>
   ### The pipe operator ( | )
+  ### 管道操作符（ | ）
   The result of an expression might require some transformation before we’re ready to use it in a binding.  For example, we might want to display a number as a currency, force text to uppercase, or filter a list and sort it.
+  
+  在用到绑定中之前，表达式的结果可能需要一些转换。比如，我们可能希望把一个数字显示成金额、强制文本变成大写，或者过滤一个列表以及排序它。
 
   Angular [pipes](./pipes.html) are a good choice for small transformations such as these.
   Pipes are simple functions that accept an input value and return a transformed value.
   They're easy to apply within template expressions, using the **pipe operator (`|`)**:
+  
+  Angular [管道](./pipes.html)对像这样的小型转换是明智的选择。
+  管道是一个简单的函数，它接受一个输入值，并返回转换结果。
+  它们很容易用于模板表达式中，只要使用 **管道操作符（`|`）** 就行了。
 // #enddocregion expression-operators-pipe-1
 +makeExample('template-syntax/ts/app/app.component.html', 'pipes-1')(format=".")
 // #docregion expression-operators-pipe-2
 :marked
   The pipe operator passes the result of an expression on the left to a pipe function on the right.
+  
+  管道操作符会把它左侧的表达式结果传给它右侧的管道函数。
 
   We can chain expressions through multiple pipes:
+  
+  我们还可以通过多个管道串联出表达式：
 // #enddocregion expression-operators-pipe-2
 +makeExample('template-syntax/ts/app/app.component.html', 'pipes-2')(format=".")
 // #docregion expression-operators-pipe-3
 :marked
   And we can configure them too:
+  
+  我们还能配置它们：
 // #enddocregion expression-operators-pipe-3
 +makeExample('template-syntax/ts/app/app.component.html', 'pipes-3')(format=".")
 // #docregion expression-operators-pipe-4
 :marked
   The `json` pipe is particularly helpful for debugging our bindings:
+  
+  `json`管道是特别设计来帮助我们调试绑定的：
 // #enddocregion expression-operators-pipe-4
 +makeExample('template-syntax/ts/app/app.component.html', 'pipes-json')(format=".")
 
@@ -2247,81 +2509,129 @@ figure.image-display
 :marked
   <a id="safe-navigation-operator"></a>
   ### The safe navigation operator ( ?. ) and null property paths
+  ### 安全导航操作符（ ?. ）和空属性路径
 
   The Angular **safe navigation operator (`?.`)** is a fluent and convenient way to guard against null and undefined values in property paths.
   Here it is, protecting against a view render failure if the `currentHero` is null.
+  
+  Angular的 **安全导航操作符（`?.`）** 是一个流畅而便利的方式，用来保护出现在属性路径中null和undefined值。
+  意思是，当`currentHero`为空时，保护视图渲染器，让它免于失败。
 // #enddocregion expression-operators-safe-1
 +makeExample('template-syntax/ts/app/app.component.html', 'safe-2')(format=".")
 // #docregion expression-operators-safe-2
 :marked
   Let’s elaborate on the problem and this particular solution.
+  
+  我们来详细阐述一下这个问题以及这个解决方案：
 
   What happens when the following data bound `title` property is null?
+  
+  如果下列数据绑定中`title`属性为空，会发生什么？
 // #enddocregion expression-operators-safe-2
 +makeExample('template-syntax/ts/app/app.component.html', 'safe-1')(format=".")
 // #docregion expression-operators-safe-3
 :marked
   The view still renders but the displayed value is blank; we see only "The title is" with nothing after it.
   That is reasonable behavior. At least the app doesn't crash.
+  
+  这个视图仍然被渲染出来，但是显示的值是空；我们只能看到“The title is”，它后面却没有任何东西。
+  这是合理的行为。至少应用没有崩溃。
 
   Suppose the template expression involves a property path, as in this next example
   where we’re displaying the `firstName` of a null hero.
+  
+  假设模板表达式需要一个属性路径，在下一个例子中，我们要显示一个空（null）英雄的`firstName`。
 
 code-example(format="" language="html").
   The null hero's name is {{nullHero.firstName}}
+  
+  这个空英雄的名字是{{nullHero.firstName}}
 // #enddocregion expression-operators-safe-3
 // #docregion expression-operators-safe-4
 :marked
   JavaScript throws a null reference error, and so does Angular:
+  
+  JavaScript抛出了一个空引用错误，Angular也是如此。
 code-example(format="" language="html").
   TypeError: Cannot read property 'firstName' of null in [null]
+  
+  TypeError: Cannot read property 'firstName' of null in [null]
+  （类型错：无法读取null的'firstName'属性）
 // #enddocregion expression-operators-safe-4
 // #docregion expression-operators-safe-5
 :marked
   Worse, the *entire view disappears*.
+  
+  晕， *整个视图不见了* 。
 
   We could claim that this is reasonable behavior if we believed that the `hero` property must never be null.
   If it must never be null and yet it is null,
   we've made a programming error that should be caught and fixed.
   Throwing an exception is the right thing to do.
+  
+  如果确信`hero`属性永远不可能为空，我们就可以声称这是一个合理的行为。
+  如果它必须不能为空，但它仍然是空值，我们就可以制造一个编程错误，以便它被捕获和修复。
+  这种情况下，抛出一个异常正是我们应该做的。
 
   On the other hand, null values in the property path may be OK from time to time,
   especially when we know the data will arrive eventually.
+  
+  另一方面，属性路径中的空值可能只是暂时的，特别是当我们知道这些数据最终总会到达的时候。
 
   While we wait for data, the view should render without complaint, and
   the null property path should display as blank just as the `title` property does.
+  
+  当我们等待数据的时候，视图渲染器不应该抱怨，而应该把这个空属性路径显示为空白，就像`title`属性所做的那样。
 
   Unfortunately, our app crashes when the `currentHero` is null.
+  
+  不幸的是，当`currentHero`为空的时候，我们的应用崩溃了。
 
   We could code around that problem with [NgIf](#ngIf).
+  
+  我们可以通过写[NgIf](#ngIf)代码来解决这个问题。
 // #enddocregion expression-operators-safe-5
 +makeExample('template-syntax/ts/app/app.component.html', 'safe-4')(format=".")
 // #docregion expression-operators-safe-6
 :marked
   Or we could try to chain parts of the property path with `&&`, knowing that the expression bails out
   when it encounters the first null.
+  
+  或者我们可以尝试通过`&&`来把属性路径的各部分串起来，让它在遇到第一个空值的时候，就返回空。
 // #enddocregion expression-operators-safe-6
 +makeExample('template-syntax/ts/app/app.component.html', 'safe-5')(format=".")
 // #docregion expression-operators-safe-7
 :marked
   These approaches have merit but can be cumbersome, especially if the property path is long.
   Imagine guarding against a null somewhere in a long property path such as `a.b.c.d`.
+  
+  这些方法都有价值，但是会显得笨重，特别是当这个属性路径非常长的时候。
+  想象一下在一个很长的属性路径（如`a.b.c.d`）中对空值提供保护。
 // #enddocregion expression-operators-safe-7
 // #docregion expression-operators-safe-8
 :marked
   The Angular safe navigation operator (`?.`) is a more fluent and convenient way to guard against nulls in property paths.
   The expression bails out when it hits the first null value.
   The display is blank, but the app keeps rolling without errors.
+  
+  Angular安全导航操作符（`?.`）是在属性路径中保护空值的一个更加流畅、便利的方式。
+  表达式会在它遇到第一个空值的时候跳出。
+  显示是空的，但是应用正常工作，而没有发生错误。
 // #enddocregion expression-operators-safe-8
 +makeExample('template-syntax/ts/app/app.component.html', 'safe-6')(format=".")
 // #docregion expression-operators-safe-9
 :marked
   It works perfectly with long property paths such as `a?.b?.c?.d`.
+  
+  在像`a?.b?.c?.d`这样的长属性路径中，它工作得很完美。
 // #enddocregion expression-operators-safe-9
 
 // #docregion summary
 .l-main-section
 :marked
   ## Summary
+  ## 小结
   We’ve completed our survey of template syntax. Now it's time to put that knowledge to work as we write our own components and directives.
+  
+  我们完成了模板语法的概述。现在，我们该把如何写组件和指令的知识投入到实际工作当中了。
 // #enddocregion summary

From 53a55f2db35fc4584513150744e882f81260829c Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 18:45:50 +0800
Subject: [PATCH 03/12] =?UTF-8?q?=E7=BF=BB=E8=AF=91=E4=BA=86=E5=B0=8F?=
 =?UTF-8?q?=E6=8A=84=E3=80=82=20=E5=A2=9E=E5=8A=A0=E4=BA=86=E7=BF=BB?=
 =?UTF-8?q?=E8=AF=91=E7=9A=84About=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 public/docs/ts/latest/cheatsheet.jade         |   3 +-
 .../docs/ts/latest/guide/cheatsheet-cn.json   | 513 ++++++++++++++++++
 public/translate/cn/about.jade                |  23 +
 3 files changed, 538 insertions(+), 1 deletion(-)
 create mode 100644 public/docs/ts/latest/guide/cheatsheet-cn.json
 create mode 100644 public/translate/cn/about.jade

diff --git a/public/docs/ts/latest/cheatsheet.jade b/public/docs/ts/latest/cheatsheet.jade
index 4548cf52e0..68eb320686 100644
--- a/public/docs/ts/latest/cheatsheet.jade
+++ b/public/docs/ts/latest/cheatsheet.jade
@@ -1,7 +1,8 @@
 - var base = current.path[4] ? '.' : './guide';
 .banner
   p.text-body This cheat sheet is provisional and may change. Angular 2 is currently in Beta.
+  p.text-body 本小抄是临时的，将来可能改变。Angular 2目前还是Beta状态。
 
 article(class="l-content-small grid-fluid docs-content")
   .cheatsheet
-    ngio-cheatsheet(src= base + '/cheatsheet.json')
+    ngio-cheatsheet(src= base + '/cheatsheet-cn.json')
diff --git a/public/docs/ts/latest/guide/cheatsheet-cn.json b/public/docs/ts/latest/guide/cheatsheet-cn.json
new file mode 100644
index 0000000000..0cca92207e
--- /dev/null
+++ b/public/docs/ts/latest/guide/cheatsheet-cn.json
@@ -0,0 +1,513 @@
+{
+  "currentEnvironment": "TypeScript",
+  "version": {
+    "raw": "2.0.0-rc.1",
+    "major": 2,
+    "minor": 0,
+    "patch": 0,
+    "prerelease": [
+      "local"
+    ],
+    "build": "sha.48e03ae",
+    "version": "2.0.0-local",
+    "codeName": "snapshot",
+    "isSnapshot": true,
+    "full": "2.0.0-local+sha.48e03ae",
+    "branch": "master",
+    "commitSHA": "48e03ae748c0d68292380c4af2361faab5f6b497"
+  },
+  "sections": [
+    {
+      "name": "引导",
+      "description": "<p><code>import {bootstrap} from &#39;angular2/platform/browser&#39;;</code>\n\n</p>\n",
+      "items": [
+        {
+          "syntax": "bootstrap​(MyAppComponent, [MyService, provide(...)]);",
+          "bold": [
+            "provide"
+          ],
+          "description": "<p>以MyAppComponent作为根组件引导应用，并且配置DI的各种provider。</p>\n"
+        }
+      ],
+      "index": 0
+    },
+    {
+      "name": "模板语法",
+      "description": "",
+      "items": [
+        {
+          "syntax": "<input [value]=\"firstName\">",
+          "bold": [
+            "[value]"
+          ],
+          "description": "<p>把属性<code>value</code>绑定到表达式<code>firstName</code>的结果。</p>\n"
+        },
+        {
+          "syntax": "<div [attr.role]=\"myAriaRole\">",
+          "bold": [
+            "[attr.role]"
+          ],
+          "description": "<p>把Attribute <code>role</code> 绑定到表达式 <code>myAriaRole</code>的结果。</p>\n"
+        },
+        {
+          "syntax": "<div [class.extra-sparkle]=\"isDelightful\">",
+          "bold": [
+            "[class.extra-sparkle]"
+          ],
+          "description": "<p>把元素是否出现CSS类<code>extra-sparkle</code>，绑定到一个表达式<code>isDelightful</code>的结果是否为真。</p>\n"
+        },
+        {
+          "syntax": "<div [style.width.px]=\"mySize\">",
+          "bold": [
+            "[style.width.px]"
+          ],
+          "description": "<p>把样式的<code>width</code>属性绑定到表达式<code>mySize</code>的结果，以px为单位。这个单位是可选的。</p>\n"
+        },
+        {
+          "syntax": "<button (click)=\"readRainbow($event)\">",
+          "bold": [
+            "(click)"
+          ],
+          "description": "<p>当按钮（及其子元素）上的click事件被触发时，调用<code>readRainbow</code>方法，并把事件对象作为参数传入。</p>\n"
+        },
+        {
+          "syntax": "<div title=\"Hello {{ponyName}}\">",
+          "bold": [
+            "{{ponyName}}"
+          ],
+          "description": "<p>把属性绑定到一个插值表达式字符串，比如 &quot;Hello Seabiscuit&quot;. 等价于：\n<code>&lt;div [title]=&quot;&#39;Hello&#39; + ponyName&quot;&gt;</code></p>\n"
+        },
+        {
+          "syntax": "<p>Hello {{ponyName}}</p>",
+          "bold": [
+            "{{ponyName}}"
+          ],
+          "description": "<p>把文本内容绑定到一个插值表达式，比如 &quot;Hello Seabiscuit&quot;.</p>\n"
+        },
+        {
+          "syntax": "<my-cmp [(title)]=\"name\">",
+          "bold": [
+            "[(title)]"
+          ],
+          "description": "<p>设置双向数据绑定。等价于：<code>&lt;my-cmp [title]=&quot;name&quot; (titleChange)=&quot;name=$event&quot;&gt;</code></p>\n"
+        },
+        {
+          "syntax": "<video #movieplayer ...>\n  <button (click)=\"movieplayer.play()\">\n</video>",
+          "bold": [
+            "#movieplayer",
+            "(click)"
+          ],
+          "description": "<p>创建一个局部变量 <code>movieplayer</code> ，它提供到<code>video</code>元素实例的访问，可用于当前模板中的数据绑定和事件绑定表达式中。</p>\n"
+        },
+        {
+          "syntax": "<p *myUnless=\"myExpression\">...</p>",
+          "bold": [
+            "*myUnless"
+          ],
+          "description": "<p><code>*</code>符号表示当前元素将被转变成一个内嵌模板。等价于：\n<code>&lt;template [myUnless]=&quot;myExpression&quot;&gt;&lt;p&gt;...&lt;/p&gt;&lt;/template&gt;</code></p>\n"
+        },
+        {
+          "syntax": "<p>Card No.: {{cardNumber | myCreditCardNumberFormatter}}</p>",
+          "bold": [
+            "{{cardNumber | myCreditCardNumberFormatter}}"
+          ],
+          "description": "<p>通过名叫<code>myCreditCardNumberFormatter</code>的管道，转换表达式的当前值<code>cardNumber</code>。</p>\n"
+        },
+        {
+          "syntax": "<p>Employer: {{employer?.companyName}}</p>",
+          "bold": [
+            "{{employer?.companyName}}"
+          ],
+          "description": "<p>安全导航运算符(<code>?</code>)表示<code>employer</code>字段是可选的，如果它是<code>undefined</code>表达式剩下的部分将被忽略</p>\n"
+        }
+      ],
+      "index": 1
+    },
+    {
+      "name": "内建指令",
+      "description": "<p><code>import {NgIf, ...} from &#39;angular2/common&#39;;</code>\n\n</p>\n",
+      "items": [
+        {
+          "syntax": "<section *ngIf=\"showSection\">",
+          "bold": [
+            "*ngIf"
+          ],
+          "description": "<p>基于showSection表达式的值移除或重新创建部分DOM树。</p>\n"
+        },
+        {
+          "syntax": "<li *ngFor=\"let item of list\">",
+          "bold": [
+            "*ngFor"
+          ],
+          "description": "<p>把li元素及其内容转化成一个模板，并用它来为列表中的每个条目初始化视图。</p>\n"
+        },
+        {
+          "syntax": "<div [ngSwitch]=\"conditionExpression\">\n  <template [ngSwitchWhen]=\"case1Exp\">...</template>\n  <template ngSwitchWhen=\"case2LiteralString\">...</template>\n  <template ngSwitchDefault>...</template>\n</div>",
+          "bold": [
+            "[ngSwitch]",
+            "[ngSwitchWhen]",
+            "ngSwitchWhen",
+            "ngSwitchDefault"
+          ],
+          "description": "<p>基于conditionExpression的当前值，从内嵌模板中选取一个，有条件的切换div的内容。</p>\n"
+        },
+        {
+          "syntax": "<div [ngClass]=\"{active: isActive, disabled: isDisabled}\">",
+          "bold": [
+            "[ngClass]"
+          ],
+          "description": "<p>把一个元素上CSS类的出现与否，绑定到一个真值映射表上。右侧的表达式应该返回类似{class-name: true/false}的映射表。</p>\n"
+        }
+      ],
+      "index": 2
+    },
+    {
+      "name": "表单",
+      "description": "<p><code>import {FORM_DIRECTIVES} from &#39;angular2/common&#39;;</code>\n\n</p>\n",
+      "items": [
+        {
+          "syntax": "<input [(ngModel)]=\"userName\">",
+          "bold": [
+            "[(ngModel)]"
+          ],
+          "description": "<p>提供双向绑定，为表单控件提供解析和验证。</p>\n"
+        }
+      ],
+      "index": 3
+    },
+    {
+      "name": "类装饰器",
+      "description": "<p><code>import {Directive, ...} from &#39;angular2/core&#39;;</code>\n\n</p>\n",
+      "items": [
+        {
+          "syntax": "@Component({...})\nclass MyComponent() {}",
+          "bold": [
+            "@Component({...})"
+          ],
+          "description": "<p>声明当前类是一个组件，并提供关于该组件的元数据。</p>\n"
+        },
+        {
+          "syntax": "@Directive({...})\nclass MyDirective() {}",
+          "bold": [
+            "@Directive({...})"
+          ],
+          "description": "<p>声明当前类是一个指令，并提供关于该指令的元数据。</p>\n"
+        },
+        {
+          "syntax": "@Pipe({...})\nclass MyPipe() {}",
+          "bold": [
+            "@Pipe({...})"
+          ],
+          "description": "<p>声明当前类是一个管道，并且提供该管道的元数据。</p>\n"
+        },
+        {
+          "syntax": "@Injectable()\nclass MyService() {}",
+          "bold": [
+            "@Injectable()"
+          ],
+          "description": "<p>声明当前类有一些依赖，当依赖注入器创建该类的实例时，这些依赖应该被注入到构造函数中。\n\n</p>\n"
+        }
+      ],
+      "index": 4
+    },
+    {
+      "name": "指令配置",
+      "description": "<p><code>@Directive({ property1: value1, ... })</code>\n\n</p>\n",
+      "items": [
+        {
+          "syntax": "selector: '.cool-button:not(a)'",
+          "bold": [
+            "selector:"
+          ],
+          "description": "<p>指定一个CSS选择器，以便在模板中找出该指令。支持的选择器包括<code>element</code>,\n<code>[attribute]</code>, <code>.class</code>, 和 <code>:not()</code>。</p>\n<p>不支持父子关系选择器。</p>\n"
+        },
+        {
+          "syntax": "providers: [MyService, provide(...)]",
+          "bold": [
+            "providers:"
+          ],
+          "description": "<p>为当前指令及其子指令提供依赖注入的providers数组。</p>\n"
+        }
+      ],
+      "index": 5
+    },
+    {
+      "name": "组件配置",
+      "description": "<p>\n<code>@Component</code> extends <code>@Directive</code>,\nso the <code>@Directive</code> configuration applies to components as well</p>\n",
+      "items": [
+        {
+          "syntax": "viewProviders: [MyService, provide(...)]",
+          "bold": [
+            "viewProviders:"
+          ],
+          "description": "<p>依赖注入provider的数组，局限于当前组件的视图中。</p>\n"
+        },
+        {
+          "syntax": "template: 'Hello {{name}}'\ntemplateUrl: 'my-component.html'",
+          "bold": [
+            "template:",
+            "templateUrl:"
+          ],
+          "description": "<p>当前组件视图的内联模板或外部模板地址</p>\n"
+        },
+        {
+          "syntax": "styles: ['.primary {color: red}']\nstyleUrls: ['my-component.css']",
+          "bold": [
+            "styles:",
+            "styleUrls:"
+          ],
+          "description": "<p>内联CSS样式或外部样式表URL的列表，用于给组件的视图添加样式。</p>\n"
+        },
+        {
+          "syntax": "directives: [MyDirective, MyComponent]",
+          "bold": [
+            "directives:"
+          ],
+          "description": "<p>组件模板中用到的指令列表。</p>\n"
+        },
+        {
+          "syntax": "pipes: [MyPipe, OtherPipe]",
+          "bold": [
+            "pipes:"
+          ],
+          "description": "<p>组件模板中用到的管道列表。</p>\n"
+        }
+      ],
+      "index": 6
+    },
+    {
+      "name": "供指令类或组件类用的字段装饰器。",
+      "description": "<p><code>import {Input, ...} from &#39;angular2/core&#39;;</code>\n\n</p>\n",
+      "items": [
+        {
+          "syntax": "@Input() myProperty;",
+          "bold": [
+            "@Input()"
+          ],
+          "description": "<p>声明一个输入属性，以便我们可以通过属性绑定更新它。(比如：\n<code>&lt;my-cmp [my-property]=&quot;someExpression&quot;&gt;</code>).</p>\n"
+        },
+        {
+          "syntax": "@Output() myEvent = new EventEmitter();",
+          "bold": [
+            "@Output()"
+          ],
+          "description": "<p>声明一个输出属性，以便我们可以通过事件绑定进行订阅。(比如：<code>&lt;my-cmp (my-event)=&quot;doSomething()&quot;&gt;</code>)</p>\n"
+        },
+        {
+          "syntax": "@HostBinding('[class.valid]') isValid;",
+          "bold": [
+            "@HostBinding('[class.valid]')"
+          ],
+          "description": "<p>把宿主元素的属性（比如CSS类：valid）绑定到指令/组件的属性（比如：isValid）。</p>\n"
+        },
+        {
+          "syntax": "@HostListener('click', ['$event']) onClick(e) {...}",
+          "bold": [
+            "@HostListener('click', ['$event'])"
+          ],
+          "description": "<p>通过指令/组件的方法（例如onClick）订阅宿主元素的事件（例如click），可选传入一个参数（$event）。</p>\n"
+        },
+        {
+          "syntax": "@ContentChild(myPredicate) myChildComponent;",
+          "bold": [
+            "@ContentChild(myPredicate)"
+          ],
+          "description": "<p>把组件内容查询(myPredicate)的第一个结果绑定到类的myChildComponent属性。</p>\n"
+        },
+        {
+          "syntax": "@ContentChildren(myPredicate) myChildComponents;",
+          "bold": [
+            "@ContentChildren(myPredicate)"
+          ],
+          "description": "<p>把组件内容查询(MyPredicate)的全部结果，绑定到类的myChildComponents属性。</p>\n"
+        },
+        {
+          "syntax": "@ViewChild(myPredicate) myChildComponent;",
+          "bold": [
+            "@ViewChild(myPredicate)"
+          ],
+          "description": "<p>把组件视图查询(myPredicate)的第一个结果绑定到类的myChildComponent属性。对指令无效。</p>\n"
+        },
+        {
+          "syntax": "@ViewChildren(myPredicate) myChildComponents;",
+          "bold": [
+            "@ViewChildren(myPredicate)"
+          ],
+          "description": "<p>把组件视图查询(myPredicate)的所有结果绑定到类的myChildComponents属性。对指令无效。</p>\n"
+        }
+      ],
+      "index": 7
+    },
+    {
+      "name": "指令和组件的变更检测与生命周期钩子",
+      "description": "<p>(作为类方法实现)\n</p>\n",
+      "items": [
+        {
+          "syntax": "constructor(myService: MyService, ...) { ... }",
+          "bold": [
+            "constructor(myService: MyService, ...)"
+          ],
+          "description": "<p>类的构造函数会在所有其他生命周期钩子之前调用。使用它来注入依赖，但是要避免用它做较重的工作。</p>\n"
+        },
+        {
+          "syntax": "ngOnChanges(changeRecord) { ... }",
+          "bold": [
+            "ngOnChanges(changeRecord)"
+          ],
+          "description": "<p>在输入属性每次变化了之后、开始处理内容或子视图之前被调用。</p>\n"
+        },
+        {
+          "syntax": "ngOnInit() { ... }",
+          "bold": [
+            "ngOnInit()"
+          ],
+          "description": "<p>在构造函数、初始化输入属性、第一次调用完ngOnChanges之后调用。</p>\n"
+        },
+        {
+          "syntax": "ngDoCheck() { ... }",
+          "bold": [
+            "ngDoCheck()"
+          ],
+          "description": "<p>每当检查组件或指令的输入属性是否变化时调用。通过它，可以用自定义的检查方式来扩展变更检测逻辑。</p>\n"
+        },
+        {
+          "syntax": "ngAfterContentInit() { ... }",
+          "bold": [
+            "ngAfterContentInit()"
+          ],
+          "description": "<p>当组件或指令的内容已经初始化、ngOnInit完成之后调用。</p>\n"
+        },
+        {
+          "syntax": "ngAfterContentChecked() { ... }",
+          "bold": [
+            "ngAfterContentChecked()"
+          ],
+          "description": "<p>在每次检查完组件或指令的内容之后调用。</p>\n"
+        },
+        {
+          "syntax": "ngAfterViewInit() { ... }",
+          "bold": [
+            "ngAfterViewInit()"
+          ],
+          "description": "<p>当组件的视图已经初始化完毕，每次ngAfterContentInit之后被调用。只适用于组件。</p>\n"
+        },
+        {
+          "syntax": "ngAfterViewChecked() { ... }",
+          "bold": [
+            "ngAfterViewChecked()"
+          ],
+          "description": "<p>每次检查完组件的视图之后调用。只适用于组件。</p>\n"
+        },
+        {
+          "syntax": "ngOnDestroy() { ... }",
+          "bold": [
+            "ngOnDestroy()"
+          ],
+          "description": "<p>在所属实例被销毁前，只调用一次。</p>\n"
+        }
+      ],
+      "index": 8
+    },
+    {
+      "name": "依赖注入配置",
+      "description": "<p><code>import {provide} from &#39;angular2/core&#39;;</code>\n\n</p>\n",
+      "items": [
+        {
+          "syntax": "provide(MyService, {useClass: MyMockService})",
+          "bold": [
+            "provide",
+            "useClass"
+          ],
+          "description": "<p>把MyService类的Provider设置或改写为MyMockService。</p>\n"
+        },
+        {
+          "syntax": "provide(MyService, {useFactory: myFactory})",
+          "bold": [
+            "provide",
+            "useFactory"
+          ],
+          "description": "<p>把MyService的Provider设置或改写为myFactory工厂函数。</p>\n"
+        },
+        {
+          "syntax": "provide(MyValue, {useValue: 41})",
+          "bold": [
+            "provide",
+            "useValue"
+          ],
+          "description": "<p>把MyValue的Provider设置或改写为值41。</p>\n"
+        }
+      ],
+      "index": 9
+    },
+    {
+      "name": "路由与导航",
+      "description": "<p><code>import {RouteConfig, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, ...} from &#39;angular2/router&#39;;</code>\n\n</p>\n",
+      "items": [
+        {
+          "syntax": "@RouteConfig([\n  { path: '/:myParam', component: MyComponent, name: 'MyCmp' },\n  { path: '/staticPath', component: ..., name: ...},\n  { path: '/*wildCardParam', component: ..., name: ...}\n])\nclass MyComponent() {}",
+          "bold": [
+            "@RouteConfig"
+          ],
+          "description": "<p>为所装饰的组件配置路由。支持静态、参数化、带通配符的路由。</p>\n"
+        },
+        {
+          "syntax": "<router-outlet></router-outlet>",
+          "bold": [
+            "router-outlet"
+          ],
+          "description": "<p>标记一个位置，用于加载当前激活路由的组件。</p>\n"
+        },
+        {
+          "syntax": "<a [routerLink]=\"[ '/MyCmp', {myParam: 'value' } ]\">",
+          "bold": [
+            "[routerLink]"
+          ],
+          "description": "<p>基于路由指令创建指向不同视图的链接，由路由名和可选参数组成。路由名匹配一个已配置路由的name属性。添加“/”前缀可以导航到根路由。添加“./”前缀可以导航到子路由。</p>\n"
+        },
+        {
+          "syntax": "@CanActivate(() => { ... })class MyComponent() {}",
+          "bold": [
+            "@CanActivate"
+          ],
+          "description": "<p>用函数定义的一个组件装饰器，路由器会先调用它来检测是否应该激活该组件。应该返回布尔值或承诺（Promise）。</p>\n"
+        },
+        {
+          "syntax": "routerOnActivate(nextInstruction, prevInstruction) { ... }",
+          "bold": [
+            "routerOnActivate"
+          ],
+          "description": "<p>导航到一个组件之后，路由器调用该组件的routerOnActivate方法（如已定义）。</p>\n"
+        },
+        {
+          "syntax": "routerCanReuse(nextInstruction, prevInstruction) { ... }",
+          "bold": [
+            "routerCanReuse"
+          ],
+          "description": "<p>路由器调用组件的routerCanReuse方法（如已定义）来检测是复用本实例还是销毁它并创建一个新的。应该返回布尔值或承诺（Promise）。</p>\n"
+        },
+        {
+          "syntax": "routerOnReuse(nextInstruction, prevInstruction) { ... }",
+          "bold": [
+            "routerOnReuse"
+          ],
+          "description": "<p>当路由器可以复用一个组件实例时，它调用组件的routerOnReuse方法（如已定义）。</p>\n"
+        },
+        {
+          "syntax": "routerCanDeactivate(nextInstruction, prevInstruction) { ... }",
+          "bold": [
+            "routerCanDeactivate"
+          ],
+          "description": "<p>路由器会调用要完成导航所需移除的每个组件的routerCanDeactivate方法（如已定义）。当且仅当所有的该方法都返回true或者承诺（Promise）被解析（Resolve）时，导航才会继续。</p>\n"
+        },
+        {
+          "syntax": "routerOnDeactivate(nextInstruction, prevInstruction) { ... }",
+          "bold": [
+            "routerOnDeactivate"
+          ],
+          "description": "<p>在每个指令因为路由变更而被移除之前调用。可以返回一个承诺，来阻止移除本指令 —— 直到承诺（Promise）被解析（Resolve）。</p>\n"
+        }
+      ],
+      "index": 10
+    }
+  ]
+}
diff --git a/public/translate/cn/about.jade b/public/translate/cn/about.jade
new file mode 100644
index 0000000000..5a99be77e1
--- /dev/null
+++ b/public/translate/cn/about.jade
@@ -0,0 +1,23 @@
+:marked
+  ## 关于中文版
+  这是一份跟官方网站保持 **同步更新** 的中文版。虽然保持同步是很累的，不过为了防止过时的内容误导读者，这份额外的付出还是很值得的。
+  我们全文采用意译的方式，在彻底理解作者意思的前提下用中文重新表述，力求做到“信雅达”。
+  
+  当然，即便如此，我们会错意的可能性也还是有的，所以我们的译稿都提供了中英文对照，如果你对某些含义有疑问，可以看一下对应的英文版内容。
+  
+  本文档目前只完成了初译，尚未进行审校和统稿，因此语言风格和表达上可能还有问题，欢迎到我们的[github]()上提出issue。
+  
+  本文档遵循 C.C. 授权方式，你不用知会我们就可以转载，但是必须保证 **不做任何修改** 。
+  ## 关于译者
+  本文档有两位译者，他们是多年的好友。这次利用业余时间联手翻译，就是因为看好Angular 2的前景，希望帮助大家在这项技术上能跟国外同步前进。
+  ### 汪志成（雪狼）
+  《AngularJS深度剖析与最佳实践》的作者之一，ThoughtWorks高级咨询师。他从1998年开始做商业软件开发，拥有超过18年的从业经验，至今仍热衷于编程。
+  
+  虽然一直在做编程工作，不过他最热衷的却是国学，特别是儒学与诗词。孟子曰：“得天下英才而教育之，三乐也”，力求践行之。
+  ### 叶志敏
+  早期翻译软件《东方快车》的产品经理，至今已在英国留学和生活了十年。有多年在养老院工作的经历，他正在用Angular 2与.net开发一个养老院管理系统。
+  
+  ## 支持我们
+  由于我们对翻译质量的极端要求，所以很抱歉，我们暂时无法接受新人参与，否则我们需要花费大量精力去review。
+  
+  你可以精神上支持我们：提供反馈意见、纠错、帮我们宣传等等。

From ae6ae103c09c8a76edda5b4d365417850721254c Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 19:30:30 +0800
Subject: [PATCH 04/12] =?UTF-8?q?=E5=AE=8C=E5=96=84=E4=BA=86=E7=BF=BB?=
 =?UTF-8?q?=E8=AF=91=E7=9A=84About=E3=80=82=E5=8A=A0=E4=B8=8A=E4=BA=86?=
 =?UTF-8?q?=E9=A6=96=E9=A1=B5=E7=9A=84=E9=93=BE=E6=8E=A5=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 public/_includes/_main-nav.jade |  1 +
 public/translate/cn/about.jade  | 23 +++++++++++++++++------
 2 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/public/_includes/_main-nav.jade b/public/_includes/_main-nav.jade
index 256c2dca3f..1b13d2b3ce 100644
--- a/public/_includes/_main-nav.jade
+++ b/public/_includes/_main-nav.jade
@@ -12,4 +12,5 @@ md-toolbar(class="main-nav background-regal l-pinned-top l-layer-5",scroll-y-off
       li.l-left <a class="main-nav-button" href="/docs/#{language}/latest/" md-button>文档</a>
       li.l-left <a class="main-nav-button" href="/events.html" md-button>事件</a>
       li.l-left <a class="main-nav-button" href="/news.html" md-button>新闻</a>
+      li.l-left <a class="main-nav-button" href="/translate/cn/about.html" md-button>关于中文版</a>
       li.l-right <a class="main-nav-button" href="/docs/ts/latest/quickstart.html" md-button>立即开始！</a>
diff --git a/public/translate/cn/about.jade b/public/translate/cn/about.jade
index 5a99be77e1..376b9d27c0 100644
--- a/public/translate/cn/about.jade
+++ b/public/translate/cn/about.jade
@@ -1,23 +1,34 @@
 :marked
   ## 关于中文版
-  这是一份跟官方网站保持 **同步更新** 的中文版。虽然保持同步是很累的，不过为了防止过时的内容误导读者，这份额外的付出还是很值得的。
+  这是一份跟官方网站保持 **同步更新** 的中文版。虽然保持同步非常耗费精力，不过为了防止过时的内容误导读者，这份额外的付出还是很值得的。
   我们全文采用意译的方式，在彻底理解作者意思的前提下用中文重新表述，力求做到“信雅达”。
   
   当然，即便如此，我们会错意的可能性也还是有的，所以我们的译稿都提供了中英文对照，如果你对某些含义有疑问，可以看一下对应的英文版内容。
   
-  本文档目前只完成了初译，尚未进行审校和统稿，因此语言风格和表达上可能还有问题，欢迎到我们的[github]()上提出issue。
+  本文档目前只完成了部分章节的初译，尚未完成审校和统稿，因此语言风格和表达上可能还有问题，欢迎到我们的[github](https://github.com/angular-live/angular.io)上提出issue。
   
-  本文档遵循 C.C. 授权方式，你不用知会我们就可以转载，但是必须保证 **不做任何修改** 。
+  本文档的任何更新都会实时发布于我们的 [首发网站](http://www.angular.live) 。如果你要进行转载，请自行同步，或者在想要同步到最新版时 [联系我们](mailto:traveller@163.com) 。
+  ## 授权方式
+  本文档遵循“保持署名—非商用”创意共享4.0许可证（CC BY-NC 4.0）授权方式，你不用知会我们就可以任意转载，但必须保持署名（特别是：不得去掉本页入口链接，也不得修改本页内容），并且不得用于商业目的。
   ## 关于译者
   本文档有两位译者，他们是多年的好友。这次利用业余时间联手翻译，就是因为看好Angular 2的前景，希望帮助大家在这项技术上能跟国外同步前进。
   ### 汪志成（雪狼）
   《AngularJS深度剖析与最佳实践》的作者之一，ThoughtWorks高级咨询师。他从1998年开始做商业软件开发，拥有超过18年的从业经验，至今仍热衷于编程。
   
   虽然一直在做编程工作，不过他最热衷的却是国学，特别是儒学与诗词。孟子曰：“得天下英才而教育之，三乐也”，力求践行之。
+  
+  小道消息：他当年英语四级都没考过哦，现在却可以直接读各种英文资料了。所以，不要怕，英语不是老虎，我行你也行。
   ### 叶志敏
-  早期翻译软件《东方快车》的产品经理，至今已在英国留学和生活了十年。有多年在养老院工作的经历，他正在用Angular 2与.net开发一个养老院管理系统。
+  早期翻译软件《东方快车》的产品经理，至今已在英国留学和生活了十年。有多年在英国养老院工作的经历，他正在用Angular 2与.net开发一个养老院管理系统。
   
   ## 支持我们
-  由于我们对翻译质量的极端要求，所以很抱歉，我们暂时无法接受新人参与，否则我们需要花费大量精力去review。
+  由于我们对翻译质量的极端要求，所以很抱歉，我们暂时无法接受新人一同翻译，否则我们需要花费大量精力去review。
+  
+  但你可以精神上支持我们：在Github上给我们Star、提供反馈、纠错、帮我们宣传等等。
+  
+  当然如果觉得翻译质量高到狠狠点赞都不够，也可以在物质上支持我们，比如：通过微信支付资助我们 ^_^ ：
+  
+  ![微信支付](./wechat.jpg)
+  
+  金额上请随意，比如你的一顿早餐钱 —— 什么？你不吃早餐？那从现在就开始吧，不然该怎么资助我们？作为程序员，最重要的是身体、身体、身体，重要的事情说三遍，这是一个18年老程序员的忠告。
   
-  你可以精神上支持我们：提供反馈意见、纠错、帮我们宣传等等。

From af7a2e874d078398e851a8e4aa36df75b30853a0 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 19:47:24 +0800
Subject: [PATCH 05/12] =?UTF-8?q?=E5=BE=AE=E8=B0=83=E4=BA=86=E4=B8=80?=
 =?UTF-8?q?=E4=B8=8B=E3=80=8A=E5=85=B3=E4=BA=8E=E4=B8=AD=E6=96=87=E7=89=88?=
 =?UTF-8?q?=E3=80=8B=E7=9A=84=E8=AF=AD=E8=A8=80=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 public/translate/cn/about.jade | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/public/translate/cn/about.jade b/public/translate/cn/about.jade
index 376b9d27c0..931ecb8b3f 100644
--- a/public/translate/cn/about.jade
+++ b/public/translate/cn/about.jade
@@ -3,11 +3,11 @@
   这是一份跟官方网站保持 **同步更新** 的中文版。虽然保持同步非常耗费精力，不过为了防止过时的内容误导读者，这份额外的付出还是很值得的。
   我们全文采用意译的方式，在彻底理解作者意思的前提下用中文重新表述，力求做到“信雅达”。
   
-  当然，即便如此，我们会错意的可能性也还是有的，所以我们的译稿都提供了中英文对照，如果你对某些含义有疑问，可以看一下对应的英文版内容。
+  当然，即便如此，我们会错意的可能性也还是有的，所以我们的译稿都提供了中英文对照，如果你对某些语句有疑问，可以看一下对应的英文版内容。
   
-  本文档目前只完成了部分章节的初译，尚未完成审校和统稿，因此语言风格和表达上可能还有问题，欢迎到我们的[github](https://github.com/angular-live/angular.io)上提出issue。
+  本文档目前只完成了部分章节的初译，尚未完成审校和统稿，因此语言风格和表达等可能还有问题，欢迎到我们的[github](https://github.com/angular-live/angular.io)上提出issue。
   
-  本文档的任何更新都会实时发布于我们的 [首发网站](http://www.angular.live) 。如果你要进行转载，请自行同步，或者在想要同步到最新版时 [联系我们](mailto:traveller@163.com) 。
+  本文档的任何更新都会实时发布于我们的 [首发网站](http://www.angular.live) 。如果你要进行转载，请自行同步（不过小心别DDoS了我们），或者在想要同步到最新版时 [联系我们](mailto:traveller@163.com) 。
   ## 授权方式
   本文档遵循“保持署名—非商用”创意共享4.0许可证（CC BY-NC 4.0）授权方式，你不用知会我们就可以任意转载，但必须保持署名（特别是：不得去掉本页入口链接，也不得修改本页内容），并且不得用于商业目的。
   ## 关于译者
@@ -15,20 +15,19 @@
   ### 汪志成（雪狼）
   《AngularJS深度剖析与最佳实践》的作者之一，ThoughtWorks高级咨询师。他从1998年开始做商业软件开发，拥有超过18年的从业经验，至今仍热衷于编程。
   
-  虽然一直在做编程工作，不过他最热衷的却是国学，特别是儒学与诗词。孟子曰：“得天下英才而教育之，三乐也”，力求践行之。
+  虽然一直在做编程工作，不过他最热衷的却是国学，特别是儒学与诗词。孟子曰：“得天下英才而教育之，三乐也”，愿践行之。
   
-  小道消息：他当年英语四级都没考过哦，现在却可以直接读各种英文资料了。所以，不要怕，英语不是老虎，我行你也行。
+  小道消息：他当年英语四级都没考过哦，现在却可以直接读各种英文资料了。所以，不要怕，英文不是老虎，我行你也行。
   ### 叶志敏
-  早期翻译软件《东方快车》的产品经理，至今已在英国留学和生活了十年。有多年在英国养老院工作的经历，他正在用Angular 2与.net开发一个养老院管理系统。
+  早期翻译软件《东方快车》的产品经理，至今已在英国留学和生活了十年。有多年在英国养老院工作的经历，他正在用Angular 2与.net Framework开发一套养老院管理系统。
   
   ## 支持我们
-  由于我们对翻译质量的极端要求，所以很抱歉，我们暂时无法接受新人一同翻译，否则我们需要花费大量精力去review。
+  由于我们对翻译质量的极端要求，所以很抱歉，我们暂时无法接受新人加入翻译，否则我们需要花费大量精力进行review。
   
-  但你可以精神上支持我们：在Github上给我们Star、提供反馈、纠错、帮我们宣传等等。
+  但你可以在精神上支持我们：在Github上给我们Star、提供反馈、纠错、帮我们宣传等等。
   
-  当然如果觉得翻译质量高到狠狠点赞都不够，也可以在物质上支持我们，比如：通过微信支付资助我们 ^_^ ：
+  当然如果实在觉得翻译质量高到狠狠点赞都不够，也可以在物质上支持我们，比如：通过微信支付资助我们 ^_^ ：
   
   ![微信支付](./wechat.jpg)
   
-  金额上请随意，比如你的一顿早餐钱 —— 什么？你不吃早餐？那从现在就开始吧，不然该怎么资助我们？作为程序员，最重要的是身体、身体、身体，重要的事情说三遍，这是一个18年老程序员的忠告。
-  
+  金额上请随意，比如你的一顿早餐钱 —— 什么？你不吃早餐？那就从现在开始吃吧，不然怎么资助我们？严肃脸：作为程序员，最重要的是身体、身体、身体，重要的事情说三遍，这是一个18年老程序员的忠告。  

From a2a0ff34c8f98a5ff3348cb9348732afed8dd3e3 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 19:56:20 +0800
Subject: [PATCH 06/12] review

---
 public/docs/ts/latest/testing/index.jade | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/public/docs/ts/latest/testing/index.jade b/public/docs/ts/latest/testing/index.jade
index d2bd66d839..c2a60b8582 100644
--- a/public/docs/ts/latest/testing/index.jade
+++ b/public/docs/ts/latest/testing/index.jade
@@ -5,14 +5,14 @@
   
   1. They **guard** against breaking existing code (“regressions”) when we make changes.
   
-  1. 当我们改变代码是，他们**守护**已有代码，以防被破坏。
+  1. 当我们改变代码时，它们**守护**已有代码，以防被破坏。
   1. They **clarify** what  the code does both when used as intended and when faced with deviant conditions.
   
-  1. 在我们正确使用代码和面对异常情况时，他们**澄清**代码做什么。
+  1. 在我们正确使用代码和面对异常情况时，它们**澄清**代码做什么。
   1. They **reveal** mistakes in design and implementation. Tests force us to look at our code from many angles. When a part of our application seems hard to test, 
   we may have discovered a design flaw, something we can cure now rather than later when it becomes expensive to fix.
   
-  1.他们**揭露**我们设计的执行的错误。测试强迫我们从多个角度看代码。当应用程序的一个部分看起来很难测试，我们可能会发现设计缺陷，这是我们可以立刻修复的，而不是等到它变的很难修复的时候。
+  1.它们**揭露**我们设计的执行的错误。测试强迫我们从多个角度看代码。当应用程序的一个部分看起来很难测试，我们可能会发现设计缺陷，这是我们可以立刻修复的，而不是等到它变的很难修复的时候。
 
 .alert.is-important
   :marked

From 7247b30c9887bba9307875d7ee2896d42c50ed91 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 19:57:11 +0800
Subject: [PATCH 07/12] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E9=81=97=E6=BC=8F?=
 =?UTF-8?q?=E7=9A=84=E5=9B=BE=E7=89=87?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 public/translate/cn/wechat.jpg | Bin 0 -> 46427 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 public/translate/cn/wechat.jpg

diff --git a/public/translate/cn/wechat.jpg b/public/translate/cn/wechat.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..f64f39305fce5d723159dcc986b093dca9c7e914
GIT binary patch
literal 46427
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
YpeB<e^}lw&OD6TJT37JD-+uUi0Q1z)QUCw|

literal 0
HcmV?d00001


From a8d1775bf2f5f17d17d999ba6b9d5343fb889a3e Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 20:08:23 +0800
Subject: [PATCH 08/12] =?UTF-8?q?=E5=8A=A0=E4=B8=8ACC=20BY-NC=E9=93=BE?=
 =?UTF-8?q?=E6=8E=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 public/translate/cn/about.jade | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/public/translate/cn/about.jade b/public/translate/cn/about.jade
index 931ecb8b3f..b4ec8c1fad 100644
--- a/public/translate/cn/about.jade
+++ b/public/translate/cn/about.jade
@@ -9,7 +9,7 @@
   
   本文档的任何更新都会实时发布于我们的 [首发网站](http://www.angular.live) 。如果你要进行转载，请自行同步（不过小心别DDoS了我们），或者在想要同步到最新版时 [联系我们](mailto:traveller@163.com) 。
   ## 授权方式
-  本文档遵循“保持署名—非商用”创意共享4.0许可证（CC BY-NC 4.0）授权方式，你不用知会我们就可以任意转载，但必须保持署名（特别是：不得去掉本页入口链接，也不得修改本页内容），并且不得用于商业目的。
+  本文档遵循[“保持署名—非商用”创意共享4.0许可证（CC BY-NC 4.0）](http://creativecommons.org/licenses/by-nc/4.0/deed.zh)授权方式，你不用知会我们就可以任意转载，但必须保持署名（特别是：不得去掉本页入口链接，也不得修改本页内容），并且不得用于商业目的。
   ## 关于译者
   本文档有两位译者，他们是多年的好友。这次利用业余时间联手翻译，就是因为看好Angular 2的前景，希望帮助大家在这项技术上能跟国外同步前进。
   ### 汪志成（雪狼）

From 72773b1f0fcaf52438b4ebfd2f4fe9bbfa4b59a6 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 21:40:37 +0800
Subject: [PATCH 09/12] =?UTF-8?q?=E4=BF=AE=E8=AE=A2=E4=BA=86=E4=B8=80?=
 =?UTF-8?q?=E9=83=A8=E5=88=86=E6=9C=AF=E8=AF=AD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 public/docs/ts/latest/glossary.jade | 137 ++++++++++++++--------------
 1 file changed, 70 insertions(+), 67 deletions(-)

diff --git a/public/docs/ts/latest/glossary.jade b/public/docs/ts/latest/glossary.jade
index c8c47c67b7..be49cb1027 100644
--- a/public/docs/ts/latest/glossary.jade
+++ b/public/docs/ts/latest/glossary.jade
@@ -100,6 +100,8 @@ include _util-fns
     export { HeroComponent } from './hero.component.ts'; // re-export the named thing
   :marked
     Now a consumer can import what it needs from the barrel.
+    
+    现在，消费者就可以从这个封装桶中导入它需要的东西了。
   code-example(format='').
     import { Hero, HeroService } from '../heroes'; // index is implied
   :marked
@@ -128,12 +130,12 @@ include _util-fns
     between a "token" or "key" and a dependency [provider](#provider).
     This more rare usage should be clear in context.
 
-    有可能指的是[依赖注入](#dependency-injection)在一个记号(Token)或键值(Key)和一个依赖[Provider](#provider)之间的绑定。
-    这个用法很少，而且一般都应该在上下文中明确标示。
+    有可能指的是[依赖注入](#dependency-injection)在一个Token或Key和一个依赖的[Provider](#provider)之间的绑定。
+    这种用法很少，而且一般都会在上下文中写清楚。
 
 :marked
   ## Bootstrap
-  ## 引导程序
+  ## 启动/引导
 .l-sub-section
   :marked
     We launch an Angular application by "bootstrapping" it with the `bootstrap` method.
@@ -141,11 +143,12 @@ include _util-fns
     and optionally registers service [providers](#provider) with the
     [dependency injection system](#dependency-injection).
 
-    我们通过一个名叫`bootstrap`的类方法来引导装入Angular应用程序。这个`bootstrap`类方法会识别应用程序的顶级“根”[组件](#component)，
-    并可能通过[依赖注入系统](#dependency-injection)注册服务[Provider](#provider)。
+    我们通过一个名叫`bootstrap`的类方法来引导Angular应用程序。这个`bootstrap`类方法会识别应用程序的顶级“根”[组件](#component)，
+    并可能通过[依赖注入体系](#dependency-injection)注册服务的[Provider](#provider)。
 
     One can bootstrap multiple apps in the same `index.html`, each with its own top level root.
-    你可以在同一个`index.html`启动多个程序，每个程序都有自己的顶级根组件。
+    
+    你可以在同一个`index.html`中引导多个应用，每个应用都有自己的顶级根组件。
 
 <a id="C"></a>
 .l-main-section
@@ -157,17 +160,17 @@ include _util-fns
     The practice of writing compound words or phrases such that each word or abbreviation begins with a capital letter 
     _except the first letter which is a lowercase letter_. 
 
-    驼峰式命名法是除了首字母小写外，每一个单词或简写以大写字母开始编写词汇或短语的实践方法。
+    驼峰式命名法是指除了首字母要小写外，每个单词或缩写都以大写字母开头儿的形式来拼写复合词或短语的一种实践。
 
     Function, property, and method names are typically spelled in camelCase. Examples include: `square`, `firstName` and `getHeroes`.
 
-    函数、属性和方法命名一般都使用驼峰式大小写命名法。比如`square`, `firstName` 和 `getHeroes`等。
+    函数、属性和方法命名一般都使用驼峰式拼写法。比如`square`, `firstName` 和 `getHeroes`等。
 
     This form is also known as **lower camel case**, to distinguish it from **upper camel case** which we call [PascalCase](#pascalcase).
     When we write "camelCase" in this documentation we always mean *lower camel case*.
 
-    这种形式也被叫做**小驼峰式命名法**（**lower camel case**），以便区分**大驼峰式命名法**（我们也叫帕斯卡命名法）。
-    当我们文档中提到“驼峰式命名法” （“camelCase”）的时候，所指的都是小驼峰命名法。
+    这种形式也被叫做**小驼峰式命名法（lower camel case）**，以区分于**大驼峰式命名法**（我们也叫Pascal命名法）。
+    当我们在文档中提到“驼峰式命名法（camelCase）”的时候，所指的都是小驼峰命名法。
 
 :marked
   ## Component
@@ -178,12 +181,12 @@ include _util-fns
     to a [View](#view) and handling most of the view’s display
     and user-interaction logic.
 
-    组件是一个用来展示数据到[视图](#view)，并处理几乎所有视图显示以及用户交互逻辑的Angular类（Angular Class）。
+    组件是一个用来把数据展示到[视图](#view)，并处理几乎所有视图显示以及用户交互逻辑的Angular类。
 
     The Component is one of the most important building blocks in the Angular system.
     It is, in fact, an Angular [Directive](#directive) with a companion [Template](#template).
 
-    组件是Angular系统的最重要的基本单位之一。
+    组件是Angular系统的最重要的基本构造块儿之一。
     它其实是一个拥有[模板](#template)的[指令](#directive)。
 
     The  developer applies the `#{atSym}Component` !{decorator} to
@@ -191,13 +194,13 @@ include _util-fns
     that Angular needs to create a component instance and render it with its template
     as a view.
 
-    开发人员在使用`#{atSym}Component`!{decorator}来装饰一个组件类，就是把这个类附加到核心组件元数据（essential component metadata）上面。
-    Angular利用这个核心组件的元数据信息，来建立一个组件实例，并把组件的模板作为视图渲染出来。
+    开发人员使用`#{atSym}Component`!{decoratorCn}来装饰一个组件类，也就是把这个核心组件的元数据附加到类上。
+    Angular利用这个元数据信息，来创建一个组件实例，并把组件的模板作为视图渲染出来。
 
     Those familiar with "MVC" and "MVVM" patterns will recognize
     the Component in the role of "Controller" or "View Model".
 
-    那些熟悉 "MVC" 和 "MVVM" 架构模式的应该能意识到组件充当了控制和视图模型的角色。
+    如果你熟悉 "MVC" 和 "MVVM" 架构模式，就会意识到“组件”充当了“控制器”和“视图模型”的角色。
 // #enddocregion b-c
 
 // #docregion d1
@@ -228,48 +231,47 @@ include _util-fns
     Applications display data values to a user and respond to user
     actions (clicks, touches, keystrokes).
 
-    应用程序一般将数据展示给用户，并对用户的操作（点击、触屏、按键）做出回应。
+    应用程序会将数据展示给用户，并对用户的操作（点击、触屏、按键）做出回应。
     
     We could push application data values into HTML, attach
     event listeners, pull changed values from the screen, and
     update application data values ... all by hand.
     
-    我们可以自己处理这些操作：将数据显示到HTML网页，添加事件监听器，从屏幕获取数据变化，然后更新数据等等。。。
+    我们当然可以自己处理这些操作：将数据显示到HTML网页，添加事件监听器，从屏幕获取数据变化，然后更新数据等等……
 
     Or we could declare the relationship between an HTML widget
     and an application data source ... and let a data binding
     framework handle the details.
     
-    或者，我们可以声明HTML小部件和数据源的关系...，让一个数据绑定框架工具来处理所有细节。
+    或者，我们也可以声明HTML小部件和数据源的关系……，让一个数据绑定框架来处理所有细节。
 
     Data Binding is that second approach. Angular has a rich
     data binding framework with a variety of data binding
     operations and supporting declaration syntax.
     
-    数据绑定是第二种方法。Angular有一个非常强大的数据绑定框架工具，具有多种用来数据绑定的操作，并支持声明语法规则。
+    这第二种方法就是数据绑定。Angular有一个非常强大的数据绑定框架，具有多种用来数据绑定的操作，并支持声明语法规则。
 
      The many forms of binding include:
+     绑定形式包括：
      * [Interpolation](guide/template-syntax.html#interpolation)
+     * [插值表达式（Interpolation）](guide/template-syntax.html#interpolation)
      * [Property Binding](guide/template-syntax.html#property-binding)
+     * [属性绑定（Property Binding）](guide/template-syntax.html#property-binding)
      * [Event Binding](guide/template-syntax.html#event-binding)
+     * [事件绑定（Event Binding）](guide/template-syntax.html#event-binding)
      * [Attribute Binding](guide/template-syntax.html#attribute-binding)
+     * [Attribute绑定（Attribute Binding）](guide/template-syntax.html#attribute-binding)
      * [Class Binding](guide/template-syntax.html#class-binding)
+     * [类绑定（Class Binding）](guide/template-syntax.html#class-binding)
      * [Style Binding](guide/template-syntax.html#style-binding)
+     * [样式绑定（Style Binding）](guide/template-syntax.html#style-binding)
      * [Two-way data binding with ngModel](guide/template-syntax.html#ng-model)
-
-     绑定模式包括：
-     * [插值Interpolation](guide/template-syntax.html#interpolation)
-     * [属性绑定Property Binding](guide/template-syntax.html#property-binding)
-     * [事件绑定Event Binding](guide/template-syntax.html#event-binding)
-     * [特征绑定Attribute Binding](guide/template-syntax.html#attribute-binding)
-     * [类绑定Class Binding](guide/template-syntax.html#class-binding)
-     * [样式绑定Style Binding](guide/template-syntax.html#style-binding)
-     * [使用ngModel进行双向数据绑定Two-way data binding with ngModel](guide/template-syntax.html#ng-model)
+     * [基于ngModel的双向数据绑定（Two-way data binding with ngModel）](guide/template-syntax.html#ng-model)
      
     Learn more about data binding in the
     [Template Syntax](guide/template-syntax.html#data-binding) chapter.
     
-    到[模板语法](guide/template-syntax.html#data-binding)章节获取更多关于数据绑定的知识。
+    要了解关于数据绑定的更多知识，请参见[模板语法](guide/template-syntax.html#data-binding)一章。
 
 // #enddocregion d1
 <a id="decorator"></a> <a id="decoration"></a>
@@ -280,28 +282,28 @@ include _util-fns
   :marked
     A Decorator is a **function** that adds metadata to a class, its members (properties, methods) and function arguments.
     
-    一个装饰器是一个**函数**，这个函数将元数据添加到一个类、类成员（属性、方法）和函数上。
+    装饰器是一个**函数**，这个函数将元数据添加到类、类成员（属性、方法）和函数上。
     
     Decorators are a JavaScript language [feature](https://github.com/wycats/javascript-decorators), implemented in TypeScript and proposed for ES2016 (AKA ES7).
     
-    装饰器是一个Javascript的语言[特征](https://github.com/wycats/javascript-decorators)，装饰器在TypeScript里面已经采用并实施了，它也被推荐到ES2016（也就是ES7）
+    装饰器是一个JavaScript的语言[特征](https://github.com/wycats/javascript-decorators)，装饰器在TypeScript里面已经采纳并实现了，并被推荐到了ES2016（也就是ES7）。
 
     We apply a decorator by positioning it
     immediately above or to the left of the thing it decorates.
     
-    我们应用装饰器的方法是把装饰器放到被装饰的对象的上面或者左边。
+    我们应用装饰器的方法是把装饰器放到被装饰对象的上面或左边。
 
     Angular has its own set of decorators to help it interoperate with our application parts.
     Here is an example of a `@Component` decorator that identifies a
     class as an Angular [Component](#component) and an `@Input` decorator applied to a property
     of that component.
     
-    Angular使用一套自己的装饰器来实现应用程序的各部分的相互操作。
-    下面的例子是一个使用`@Component`装饰器来将一个类标示为一个Angular[组件](#component)，并使用`@Input`装饰器装饰这个组件的一个属性。
+    Angular使用自己的一套装饰器来实现应用程序各部分之间的相互操作。
+    下面的例子中使用了`@Component`装饰器来将一个类标记为一个Angular[组件](#component)，并用`@Input`装饰器来装饰该组件的一个属性。
     
     The elided object argument to the `@Component` decorator would contain the pertinent component metadata.
     
-    被省略的`@Component`装饰器的参数对象可能包含了相关的组件元数据。
+    `@Component`装饰器中被省略的参数对象还可以包含和组件有关的元数据。
     
     ```
     @Component({...})
@@ -311,19 +313,19 @@ include _util-fns
       name:string;
     }
     ```
+    
     The scope of a decorator is limited to the language feature
     that it decorates. None of the decorations shown here will "leak" to other
     classes appearing below it in the file.
     
-    一个装饰器的作用范围会被限制在被装饰的作用范围之内。在以上的例子中，没有一个装饰器会“泄露”到其他类，就算这些其他类在同一个文件紧跟着上面的类。
-    
+    一个装饰器的作用范围会被限制在它所装饰的东西上，这是一个语言级特性。在上面这个例子中，就算其他类在同一个文件中紧跟着上面的类也不会有任何装饰器“泄露”到其他类。
 
   .alert.is-important
     :marked
       Always include the parentheses `()` when applying a decorator.
       A decorator is a **function** that must be called when applied.
       
-      总是在装饰器后面加包括`()`。因为装饰器是**函数**，在装饰的时候一定会被运行。
+      永远别忘了在装饰器后面加括号`()`。因为装饰器是 **函数** ，在应用它的时候一定要被调用。
 
 // #docregion d2
 :marked
@@ -335,80 +337,80 @@ include _util-fns
     for creating and delivering parts of an application to other
     parts of an application that request them.
     
-    依赖注入既是设计模式，同时也是一种机制：当应用程序的一些部件需要另一些部件的时候，使用依赖注入机制来新建被请求的部件并将其注入到发出请求的部件。
+    依赖注入既是设计模式，同时也是一种机制：当应用程序的一些部件需要另一些部件的时候，使用依赖注入机制来创建被请求的部件并将其注入到发出请求的部件。
 
     Angular developers prefer to build applications by defining many simple parts
     that each do one thing well and then wire them together at runtime.
     
-    Angular开发者比较倾向的开发应用程序的方法是，定义许多精简小部件，每个小部件只做一件事并做好自己那件事，然后在运行时间把这些精简小部件连在一起组成应用程序。
+    Angular开发者喜欢的构建应用程序的方法是：定义许多精简小部件，每个小部件只做一件事并做好它，然后在运行期把这些精简小部件装配在一起组成应用程序。
 
     These parts often rely on other parts. An Angular [Component](#component)
     part might rely on a service part to get data or perform a calculation. When a
     part "A" relies on another part "B", we say that "A" depends on "B" and
     that "B" is a dependency of "A".
     
-    这些小部件通常依赖其他小部件。一个Angular[组件](#component)可能依赖一个服务部件来获取数据或者处理运算。当部件A依赖部件B，我们说A依赖B，B是A的“依赖”。
+    这些小部件通常会依赖其他小部件。一个Angular[组件](#component)可能依赖一个“服务”部件来获取数据或者处理运算。当部件A要靠另一个部件B才能工作，我们就说A依赖B，B是A的“依赖”。
 
     We can ask a "Dependency Injection System" to create "A"
     for us and handle all the dependencies.
     If "A" needs "B" and "B" needs "C", the system resolves that chain of dependencies
     and returns a fully prepared instance of "A".
     
-    我们可以让“依赖注入系统”为我们新建一个部件A并处理所有A的“依赖”。如果A需要B，B需要C，这个系统便解析这个依赖链，返回给我们一个完整准备妥当的A实例。
+    我们可以让“依赖注入系统”为我们创建一个部件A并处理所有A的“依赖”。如果A需要B，B需要C，这个系统便解析这个依赖链，给我们返回一个完全准备好的A实例。
 
     Angular provides and relies upon its own sophisticated
     [Dependency Injection](dependency-injection.html) system
     to assemble and run applications by "injecting" application parts
     into other application parts where and when needed.
     
-    Angular提供并使用自己设计精密的[依赖注入](dependency-injection.html)系统来组装和运行应用程序：按时按需的将一些部件“注入”到另一些部件里面。
+    Angular提供并使用自己设计精密的[依赖注入](dependency-injection.html)系统来组装和运行应用程序：在要用时，将一些部件“注入”到另一些部件里面。
 
     At the core is an [`Injector`](#injector) that returns dependency values on request.
     The expression `injector.get(token)` returns the value associated with the given token.
     
-    依赖注入的核心是一个[`注入器`](#injector)，这个注入器按需返回依赖部件。`injector.get(token)`方法返回和提供的符记参数相关的依赖部件。
+    依赖注入的核心是一个[`Injector`](#injector)，这个注入器按需返回依赖部件。`injector.get(token)`方法返回和提供的Token参数相关的依赖部件。
 
     A token is an Angular type (`OpaqueToken`). We rarely deal with tokens directly; most
     methods accept a class name (`Foo`) or a string ("foo") and Angular converts it
     to a token. When we write `injector.get(Foo)`, the injector returns
     the value associated with the token for the `Foo` class, typically an instance of `Foo` itself.
     
-    令牌是一个Angular的类型(`OpaqueToken`)。我们很少需要直接接触令牌。绝大多数类方法都接受类名称 (`Foo`)或者字符串("foo")，Angular把这些类名称和字符串转换为令牌。
-    当我们使用`injector.get(Foo)`，注入器返回用 `Foo`类生成的的令牌对应的依赖值，这个依赖值一般是`Foo`类实例。
+    Token是一个Angular中的类型(`OpaqueToken`)。我们很少需要直接接触Token。绝大多数类方法都接受类名称 (`Foo`)或者字符串("foo")，Angular把这些类名称和字符串转换为Token。
+    当我们调用`injector.get(Foo)`时，注入器返回用`Foo`类生成的的Token对应的依赖值，这个依赖值通常是`Foo`类的实例。
 
     Angular makes similar requests internally during many of its operations
     as when it creates a [`Component`](#AppComponent) for display.
     
-    Angular新建一个[组件](#AppComponent)的过程中，会在内部有很多类似的（依赖注入）请求。
+    Angular在创建[组件](#AppComponent)以供显示的过程中，会在内部执行很多类似的依赖注入请求。
 
     The `Injector` maintains an internal map of tokens to dependency values.
     If the `Injector` can't find a value for a given token, it creates
     a new value using a `Provider` for that token.
     
-    `注入器`维护一个令牌与其对应的依赖值对照图。如果`注入器`不能找到一个令牌对应的依赖值，它就会使用`Provider`新建一个依赖值。
+    `注入器`维护一个Token与其对应的依赖值对照图。如果`Injector`不能找到一个Token对应的依赖值，它就会使用`Provider`来创建一个依赖值。
 
     A [Provider](#provider) is a recipe for
     creating new instances of a dependency value associated with a particular token.
     
-    一个`Provider`(#provider)是一个使用指定令牌来新建其对应的依赖实例的方法。
+    `Provider`(#provider)是使用指定Token来创建相应依赖实例的“菜谱”之一。
 
     An injector can only create a value for a given token if it has
     a `Provider` for that token in its internal provider registry.
     Registering providers is a critical preparatory step.
     
-    如果在注入器的内部注册表里面，一个令牌对应的依赖值是一个`Provider`，那么注入器只能为令牌创建一个依赖值。注册Provider是一个非常关键的准备步骤。
+    如果在注入器的内部注册表中，一个Token对应的依赖值是一个`Provider`，那么注入器就得为这个Token创建一个依赖值。所以注册Provider是一个非常关键的准备步骤。
 
     Angular registers some of its own providers with every injector.
     We can register our own providers. Quite often the best time to register a `Provider`
     is when we [bootstrap](#bootstrap) the application.
     There are other opportunities to register as well.
     
-    Angular为每个注册器注册很多自己的Provider。我们可以注册一些自己的Provider。一般最好的注册Provider的时间是在应用程序的[引导程序Bootstrap](#bootstrap)的时候。
-    我们也有其他很多机会注册Provider。
+    Angular会为每个注册器注册很多自己的内置Provider。我们也可以注册自己的Provider。通常注册Provider的最佳时间是在应用程序开始[引导](#bootstrap)的时候。
+    当然，我们也有其它很多机会注册Provider。
 
     Learn more in the [Dependency Injection](guide/dependency-injection.html) chapter.
     
-    到[依赖注入](guide/dependency-injection.html)章节学习更多关于依赖注入的知识
+    要了解关于依赖注入的更多知识，请参见[依赖注入](guide/dependency-injection.html)一章。
     
 :marked
   ## Directive
@@ -418,7 +420,7 @@ include _util-fns
     An Angular class responsible for creating, re-shaping, and interacting with HTML elements
     in the browser DOM. Directives are Angular's most fundamental feature.
 
-    指令是一个Angular类，这个类负责新建和重塑浏览器DOM里面HTML元素，同时负责与HTML元素的互动。指令是Angular的最基本的特征。
+    指令是一个Angular类，这个类负责创建和重塑浏览器DOM中的HTML元素，同时负责与HTML元素的互动。指令是Angular中最基本的特性。
 
     A Directive is almost always associated with an HTML element or attribute.
     We often refer to such an element or attribute as the directive itself.
@@ -426,16 +428,16 @@ include _util-fns
     it creates the matching directive class instance
     and gives that instance control over that portion of the browser DOM.
     
-    指令几乎都是对HTML元素或元素的特征关联的。我们通常把这些关联的HTML元素或者元素特征当做指令本身。
-    当Angular在一个HTML模板里面遇到一个指令的时候，它新建一个与该指令配套类的实例，然后把浏览器这个部分的DOM的控制交给这个类。
+    指令几乎都是关联到HTML元素或Attribute的。我们通常把这些关联的HTML元素或者Attribute当做指令本身。
+    当Angular在HTML模板中遇到一个指令的时候，它就找出一个与该指令匹配的类，创建此类的实例，然后把浏览器中这部分DOM的控制权交给该实例。
 
     Developers can invent custom HTML markup (e.g., `<my-directive>`) to
     associate with their custom directives. They add this custom markup to HTML templates
     as if they were writing native HTML. In this way, directives become extensions of
     HTML itself.
     
-    开发人员可以为自制指令指定自定义的HTML标记（比如`<my-directive>`），然后，他们便可以像使用HTML自带标记一样把这些自定义的标记放到HTML模板里。
-    这样，指令就变成了HTML的拓展了。
+    开发人员可以为自定义指令指定自定义的HTML标签（比如`<my-directive>`），然后，他们就可以像写原生HTML一样把这些自定义标签放到HTML模板里了。
+    这样，指令就变成了HTML本身的拓展。
 
     Directives fall into one of three categories:
     
@@ -445,17 +447,17 @@ include _util-fns
     render application [views]. Components are usually represented as HTML elements.
     They are the building blocks of an Angular application and the
     developer can expect to write a lot of them.    
-    1. [组件](#component): 结合了程序逻辑和一个用来渲染试图的HTML模板[views]。组件一般由HTML元素代表。它们是用来组建Angular应用程序的基本单元，所以可以预料到开发人员会写很多很多组件。
+    1. [组件](#component): 用来程序逻辑和一个用来渲染视图的HTML模板[views]。组件一般表示成HTML元素的形式。它们是用来构建Angular应用程序的基本单元。可以预料，开发人员将会写很多很多组件。
 
     1. [Attribute Directives](#attribute-directive) that can listen to and modify the behavior of
     other HTML elements, attributes, properties, and components. They are usually represented
     as HTML attributes, hence the name.
-    1. [特征指令](#attribute-directive)：可以监控和修改HTML元素、元素特征、属性和组件等的行为。它们一般有HTML元素特征（名）来体现。
+    1. [Attribute指令](#attribute-directive)：可以监控和修改其它HTML元素、Attribute、属性和组件之类的行为。它们一般表示为HTML元素Attibute，故名。
 
     1. [Structural Directives](#structural-directive), a directive responsible for
     shaping or re-shaping HTML layout, typically by adding, removing, or manipulating
     elements and their children.
-    1. [结构型指令](#structural-directive)：负责塑造或重塑HTML布局。一般都是通过添加、删除或者操作HTML元素和他的子级元素来实现的。
+    1. [结构型指令](#structural-directive)：负责塑造或重塑HTML布局。这一般是通过添加、删除或者操作HTML元素及其子元素来实现的。
 // #enddocregion d2
 
 // #docregion e1
@@ -538,7 +540,7 @@ include _util-fns
     that can find a named "dependency" in its cache or create such a thing
     with a registered [provider](#provider).
 
-    一个Angular[依赖注入系统](#dependency-injection)内部的对象，它可以在自己的内部缓存找到已点名的依赖或者利用一个注册过的[provider](#provider)新建一个依赖。
+    一个Angular[依赖注入系统](#dependency-injection)内部的对象，它可以在自己的内部缓存找到已点名的依赖或者利用一个注册过的[provider](#provider)创建一个依赖。
 :marked
   ## Input
 .l-sub-section
@@ -607,7 +609,7 @@ include _util-fns
     [Directives](#directive) and [Components](#component) have a lifecycle
     managed by Angular as it creates, updates and destroys them.
     
-    [指令Directives](#directive)和[组件Components](#component)有生命周期，由Angular在新建、更新和销毁他们的过程中管理。
+    [指令Directives](#directive)和[组件Components](#component)有生命周期，由Angular在创建、更新和销毁他们的过程中管理。
 
     Developers can tap into key moments in that lifecycle by implementing
     one or more of the "Lifecycle Hook" interfaces.
@@ -707,6 +709,7 @@ include _util-fns
 // #docregion n-s
 - var lang = current.path[1]
 - var decorator = lang === 'dart' ? 'annotation' : '<a href="#decorator">decorator</a>'
+- var decoratorCn = lang === 'dart' ? '注解' : '<a href="#decorator">装饰器</a>'
 - var atSym = lang === 'js' ? '' : '@'
 <a id="N"></a>
 <a id="O"></a>
@@ -756,7 +759,7 @@ include _util-fns
     to associate the pipe function with a name. We then can use that
     name in our HTML to declaratively transform values on screen.
     
-    Angular的管道是一个函数，用来把输入值转变为输出值给视图 [view](#view)。我们使用 `#{atSym}Pipe` !{decorator}来把管道函数链接到它的名字上。
+    Angular的管道是一个函数，用来把输入值转变为输出值给视图 [view](#view)。我们使用 `#{atSym}Pipe` !{decoratorCn}来把管道函数链接到它的名字上。
     然后，我们可以在HTML中使用它的名字来，用声明的形式，在显示时把输入值转变输出值。
     
     Here's an example that uses the built-in `currency` pipe to display
@@ -779,17 +782,17 @@ include _util-fns
     A Provider creates a new instance of a dependency for the Dependency Injection system.
     It relates a lookup token to code - sometimes called a "recipe" - that can create a dependency value.
     
-    Provider为依赖注入系统新建一个依赖的实例。它是关于通过令牌查询代码，有时被叫做“方剂”，可以创建依赖值。
+    Provider为依赖注入系统创建一个依赖的实例。它是关于通过Token查询代码，有时被叫做“方剂”，可以创建依赖值。
     
     For example, `new Provider(Foo, {useClass: Foo})` creates a `Provider`
     that relates the `Foo` token to a function that creates a new instance of the `Foo` class.
     
-    比如，`new Provider(Foo, {useClass: Foo})`新建一个`Provider`，把`Foo`令牌联系到一个函数，这个函数新建一个`Foo`类的实例。
+    比如，`new Provider(Foo, {useClass: Foo})`创建一个`Provider`，把`Foo`Token联系到一个函数，这个函数创建一个`Foo`类的实例。
 
     There are other ways to create tokens and recipes.
     See [Dependency Injection](#dependency-injection) chapter to learn more.
     
-    还有其他一些方法建立令牌和方剂。
+    还有其他一些方法建立Token和方剂。
     请看[依赖注入Dependency Injection](#dependency-injection)以获取更多信息。 
 
 .l-main-section

From 99d89072d582ec061b522b1b6df2406964284a08 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 21:50:33 +0800
Subject: [PATCH 10/12] =?UTF-8?q?=E6=8A=8A=E6=89=80=E6=9C=89=E8=AF=AF?=
 =?UTF-8?q?=E7=94=A8=E7=9A=84=E4=BB=96=E6=94=B9=E6=88=90=E5=AE=83?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../cookbook/component-communication.jade     |  4 ++--
 .../latest/cookbook/dependency-injection.jade | 20 +++++++++----------
 .../docs/ts/latest/cookbook/dynamic-form.jade |  4 ++--
 public/docs/ts/latest/glossary.jade           | 20 +++++++++----------
 public/docs/ts/latest/guide/_data.json        |  2 +-
 public/docs/ts/latest/guide/architecture.jade |  8 ++++----
 .../docs/ts/latest/guide/cheatsheet-cn.json   |  2 +-
 .../docs/ts/latest/guide/displaying-data.jade |  2 +-
 public/docs/ts/latest/guide/forms.jade        |  4 ++--
 public/docs/ts/latest/guide/index.jade        |  2 +-
 public/docs/ts/latest/guide/style-guide.jade  | 10 +++++-----
 .../docs/ts/latest/guide/template-syntax.jade |  2 +-
 public/docs/ts/latest/quickstart.jade         |  4 ++--
 .../ts/latest/testing/first-app-tests.jade    |  2 +-
 .../latest/testing/jasmine-testing-101.jade   |  6 +++---
 public/docs/ts/latest/tutorial/toh-pt1.jade   |  2 +-
 public/docs/ts/latest/tutorial/toh-pt3.jade   |  2 +-
 public/docs/ts/latest/tutorial/toh-pt4.jade   |  2 +-
 public/docs/ts/latest/tutorial/toh-pt5.jade   |  2 +-
 19 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/public/docs/ts/latest/cookbook/component-communication.jade b/public/docs/ts/latest/cookbook/component-communication.jade
index 61b68a572b..1192399299 100644
--- a/public/docs/ts/latest/cookbook/component-communication.jade
+++ b/public/docs/ts/latest/cookbook/component-communication.jade
@@ -168,7 +168,7 @@ figure.image-display
 :marked
   The `VersionParentComponent` supplies the `minor` and `major` values and binds buttons to methods that change them.
   
-  `VersionParentComponent`提供`minor`和`major`值，将变换他们值得类方法绑定到按钮上。
+  `VersionParentComponent`提供`minor`和`major`值，将变换它们值的类方法绑定到按钮上。
   
 +makeExample('cb-component-communication/ts/app/version-parent.component.ts')
 
@@ -442,7 +442,7 @@ a(id="countdown-tests")
   Each `AstronautComponent` is a child of the `MissionControlComponent` and therefore receives its parent's service instance:
   
   `AstronautComponent`也通过自己的构造函数注入该服务。
-  每个`AstronautComponent`都是`MissionControlComponent`的子级，所以他们获取它们父级的服务的实例。
+  每个`AstronautComponent`都是`MissionControlComponent`的子级，所以它们获取它们父级的服务的实例。
   
 +makeExample('cb-component-communication/ts/app/astronaut.component.ts')
 
diff --git a/public/docs/ts/latest/cookbook/dependency-injection.jade b/public/docs/ts/latest/cookbook/dependency-injection.jade
index cc2ab6c231..e3ba72fb40 100644
--- a/public/docs/ts/latest/cookbook/dependency-injection.jade
+++ b/public/docs/ts/latest/cookbook/dependency-injection.jade
@@ -162,7 +162,7 @@ a(id="nested-dependencies")
   Resolving these nested dependencies in the correct order is also the framework's job.
   At each step, the consumer of dependencies simply declares what it requires in its constructor and the framework takes over.
   
-  有时候一个服务依赖其他服务...（其他服务）可能依赖另外的服务。按正确的顺序来解析这些嵌套依赖也是框架工具（Angualar 2依赖注入）的工作。
+  有时候一个服务依赖其它服务...而其它服务可能依赖另外的服务。按正确的顺序来解析这些嵌套依赖也是框架工具（Angualar 2依赖注入）的工作。
   在每一步，依赖的使用者只是在它的构造函数里简单地声明它需要什么，框架工具会做剩余的事情。
   
   For example, we inject both the `LoggerService` and the `UserContext` in the `AppComponent`. 
@@ -185,7 +185,7 @@ a(id="nested-dependencies")
  The `UserService` has no dependencies so the dependency injection framework can just `new` one into existence.
  
  当Angular新建一个`AppComponent`，依赖注入框架工具创建一个`LoggerService`的实例，和开始创建`UserContextService`。`UserContextService`需要框架工具已经有了的`LoggerService`和还没创建的`UserService`。
- `UserService`没有其他依赖，所以依赖注入框架工具可以直接`new`一个实例。
+ `UserService`没有其它依赖，所以依赖注入框架工具可以直接`new`一个实例。
  
  The beauty of dependency injection is that the author of `AppComponent` didn't care about any of this. 
  The author simply declared what was needed in the constructor (`LoggerService` and `UserContextService`) and the framework did the rest.
@@ -315,7 +315,7 @@ figure.image-display
   We call this *sandboxing* because each service and component instance has its own sandbox to play in.
   
   一个管理自己伴随组件实例状态的服务是个好例子。
-  对每个组件，我们都需要该服务的单独实例。每个服务有自己的工作-状态，与其他组件的服务-和-状态隔离。我们叫这个*sandboxing*，因为每个服务和组件实例都在自己的沙盒里运行。
+  对每个组件，我们都需要该服务的单独实例。每个服务有自己的工作-状态，与其它组件的服务-和-状态隔离。我们叫这个*sandboxing*，因为每个服务和组件实例都在自己的沙盒里运行。
   
   <a id="hero-bios-component"></a>
   Imagine a `HeroBiosComponent` that presents three instances of the `HeroBioComponent`. 
@@ -326,7 +326,7 @@ figure.image-display
   Each `HeroBioComponent` can edit a single hero's biography. 
   A `HeroBioComponent` relies on a `HeroCacheService` to fetch, cache, and perform other persistence operations on that hero.
   
-  每个`HeroBioComponent`都能编辑一个英雄的生平。一个`HeroBioComponent`依赖一个`HeroCacheService`来对该英雄进行读取、缓存和执行其他持久性质的操作。
+  每个`HeroBioComponent`都能编辑一个英雄的生平。一个`HeroBioComponent`依赖一个`HeroCacheService`来对该英雄进行读取、缓存和执行其它持久性质的操作。
 +makeExample('cb-dependency-injection/ts/app/hero-cache.service.ts','service','app/hero-cache.service.ts')  
 :marked
   Clearly the three instances of the `HeroBioComponent` can't share the same `HeroCacheService`. 
@@ -585,11 +585,11 @@ figure.image-display
   But not every dependency can be satisfied by creating a new instance of a class.
   We need other ways to deliver dependency values and that means we need other ways to specify a provider.
   
-  这就是那么简单，因为最常见的被注入的服务是一个类的实例。但是，不是所有的依赖能在能建立一个类的新实例就够了的。我们需要其他的提交依赖值得方法，也就是说我们需要其他方法来制定一个provider。
+  这就是那么简单，因为最常见的被注入的服务是一个类的实例。但是，不是所有的依赖能在能建立一个类的新实例就够了的。我们需要其它的提交依赖值得方法，也就是说我们需要其它方法来指定一个provider。
   
   The `HeroOfTheMonthComponent` example demonstrates many of the alternatives and why we need them. 
   
-  `HeroOfTheMonthComponent`例子示范了一些备择方案，揭示了为什么我们需要他们。
+  `HeroOfTheMonthComponent`例子示范了一些备择方案，揭示了为什么我们需要它们。
 figure.image-display
   img(src="/resources/images/cookbooks/dependency-injection/hero-of-month.png" alt="Hero of the month" width="300px")
 :marked
@@ -663,7 +663,7 @@ a(id='usevalue')
 :marked
   The other providers create their values *lazily* when they're needed for injection.
   
-  其他providers只在注入需要他们的时候才创建他们值 - *延迟加载*
+  其它providers只在注入需要它们的时候才创建它们值 - *延迟加载*
 
 .l-main-section
 a(id='useclass')
@@ -806,7 +806,7 @@ a(id='usefactory')
     Look at the [live example](/resources/live-examples/cb-dependency-injection/ts/plnkr.html)
     for the full source code.
       
-    该函数从`HeroService`获取英雄参赛者，从中取`2`个作为亚军，并把他们的名字合并起来。亲到[在线例子](/resources/live-examples/cb-dependency-injection/ts/plnkr.html)看全部原代码。
+    该函数从`HeroService`获取英雄参赛者，从中取`2`个作为亚军，并把他们的名字合并起来。请到[在线例子](/resources/live-examples/cb-dependency-injection/ts/plnkr.html)看全部原代码。
 
 
 a(id="tokens")
@@ -915,7 +915,7 @@ a(id='opaque-token')
   a JavaScript object that has a friendly name but won't conflict with 
   another token that happens to have the same name.
   
-  这样的对象没有应用程序接口，所以不能用一个类来表示。它们可被一个唯一的和标志性的令牌更好的表达，一个JavaScript对象，拥有一个友好的名字但是不会与其他名字相同的令牌有冲突。
+  这样的对象没有应用程序接口，所以不能用一个类来表示。它们可被一个唯一的和标志性的令牌更好的表达，一个JavaScript对象，拥有一个友好的名字但是不会与其它名字相同的令牌有冲突。
   
   The `OpaqueToken` has these characteristics.
   We encountered them twice in the *Hero of the Month* example, 
@@ -941,7 +941,7 @@ a(id="di-inheritance")
   we must re-provide and re-inject them in the derived class
   and then pass them down to the base class through the constructor.
   
-  当编写一个从另一个组件衍生的组件的时候，我们要格外小心。如果基础组件有注入的依赖，我们必须要在衍生类中重新提供和重新注入它们，并且将他们通过构造函数传给基本类。
+  当编写一个从另一个组件衍生的组件的时候，我们要格外小心。如果基础组件有注入的依赖，我们必须要在衍生类中重新提供和重新注入它们，并且将它们通过构造函数传给基本类。
   
   In this contrived example, `SortedHeroesComponent` inherits from `HeroesBaseComponent` 
   to display a *sorted* list of heroes.
diff --git a/public/docs/ts/latest/cookbook/dynamic-form.jade b/public/docs/ts/latest/cookbook/dynamic-form.jade
index e69c3bc8ee..02b28553b3 100644
--- a/public/docs/ts/latest/cookbook/dynamic-form.jade
+++ b/public/docs/ts/latest/cookbook/dynamic-form.jade
@@ -5,7 +5,7 @@ include ../_util-fns
    especially if we'll need a great number of them, they're similar to each other, and they change frequently 
    to meet rapidly changing business and regulatory requirements.
    
-   我们不可能一直觉得手动编写表单和需要的工作量和时间成正比，特别是当我们需要编写大量的表单，他们非常类似，而且他们需要随着商务和政策需求的迅速变化而变化。
+   我们不可能一直觉得手动编写表单和需要的工作量和时间成正比，特别是当我们需要编写大量的表单，它们非常类似，而且它们需要随着商务和政策需求的迅速变化而变化。
    
    It may be more economical to create the forms dynamically, based on metadata that describe the business object model.
    
@@ -166,7 +166,7 @@ include ../_util-fns
    Although in this example we're modelling a job application for heroes, there are no references to any specific hero question 
    outside the objects returned by `QuestionService`. 
    
-   虽然在这个例子中，我们是在为英雄工作申请表建模，但是除了`QuestionService`返回的对象外，没有其他任何地方有指定英雄问卷相关的内容。
+   虽然在这个例子中，我们是在为英雄工作申请表建模，但是除了`QuestionService`返回的对象外，没有其它任何地方有指定英雄问卷相关的内容。
    
    This is very important since it allows us to repurpose the components for any type of survey
    as long as it's compatible with our *question* object model. 
diff --git a/public/docs/ts/latest/glossary.jade b/public/docs/ts/latest/glossary.jade
index be49cb1027..a72c81b057 100644
--- a/public/docs/ts/latest/glossary.jade
+++ b/public/docs/ts/latest/glossary.jade
@@ -318,7 +318,7 @@ include _util-fns
     that it decorates. None of the decorations shown here will "leak" to other
     classes appearing below it in the file.
     
-    一个装饰器的作用范围会被限制在它所装饰的东西上，这是一个语言级特性。在上面这个例子中，就算其他类在同一个文件中紧跟着上面的类也不会有任何装饰器“泄露”到其他类。
+    一个装饰器的作用范围会被限制在它所装饰的东西上，这是一个语言级特性。在上面这个例子中，就算其它类在同一个文件中紧跟着上面的类也不会有任何装饰器“泄露”到其它类。
 
   .alert.is-important
     :marked
@@ -349,7 +349,7 @@ include _util-fns
     part "A" relies on another part "B", we say that "A" depends on "B" and
     that "B" is a dependency of "A".
     
-    这些小部件通常会依赖其他小部件。一个Angular[组件](#component)可能依赖一个“服务”部件来获取数据或者处理运算。当部件A要靠另一个部件B才能工作，我们就说A依赖B，B是A的“依赖”。
+    这些小部件通常会依赖其它小部件。一个Angular[组件](#component)可能依赖一个“服务”部件来获取数据或者处理运算。当部件A要靠另一个部件B才能工作，我们就说A依赖B，B是A的“依赖”。
 
     We can ask a "Dependency Injection System" to create "A"
     for us and handle all the dependencies.
@@ -471,7 +471,7 @@ include _util-fns
   :marked
     The [official JavaScript language specification](https://en.wikipedia.org/wiki/ECMAScript).
     
-    [官方Javascript语言规范](https://en.wikipedia.org/wiki/ECMAScript)
+    [官方JavaScript语言规范](https://en.wikipedia.org/wiki/ECMAScript)
     
     The latest approved version of JavaScript is
     [ECMAScript 2015](http://www.ecma-international.org/ecma-262/6.0/)
@@ -485,7 +485,7 @@ include _util-fns
     Applications written in ES2015 or one of its dialects must be "[transpiled](#transpile)"
     to ES5 JavaScript.
     
-    目前，几乎所有现代游览器都只支持上一版本“ECMAScript 5” （也就是ES5）标准。使用ES2015或者其他兼容语言开发的应用程序，都必须被编译“[transpiled](#transpile)”成ES5 Javascript。
+    目前，几乎所有现代游览器都只支持上一版本“ECMAScript 5” （也就是ES5）标准。使用ES2015或者其它兼容语言开发的应用程序，都必须被编译“[transpiled](#transpile)”成ES5 JavaScript。
 
     Angular 2 developers may choose to write in ES5 directly.
     
@@ -609,7 +609,7 @@ include _util-fns
     [Directives](#directive) and [Components](#component) have a lifecycle
     managed by Angular as it creates, updates and destroys them.
     
-    [指令Directives](#directive)和[组件Components](#component)有生命周期，由Angular在创建、更新和销毁他们的过程中管理。
+    [指令Directives](#directive)和[组件Components](#component)有生命周期，由Angular在创建、更新和销毁它们的过程中管理。
 
     Developers can tap into key moments in that lifecycle by implementing
     one or more of the "Lifecycle Hook" interfaces.
@@ -665,7 +665,7 @@ include _util-fns
     In general, we assemble our application from many modules, both the ones we write ourselves
     and the ones we acquire from others.
     
-    一般来说，我们用模块来组装我们的应用程序，这些模块包含我们自己编写的模块和从其他地方获取的模块。
+    一般来说，我们用模块来组装我们的应用程序，这些模块包含我们自己编写的模块和从其它地方获取的模块。
 
     A typical module is a cohesive block of code dedicated to a single purpose.
     
@@ -792,7 +792,7 @@ include _util-fns
     There are other ways to create tokens and recipes.
     See [Dependency Injection](#dependency-injection) chapter to learn more.
     
-    还有其他一些方法建立Token和方剂。
+    还有其它一些方法建立Token和方剂。
     请看[依赖注入Dependency Injection](#dependency-injection)以获取更多信息。 
 
 .l-main-section
@@ -808,7 +808,7 @@ include _util-fns
     and taking other similar actions that cause the application to
     replace one view with another.
     
-    大部分应用程序包含多个屏或视图[views](#view)。用户通过点击链接、按钮和其他类似动作，在他们之间穿梭，这样应用程序从一个视图变换到另一个视图。
+    大部分应用程序包含多个屏或视图[views](#view)。用户通过点击链接、按钮和其它类似动作，在它们之间穿梭，这样应用程序从一个视图变换到另一个视图。
 
     The Angular [Component Router](guide/router.html) is a richly featured mechanism for configuring
     and managing the entire view navigation process including the creation and destruction
@@ -933,7 +933,7 @@ include _util-fns
     TypeScript is the preferred language for Angular 2 development although
     we are welcome to write in other JavaScript dialects such as [ES5](#es5).
     
-    TypeScript是Angular 2推荐使用的语言，当然，我们也欢迎使用其他JavaScript语言，比如[ES5](#es5)。
+    TypeScript是Angular 2推荐使用的语言，当然，我们也欢迎使用其它JavaScript语言，比如[ES5](#es5)。
 
     Angular 2 itself is written in TypeScript.
     
@@ -971,7 +971,7 @@ include _util-fns
     dynamically as the user navigates through the application, typically
     under the control of a [router](#router).
     
-    视图一般包含其他视图，任何视图在用户在应用程序中导航的时候，可能被动态加载或卸载，一般[路由器](#router)的控制下进行。
+    视图一般包含其它视图，任何视图在用户在应用程序中导航的时候，可能被动态加载或卸载，一般[路由器](#router)的控制下进行。
 
 .l-main-section
 <a id="W"></a>
diff --git a/public/docs/ts/latest/guide/_data.json b/public/docs/ts/latest/guide/_data.json
index 43cfb4752b..42969ebb71 100644
--- a/public/docs/ts/latest/guide/_data.json
+++ b/public/docs/ts/latest/guide/_data.json
@@ -17,7 +17,7 @@
 
   "displaying-data": {
     "title": "显示数据",
-    "intro": "利用插值表达式和其他形式的属性绑定机制，把数据显示到UI上。",
+    "intro": "利用插值表达式和其它形式的属性绑定机制，把数据显示到UI上。",
     "nextable": true,
     "basics": true
   },
diff --git a/public/docs/ts/latest/guide/architecture.jade b/public/docs/ts/latest/guide/architecture.jade
index 08bddc36d6..a2e18c59cd 100644
--- a/public/docs/ts/latest/guide/architecture.jade
+++ b/public/docs/ts/latest/guide/architecture.jade
@@ -295,7 +295,7 @@ figure
   What are `*ngFor`, `{{hero.name}}`, `(click)`, `[hero]`, and `<hero-detail>`?
   
   我们认得`<h2>`和`<div>`。
-  但有一些其他的标签/属性是我们在学校中从没有听说过的。
+  但有一些其它的标签/属性是我们在学校中从没有听说过的。
   什么是`*ngFor`、`{{hero.name}}`、`(click)`、`[hero]`和`<hero-detail>`？
   
   These are examples of Angular's [template syntax](template-syntax.html). 
@@ -579,7 +579,7 @@ figure
   **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.
   
@@ -814,13 +814,13 @@ figure
   and it's more than enough to get going.
   But it doesn't include everything we'll need or want to know.
     
-  这是Angular应用中所有其他东西的基础，而且它已经绰绰有余了。
+  这是Angular应用中所有其它东西的基础，而且它已经绰绰有余了。
   但它还没有包括我们所要用的或想知道的一切。
 <a id="other-stuff"></a>  
 .l-main-section
 :marked
   ## The Other Stuff
-  ## 其他东西
+  ## 其它东西
   
   Here is a brief, alphabetical list of other important Angular features and services. 
   Most of them are covered in this Developers Guide (or soon will be):
diff --git a/public/docs/ts/latest/guide/cheatsheet-cn.json b/public/docs/ts/latest/guide/cheatsheet-cn.json
index 0cca92207e..91961c261c 100644
--- a/public/docs/ts/latest/guide/cheatsheet-cn.json
+++ b/public/docs/ts/latest/guide/cheatsheet-cn.json
@@ -347,7 +347,7 @@
           "bold": [
             "constructor(myService: MyService, ...)"
           ],
-          "description": "<p>类的构造函数会在所有其他生命周期钩子之前调用。使用它来注入依赖，但是要避免用它做较重的工作。</p>\n"
+          "description": "<p>类的构造函数会在所有其它生命周期钩子之前调用。使用它来注入依赖，但是要避免用它做较重的工作。</p>\n"
         },
         {
           "syntax": "ngOnChanges(changeRecord) { ... }",
diff --git a/public/docs/ts/latest/guide/displaying-data.jade b/public/docs/ts/latest/guide/displaying-data.jade
index 2bc0b38c09..11fc5747c2 100644
--- a/public/docs/ts/latest/guide/displaying-data.jade
+++ b/public/docs/ts/latest/guide/displaying-data.jade
@@ -367,7 +367,7 @@ figure.image-display
     we were conditionally including or excluding a big chunk of HTML with many data bindings.
     
     Angular并不是在显示和隐藏这条消息，它是在从DOM中添加和移除这段元素。
-    在这个范例中，他们几乎等价。但是如果我们要根据条件包含或排除一大段具有很多数据绑定的HTML，性能上的区别就会很明显。
+    在这个范例中，它们几乎等价。但是如果我们要根据条件包含或排除一大段具有很多数据绑定的HTML，性能上的区别就会很明显。
 :marked
   Try it out. Because the array has four items, the message should appear.
   Go back into `app.component.ts` and delete or comment out one of the elements from the hero array.
diff --git a/public/docs/ts/latest/guide/forms.jade b/public/docs/ts/latest/guide/forms.jade
index d3551efc4d..c540bbceee 100644
--- a/public/docs/ts/latest/guide/forms.jade
+++ b/public/docs/ts/latest/guide/forms.jade
@@ -444,7 +444,7 @@ figure.image-display
   from the interpolated text.
   At some point it might look like this.
   
-  如果我们现在运行这个应用，并且开始在 *姓名* 输入框中键入、添加和删除字符，我们将看到他们从插值结果中显示和消失。
+  如果我们现在运行这个应用，并且开始在 *姓名* 输入框中键入、添加和删除字符，我们将看到它们从插值结果中显示和消失。
   某一瞬间，它看起来可能是这样。
 figure.image-display
   img(src="/resources/images/devguide/forms/ng-model-in-action.png" width="400px" alt="操作中的ngModel")
@@ -948,7 +948,7 @@ figure.image-display
     control* is valid.
     
     `NgForm`指令使用额外的特性扩充了`form`元素。
-    它保存我们通过`ngControl`属性为各个元素创建的控件类，并且监听他们的属性变化，包括有效性。
+    它保存我们通过`ngControl`属性为各个元素创建的控件类，并且监听它们的属性变化，包括有效性。
     它还有自己的`valid`属性，只有当 *每一个被包含的控件* 都有效时，它才有效。
     
 :marked
diff --git a/public/docs/ts/latest/guide/index.jade b/public/docs/ts/latest/guide/index.jade
index b9b402f062..bf39ebf289 100644
--- a/public/docs/ts/latest/guide/index.jade
+++ b/public/docs/ts/latest/guide/index.jade
@@ -170,7 +170,7 @@ table(width="100%")
   
   少量早期的章节是作为教程来写的，并且被清晰地标注出来。
   但大部分章节都不是教程。
-  他们的目的是展示代码中的关键点，而不是解释构建这个范例所需的每一个步骤。
+  它们的目的是展示代码中的关键点，而不是解释构建这个范例所需的每一个步骤。
   我们总能从鲜活范例的链接找到完整的源代码。
   
   ## References
diff --git a/public/docs/ts/latest/guide/style-guide.jade b/public/docs/ts/latest/guide/style-guide.jade
index 8b0aca4766..f32f6647c6 100644
--- a/public/docs/ts/latest/guide/style-guide.jade
+++ b/public/docs/ts/latest/guide/style-guide.jade
@@ -14,7 +14,7 @@ include ../_util-fns
 
   The purpose of this style guide is to provide guidance on building Angular applications by showing the conventions we use and, more importantly, why we choose them.
   
-  本风格指南的目的是，通过展示我们使用的规则，更加重要的，展示我们为什么要选择他们，来为建造Angular应用程序提供一个向导。
+  本风格指南的目的是，通过展示我们使用的规则，更加重要的，展示我们为什么要选择它们，来为建造Angular应用程序提供一个向导。
 .l-main-section
 
 :marked
@@ -102,7 +102,7 @@ a(id='toc')
   We apply the [Single Responsibility Principle](https:\/\/en.wikipedia.org/wiki/Single_responsibility_principle) to all Components, Services, and other symbols we create. 
   This helps make our app cleaner, easier to read and maintain, and more testable.
   
-  我们对我们创建的所有组件、服务和其他标志等，应用[单一职责原则](https:\/\/en.wikipedia.org/wiki/Single_responsibility_principle)。这样能帮助把我们的应用程序弄的干净、易读、易于维护和易测试。
+  我们对我们创建的所有组件、服务和其它标志等，应用[单一职责原则](https:\/\/en.wikipedia.org/wiki/Single_responsibility_principle)。这样能帮助把我们的应用程序弄的干净、易读、易于维护和易测试。
 
   ### Rule of One
   ### 单一规则
@@ -198,7 +198,7 @@ a(href="#toc") 回到顶部
   :marked
     **Why?** Small functions are easier to test, especially when they do one thing and serve one purpose.
     
-    **为什么？** 小函数更加容易被测试，特别是当他们只做一件事，为一个目的服务的时候。
+    **为什么？** 小函数更加容易被测试，特别是当它们只做一件事，为一个目的服务的时候。
 
 .s-why
   :marked
@@ -308,7 +308,7 @@ a(href="#toc") 回到顶部
   :marked
     **Do** use conventional suffixes for the types including `*.service.ts`, `*.component.ts`, `*.pipe.ts`. Invent other suffixes where desired, but take care in having too many.
     
-    **做** 使用依照惯例的后缀来描述类型，包括`*.service.ts`、`*.component.ts`、`*.pipe.ts`。如果你想，你可以发明其他的后缀，但是请注意不要有太多。
+    **做** 使用依照惯例的后缀来描述类型，包括`*.service.ts`、`*.component.ts`、`*.pipe.ts`。如果你想，你可以发明其它的后缀，但是请注意不要有太多。
 
 .s-why
   :marked
@@ -344,7 +344,7 @@ a(href="#toc") 回到顶部
 .s-rule.do
   :marked
     **Do** use consistent names for all assets named after what they represent.
-    **做** 为所有财产的使用统一的命名：以他们所代表的东西命名
+    **做** 为所有财产的使用统一的命名：以它们所代表的东西命名
 
 .s-rule.do
   :marked
diff --git a/public/docs/ts/latest/guide/template-syntax.jade b/public/docs/ts/latest/guide/template-syntax.jade
index 655efd11ed..b096f393bc 100644
--- a/public/docs/ts/latest/guide/template-syntax.jade
+++ b/public/docs/ts/latest/guide/template-syntax.jade
@@ -298,7 +298,7 @@ include ../_util-fns
   where it will be easier to develop and test.
   
   一个属性名或方法调用属于常态。偶尔的逻辑取反(`!`)也还凑合。
-  其他情况下，组件会自己界定应用逻辑和业务逻辑，它将让开发和测试变得更容易。
+  其它情况下，组件会自己界定应用逻辑和业务逻辑，它将让开发和测试变得更容易。
 
   #### Idempotence
   #### 幂等性
diff --git a/public/docs/ts/latest/quickstart.jade b/public/docs/ts/latest/quickstart.jade
index c1ecedf7c6..62f875f0c6 100644
--- a/public/docs/ts/latest/quickstart.jade
+++ b/public/docs/ts/latest/quickstart.jade
@@ -328,7 +328,7 @@ a(id="component-import")
 
     Angular apps are modular. They consist of many files each dedicated to a purpose.
 
-    Angular的应用都是模块化的。他们由很多职责明确的文件组成。
+    Angular的应用都是模块化的。它们由很多职责明确的文件组成。
           
     Angular itself is modular. It is a collection of library modules
     each made up of several, related features that we'll use to build our application.
@@ -413,7 +413,7 @@ a(id="component-import")
     We **export** `AppComponent` so that we can **import** it elsewhere in our application,
     as we'll see when we create `main.ts`.
 
-    我们 **导出** `AppComponent`，以便我们可以在应用的其他地方 **导入** 它 —— 比如我们创建`main.ts`时。
+    我们 **导出** `AppComponent`，以便我们可以在应用的其它地方 **导入** 它 —— 比如我们创建`main.ts`时。
 a(id="main")
 .l-main-section
 :marked
diff --git a/public/docs/ts/latest/testing/first-app-tests.jade b/public/docs/ts/latest/testing/first-app-tests.jade
index b3d975c35c..3cf47233c8 100644
--- a/public/docs/ts/latest/testing/first-app-tests.jade
+++ b/public/docs/ts/latest/testing/first-app-tests.jade
@@ -25,7 +25,7 @@ include ../_util-fns
     the [Tour of Heroes](../tutorial/) tutorial
     such as <code>npm</code>, <code>gulp</code>, and <code>live-server</code>.
     
-    本单元测试章节是在其他章节的基础上编写的。我们建议你按顺序阅读他们。我们同时假设你已经对Angular 2的原理、在[快速开始](../quickstart.html)里介绍的工具、
+    本单元测试章节是在其它章节的基础上编写的。我们建议你按顺序阅读它们。我们同时假设你已经对Angular 2的原理、在[快速开始](../quickstart.html)里介绍的工具、
     [英雄指南](../tutorial)和<code>npm</code>, <code>gulp</code>, and <code>live-server</code>等工具都所有了解。
 
 .l-main-section
diff --git a/public/docs/ts/latest/testing/jasmine-testing-101.jade b/public/docs/ts/latest/testing/jasmine-testing-101.jade
index 43582e2603..d9d97bf683 100644
--- a/public/docs/ts/latest/testing/jasmine-testing-101.jade
+++ b/public/docs/ts/latest/testing/jasmine-testing-101.jade
@@ -71,7 +71,7 @@ pre.prettyprint.lang-bash
 :marked
   In the head we have three Jasmine scripts and one Jasmine css file. That’s the foundation for running any tests.
   
-  在head里面，我们有三个Jasmine脚本和一个Jasmine css文件。他们是运行任何测试的奠基石。
+  在head里面，我们有三个Jasmine脚本和一个Jasmine css文件。它们是运行任何测试的奠基石。
 
   We’ll write our first test with inline JavaScript inside the body tag:
   
@@ -163,7 +163,7 @@ pre.prettyprint.lang-bash
     what `it` and `expect` are because they lack the typing files that describe Jasmine.
     We can ignore those annoying complaints for now as they are harmless.
     
-    我们的编辑器和编译器可能会抱怨，说他们不知道什么是`it`和`expect`，因为他们缺少描述Jasmine的typing文件。我们暂时可以忽略这些讨厌的抱怨，他们目前并无害处。
+    我们的编辑器和编译器可能会抱怨，说它们不知道什么是`it`和`expect`，因为它们缺少描述Jasmine的typing文件。我们暂时可以忽略这些讨厌的抱怨，它们目前并无害处。
 
 :marked
   If we reload the browser, we should see the same Jasmine test-runner output as before.
@@ -193,7 +193,7 @@ pre.prettyprint.lang-bash
 .l-main-section
 :marked
   ## Add a describe and another test
-  ## 添加一个describe和其他测试
+  ## 添加一个describe和其它测试
 
   We can’t tell what file produced these test results. We only have one file at the moment but soon we’ll write more.
   
diff --git a/public/docs/ts/latest/tutorial/toh-pt1.jade b/public/docs/ts/latest/tutorial/toh-pt1.jade
index 81663682a6..d8625856d4 100644
--- a/public/docs/ts/latest/tutorial/toh-pt1.jade
+++ b/public/docs/ts/latest/tutorial/toh-pt1.jade
@@ -279,6 +279,6 @@ code-example(language="html").
   [next tutorial chapter](./toh-pt2.html).
 
   我们的《英雄指南》只显示了一个英雄，而我们真正想显示的是一个英雄列表。
-  我们还希望允许用户选择一个英雄，并且显示他们的详情。
+  我们还希望允许用户选择一个英雄，并且显示他的详情。
   我们还将学习更多：接收一个列表、把它们绑定到模板，以及让用户选择它。
   这些都在[教程的下一章](./toh-pt2.html)。
diff --git a/public/docs/ts/latest/tutorial/toh-pt3.jade b/public/docs/ts/latest/tutorial/toh-pt3.jade
index 3a8c37135b..efb2d35e0f 100644
--- a/public/docs/ts/latest/tutorial/toh-pt3.jade
+++ b/public/docs/ts/latest/tutorial/toh-pt3.jade
@@ -121,7 +121,7 @@ code-example(format="." language="bash").
   Then we export the class to make it available to other components.
   
   我们使用`@Component`装饰器创建元数据，在元数据中，我们指定选择器的名字，用以标记此组件的元素。
-  然后，我们导出这个类，以便其他组件可以使用它。
+  然后，我们导出这个类，以便其它组件可以使用它。
   
   When we finish here, we'll import it into `AppComponent` and create a corresponding `<my-hero-detail>`  element.
   
diff --git a/public/docs/ts/latest/tutorial/toh-pt4.jade b/public/docs/ts/latest/tutorial/toh-pt4.jade
index 7af5e3047f..bb04bd5ce2 100644
--- a/public/docs/ts/latest/tutorial/toh-pt4.jade
+++ b/public/docs/ts/latest/tutorial/toh-pt4.jade
@@ -484,7 +484,7 @@ code-example(format="." language="html").
   :marked
     We are simplifying. Learn about ES2015 Promises [here](http://exploringjs.com/es6/ch_promises.html) and elsewhere on the web.
     
-    这里只是粗浅的说说，要了解更多，请参见[这里](http://exploringjs.com/es6/ch_promises.html)以及在Web上搜索其他学习资源。
+    这里只是粗浅的说说，要了解更多，请参见[这里](http://exploringjs.com/es6/ch_promises.html)以及在Web上搜索其它学习资源。
 :marked
   Update the `HeroService` with this promise-returning `getHeroes` method:
   
diff --git a/public/docs/ts/latest/tutorial/toh-pt5.jade b/public/docs/ts/latest/tutorial/toh-pt5.jade
index fd5ae80102..5a1e0b8b1b 100644
--- a/public/docs/ts/latest/tutorial/toh-pt5.jade
+++ b/public/docs/ts/latest/tutorial/toh-pt5.jade
@@ -385,7 +385,7 @@ code-example(format="." language="bash").
   we call this type of component a *Router Component*.
 
   *AppComponent* 现在有了一个路由器，并且能显示路由到的视图。
-  因此，为了把它从其他种类的组件中区分出来，我们称这类组件为 *路由器组件*。
+  因此，为了把它从其它种类的组件中区分出来，我们称这类组件为 *路由器组件*。
 
 :marked
   ## Add a *Dashboard*

From 65a3fdb9f3bcaf40f70815907684e9e2582f78a1 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 21:55:34 +0800
Subject: [PATCH 11/12] =?UTF-8?q?=E4=BF=AE=E6=94=B9Javascript=E5=A4=A7?=
 =?UTF-8?q?=E5=B0=8F=E5=86=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 public/docs/ts/latest/glossary.jade                    | 10 +++++-----
 public/docs/ts/latest/testing/jasmine-testing-101.jade |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/public/docs/ts/latest/glossary.jade b/public/docs/ts/latest/glossary.jade
index a72c81b057..0d730a3780 100644
--- a/public/docs/ts/latest/glossary.jade
+++ b/public/docs/ts/latest/glossary.jade
@@ -479,7 +479,7 @@ include _util-fns
     either in this version of the language or a dialect that strives to be
     compatible with it such as [TypeScript](#typesScript).
     
-    最新的被认可的Javascript版本是[ECMAScript 2015](http://www.ecma-international.org/ecma-262/6.0/)，（也交“ES2015”或“ES6”）。Angular 2的开发者要么这个版本的Javascript，要么使用与这个版本兼容的语言，比如[TypeScript](#typesScript)。
+    最新的被认可的JavaScript版本是[ECMAScript 2015](http://www.ecma-international.org/ecma-262/6.0/)，（也叫“ES2015”或“ES6”）。Angular 2的开发者要么使用这个版本的JavaScript，要么使用与这个版本兼容的语言，比如[TypeScript](#typesScript)。
    
     Most modern browsers today only support the prior "ECMAScript 5" (AKA ES5) standard.
     Applications written in ES2015 or one of its dialects must be "[transpiled](#transpile)"
@@ -499,7 +499,7 @@ include _util-fns
     [ECMAScript 2015](http://www.ecma-international.org/ecma-262/6.0/)
     (AKA "ES2015" or "ES6")
     
-    最新发布的Javascript版本，[ECMAScript 2015](http://www.ecma-international.org/ecma-262/6.0/)
+    最新发布的JavaScript版本，[ECMAScript 2015](http://www.ecma-international.org/ecma-262/6.0/)
     (即 "ES2015" 或 "ES6")
 :marked
   ## ES2015
@@ -522,7 +522,7 @@ include _util-fns
     Short hand for "ECMAScript 5", the version of JavaScript run by most modern browsers.
     See [ECMAScript](#ecmascript).
     
-    “ECMAScript 5”的简写，大部分现代浏览器使用的Javascript版本。请看[ECMAScript](#ecmascript)。
+    “ECMAScript 5”的简写，大部分现代浏览器使用的JavaScript版本。请看[ECMAScript](#ecmascript)。
 // #enddocregion e2
 
 // #docregion f-l
@@ -901,7 +901,7 @@ include _util-fns
     a [data binding](#data-binding).  Learn how to write template expressions
     in the [Template Syntax](guide/template-syntax.html#template-expressions) chapter.
 
-    Angular在[数据绑定data binding](#data-binding)内评估的类似Javascript语法的表达式。在[模板语法Template Syntax](guide/template-syntax.html#template-expressions)章节了解更多模板表达式的知识。
+    Angular在[数据绑定data binding](#data-binding)内求值的类似JavaScript语法的表达式。在[模板语法Template Syntax](guide/template-syntax.html#template-expressions)章节了解更多模板表达式的知识。
 // #enddocregion t1
 // #docregion t2
 :marked
@@ -912,7 +912,7 @@ include _util-fns
     The process of transforming code written in one form of JavaScript
     (e.g., TypeScript) into another form of JavaScript  (e.g., [ES5](#es5)).
 
-    把用Javascript形式语言（比如TypeScript）编写的程序转换到另一个形式的JavaScript（例如[ES5](#es5))。
+    把用JavaScript形式语言（比如TypeScript）编写的程序转换到另一个形式的JavaScript（例如[ES5](#es5))。
  :marked
   ## TypeScript
 .l-sub-section
diff --git a/public/docs/ts/latest/testing/jasmine-testing-101.jade b/public/docs/ts/latest/testing/jasmine-testing-101.jade
index d9d97bf683..aa9862e7b8 100644
--- a/public/docs/ts/latest/testing/jasmine-testing-101.jade
+++ b/public/docs/ts/latest/testing/jasmine-testing-101.jade
@@ -123,7 +123,7 @@ figure.image-display
 :marked
   Hold on! We wrote a TypeScript file but we’re loading a JavaScript file?
   
-  等等！我们编写了TypeScript文件，但是我们却加载了一个Javascript文件？
+  等等！我们编写了TypeScript文件，但是我们却加载了一个JavaScript文件？
   
   That’s a reminder that we need to compile our TypeScript test files as we do our TypeScript application files.  Do that next.
   

From f0e75413c854b8966c506c7c351339c9f5e98512 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Mon, 9 May 2016 22:16:34 +0800
Subject: [PATCH 12/12] =?UTF-8?q?=E8=AF=B7=E7=9C=8B=E6=94=B9=E6=88=90?=
 =?UTF-8?q?=E5=8F=82=E8=A7=81=EF=BC=8C=E6=9B=B4=E4=B9=A6=E9=9D=A2=E5=8C=96?=
 =?UTF-8?q?=E3=80=82=20=E4=BF=AE=E8=AE=A2=E4=BA=86=E4=B8=80=E4=BA=9B?=
 =?UTF-8?q?=E8=AF=8D=E6=B1=87=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../cookbook/component-communication.jade     |  2 +-
 .../latest/cookbook/dependency-injection.jade |  2 +-
 .../docs/ts/latest/cookbook/dynamic-form.jade |  2 +-
 .../latest/cookbook/set-document-title.jade   |  2 +-
 public/docs/ts/latest/glossary.jade           | 55 +++++++++----------
 5 files changed, 31 insertions(+), 32 deletions(-)

diff --git a/public/docs/ts/latest/cookbook/component-communication.jade b/public/docs/ts/latest/cookbook/component-communication.jade
index 1192399299..885157ae3f 100644
--- a/public/docs/ts/latest/cookbook/component-communication.jade
+++ b/public/docs/ts/latest/cookbook/component-communication.jade
@@ -49,7 +49,7 @@ include ../_util-fns
 :marked
   **See the [live example](/resources/live-examples/cb-component-communication/ts/plnkr.html)**.
   
-  **请看[在线例子](/resources/live-examples/cb-component-communication/ts/plnkr.html)**
+  **参见[在线例子](/resources/live-examples/cb-component-communication/ts/plnkr.html)**
 
 .l-main-section
 <a id="parent-to-child"></a>
diff --git a/public/docs/ts/latest/cookbook/dependency-injection.jade b/public/docs/ts/latest/cookbook/dependency-injection.jade
index e3ba72fb40..0e51fab72a 100644
--- a/public/docs/ts/latest/cookbook/dependency-injection.jade
+++ b/public/docs/ts/latest/cookbook/dependency-injection.jade
@@ -70,7 +70,7 @@ include ../_util-fns
 :marked
    **See the [live example](/resources/live-examples/cb-dependency-injection/ts/plnkr.html)**
    of the code supporting this cookbook.        
-   获取本“食谱”的代码支持，**请看[在线例子](/resources/live-examples/cb-dependency-injection/ts/plnkr.html)**。
+   获取本“食谱”的代码支持，**参见[在线例子](/resources/live-examples/cb-dependency-injection/ts/plnkr.html)**。
 .l-main-section
 
 <a id="app-wide-dependencies"></a>
diff --git a/public/docs/ts/latest/cookbook/dynamic-form.jade b/public/docs/ts/latest/cookbook/dynamic-form.jade
index 02b28553b3..9d26546d9d 100644
--- a/public/docs/ts/latest/cookbook/dynamic-form.jade
+++ b/public/docs/ts/latest/cookbook/dynamic-form.jade
@@ -40,7 +40,7 @@ include ../_util-fns
 :marked
    **See the [live example](/resources/live-examples/cb-dynamic-form/ts/plnkr.html)**.
    
-   **请看[在线例子](/resources/live-examples/cb-dynamic-form/ts/plnkr.html)**.
+   **参见[在线例子](/resources/live-examples/cb-dynamic-form/ts/plnkr.html)**.
    
 .l-main-section
 <a id="object-model"></a>
diff --git a/public/docs/ts/latest/cookbook/set-document-title.jade b/public/docs/ts/latest/cookbook/set-document-title.jade
index ef5b821e0a..25eca83f65 100644
--- a/public/docs/ts/latest/cookbook/set-document-title.jade
+++ b/public/docs/ts/latest/cookbook/set-document-title.jade
@@ -9,7 +9,7 @@ a(id='top')
 :marked
   **See the [live example](/resources/live-examples/cb-set-document-title/ts/plnkr.html)**.
   
-  **请看[在线例子](/resources/live-examples/cb-set-document-title/ts/plnkr.html)**.
+  **参见[在线例子](/resources/live-examples/cb-set-document-title/ts/plnkr.html)**.
 .l-sub-section
   img(src='/resources/images/devguide/plunker-separate-window-button.png' alt="pop out the window" align="right" style="margin-right:-20px")
   :marked
diff --git a/public/docs/ts/latest/glossary.jade b/public/docs/ts/latest/glossary.jade
index 0d730a3780..e7e95f1316 100644
--- a/public/docs/ts/latest/glossary.jade
+++ b/public/docs/ts/latest/glossary.jade
@@ -485,7 +485,7 @@ include _util-fns
     Applications written in ES2015 or one of its dialects must be "[transpiled](#transpile)"
     to ES5 JavaScript.
     
-    目前，几乎所有现代游览器都只支持上一版本“ECMAScript 5” （也就是ES5）标准。使用ES2015或者其它兼容语言开发的应用程序，都必须被编译“[transpiled](#transpile)”成ES5 JavaScript。
+    目前，几乎所有现代游览器都只支持上一个版本的“ECMAScript 5” （也就是ES5）标准。使用ES2015或者其它兼容语言开发的应用程序，都必须被“[转译](#transpile)”成ES5 JavaScript。
 
     Angular 2 developers may choose to write in ES5 directly.
     
@@ -522,7 +522,7 @@ include _util-fns
     Short hand for "ECMAScript 5", the version of JavaScript run by most modern browsers.
     See [ECMAScript](#ecmascript).
     
-    “ECMAScript 5”的简写，大部分现代浏览器使用的JavaScript版本。请看[ECMAScript](#ecmascript)。
+    “ECMAScript 5”的简写，大部分现代浏览器使用的JavaScript版本。参见[ECMAScript](#ecmascript)。
 // #enddocregion e2
 
 // #docregion f-l
@@ -540,7 +540,7 @@ include _util-fns
     that can find a named "dependency" in its cache or create such a thing
     with a registered [provider](#provider).
 
-    一个Angular[依赖注入系统](#dependency-injection)内部的对象，它可以在自己的内部缓存找到已点名的依赖或者利用一个注册过的[provider](#provider)创建一个依赖。
+    Angular[依赖注入系统](#dependency-injection)中的一个对象，它可以在自己的缓存中找到一个“有名字的依赖”或者利用一个已注册的[provider](#provider)创建这样的依赖。
 :marked
   ## Input
 .l-sub-section
@@ -550,11 +550,11 @@ include _util-fns
     Data values flow *into* this property from the data source identified
     in the template expression to the right of the equal sign.
     
-    一个指令属性：是[属性绑定Property Binding](guide/template-syntax.html#property-binding)的目标。数据值从处于模板表达式等号右边的数据源中，流入这个指令属性。
+    指令属性可以作为[属性绑定](guide/template-syntax.html#property-binding)的目标。数据值会从模板表达式等号右侧的数据源中，流入这个属性。
 
     See the [Template Syntax](guide/template-syntax.html#inputs-outputs) chapter.
     
-    请看[模板语法Template Syntax](guide/template-syntax.html#inputs-outputs)章节。
+    参见[模板语法Template Syntax](guide/template-syntax.html#inputs-outputs)一章。
 
 :marked
   ## Interpolation
@@ -567,7 +567,7 @@ include _util-fns
     before it is assigned to an element property
     or displayed between element tags as in this example.
     
-    一种[属性数据绑定Property Data Binding](#data-binding) 的方式：在双大括号中间的[模板表达式](#template-expression)被渲染成文本。在被指派给元素属性或者在元素标记中间显示之前，这些文本可能与傍边的文本先合并，请看下面的例子。
+    [属性数据绑定](#data-binding) 的格式之一：位于双大括号中的[模板表达式](#template-expression)会被渲染成文本。在被赋值给元素属性或者显示在元素标记中之前，这些文本可能先与周边的文本合并，参见下面的例子。
 
   code-example(language="html" escape="html").
     <label>My current hero is {{hero.name}}</label>
@@ -576,7 +576,7 @@ include _util-fns
     Learn more about interpolation in the
     [Template Syntax](guide/template-syntax.html#interpolation) chapter.
     
-    从[模板语法Template Syntax](guide/template-syntax.html#interpolation)章节学习更多关于插值表达式的知识。
+    要学习关于插值表达式的更多知识，参见[模板语法](guide/template-syntax.html#interpolation)一章。
 
 <a id="J"></a>
 
@@ -589,15 +589,15 @@ include _util-fns
   :marked
     The practice of writing compound words or phrases such that each word is separated by a dash or hyphen (-). 
      
-    使用中线来分割每个单词的编写复合词或短语的命名方法。
+    使用中线（-）分隔每个单词来书写复合词或短语的命名方法。
     
     Directive selectors and the root of filenames are often spelled in kebab-case. Examples include: `my-app` and the `hero-list.component.ts`.
     
-    指令选择器和文件名字等一般都用烤串命名法Kebab-case。比如`my-app`和`hero-list.component.ts`。
+    指令选择器和文件名等一般都用烤串命名法。比如`my-app`和`hero-list.component.ts`。
     
     This form is also known as [dash-case](#dash-case).
     
-    这种命名法也被叫做[中线命名法dash-case](#dash-case)
+    这种格式也叫[中线命名法](#dash-case)。
 
 <a id="L"></a>
 .l-main-section
@@ -609,43 +609,42 @@ include _util-fns
     [Directives](#directive) and [Components](#component) have a lifecycle
     managed by Angular as it creates, updates and destroys them.
     
-    [指令Directives](#directive)和[组件Components](#component)有生命周期，由Angular在创建、更新和销毁它们的过程中管理。
+    [指令Directives](#directive)和[组件Components](#component)具有生命周期，它们由Angular在创建、更新和销毁它们的过程中进行管理。
 
     Developers can tap into key moments in that lifecycle by implementing
     one or more of the "Lifecycle Hook" interfaces.
     
-    开发者可以通过实现一个或多个“生命周期钩子”接口，切入到这个生命周期的关键时间点中。
+    开发者可以通过实现一个或多个“生命周期钩子”接口，切入到生命周期中的关键时间点。
 
     Each interface has a single hook method whose name is the interface name prefixed with `ng`.
     For example, the `OnInit` interface has a hook method names `ngOnInit`.
     
-    每个接口有一个唯一的钩子类方法方法，它的名字一般是接口的名字加前缀 `ng`。比如，`OnInit`接口的钩子类方法方法名字为 `ngOnInit`。
+    每个接口只有一个钩子方法，方法名一般是接口的名字加前缀 `ng`。比如，`OnInit`接口的钩子类的方法名为 `ngOnInit`。
 
     Angular calls these hook methods in the following order:
     
     Angular会按照下面的顺序调用钩子类方法：
     
     * `ngOnChanges` - called when an [input](#input)/[output](#output) binding values change
-    * `ngOnInit` - after the first `ngOnChanges`
-    * `ngDoCheck` - developer's custom change detection
-    * `ngAfterContentInit` - after component content initialized
-    * `ngAfterContentChecked` - after every check of component content
-    * `ngAfterViewInit` - after component's view(s) are initialized
-    * `ngAfterViewChecked` - after every check of a component's view(s)
-    * `ngOnDestroy` - just before the directive is destroyed.
-    
     * `ngOnChanges` - 在[输入input](#input)/[输出output](#output)绑定的值变化的时候调用。
+    * `ngOnInit` - after the first `ngOnChanges`
     * `ngOnInit` - 在第一个`ngOnChanges`后调用。
+    * `ngDoCheck` - developer's custom change detection
     * `ngDoCheck` - 开发者自定义变化监测器。
+    * `ngAfterContentInit` - after component content initialized
     * `ngAfterContentInit` - 在组件初始化以后调用。
+    * `ngAfterContentChecked` - after every check of component content
     * `ngAfterContentChecked` - 在检查每个组件内容后调用。
+    * `ngAfterViewInit` - after component's view(s) are initialized
     * `ngAfterViewInit` - 在组件试图初始化后调用。
+    * `ngAfterViewChecked` - after every check of a component's view(s)
     * `ngAfterViewChecked` - 在检查每个组件试图后调用
+    * `ngOnDestroy` - just before the directive is destroyed.
     * `ngOnDestroy` - 在指令销毁前调用。
 
     Learn more in the [Lifecycle Hooks](guide/lifecycle-hooks.html) chapter.
     
-    请看[生命周期钩子Lifecycle Hooks](guide/lifecycle-hooks.html)章节。 
+    要了解更多，参见[生命周期钩子Lifecycle Hooks](guide/lifecycle-hooks.html)一章。 
 // #enddocregion f-l
 
 // #docregion m1
@@ -669,19 +668,19 @@ include _util-fns
 
     A typical module is a cohesive block of code dedicated to a single purpose.
     
-    一个典型的模块，是单一用途的代码块的凝聚。
+    典型的模块，是具有单一用途的内聚代码块。
 
     A module **exports** something of value in that code, typically one thing such as a class.
     A module that needs that thing, **imports** it.
     
-    模块一般**输出**一个东西：类。
-    模块如果需要什么东西，那就**导入**它。
+    模块一般 **输出** 一个东西：类。
+    模块如果需要什么东西，那就 **导入** 它。
 
     The structure of Angular modules and the import/export syntax
     is based on the [ES2015](#es2015) module standard
     described [here](http://www.2ality.com/2014/09/es6-modules-final.html).
     
-    Angular的模块结构和输出/导入语法是基于[ES2015](#es2015)模块标准上的，请看[这里](http://www.2ality.com/2014/09/es6-modules-final.html).
+    Angular的模块结构和输出/导入语法是基于[ES2015](#es2015)模块标准的，参见[这里](http://www.2ality.com/2014/09/es6-modules-final.html).
 
     An application that adheres to this standard requires a module loader to
     load modules on request and resolve inter-module dependencies.
@@ -729,7 +728,7 @@ include _util-fns
     
     See the [Template Syntax](guide/template-syntax.html#inputs-outputs) chapter.
     
-    请看[模板语法Template Syntax](guide/template-syntax.html#inputs-outputs)章节。
+    参见[模板语法Template Syntax](guide/template-syntax.html#inputs-outputs)章节。
 
 .l-main-section
 <a id="P"></a>
@@ -793,7 +792,7 @@ include _util-fns
     See [Dependency Injection](#dependency-injection) chapter to learn more.
     
     还有其它一些方法建立Token和方剂。
-    请看[依赖注入Dependency Injection](#dependency-injection)以获取更多信息。 
+    参见[依赖注入Dependency Injection](#dependency-injection)以获取更多信息。 
 
 .l-main-section
 <a id="Q"></a>