Glossary

开发者可以在构造时 (build-time) 编译 Angular 应用程序。 通过compiler-cli - ngc编译应用程序，应用可以从一个模块工厂直接启动， 意味着不再需要把 Angular 编译器添加到 JavaScript 包中。 预编译的应用程序加载迅速，具有更高的性能。

You can compile Angular applications at build time. By compiling your application using the compiler-cli, ngc, you can bootstrap directly to a module 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.

帮助我们将一个应用程序组织成内聚的功能模块群。 一个 Angular 模块标识应用程序使用的组件、指令和管道等，还包含应用程序需要的外部 Angular 模块的列表，例如FormsModule。

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 应用程序都有一个应用程序根模块类。按规约这个类的名字为AppModule，存放在名为app.module.ts的文件。

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 模块。

For details and examples, see the Angular Modules (NgModule) page.

实际上，是装饰 (decoration) 的同义词。

In practice, a synonym for Decoration.

指令 (directive)的一种。可以监听或修改其它 HTML 元素、特性 (attribute)、属性 (property)、组件的行为。通常用作 HTML 属性，就像它的名字所暗示的那样。

A category of 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.

例如，ngClass指令就是典型的属性型指令。它可以添加或移除 CSS 类名。

For example, you can use the ngClass directive to add and remove CSS class names.

要了解更多信息，请参见属性型指令页。

Learn about them in the Attribute Directives guide.

封装桶是把多个模块的导出结果汇总到单一的 ES2015 模块的一种方式。 封装桶本身是一个 ES2015 模块文件，它重新导出选中的导出，这些导入来自其它 ES2015 模块。

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.

例如，设想在heroes目录下有三个 ES2015 模块：

For example, imagine three ES2015 modules in a heroes folder:

// heroes/hero.component.ts
export class HeroComponent {}

// heroes/hero.model.ts
export class Hero {}

  // heroes/hero.service.ts
  export class HeroService {}

如果没有封装桶，消费者需要三条导入语句：

Without a barrel, a consumer needs three import statements:

import { HeroComponent } from '../heroes/hero.component.ts';
import { Hero }          from '../heroes/hero.model.ts';
import { HeroService }   from '../heroes/hero.service.ts';

在heroes目录下添加一个封装桶（按约定叫做index），它导出所有这三项：

You can add a barrel to the heroes folder (called index, by convention) that exports all of these items:

export * from './hero.model.ts';   // re-export all of its exports
export * from './hero.service.ts'; // re-export all of its exports
export { HeroComponent } from './hero.component.ts'; // re-export the named thing

现在，消费者就就可以从这个封装桶中导入它需要的东西了。

Now a consumer can import what it needs from the barrel.

import { Hero, HeroService } from '../heroes'; // index is implied

Angular 的每个范围化包 (scoped package) 都有一个名为index的封装桶。

The Angular scoped packages each have a barrel named index.

几乎都是指的数据绑定 (data binding) 和将 HTML 对象属性绑定到数据对象属性的行为。

Usually refers to data binding and the act of binding an HTML object property to a data object property.

有时也会指在“令牌”（也称为键）和依赖提供商 (provider) 之间的依赖注入 (dependency injection) 绑定。 这种用法很少，而且一般都会在上下文中写清楚。

Sometimes refers to a dependency-injection binding between a "token"—also referred to as a "key"—and a dependency provider.

通过应用程序根 Angular 模块来启动 Angular 应用程序。 启动过程标识应用的顶级“根”组件 (component)，也就是应用加载的第一个组件。 更多信息，见设置。

You launch an Angular application by "bootstrapping" it using the application root Angular module (AppModule). Bootstrapping identifies an application's top level "root" component, which is the first component that is loaded for the application. For more information, see the Setup page.

你可以在同一个index.html中引导多个应用，每个应用都有它自己的顶级根组件。

You can bootstrap multiple apps in the same index.html, each app with its own top-level root.

驼峰式命名法是书写复合词或短语的一种形式，除首字母要小写外，每个单词或缩写都以大写字母开头。

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 lowercase.

