anchor.diff:        The practice of writing compound words or phrases such that an
         underscore (`_`) separates one word from the next. This form is also known as **underscore case**.
   
  -      用下划线分隔复合词或词组的命名方法称为**下划线命名法**。
  +      蛇形命名法是书写复合词或短语的一种形式，用下划线分隔每个单词，也称**下划线命名法**。
   
   :marked
     ## Service
  -  ## 服务（service）
  +
  +  ## 服务 (service)
  +
   .l-sub-section
     :marked
       For data or logic that is not associated
       with a specific view or that you want to share across components, build services.
   
  -    组件很强大很好...但是，我们该如何处理那些不与任何特定视图相关的数据和逻辑？又如何在组件之间共享这些数据和逻辑？我们创建服务！
  +    服务用于封装不与任何特定视图相关的数据和逻辑，或者用于在组件之间共享数据和逻辑。
   
       Applications often require services such as a hero data service or a logging service.
   
  -    应用程序经常需要服务，比如英雄数据服务或者日志服务。组件依赖这些服务来做一些繁重的工作。
  +    应用程序经常需要服务，例如英雄数据服务或者日志服务。
   
       A service is a class with a focused purpose.
       We often create a service to implement features that are
       independent from any specific view,
       provide shared data or logic across components, or encapsulate external interactions.
   
  -    服务是一个具有特定功能的类。我们经常创建服务来实现不依赖任何特定视图的特征、在组件之间提供共享数据或逻辑，或者封装外部互动等。
  +    服务是一个具有特定功能的类。
  +    我们经常创建服务来实现不依赖任何特定视图的特征，
  +    在组件之间提供共享数据或逻辑，或者封装外部的交互。
   
       For more information, see the [Services](!{docsLatest}/tutorial/toh-pt4.html) page of the [Tour of Heroes](!{docsLatest}/tutorial/) tutorial.
   
  -    要了解更多，参见[英雄指南](!{docsLatest}/tutorial/)教程中的[服务](!{docsLatest}/tutorial/toh-pt4.html)页。
  +    更多信息，见[英雄指南](!{docsLatest}/tutorial/)中的[服务](!{docsLatest}/tutorial/toh-pt4.html)。
   
   :marked
     ## Structural directive
  -  ## 结构型指令（structural directive）
  +
  +  ## 结构型指令 (structural directive)
  +
   .l-sub-section
     :marked
       A category of [directive](#directive) that can
       shape or reshape HTML layout, typically by adding, removing, or manipulating
       elements and their children; for example, the `ngIf` "conditional element" directive and the `ngFor` "repeater" directive.
   
  -    结构型指令是一种可以通过添加、删除或操作元素和其各级子元素来塑造或重塑HTML布局的[指令(Directive)](#directive)，
  +    结构型指令是[指令 (directive)](#directive)一种，
  +    可以通过添加、删除或操作元素和其各级子元素来塑造或重塑 HTML 布局。
  +    例如，`ngIf`是"条件化元素"指令，`ngFor`是“重复器”指令。
   
       Read more in the [Structural Directives](!{docsLatest}/guide/structural-directives.html) page.
   
  -    要了解更多，请参见[结构型指令](!{docsLatest}/guide/structural-directives.html)页。
  +    更多信息，见[结构型指令](!{docsLatest}/guide/structural-directives.html)。
   
   // #enddocregion n-s-2
   
   .l-main-section#T
   :marked
     ## Template
  -  ## 模板（template）
  +
  +  ## 模板 (template)
  +
   .l-sub-section
     :marked
       A template is a chunk of HTML that Angular uses to render a [view](#view) with
       the support and continuing guidance of an Angular [directive](#directive),
       most notably a [component](#component).
   
  -    模板是一大块HTML。Angular会在[指令(Directive)](#directive)特别是[组件(Component)](#component)的支持和持续指导下，用它来渲染[视图(View)](#view)。
  +    模板是一大块 HTML。Angular 会在[指令 (directive)](#directive) 特别是[组件 (component)](#component)
  +    的支持和持续指导下，用它来渲染[视图 (view)](#view)。
   
   +ifDocsFor('ts|js')
     :marked
       ## Template-driven forms
  -    ## 模板驱动表单（template-driven forms）
  +
  +    ## 模板驱动表单 (template-driven forms)
  +
     .l-sub-section
       :marked
         A technique for building Angular forms using HTML forms and input elements in the view.
         The alternate technique is [Reactive Forms](#reactive-forms).
   
  -      这是一项在视图中使用HTML表单和输入类元素构建Angular表单的技术。
  +      一项在视图中使用 HTML 表单和输入类元素构建 Angular 表单的技术。
         它的替代方案是[响应式表单](#reactive-forms)。
   
         When building template-driven forms:
  
positive.code:       and launch the application dynamically. This is a good choice during development.
        Consider using the [ahead-of-time](#aot) mode for production apps.
  
        Angular的即时编译在浏览器中启动并编译所有的组件和模块，并动态运行应用程序。它很适合在开发期使用。但是在产品发布时，
        推荐采用[预编译（Ahead of Time）](#aot)模式。
  
  .l-main-section#K
  :marked
    ## kebab-case
    ## 烤串命名法(kebab-case)
  .l-sub-section
    :marked
      See [dash-case](#dash-case).
  
      参见[中线命名法(dash-case)](#dash-case)。
  
  .l-main-section#L
  :marked
    ## Lifecycle hooks
    ## 生命周期钩子（lifecycle hook）
  .l-sub-section
    :marked
      [Directives](#directive) and [components](#component) have a lifecycle
      managed by Angular as it creates, updates, and destroys them.
  
      [指令(Directive)](#directive)和[组件(Component)](#component)具有生命周期，它们由Angular在创建、更新和销毁它们的过程中进行管理。
  
      You 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 named `ngOnInit`.
  
      每个接口只有一个钩子方法，方法名一般是接口的名字加前缀 `ng`。比如，`OnInit`接口的钩子类的方法名为 `ngOnInit`。
  
      Angular calls these hook methods in the following order:
  
      Angular会按照下面的顺序调用钩子类方法：
  
      * `ngOnChanges` - when an [input](#input)/[output](#output) binding value changes.
      * `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` - 在指令销毁前调用。
  
      Read more in the [Lifecycle Hooks](!{docsLatest}/guide/lifecycle-hooks.html) page.
  
      要了解更多，参见[生命周期钩子(Lifecycle Hook)](!{docsLatest}/guide/lifecycle-hooks.html)一章。
  // #enddocregion f-l
  
  .l-main-section#M
  
  :marked
    ## Module
    ## 模块（module）
  .l-sub-section
    block module-defn
      .alert.is-important
        :marked
         In Angular, there are two types of modules:
  
         在Angular里有两种模块：
  
         - [Angular modules](#angular-module).
         For details and examples, see the [Angular Modules](!{docsLatest}/guide/ngmodule.html) page.
  
         - [Angular 模块](#angular-module)。到[Angular Module](!{docsLatest}/guide/ngmodule.html)页查看详情和例子。
  
         - ES2015 modules, as described in this section.
  
         - 本节描述的ES2015模块。
  
      :marked
        Angular apps are modular.
  
        Angular应用程序是模块化的。
  
        In general, you assemble your application from many modules, both the ones you write and the ones you acquire from others.
  
        一般来说，我们用模块来组装应用程序，这些模块包含我们自己编写的模块和从其它地方获取的模块。
  
        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.
  
        模块代码中通常会**导出(export)**一些东西，最典型的就是类。
        模块如果需要什么东西，那就**导入(import)**它。
  
        The structure of Angular modules and the import/export syntax
        is based on the [ES2015 module standard](http://www.2ality.com/2014/09/es6-modules-final.html).
  
        Angular的模块结构和输出/导入语法是基于[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.
  
negative.code:    to a<span if-docs="ts"> module</span> factory, meaning you don't need to include the Angular compiler in your JavaScript bundle.
     Ahead-of-time compiled applications also benefit from decreased load time and increased performance.
  
     开发者可以在构造时 (build-time) 编译 Angular 应用程序。
     通过`Compiler-cli` - `ngc`编译应用程序，应用可以从一个<span if-docs="ts">模块</span>工厂直接启动，
     意味着不再需要把 Angular 编译器添加到 JavaScript 包中。
     预编译的应用程序加载迅速，具有更高的性能。
  
  +ifDocsFor('ts')
    :marked
      ## Angular module
  
      ## Angular 模块
  
    .l-sub-section
      :marked
        Helps you organize an application into cohesive blocks of functionality.
        An Angular module identifies the components, directives, and pipes that the application uses along with the list of external Angular modules that the application needs, such as `FormsModule`.
  
        帮助我们将一个应用程序组织成内聚的功能模块群。
        一个 Angular 模块标识应用程序使用的组件、指令和管道等，还包含应用程序需要的外部 Angular 模块的列表，例如`FormsModule`。
  
        Every Angular application has an application root module class. By convention, the class is
        called `AppModule` and resides in a file named `app.module.ts`.
  
        每个 Angular 应用程序都有一个应用程序根模块类。按规约这个类的名字为`AppModule`，存放在名为`app.module.ts`的文件。
  
        For details and examples, see the [Angular Module](!{docsLatest}/guide/ngmodule.html) page.
  
        要了解详情和范例，参见 [Angular 模块](!{docsLatest}/guide/ngmodule.html)。
  
  +ifDocsFor('ts|dart')
    :marked
      ## Annotation
  
      ## 注解 (annotation)
  
    .l-sub-section
      block annotation-defn
        :marked
          In practice, a synonym for [Decoration](#decorator).
  
          实际上，是[装饰 (decoration)](#decorator) 的同义词。
  
  :marked
    ## Attribute directive
  
    ## 属性型指令 (attribute directive)
  
  .l-sub-section
    :marked
      A category of [directive](#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.
  
      [指令 (directive)](#directive)的一种。可以监听或修改其它 HTML 元素、特性 (attribute)、属性 (property)、组件的行为。通常用作 HTML 属性，就像它的名字所暗示的那样。
  
      A good example of an attribute directive is the `ngClass` directive for adding and removing CSS class names.
  
      `ngClass`指令就是典型的属性型指令。它可以添加或移除 CSS 类名。
  
  .l-main-section#B
  
  +ifDocsFor('ts|js')
    :marked
      ## Barrel
  
      ## 封装桶 (barrel)
  
    .l-sub-section
      :marked
        A barrel is a way to *rollup exports* from several ES2015 modules into a single convenient ES2015 module.
        The barrel itself is an ES2015 module file that re-exports *selected* exports of other ES2015 modules.
  
        封装桶是把多个模块的*导出结果*汇总到单一的 ES2015 模块的一种方式。
        封装桶本身是一个 ES2015 模块文件，它重新导出*选中的*导出，这些导入来自其它 ES2015 模块。
  
        Imagine three ES2015 modules in a `heroes` folder:
  
        设想在`heroes`目录下有三个 ES2015 模块：
  
      code-example.
        // heroes/hero.component.ts
  