anchor.diff:      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
  
positive.code:     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网页，添加事件监听器，从屏幕获取数据变化，然后更新数据等等。。。
  
      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小部件和数据源的关系...，让一个数据绑定框架工具来处理所有细节。
  
      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有一个非常强大的数据绑定框架工具，具有多种用来数据绑定的操作，并支持声明语法规则。
  
       The many forms of binding include:
       * [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)
       * [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)
       
      Learn more about data binding in the
      [Template Syntax](guide/template-syntax.html#data-binding) chapter.
      
      到[模板语法](guide/template-syntax.html#data-binding)章节获取更多关于数据绑定的知识。
  
  // #enddocregion d1
  <a id="decorator"></a> <a id="decoration"></a>
  
negative.code:     it creates the matching directive class instance
      and gives that instance control over that portion of the browser 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本身的拓展。
  
      Directives fall into one of three categories:
      
  