通常，函数、属性和方法命名使用驼峰式拼写法。例如，square, firstName 和 getHeroes。注意这里的square是如何用驼峰式命名法表示单一词的例子。

Function, property, and method names are typically spelled in camelCase. For example, square, firstName, and getHeroes. Notice that square is an example of how you write a single word in camelCase.

这种形式也叫做小写驼峰式命名法 (lower camel case)，以区分于大写驼峰式命名法，也称 Pascal 命名法 (PascalCase)。 在文档中提到“驼峰式命名法 (camelCase) ”的时候，我们所指的都是小驼峰命名法。

camelCase is also known as lower camel case to distinguish it from upper camel case, or PascalCase. In Angular documentation, "camelCase" always means lower camel case.

组件是一个 Angular 类，用于把数据展示到视图 (view)，并处理几乎所有的视图显示和交互逻辑。

An Angular class responsible for exposing data to a view and handling most of the view’s display and user-interaction logic.

组件是 Angular 系统中最重要的基本构造块之一。 它其实是一个拥有模板 (template)的指令 (directive)。

The component is one of the most important building blocks in the Angular system. It is, in fact, an Angular directive with a companion template.

需要将#@Component装饰器应用到一个组件类，从而把必要的组件元数据附加到类上。 Angular 会需要元数据来创建一个组件实例，并把组件的模板作为视图渲染出来。

Apply the @Component decorator to the component class, thereby attaching to the class the essential component metadata that Angular needs to create a component instance and render the component with its template as a view.

如果你熟悉 "MVC" 和 "MVVM" 模式，就会意识到组件充当了“控制器 (controller) ”和“视图模型 (view model) ”的角色。

Those familiar with "MVC" and "MVVM" patterns will recognize the component in the role of "controller" or "view model".

中线命名法是书写复合词或短语的一种形式，使用中线 (-) 分隔每个单词。 这种形式也称为烤串命名法 kebab-case。

The practice of writing compound words or phrases such that each word is separated by a dash or hyphen (-). This form is also known as kebab-case.

指令的选择器（例如my-app）和文件名（例如hero-list.component.ts）通常是用中线命名法来命名。

Directive selectors (like my-app) and the root of filenames (such as hero-list.component.ts) are often spelled in dash-case.

应用程序会将数据展示给用户，并对用户的操作（点击、触屏、按键）做出回应。

Applications display data values to a user and respond to user actions (such as clicks, touches, and keystrokes).

在数据绑定机制下，我们只要声明一下HTML部件和数据源之间的关系，把细节交给框架去处理。 而以前的手动操作过程是：将数据推送到 HTML 页面中、添加事件监听器、从屏幕获取变化后的数据，并更新应用中的值。

In data binding, you declare the relationship between an HTML widget and data source and let the framework handle the details. Data binding is an alternative to manually pushing application data values into HTML, attaching event listeners, pulling changed values from the screen, and updating application data values.

Angular 有一个非常强大的数据绑定框架，具有各种数据绑定操作，并支持声明式语法。

Angular has a rich data-binding framework with a variety of data-binding operations and supporting declaration syntax.

更多的绑定形式，见模板语法：

Read about the following forms of binding in the Template Syntax page:

• 插值表达式 (interpolation)

  Interpolation

• property 绑定 (property binding)

  Property binding

• 事件绑定 (event binding)

  Event binding

• attribute 绑定 (attribute binding)

  Attribute binding

• CSS 类绑定 (class binding)

  Class binding

• 样式绑定 (style binding)

  Style binding

• 基于 ngModel 的双向数据绑定 (Two-way data binding with ngModel)

  Two-way data binding with ngModel

装饰器是一个函数，它将元数据添加到类、类成员（属性、方法）和函数参数。

A function that adds metadata to a class, its members (properties, methods) and function arguments.

装饰器是一个 JavaScript 的语言特性，装饰器在 TypeScript 里已经实现，并被推荐到了ES2016（也就是ES7）。

Decorators are a JavaScript language feature, implemented in TypeScript and proposed for ES2016 (also known as ES7).

