anchor.diff:        for any particular 3rd party library (although most examples use SystemJS).
         You may pick any module library that conforms to the standard.
   
  -      采用这个标准的应用程序需要一个模块加载器来按需加载模块并解析模块的依赖关系。Angular不包含任何模块加载器，也不偏爱哪一个第三方库(虽然几乎所有例子都使用SystemJS)。
  -      你可以自行选择任何与这个标准兼容的模块化库。
  +      采用这个标准的应用程序需要一个模块加载器来按需加载模块，并解析模块间的依赖关系。
  +      Angular 不附带模块加载器，也不偏爱任何第三方库（虽然大多数例子使用SystemJS）。
  +      你可以选择任何与这个标准兼容的模块化库。
   
         Modules are typically named after the file in which the exported thing is defined.
         The Angular [DatePipe](https://github.com/angular/angular/blob/master/modules/@angular/common/src/pipes/date_pipe.ts)
         class belongs to a feature module named `date_pipe` in the file `date_pipe.ts`.
   
  -      模块一般与它定义导出物的文件同名。比如, Angular的[日期管道(DatePipe)](https://github.com/angular/angular/blob/master/modules/angular2/src/common/pipes/date_pipe.ts)类属于名叫`date_pipe`的特性模块，位于文件`date_pipe.ts`中。
  +      模块一般与它定义导出物的文件同名。例如，Angular 的 [DatePipe](https://github.com/angular/angular/blob/master/modules/angular2/src/common/pipes/date_pipe.ts) 类属于名叫`date_pipe`的特性模块，位于`date_pipe.ts`文件中。
   
         You rarely access Angular feature modules directly. You usually import them from one of the Angular [scoped packages](#scoped-package) such as `@angular/core`.
   
  -      你很少需要直接访问Angular的特性模块。
  -      而通常会从一个Angular的[范围化包(Scoped Package)](#scoped-package)中导入它们，比如`@angular/core`。
  +      你很少需要直接访问 Angular 的特性模块。
  +      而通常会从一个 Angular [范围化包 (scoped package)](#scoped-package)中导入它们，例如`@angular/core`。
   
   a#N
   .l-main-section#O
  
positive.code:       asynchronous events by checking for data changes, and updating
        the information it displays via [data bindings](#data-binding).
  
        Angular会在一个 Zone 区域中运行应用程序，在这个区域中，它可以对异步事件做出反应，可以通过检查数据变更、利用[数据绑定(Data Bindings)](#data-binding)来更新信息显示。
  
        Learn more about zones in this
        [Brian Ford video](https://www.youtube.com/watch?v=3IqtmUscE_U).
  
        到[Brian Ford的视频](https://www.youtube.com/watch?v=3IqtmUscE_U)学习更多关于区域的知识。
  
negative.code: 
  :marked
    ## Dependency injection
  
    ## 依赖注入 (dependency injection)
  .l-sub-section
    :marked
      Dependency injection is both a design pattern and a mechanism
      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 wiring them together at runtime.
  
      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
      part "A" relies on another part "B", you say that "A" depends on "B" and
      that "B" is a dependency of "A".
  
      这些部件通常会依赖其它部件。一个 Angular [组件 (component)](#component)
      可能依赖一个服务部件来获取数据或执行运算。
      如果部件 “A” 要靠另一个部件 “B” 才能工作，我们称 “A” 依赖 “B” ，“B” 是 “A” 的依赖。
  
      You 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” 需要 “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)](dependency-injection.html)系统来组装和运行应用程序，在需要的地方和时刻，将一些部件“注入”到另一些部件里面。
  
      At the core there is an [`injector`](#injector) that returns dependency values on request.
      The expression `injector.get(token)` returns the value associated with the given token.
  
      在 Angular 内核中有一个[注入器 (injector)](#injector)，当请求时返回依赖值。
      表达式`injector.get(token)`返回与该token（令牌）参数相关的值。
  
      A token is an Angular type (`OpaqueToken`). You rarely deal with tokens directly; most
      methods accept a class name (`Foo`) or a string ("foo") and Angular converts it
      to a token. When you 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`类的实例。
  
      During many of its operations, Angular makes similar requests internally, such as when it creates a [`component`](#component) for display.
  
      Angular 在内部执行很多类似的依赖注入请求，例如，在创建用于显示的[组件 (component)](#component)。
  
      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.
  
      注入器 (`Injector`) 维护一个令牌到依赖值的映射表。
      如果注入器找不到给定令牌对应的依赖值，它会使用提供商 (`Provider`) 创建一个依赖值。
  
      A [provider](#provider) is a recipe for
      creating new instances of a dependency value associated with a particular token.
  
      [提供商 (provider)](#provider)是一个“菜谱”，用于创建特定令牌对应的依赖实例。
  
      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.
  
      只有当注入器内部提供商注册表中存在与令牌对应的提供商时，
      注入器才能为这个令牌创建一个依赖值。所以注册提供商是一个非常关键的准备步骤。
  
      Angular registers some of its own providers with every injector.
      We can register our own providers.
  
      Angular 会为每个注册器注册很多内置提供商。
      我们也可以注册自己的提供商。
  
      Read more in the [Dependency Injection](!{docsLatest}/guide/dependency-injection.html) page.
  
      更多信息，见[依赖注入 (dependency injection)](!{docsLatest}/guide/dependency-injection.html)。
  
  :marked
    ## Directive
  
    ## 指令 (directive)
  
  .l-sub-section
    :marked
      An Angular class responsible for creating, reshaping, and interacting with HTML elements
      in the browser DOM. Directives are Angular's most fundamental feature.
  
      指令是一个 Angular 类，负责创建和重塑浏览器 DOM 中的 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.
  