要想应用装饰器，把它放到被装饰对象的上面或左边。

To apply a decorator, position it immediately above or to the left of the item it decorates.

Angular 使用自己的一套装饰器来实现应用程序各部件之间的相互操作。 下面的例子中使用了@Component装饰器来将一个类标记为 Angular 组件 (component)， 并将@Input装饰器来应用到组件的name属性。 @Component装饰器中省略的参数对象会包含与组件有关的元数据。

Angular has its own set of decorators to help it interoperate with your application parts. The following example is a @Component decorator that identifies a class as an Angular component and an @Input decorator applied to the name property of that component. The elided object argument to the @Component decorator would contain the pertinent component metadata.

export class AppComponent {
  constructor(@Inject('SpecialFoo') public foo:Foo) {}
  @Input() 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 that follow it in the file.

依赖注入既是设计模式，同时又是一种机制：当应用程序的一些部件需要另一些部件时， 利用依赖注入来创建被请求的部件，并将它们注入到发出请求的部件中。

A design pattern and mechanism for creating and delivering parts of an application to other parts of an application that request them.

Angular 开发者构建应用程序时的首选方法是：定义许多简单部件， 每个部件只做一件事并做好它，然后在运行时把它们装配在一起组成应用程序。

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 组件 (component) 可能依赖一个服务部件来获取数据或执行运算。 如果部件 “A” 要靠另一个部件 “B” 才能工作，我们称 “A” 依赖 “B” ，“B” 是 “A” 的依赖。

These parts often rely on other parts. An Angular 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."

可以要求“依赖注入系统”为我们创建 “A” 并处理所有依赖。如果 “A” 需要 “B” ，“B” 需要 “C ”， 系统将解析这个依赖链，返回一个完全准备好的 “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."

Angular 提供并使用自己精心设计的依赖注入 (dependency injection)系统来组装和运行应用程序，在需要的地方和时刻，将一些部件“注入”到另一些部件里面。

Angular provides and relies upon its own sophisticated dependency-injection system to assemble and run applications by "injecting" application parts into other application parts where and when needed.

在 Angular 内核中有一个注入器 (injector)，当请求时返回依赖值。 表达式injector.get(token)返回与该token（令牌）参数相关的值。

At the core, an injector returns dependency values on request. The expression injector.get(token) returns the value associated with the given token.

令牌是一个 Angular 中的类型 (InjectionToken)。我们很少直接处理令牌。 绝大多数方法都接受类名 (Foo) 或字符串 ("foo")， Angular 会把这些类名称和字符串转换成令牌。 当调用injector.get(Foo)时，注入器返回用Foo类生成的令牌所对应的依赖值，该依赖值通常是Foo类的实例。

A token is an Angular type (InjectionToken). You rarely need to work 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 在内部执行很多类似的依赖注入请求，例如，在创建用于显示的组件 (component)。

During many of its operations, Angular makes similar requests internally, such as when it creates a component for display.

注入器 (Injector) 维护一个令牌到依赖值的映射表。 如果注入器找不到给定令牌对应的依赖值，它会使用提供商 (Provider) 创建一个依赖值。

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)是一个“菜谱”，用于创建特定令牌对应的依赖实例。

A provider is a recipe for creating new instances of a dependency value associated with a particular 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.

Angular 会为每个注册器注册很多内置提供商。 我们也可以注册自己的提供商。

Angular registers some of its own providers with every injector. You can register your own providers.

更多信息，参见依赖注入 (dependency injection)。

Read more in the Dependency Injection page.

指令是一个 Angular 类，负责创建和重塑浏览器 DOM 中的 HTML 元素，并与之互动。 指令是 Angular 中最基本的特性之一。

An Angular class responsible for creating, reshaping, and interacting with HTML elements in the browser DOM. The directive is Angular's most fundamental feature.

指令几乎总与 HTML 元素或属性 (attribute) 相关。 我们通常把这些关联到的 HTML 元素或者属性 (attribute) 当做指令本身。 当 Angular 在 HTML 模板中遇到一个指令的时候， 它会创建匹配的指令类的实例，并把浏览器中这部分 DOM 的控制权交给它。

A directive is usually associated with an HTML element or attribute. This element or attribute is often referred to as the directive itself. When Angular finds a directive in an HTML template, it creates the matching directive class instance and gives the instance control over that portion of the browser DOM.

你可以自定义 HTML 标签（例如<my-directive>）来关联自定义指令。 然后，可以像写原生 HTML 一样把这些自定义标签放到 HTML 模板里。 这样，指令就变成了 HTML 本身的拓展。

You can invent custom HTML markup (for example, <my-directive>) to associate with your custom directives. You add this custom markup to HTML templates as if you were writing native HTML. In this way, directives become extensions of HTML itself.

指令分为三类：

Directives fall into one of the following categories:

• 组件 (component): 用于组合程序逻辑和 HTML 模板，渲染出应用程序的视图。 组件一般表示成 HTML 元素的形式，它们是构建 Angular 应用程序的基本单元。

  Components combine application logic with an HTML template to render application views. Components are usually represented as HTML elements. They are the building blocks of an Angular application.

• 属性型指令 (attribute directive)：可以监控和修改其它 HTML 元素、 HTML 属性 (attribute)、 DOM 属性 (property)、组件等行为等等。它们通常表示为 HTML 属性 (attibute)，故名。

  Attribute directives 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.

• 结构型指令 (structural directive)：负责塑造或重塑 HTML 布局。这一般是通过添加、删除或者操作 HTML 元素及其子元素来实现的。

  Structural directives are responsible for shaping or reshaping HTML layout, typically by adding, removing, or manipulating elements and their children.

官方 JavaScript 语言规范

The official JavaScript language specification.

最新批准的 JavaScript 版本是ECMAScript 2016（也称“ES2016”或“ES7”）。 Angular 的开发人员要么使用这个版本的语言，要么使用与之兼容的方言，例如 TypeScript。

The latest approved version of JavaScript is ECMAScript 2016 (also known as "ES2016" or "ES7"). Many Angular developers write their applications in ES7 or a dialect that strives to be compatible with it, such as TypeScript.

目前，几乎所有现代游览器只支持很老的“ECMAScript 5” （也称ES5）标准。 使用ES2016、ES2015或者其它方言开发的应用程序，必须“转译 (transpile)”成 ES5 JavaScript。

Most modern browsers only support the much older "ECMAScript 5" (also known as "ES5") standard. Applications written in ES2016, ES2015, or one of their dialects must be transpiled to ES5 JavaScript.

Angular 的开发人员也可以选择直接使用 ES5 编程。

Angular developers can write in ES5 directly.

ECMAScript 2015 的缩写。

Short hand for ECMAScript 2015.

“ECMAScript 5”的简写，大部分现代浏览器使用的 JavaScript 版本。

Short hand for ECMAScript 5, the version of JavaScript run by most modern browsers.

ECMAScript 2015 的简写。

Short hand for ECMAScript 2015.

Angular 依赖注入系统 (Dependency Injection System)中的一个对象， 它可以在自己的缓存中找到一个命名的“依赖”或者利用已注册的提供商 (provider) 创建这样一个依赖。

An object in the Angular dependency-injection system that can find a named dependency in its cache or create a dependency with a registered provider.

输入属性是一个指令属性，可以作为属性绑定 (property binding)（详情参见模板语法页）的目标。 数据值会从模板表达式等号右侧的数据源流入这个属性。

A directive property that can be the target of a property binding (explained in detail in the Template Syntax page). Data values flow into this property from the data source identified in the template expression to the right of the equal sign.

见模板语法中的输入与输出属性。

See the Input and output properties section of the Template Syntax page.

属性数据绑定 (property data binding) 的一种形式，位于双大括号中的模板表达式 (template expression)会被渲染成文本。 在被赋值给元素属性或者显示在元素标签中之前，这些文本可能会先与周边的文本合并，参见下面的例子。

A form of property data binding in which a template expression between double-curly braces renders as text. That text may be concatenated with neighboring text before it is assigned to an element property or displayed between element tags, as in this example.

<label>My current hero is {{hero.name}}</label>

更多信息，见模板语法中的插值表达式。

Read more about interpolation in the Template Syntax page.

Angular 的即时编译在浏览器中启动并编译所有的组件和模块，动态运行应用程序。 它很适合在开发过程中使用。但是在产品发布时，推荐采用预编译 (ahead-of-time) 模式。

A bootstrapping method of compiling components and modules in the browser and launching the application dynamically. Just-in-time mode is a good choice during development. Consider using the ahead-of-time mode for production apps.

见中线命名法 (dash-case)。

See dash-case.

指令 (directive) 和组件 (component) 具有生命周期，由 Angular 在创建、更新和销毁它们的过程中进行管理。

Directives and components have a lifecycle managed by Angular as it creates, updates, and destroys them.

你可以通过实现一个或多个生命周期钩子接口，切入到生命周期中的关键时间点。

You can tap into key moments in that lifecycle by implementing one or more of the lifecycle hook interfaces.

每个接口只有一个钩子方法，方法名是接口名加前缀 ng。例如，OnInit接口的钩子方法名为 ngOnInit。

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.

Angular 会按以下顺序调用钩子方法：

Angular calls these hook methods in the following order:

• ngOnChanges - 在输入属性 (input)/输出属性 (output)的绑定值发生变化时调用。

  ngOnChanges: when an input/output binding value changes.

• ngOnInit - 在第一次ngOnChanges完成后调用。

  ngOnInit: after the first ngOnChanges.

• ngDoCheck - 开发者自定义变更检测。

  ngDoCheck: developer's custom change detection.

• ngAfterContentInit - 在组件内容初始化后调用。

  ngAfterContentInit: after component content initialized.

• ngAfterContentChecked - 在组件内容每次检查后调用。

  ngAfterContentChecked: after every check of component content.

• ngAfterViewInit - 在组件视图初始化后调用。

  ngAfterViewInit: after a component's views are initialized.

• ngAfterViewChecked - 在组件视图每次检查后调用。

  ngAfterViewChecked: after every check of a component's views.

• ngOnDestroy - 在指令销毁前调用。

  ngOnDestroy: just before the directive is destroyed.

更多信息，见生命周期钩子 (lifecycle hook)。

Read more in the Lifecycle Hooks page.

模块是一个内聚的代码块，具有单一用途。

A cohesive block of code dedicated to a single purpose.

Angular 应用程序是模块化的。

Angular apps are modular.

一般来说，我们用模块来组装应用程序，这些模块包含自己编写的模块和从其它地方获取的模块。

In general, you assemble an application from many modules, both the ones you write and the ones you acquire from others.

模块会导出 (export) 代码中的某些值，最典型的就是类。 模块如果需要什么东西，那就导入 (import) 它。

A module exports something of value in that code, typically one thing such as a class; a module that needs that class imports it.

Angular 的模块结构和导入/导出语法是基于 ES2015 模块标准的。

The structure of Angular modules and the import/export syntax is based on the ES2015 module standard.

采用这个标准的应用程序需要一个模块加载器来按需加载模块，并解析模块间的依赖关系。 Angular 不附带模块加载器，也不偏爱任何第三方库（虽然大多数例子使用SystemJS）。 你可以选择任何与这个标准兼容的模块化库。

An application that adheres to this standard requires a module loader to load modules on request and resolve inter-module dependencies. Angular doesn't include a module loader and doesn't have a preference for any particular third- party library (although most examples use SystemJS). You can use any module library that conforms to the standard.

模块一般与它定义导出物的文件同名。例如，Angular 的 DatePipe 类属于名叫date_pipe的特性模块，位于date_pipe.ts文件中。

Modules are typically named after the file in which the exported thing is defined. The Angular DatePipe class belongs to a feature module named date_pipe in the file date_pipe.ts.

你很少需要直接访问 Angular 的特性模块。 而通常会从一个 Angular 范围化包 (scoped package)中导入它们，例如@angular/core。

You rarely access Angular feature modules directly. You usually import them from an Angular scoped package such as @angular/core.

一个Observable是一个数组，其中的元素随着时间的流逝异步地到达。 Observable帮助我们管理异步数据，例如来自后台服务的数据。 Angular 自身使用了Observable，包括 Angular 的事件系统和它的 http 客户端服务。

An array whose items arrive asynchronously over time. Observables help you manage asynchronous data, such as data coming from a backend service. Observables are used within Angular itself, including Angular's event system and its HTTP client service.

为了使用Observable， Angular 采用了名为 Reactive Extensions (RxJS) 的第三方包。 在下个版本的 JavaScript - ES 2016 中，Observable是建议的特性之一。

To use observables, Angular uses a third-party library called Reactive Extensions (RxJS). Observables are a proposed feature for ES 2016, the next version of JavaScript.

输出属性是一个指令属性，可作为事件绑定的 目标 。 事件流从这个属性流出到模板表达式等号的右边的接收者。

A directive property that can be the target of event binding (read more in the event binding section of the Template Syntax page). Events stream out of this property to the receiver identified in the template expression to the right of the equal sign.

参见模板语法中的输入与输出属性部分。

See the Input and output properties section of the Template Syntax page.

Pascal 命名法是书写单词、复合词或短语的一种形式，每个单词或缩写都以大写开头。 类名一般都采用 Pascal 命名法。例如Person和HeroDetailComponent。

The practice of writing individual words, compound words, or phrases such that each word or abbreviation begins with a capital letter. Class names are typically spelled in PascalCase. For example, Person and HeroDetailComponent.

这种形式也称大写驼峰式命名法，以区别于小写驼峰式命名法”或驼峰式命名法 (camelCase) 。 在本文档中，“Pascal 命名法”都是指的大写驼峰式命名法，“驼峰式命名法”指的都是小写驼峰式命名法。

This form is also known as upper camel case to distinguish it from lower camel case or simply camelCase. In this documentation, "PascalCase" means upper camel case and "camelCase" means lower camel case.

Angular 管道是一个函数，用于把输入值转换成输出值以供视图 (view)显示。 下面这个例子中，用内置的currency管道把数字值显示为本地货币格式。

An Angular pipe is a function that transforms input values to output values for display in a view. Here's an example that uses the built-in currency pipe to display a numeric value in the local currency.

<label>Price: </label>{{product.price | currency}}

我们还可以写自己的自定义管道。 更多信息，见管道。

You can also write your own custom pipes. Read more in the page on pipes.

依赖注入系统依靠提供商来创建依赖的实例。 它把一个查找令牌和代码（有时也叫“配方”）关联到一起，以便创建依赖值。

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.

通过组件中代码构建 Angular 表单的一种技术。 另一种技术是模板驱动表单

A technique for building Angular forms through code in a component. The alternative technique is template-driven forms.

构建响应式表单时：

When building reactive forms:

• 组件是“真理之源”。表单验证在组件代码中定义。

  The "source of truth" is the component. The validation is defined using code in the component.

• 在组件类中，使用new FormControl()或者FormBuilder显性地创建每个控件。

  Each control is explicitly created in the component class with new FormControl() or with FormBuilder.

• 模板中的input元素不使用ngModel。

  The template input elements do not use ngModel.

• 相关联的 Angular 指令全部以Form开头，例如FormGroup、FormControl和FormControlName。

  The associated Angular directives are all prefixed with Form, such as FormGroup, FormControl, and FormControlName.

动态表单非常强大、灵活，它在复杂数据输入的场景下尤其好用，例如动态的生成表单控制器。

Reactive forms are powerful, flexible, and a good choice for more complex data-entry form scenarios, such as dynamic generation of form controls.

大多数应用程序包含多个屏幕或视图 (view)。 用户通过点击链接、按钮和其它类似动作，在它们之间导航，使应用程序从一个视图切换到另一个视图。

Most applications consist of many screens or views. The user navigates among them by clicking links and buttons, and performing other similar actions that cause the application to replace one view with another.

Angular 的组件路由器是一个特性丰富的机制，可以配置和管理整个导航过程，包括建立和销毁视图。

The Angular component router is a richly featured mechanism for configuring and managing the entire view navigation process, including the creation and destruction of views.

多数情况下，组件会通过RouterConfig中定义的路由到视图的对照表来附加到路由器上。

In most cases, components become attached to a router by means of a RouterConfig that defines routes to views.

路由组件的模板中带有一个RouterOutlet元素，那是显示路由器生成的视图的地方。

A routing component's template has a RouterOutlet element where it can display views produced by the router.

应用中的其它视图中某些锚标签或按钮上带有RouterLink指令，用户可以点击它们进行导航。

Other views in the application likely have anchor tags or buttons with RouterLink directives that users can click to navigate.

更多信息，见路由与导航。

For more information, see the Routing & Navigation page.

一个独立的 Angular 模块，用来提供导航所需的服务提供商和指令。

A separate Angular module that provides the necessary service providers and directives for navigating through application views.

更多信息，见路由与导航。

For more information, see the Routing & Navigation page.

一个带有 RouterOutlet 的 Angular 组件，根据路由器导航来显示视图。

An Angular component with a RouterOutlet that displays views based on router navigations.

更多信息，见路由与导航。

For more information, see the Routing & Navigation page.

对相关的npm包进行分组的一种方式，参阅npm-scope。

A way to group related npm packages. Read more at the npm-scope page.

Angular 模块是用一系列范围化包的形式发布的，例如@angular/core、@angular/common、@angular/platform-browser-dynamic、@angular/http和@angular/router。

Angular modules are delivered within scoped packages such as @angular/core, @angular/common, @angular/platform-browser-dynamic, @angular/http, and @angular/router.

导入范围化包与导入普通包方式相同。 从消费者的视角看，唯一的不同是那些包的名字是用 Angular 的范围化包名@angular开头的。

Import a scoped package the same way that you import a normal package. The only difference, from a consumer perspective, is that the scoped package name begins with the Angular scope name, @angular.

import { Component } from '@angular/core';

服务用于封装不与任何特定视图相关的数据和逻辑，或者用于在组件之间共享数据和逻辑。

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. You 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.

应用通常都需要服务，比如数据服务或者日志服务。

Applications often require services such as a data service or a logging service.

更多信息，见英雄指南中的服务。

For more information, see the Services page of the Tour of Heroes tutorial.

写复合词或短语的一种方式，在多个词之间用下划线(_)分隔。也叫下划线命名法

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.

结构型指令是指令 (directive)一种， 可以通过在DOM中添加、删除或操作元素和其各级子元素来塑造或重塑 HTML 布局。 例如，ngIf这个“条件化元素”指令，ngFor这个“重复器”指令都是众所周知的例子。

A category of directive that can shape or reshape HTML layout, typically by adding and removing elements in the DOM. The ngIf "conditional element" directive and the ngFor "repeater" directive are well-known examples.

更多信息，见结构型指令。

Read more in the Structural Directives page.

模板是一大块 HTML。Angular 会在指令 (directive) 特别是组件 (component) 的支持和持续指导下，用它来渲染视图 (view)。

A chunk of HTML that Angular uses to render a view with the support and guidance of an Angular directive, most notably a component.

一项在视图中使用 HTML 表单和输入类元素构建 Angular 表单的技术。 它的替代方案是响应式表单。

A technique for building Angular forms using HTML forms and input elements in the view. The alternate technique is Reactive Forms.

当构建模板驱动表单时：

When building template-driven forms:

• 模板是“真理之源”。使用属性 (attribute) 在单个输入元素上定义验证规则。

  The "source of truth" is the template. The validation is defined using attributes on the individual input elements.

• 使用ngModel进行双向绑定，保持组件模型和用户输入之间的同步。

  Two-way binding with ngModel keeps the component model synchronized with the user's entry into the input elements.

• 在幕后，Angular 为每个带有name属性和双向绑定的输入元素创建了一个新的控件。

  Behind the scenes, Angular creates a new control for each input element, provided you have set up a name attribute and two-way binding for each input.

• 相关的 Angular 指令都带有ng前缀，例如ngForm、ngModel和ngModelGroup。

  The associated Angular directives are all prefixed with ng such as ngForm, ngModel, and ngModelGroup.

模板驱动表单便捷、快速、简单，是很多基础型数据输入表单的最佳选择。

Template-driven forms are convenient, quick, and simple. They are a good choice for many basic data-entry form scenarios.

要了解如何构建模板驱动表单的更多信息，参见表单页。

Read about how to build template-driven forms in the Forms page.

Angular 用来在数据绑定 (data binding)内求值的、类似JavaScript语法的表达式。

A TypeScript-like syntax that Angular evaluates within a data binding.

到模板语法一章的模板表达式部分了解更多模板表达式的知识。

Read about how to write template expressions in the Template expressions section of the Template Syntax page.

把一种形式的 JavaScript（例如 TypeScript）转换成另一种形式的 JavaScript（例如 ES5）的过程。

The process of transforming code written in one form of JavaScript (such as TypeScript) into another form of JavaScript (such as ES5).

JavaScript 的一个版本，支持了几乎所有 ECMAScript 2015 语言特性，例如装饰器 (decorator))。

A version of JavaScript that supports most ECMAScript 2015 language features such as decorators.

TypeScript 还以它的可选类型系统而著称。 该类型系统提供了编译时类型检查和强大的工具支持（例如 “Intellisense”，代码补齐，重构和智能搜索等）。 许多代码编辑器和 IDE 都原生支持 TypeScript 或通过插件提供支持。

TypeScript is also notable for its optional typing system, which provides compile-time type checking and strong tooling support (such as "intellisense," code completion, refactoring, and intelligent search). Many code editors and IDEs support TypeScript either natively or with plugins.

TypeScript 是 Angular 的首选语言，当然，你可以使用其它 JavaScript 方言，例如ES5。

TypeScript is the preferred language for Angular development, although you can use other JavaScript dialects such as ES5.

更多信息，见typescript.org。

Read more about TypeScript at typescriptlang.org.

视图是屏幕中一小块，用来显示信息并响应用户动作，例如点击、移动鼠标和按键。

A portion of the screen that displays information and responds to user actions such as clicks, mouse moves, and keystrokes.

Angular 在一个或多个指令 (directive) 的控制下渲染视图， 尤其是组件 (component) 指令及其模板 (template)。 组件扮演着非常重要的角色，我们甚至经常会为了方便, 直接用视图作为组件的代名词。

Angular renders a view under the control of one or more directives, especially component directives and their companion templates. The component plays such a prominent role that it's often convenient to refer to a component as a view.

视图一般包含其它视图，在用户在应用程序中导航时， 任何视图都可能被动态加载或卸载，这一般会在路由器 (router) 的控制下进行。

Views often contain other views. Any view might be loaded and unloaded dynamically as the user navigates through the application, typically under the control of a router.

区域是一种用来封装和截听 JavaScript 应用程序异步活动的机制。

A mechanism for encapsulating and intercepting a JavaScript application's asynchronous activity.

浏览器中的 DOM 和 JavaScript 之间常会有一些数量有限的异步活动， 例如 DOM 事件（例如点击）、承诺 (promise) 和通过 XHR 调用远程服务。

The browser DOM and JavaScript have a limited number of asynchronous activities, such as DOM events (for example, clicks), promises, and XHR calls to remote servers.

区域能截听所有这些活动，并让“区域的客户”有机会在异步活动完成之前和之后采取行动。

Zones intercept all of these activities and give a "zone client" the opportunity to take action before and after the async activity finishes.

Angular 会在一个 Zone 区域中运行应用程序，在这个区域中，它可以对异步事件做出反应，可以通过检查数据变更、利用数据绑定 (data bindings) 来更新信息显示。

Angular runs your application in a zone where it can respond to asynchronous events by checking for data changes and updating the information it displays via data bindings.

更多信息，见 Brian Ford 的视频。

Learn more about zones in this Brian Ford video.