模板语法
Template Syntax
Angular 应用管理着用户之所见和所为，并通过 Component 类的实例（组件）和面向用户的模板交互来实现这一点。
The Angular application manages what the user sees and can do, achieving this through the interaction of a component class instance (the component) and its user-facing template.
从使用模型-视图-控制器 (MVC) 或模型-视图-视图模型 (MVVM) 的经验中，很多开发人员都熟悉了组件和模板这两个概念。 在 Angular 中，组件扮演着控制器或视图模型的角色，模板则扮演视图的角色。
You may be familiar with the component/template duality from your 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.
这是一篇关于 Angular 模板语言的技术大全。 它解释了模板语言的基本原理，并描述了你将在文档中其它地方遇到的大部分语法。
This page is a comprehensive technical reference to the Angular template language. It explains basic principles of the template language and describes most of the syntax that you'll encounter elsewhere in the documentation.
这里还有很多代码片段用来解释技术点和概念，它们全都在
Many code snippets illustrate the points and concepts, all of them available in the
模板中的 HTML
HTML in templates
HTML 是 Angular 模板的语言。几乎所有的 HTML 语法都是有效的模板语法。 但值得注意的例外是 <script> 元素，它被禁用了，以阻止脚本注入攻击的风险。（实际上，<script> 只是被忽略了。） 参见安全页了解详情。
HTML is the language of the Angular template. 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 ignored and a warning appears in the browser console. See the Security page for details.
有些合法的 HTML 被用在模板中是没有意义的。<html>、<body> 和 <base> 元素这个舞台上中并没有扮演有用的角色。剩下的所有元素基本上就都一样用了。
Some legal HTML doesn't make much sense in a template. The <html>, <body>, and <base> elements have no useful role. Pretty much everything else is fair game.
可以通过组件和指令来扩展模板中的 HTML 词汇。它们看上去就是新元素和属性。接下来将学习如何通过数据绑定来动态获取/设置 DOM（文档对象模型）的值。
You can extend the HTML vocabulary of your templates with components and directives that appear as new elements and attributes. In the following sections, you'll learn how to get and set DOM (Document Object Model) values dynamically through data binding.
首先看看数据绑定的第一种形式 —— 插值表达式，它展示了模板的 HTML 可以有多丰富。
Begin with the first form of data binding—interpolation—to see how much richer template HTML can be.
插值表达式 ( {{...}} )
Interpolation ( {{...}} )
在以前的 Angular 教程中，你遇到过由双花括号括起来的插值表达式，{{ 和 }}。
You met the double-curly braces of interpolation, {{ and }}, early in your Angular education.
<p>My current hero is {{currentHero.name}}</p>
插值表达式可以把计算后的字符串插入到 HTML 元素标签内的文本或对标签的属性进行赋值。
You use interpolation to weave calculated strings into the text between HTML element tags and within attribute assignments.
<h3>
{{title}}
<img src="{{heroImageUrl}}" style="height:30px">
</h3>
在括号之间的“素材”，通常是组件属性的名字。Angular 会用组件中相应属性的字符串值，替换这个名字。 上例中，Angular 计算 title 和 heroImageUrl 属性的值，并把它们填在空白处。 首先显示粗体的应用标题，然后显示英雄的图片。
The text 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 the example above, Angular evaluates the title and heroImageUrl properties and "fills in the blanks", first displaying a bold application title and then a heroic image.
一般来说，括号间的素材是一个模板表达式，Angular 先对它求值，再把它转换成字符串。 下列插值表达式通过把括号中的两个数字相加说明了这一点：
More generally, the text 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:
<!-- "The sum of 1 + 1 is 2" -->
<p>The sum of 1 + 1 is {{1 + 1}}</p>
这个表达式可以调用宿主组件的方法，就像下面用的 getVal()：
The expression can invoke methods of the host component such as getVal(), seen here:
<!-- "The sum of 1 + 1 is not 4" -->
<p>The sum of 1 + 1 is not {{1 + 1 + getVal()}}</p>
Angular 对所有双花括号中的表达式求值，把求值的结果转换成字符串，并把它们跟相邻的字符串字面量连接起来。最后，把这个组合出来的插值结果赋给元素或指令的属性。
Angular evaluates all expressions in double curly braces, converts the expression results to strings, and links them with neighboring literal strings. Finally, it assigns this composite interpolated result to an element or directive property.
表面上看，你在元素标签之间插入了结果和对标签的属性进行了赋值。 这样思考起来很方便，并且这个误解很少给你带来麻烦。 但严格来讲，这是不对的。插值表达式是一个特殊的语法，Angular 把它转换成了属性绑定，后面将会解释这一点。
You appear to be inserting the result between element tags and assigning it to attributes. It's convenient to think so, and you rarely suffer for this mistake. Though this is not exactly true. Interpolation is a special syntax that Angular converts into a property binding, as is explained below.
讲解属性绑定之前，先深入了解一下模板表达式和模板语句。
But first, let's take a closer look at template expressions and statements.
模板表达式
Template expressions
模板表达式产生一个值。 Angular 执行这个表达式，并把它赋值给绑定目标的属性，这个绑定目标可能是 HTML 元素、组件或指令。
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.
{{1 + 1}} 中所包含的模板表达式是 1 + 1。 在属性绑定中会再次看到模板表达式，它出现在 = 右侧的引号中，就像这样：[property]="expression"。
The interpolation braces in {{1 + 1}} surround the template expression 1 + 1. In the property binding section below, a template expression appears in quotes to the right of the = symbol as in [property]="expression".
编写模板表达式所用的语言看起来很像 JavaScript。 很多 JavaScript 表达式也是合法的模板表达式，但不是全部。
You write these template expressions in a language that looks like JavaScript. Many JavaScript expressions are legal template expressions, but not all.
JavaScript 中那些具有或可能引发副作用的表达式是被禁止的，包括：
JavaScript expressions that have or promote side effects are prohibited, including:
赋值 (
=,+=,-=, ...)assignments (
=,+=,-=, ...)new运算符new使用
;或,的链式表达式chaining expressions with
;or,自增和自减运算符：
++和--increment and decrement operators (
++and--)
和 JavaScript 语 法的其它显著不同包括：
Other notable differences from JavaScript syntax include:
不支持位运算
|和&no support for the bitwise operators
|and&具有新的模板表达式运算符，比如
|、?.和!。new template expression operators, such as
|,?.and!.
表达式上下文
Expression context
典型的表达式上下文就是这个组件实例，它是各种绑定值的来源。 在下面的代码片段中，双花括号中的 title 和引号中的 isUnchanged 所引用的都是 AppComponent 中的属性。
The expression context is typically the component instance. In the following snippets, the title within double-curly braces and the isUnchanged in quotes refer to properties of the AppComponent.
{{title}}
<span [hidden]="isUnchanged">changed</span>
表达式的上下文可以包括组件之外的对象。 比如模板输入变量 (let hero)和模板引用变量(#heroInput)就是备选的上下文对象之一。
An expression may also refer to properties of the template's context such as a template input variable (let hero) or a template reference variable (#heroInput).
<div *ngFor="let hero of heroes">{{hero.name}}</div>
<input #heroInput> {{heroInput.value}}
表达式中的上下文变量是由模板变量、指令的上下文变量（如果有）和组件的成员叠加而成的。 如果你要引用的变量名存在于一个以上的命名空间中，那么，模板变量是最优先的，其次是指令的上下文变量，最后是组件的成员。
The context for terms in an expression is a blend of the template variables, the directive's context object (if it has one), and the component's members. If you reference a name that belongs to more than one of these namespaces, the template variable name takes precedence, followed by a name in the directive's context, and, lastly, the component's member names.
上一个例子中就体现了这种命名冲突。组件具有一个名叫 hero 的属性，而 *ngFor 声明了一个也叫 hero 的模板变量。 在 {{hero.name}} 表达式中的 hero 实际引用的是模板变量，而不是组件的属性。
The previous example presents such a name collision. The component has a hero property and the *ngFor defines a hero template variable. The hero in {{hero.name}} refers to the template input variable, not the component's property.
模板表达式不能引用全局命名空间中的任何东西，比如 window 或 document。它们也不能调用 console.log 或 Math.max。 它们只能引用表达式上下文中的成员。
Template expressions cannot refer to anything in the global namespace (except undefined). They can't refer to window or document. They can't call console.log or Math.max. They are restricted to referencing members of the expression context.
表达式指南
Expression guidelines
模板表达式能成就或毁掉一个应用。请遵循下列指南：
Template expressions can make or break an application. Please follow these guidelines:
超出上面指南外的情况应该只出现在那些你确信自己已经彻底理解的特定场景中。
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.
这条规则是 Angular “单向数据流”策略的基础。 永远不用担心读取组件值可能改变另外的显示值。 在一次单独的渲染过程中，视图应该总是稳定的。
This rule is essential to Angular's "unidirectional data flow" policy. You should never worry that reading a component value might change some other displayed value. The view should be stable throughout a single rendering pass.
执行迅速
Quick execution
Angular 会在每个变更检测周期后执行模板表达式。 变更检测周期会被多种异步活动触发，比如 Promise 解析、HTTP 结果、定时器时间、按键或鼠标移动。
Angular executes template expressions after every change detection cycle. Change detection cycles are triggered by many asynchronous activities such as promise resolutions, http results, timer events, keypresses and mouse moves.
表达式应该快速结束，否则用户就会感到拖沓，特别是在较慢的设备上。 当计算代价较高时，应该考虑缓存那些从其它值计算得出的值。
Expressions should finish quickly or the user experience may drag, especially on slower devices. Consider caching values when their computation is expensive.
非常简单
Simplicity
虽然也可以写出相当复杂的模板表达式，但不要那么写。
Although it's possible to write quite complex template expressions, you should avoid them.
常规是属性名或方法调用。偶尔的逻辑取反 (!) 也还凑合。 其它情况下，应在组件中实现应用和业务逻辑，使开发和测试变得更容易。
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
最好使用幂等的表达式，因为它没有副作用，并且能提升 Angular 变更检测的性能。
An idempotent expression is ideal because it is free of side effects and improves Angular's change detection performance.
在 Angular 的术语中，幂等的表达式应该总是返回完全相同的东西，直到某个依赖值发生改变。
In Angular terms, an idempotent expression always returns exactly the same thing until one of its dependent values changes.
在单独的一次事件循环中，被依赖的值不应该改变。 如果幂等的表达式返回一个字符串或数字，连续调用它两次，也应该返回相同的字符串或数字。 如果幂等的表达式返回一个对象（包括 Date 或 Array），连续调用它两次，也应该返回同一个对象的引用。
Dependent values should not change during a single turn of the event loop. 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 an array), it returns the same object reference when called twice in a row.
模板语句
Template statements
模板语句用来响应由绑定目标（如 HTML 元素、组件或指令）触发的事件。 模板语句将在事件绑定一节看到，它出现在 = 号右侧的引号中，就像这样：(event)="statement"。
A template statement responds to an event raised by a binding target such as an element, component, or directive. You'll see template statements in the event binding section, appearing in quotes to the right of the = symbol as in (event)="statement".
<button (click)="deleteHero()">Delete hero</button>
模板语句有副作用。 这是事件处理的关键。因为你要根据用户的输入更新应用状态。
A template statement has a side effect. That's the whole point of an event. It's how you update application state from user action.
响应事件是 Angular 中“单向数据流”的另一面。 在一次事件循环中，可以随意改变任何地方的任何东西。
Responding to events is the other side of Angular's "unidirectional data flow". You're free to change anything, anywhere, during this turn of the event loop.
和模板表达式一样，模板语句使用的语言也像 JavaScript。 模板语句解析器和模板表达式解析器有所不同，特别之处在于它支持基本赋值 (=) 和表达式链 (; 和 ,)。
Like template expressions, template statements use a language that looks like JavaScript. The template statement parser differs from the template expression parser and specifically supports both basic assignment (=) and chaining expressions (with ; or ,).
然而，某些 JavaScript 语法仍然是不允许的：
However, certain JavaScript syntax is not allowed:
new运算符new自增和自减运算符：
++和--increment and decrement operators,
++and--操作并赋值，例如
+=和-=operator assignment, such as
+=and-=位操作符
|和&the bitwise operators
|and&
语句上下文
Statement context
和表达式中一样，语句只能引用语句上下文中 —— 通常是正在绑定事件的那个组件实例。
As with expressions, statements can refer only to what's in the statement context such as an event handling method of the component instance.
典型的语句上下文就是当前组件的实例。 (click)="deleteHero()" 中的 deleteHero 就是这个数据绑定组件上的一个方法。
The statement context is typically the component instance. The deleteHero in (click)="deleteHero()" is a method of the data-bound component.
<button (click)="deleteHero()">Delete hero</button>
语句上下文可以引用模板自身上下文中的属性。 在下面的例子中，就把模板的 $event 对象、模板输入变量 (let hero)和模板引用变量 (#heroForm)传给了组件中的一个事件处理器方法。
The statement context may also refer to properties of the template's own context. In the following examples, the template $event object, a template input variable (let hero), and a template reference variable (#heroForm) are passed to an event handling method of the component.
<button (click)="onSave($event)">Save</button>
<button *ngFor="let hero of heroes" (click)="deleteHero(hero)">{{hero.name}}</button>
<form #heroForm (ngSubmit)="onSubmit(heroForm)"> ... </form>
模板上下文中的变量名的优先级高于组件上下文中的变量名。在上面的 deleteHero(hero) 中，hero 是一个模板输入变量，而不是组件中的 hero 属性。
Template context names take precedence over component context names. In deleteHero(hero) above, the hero is the template input variable, not the component's hero property.
模板语句不能引用全局命名空间的任何东西。比如不能引用 window 或 document，也不能调用 console.log 或 Math.max。
Template statements cannot refer to anything in the global namespace. They can't refer to window or document. They can't call console.log or Math.max.
语句指南
Statement guidelines
和表达式一样，避免写复杂的模板语句。 常规是函数调用或者属性赋值。
As with expressions, avoid writing complex template statements. A method call or simple property assignment should be the norm.
现在，对模板表达式和语句有了一点感觉了吧。 除插值表达式外，还有各种各样的数据绑定语法，是学习它们是时候了。
Now that you have a feel for template expressions and statements, you're ready to learn about the varieties of data binding syntax beyond interpolation.
绑定语法：概览
Binding syntax: An overview
数据绑定是一种机制，用来协调用户所见和应用数据。 虽然你能往 HTML 推送值或者从 HTML 拉取值， 但如果把这些琐事交给数据绑定框架处理， 应用会更容易编写、阅读和维护。 只要简单地在绑定源和目标 HTML 元素之间声明绑定，框架就会完成这项工作。
Data binding is a mechanism for coordinating what users see, with application data values. While you could push values to and pull values from HTML, the application is easier to write, read, and maintain if you turn these chores over to a binding framework. You simply declare bindings between binding sources and target HTML elements and let the framework do the work.
Angular 提供了各种各样的数据绑定，本章将逐一讨论。 先从高层视角来看看 Angular 数据绑定及其语法。
Angular provides many kinds of data binding. This guide covers most of them, after a high-level view of Angular data binding and its syntax.
绑定的类型可以根据数据流的方向分成三类： 从数据源到视图、从视图到数据源以及双向的从视图到数据源再到视图。
Binding types can be grouped into three categories distinguished by the direction of data flow: from the source-to-view, from view-to-source, and in the two-way sequence: view-to-source-to-view:
数据方向 Data direction | 语法 Syntax | 绑定类型 Type |
|---|---|---|
单向 One-way |
| 插值表达式 Interpolation |
从视图到数据源的单向绑定 One-way |
| 事件 Event |
双向 Two-way |
| 双向 Two-way |
译注：由于 HTML attribute 和 DOM property 在中文中都被翻译成了“属性”，无法区分， 而接下来的部分重点是对它们进行比较。
我们无法改变历史，因此，在本章的翻译中，保留了它们的英文形式，不加翻译，以免混淆。 本章中，如果提到“属性”的地方，一定是指 property，因为在 Angular 中，实际上很少涉及 attribute。
但在其它章节中，为简单起见，凡是能通过上下文明显区分开的，就仍统一译为“属性”， 区分不明显的，会加注英文。
除了插值表达式之外的绑定类型，在等号左边是目标名， 无论是包在括号中 ([]、()) 还是用前缀形式 (bind-、on-、bindon-) 。
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-).
这个目标名就是属性（Property）的名字。它可能看起来像是元素属性（Attribute）的名字，但它不是。 要理解它们的不同点，你必须尝试用另一种方式来审视模板中的 HTML。
The target name is the name of a property. It may look like the name of an attribute but it never is. To appreciate the difference, you must develop a new way to think about template HTML.
新的思维模型
A new mental model
数据绑定的威力和允许用自定义标记扩展 HTML 词汇的能力，会让你把模板 HTML 当成 HTML+。
With all the power of data binding and the ability to extend the HTML vocabulary with custom markup, it is tempting to think of template HTML as HTML Plus.
它其实就是 HTML+。 但它也跟你曾使用的 HTML 有着显著的不同。 这里需要一种新的思维模型。
It really is HTML Plus. But it's also significantly different than the HTML you're used to. It requires a new mental model.
在正常的 HTML 开发过程中，你使用 HTML 元素来创建视觉结构， 通过把字符串常量设置到元素的 attribute 来修改那些元素。
In the normal course of HTML development, you create a visual structure with HTML elements, and you modify those elements by setting element attributes with string constants.
<div class="special">Mental Model</div>
<img src="assets/images/hero.png">
<button disabled>Save</button>
在 Angular 模板中，你仍使用同样的方式创建结构和初始化 attribute 值。
You still create a structure and initialize attribute values this way in Angular templates.
然后，用封装了 HTML 的组件创建新元素，并把它们当作原生 HTML 元素在模板中使用。
Then you learn to create new elements with components that encapsulate HTML and drop them into templates as if they were native HTML elements.
<!-- Normal HTML -->
<div class="special">Mental Model</div>
<!-- Wow! A new element! -->
<app-hero-detail></app-hero-detail>
这就是 HTML+。
That's HTML Plus.
现在开始学习数据绑定。你碰到的第一种数据绑定是这样的：
Then you learn about data binding. The first binding you meet might look like this:
<!-- Bind button disabled state to `isUnchanged` property -->
<button [disabled]="isUnchanged">Save</button>
过会儿再认识那个怪异的方括号记法。直觉告诉你，你正在绑定按钮的 disabled attribute。 并把它设置为组件的 isUnchanged 属性的当前值。
You'll get to that peculiar bracket notation in a moment. Looking beyond it, your intuition suggests that you're binding to the button's disabled attribute and setting it to the current value of the component's isUnchanged property.
但你的直觉是错的！日常的 HTML 思维模式在误导着你。 实际上，一旦开始数据绑定，就不再跟 HTML attribute 打交道了。 这里不是设置 attribute，而是设置 DOM 元素、组件和指令的 property。
Your intuition is incorrect! Your everyday HTML mental model is misleading. In fact, once you start data binding, you are no longer working with HTML attributes. You aren't setting attributes. You are setting the properties of DOM elements, components, and directives.
HTML attribute 与 DOM property 的对比
HTML attribute vs. DOM property
要想理解 Angular 绑定如何工作，重点是搞清 HTML attribute 和 DOM property 之间的区别。
The distinction between an HTML attribute and a DOM property is crucial to understanding how Angular binding works.
attribute 是由 HTML 定义的。property 是由 DOM (Document Object Model) 定义的。
Attributes are defined by HTML. Properties are defined by the DOM (Document Object Model).
少量 HTML attribute 和 property 之间有着 1:1 的映射，如
id。A few HTML attributes have 1:1 mapping to properties.
idis one example.有些 HTML attribute 没有对应的 property，如
colspan。Some HTML attributes don't have corresponding properties.
colspanis one example.有些 DOM property 没有对应的 attribute，如
textContent。Some DOM properties don't have corresponding attributes.
textContentis one example.大量 HTML attribute 看起来映射到了 property…… 但却不像你想的那样！
Many HTML attributes appear to map to properties ... but not in the way you might think!
最后一类尤其让人困惑…… 除非你能理解这个普遍原则：
That last category is confusing until you grasp this general rule:
attribute 初始化 DOM property，然后它们的任务就完成了。property 的值可以改变；attribute 的值不能改变。
Attributes initialize DOM properties and then they are done. Property values can change; attribute values can't.
例如，当浏览器渲染 <input type="text" value="Bob"> 时，它将创建相应 DOM 节点， 它的 value 这个 property 被初始化为 “Bob”。
For example, when the browser renders <input type="text" value="Bob">, it creates a corresponding DOM node with a value property initialized to "Bob".
当用户在输入框中输入 “Sally” 时，DOM 元素的 value 这个 property 变成了 “Sally”。 但是该 HTML 的 value 这个 attribute 保持不变。如果你读取 input 元素的 attribute，就会发现确实没变： input.getAttribute('value') // 返回 "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 you discover if you ask the input element about that attribute: input.getAttribute('value') returns "Bob".
HTML 的 value 这个 attribute 指定了初始值；DOM 的 value 这个 property 是当前值。
The HTML attribute value specifies the initial value; the DOM value property is the current value.
disabled 这个 attribute 是另一种特例。按钮的 disabled 这个 property 是 false，因为默认情况下按钮是可用的。 当你添加 disabled 这个 attribute 时，只要它出现了按钮的 disabled 这个 property 就初始化为 true，于是按钮就被禁用了。
The disabled attribute is another peculiar example. A button's disabled property is false by default so the button is enabled. When you add the disabled attribute, its presence alone initializes the button's disabled property to true so the button is disabled.
添加或删除 disabled 这个 attribute 会禁用或启用这个按钮。但 attribute 的值无关紧要，这就是你为什么没法通过 <button disabled="false">仍被禁用</button> 这种写法来启用按钮。
Adding and removing the disabled attribute disables and enables the button. The value of the attribute is irrelevant, which is why you cannot enable a button by writing <button disabled="false">Still Disabled</button>.
设置按钮的 disabled 这个 property（如，通过 Angular 绑定）可以禁用或启用这个按钮。 这就是 property 的价值。
Setting the button's disabled property (say, with an Angular binding) disables or enables the button. The value of the property matters.
就算名字相同，HTML attribute 和 DOM property 也不是同一样东西。
The HTML attribute and the DOM property are not the same thing, even when they have the same name.
这句话值得再强调一次： 模板绑定是通过 property 和事件来工作的，而不是 attribute。
This fact bears repeating: Template binding works with properties and events, not attributes.
在 Angular 的世界中，attribute 唯一的作用是用来初始化元素和指令的状态。 当进行数据绑定时，只是在与元素和指令的 property 和事件打交道，而 attribute 就完全靠边站了。
In the world of Angular, the only role of attributes is to initialize element and directive state. When you write a data binding, you're dealing exclusively with properties and events of the target object. HTML attributes effectively disappear.
把这个思维模型牢牢的印在脑子里，接下来，学习什么是绑定目标。
With this model firmly in mind, read on to learn about binding targets.
绑定目标
Binding targets
数据绑定的目标是 DOM 中的某些东西。 这个目标可能是（元素 | 组件 | 指令的）property、（元素 | 组件 | 指令的）事件，或(极少数情况下) attribute 名。 下面是的汇总表：
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:
绑定类型 Type | 目标 Target | 范例 Examples |
|---|---|---|
属性 Property | 元素的 property Element property |
|
事件 Event | 元素的事件 Element event |
|
双向 Two-way | 事件与 property Event and property |
|
Attribute | attribute（例外情况） Attribute (the exception) |
|
CSS 类 Class | |
|
样式 Style | |
|
放开眼界，来看看每种绑定类型的具体情况。
With this broad view in mind, you're ready to look at binding types in detail.
属性绑定 ( [属性名] )
Property binding ( [property] )
当要把视图元素的属性 (property) 设置为模板表达式时，就要写模板的属性 (property) 绑定。
Write a template property binding to set a property of a view element. The binding sets the property to the value of a template expression.
最常用的属性绑定是把元素属性设置为组件属性的值。 下面这个例子中，image 元素的 src 属性会被绑定到组件的 heroImageUrl 属性上：
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:
<img [src]="heroImageUrl">
另一个例子是当组件说它 isUnchanged（未改变）时禁用按钮：
Another example is disabling a button when the component says that it isUnchanged:
<button [disabled]="isUnchanged">Cancel is disabled</button>
另一个例子是设置指令的属性：
Another is setting a property of a directive:
<div [ngClass]="classes">[ngClass] binding to the classes property</div>
还有另一个例子是设置自定义组件的模型属性（这是父子组件之间通讯的重要途径）：
Yet another is setting the model property of a custom component (a great way for parent and child components to communicate):
<app-hero-detail [hero]="currentHero"></app-hero-detail>
单向输入
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.
不能使用属性绑定来从目标元素拉取值，也不能绑定到目标元素的属性来读取它。只能设置它。
You cannot use property binding to pull values out of the target element. You can't bind to a property of the target element to read it. You can only set it.
也不能使用属性 绑定 来调用目标元素上的方法。
Similarly, you cannot use property binding to call a method on the target element.
如果这个元素触发了事件，可以通过事件绑定来监听它们。
If the element raises events, you can listen to them with an event binding.
如果必须读取目标元素上的属性或调用它的某个方法，得用另一种技术。 参见 API 参考手册中的 ViewChild 和 ContentChild。
If you must read a target element property or call one of its methods, you'll need a different technique. See the API reference for ViewChild and ContentChild.
绑定目标
Binding target
包裹在方括号中的元素属性名标记着目标属性。下列代码中的目标属性是 image 元素的 src 属性。
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.
<img [src]="heroImageUrl">
有些人喜欢用 bind- 前缀的可选形式，并称之为规范形式：
Some people prefer the bind- prefix alternative, known as the canonical form:
<img bind-src="heroImageUrl">
目标的名字总是 property 的名字。即使它看起来和别的名字一样。 看到 src 时，可能会把它当做 attribute。不！它不是！它是 image 元素的 property 名。
The target name is always the name of a property, even when it appears to be the name of something else. You see src and may think it's the name of an attribute. No. It's the name of an image element property.
元素属性可能是最常见的绑定目标，但 Angular 会先去看这个名字是否是某个已知指令的属性名，就像下面的例子中一样：
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:
<div [ngClass]="classes">[ngClass] binding to the classes property</div>
严格来说，Angular 正在匹配指令的输入属性的名字。 这个名字是指令的 inputs 数组中所列的名字，或者是带有 @Input() 装饰器的属性。 这些输入属性被映射为指令自己的属性。
Technically, Angular is matching the name to a directive input, 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 就会报告“未知指令”的错误。
If the name fails to match a property of a known directive or element, Angular reports an “unknown directive” error.
消除副作用
Avoid side effects
正如以前讨论过的，模板表达式的计算不能有可见的副作用。表达式语言本身可以提供一部分安全保障。 不能在属性绑定表达式中对任何东西赋值，也不能使用自增、自减运算符。
As mentioned previously, evaluation of a template expression should have no visible side effects. The expression language itself does its part to keep you safe. You can't assign a value to anything in a property binding expression nor use the increment and decrement operators.
当然，表达式可能会调用具有副作用的属性或方法。但 Angular 没法知道这一点，也没法阻止你。
Of course, the expression might invoke a property or method that has side effects. Angular has no way of knowing that or stopping you.
表达式中可以调用像 getFoo() 这样的方法。只有你知道 getFoo() 干了什么。 如果 getFoo() 改变了某个东西，恰好又绑定到个这个东西，你就可能把自己坑了。 Angular 可能显示也可能不显示变化后的值。Angular 还可能检测到变化，并抛出警告型错误。 一般建议是，只绑定数据属性和那些只返回值而不做其它事情的方法。
The expression could call something like getFoo(). Only you know what getFoo() does. If getFoo() changes something and you happen to be binding to that something, you risk an unpleasant experience. Angular may or may not display the changed value. Angular may detect the change and throw a warning error. In general, stick to data properties and to methods that return values and do no more.
返回恰当的类型
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.
HeroDetail 组件的 hero 属性想要一个 Hero 对象，也就是你在属性绑定时发给它的那个：
The hero property of the HeroDetail component expects a Hero object, which is exactly what you're sending in the property binding:
<app-hero-detail [hero]="currentHero"></app-hero-detail>
别忘了方括号
Remember the brackets
方括号告诉 Angular 要计算模板表达式。 如果忘了加方括号，Angular 会把这个表达式当做字符串常量看待，并用该字符串来初始化目标属性。 它不会计算这个字符串。
The brackets tell Angular to evaluate the template expression. If you omit the brackets, Angular treats the string as a constant and initializes the target property with that string. It does not evaluate the string!
不要出现这样的失误：
Don't make the following mistake:
<!-- ERROR: HeroDetailComponent.hero expects a
Hero object, not the string "currentHero" -->
<app-hero-detail hero="currentHero"></app-hero-detail>
一次性字符串初始化
One-time string initialization
当满足下列条件时，应该省略括号：
You 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 you can bake into the template.
这个初始值永不改变。
This initial value never changes.
你经常这样在标准 HTML 中用这种方式初始化 attribute，这种方式也可以用在初始化指令和组件的属性。 下面这个例子把 HeroDetailComponent 的 prefix 属性初始化为固定的字符串，而不是模板表达式。Angular 设置它，然后忘记它。
You 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 about it.
<app-hero-detail prefix="You are my" [hero]="currentHero"></app-hero-detail>
作为对比，[hero] 绑定是组件的 currentHero 属性的活绑定，它会一直随着更新。
The [hero] binding, on the other hand, remains a live binding to the component's currentHero property.
属性绑定还是插值表达式？
Property binding or interpolation?
你通常得在插值表达式和属性绑定之间做出选择。 下列这几对绑定做的事情完全相同：
You often have a choice between interpolation and property binding. The following binding pairs do the same thing:
<p><img src="{{heroImageUrl}}"> is the <i>interpolated</i> image.</p>
<p><img [src]="heroImageUrl"> is the <i>property bound</i> image.</p>
<p><span>"{{title}}" is the <i>interpolated</i> title.</span></p>
<p>"<span [innerHTML]="title"></span>" is the <i>property bound</i> title.</p>
在多数情况下，插值表达式是更方便的备选项。
Interpolation is a convenient alternative to property binding in many cases.
当要渲染的数据类型是字符串时，没有技术上的理由证明哪种形式更好。 你倾向于可读性，所以倾向于插值表达式。 建议建立代码风格规则，选择一种形式， 这样，既遵循了规则，又能让手头的任务做起来更自然。
When rendering data values as strings, there is no technical reason to prefer one form to the other. You lean toward readability, which tends to favor interpolation. You suggest establishing coding style rules and choosing the form that both conforms to the rules and feels most natural for the task at hand.
但数据类型不是字符串时，就必须使用属性绑定了。
When setting an element property to a non-string data value, you must use property binding.
内容安全
Content security
假设下面的恶意内容
Imagine the following malicious content.
evilTitle = 'Template <script>alert("evil never sleeps")</script>Syntax';
幸运的是，Angular 数据绑定对危险 HTML 有防备。 在显示它们之前，它对内容先进行消毒。 不管是插值表达式还是属性绑定，都不会允许带有 script 标签的 HTML 泄漏到浏览器中。
Fortunately, Angular data binding is on alert for dangerous HTML. It sanitizes the values before displaying them. It will not allow HTML with script tags to leak into the browser, neither with interpolation nor property binding.
<!--
Angular generates warnings for these two lines as it sanitizes them
WARNING: sanitizing HTML stripped some content (see http://g.co/ng/security#xss).
-->
<p><span>"{{evilTitle}}" is the <i>interpolated</i> evil title.</span></p>
<p>"<span [innerHTML]="evilTitle"></span>" is the <i>property bound</i> evil title.</p>
插值表达式处理 script 标签与属性绑定有所不同，但是二者都只渲染没有危害的内容。
Interpolation handles the script tags differently than property binding but both approaches render the content harmlessly.
attribute、class 和 style 绑定
Attribute, class, and style bindings
模板语法为那些不太适合使用属性绑定的场景提供了专门的单向数据绑定形式。
The template syntax provides specialized one-way bindings for scenarios less well suited to property binding.
attribute 绑定
Attribute binding
可以通过attribute 绑定来直接设置 attribute 的值。
You can set the value of an attribute directly with an attribute binding.
这是“绑定到目标属性 (property)”这条规则中唯一的例外。这是唯一的能创建和设置 attribute 的绑定形式。
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。为什么 Angular 还提供了 attribute 绑定呢？
This guide stresses repeatedly 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 绑定。
You must use attribute binding when there is no element property to bind.
考虑 ARIA， SVG 和 table 中的 colspan/rowspan 等 attribute。 它们是纯粹的 attribute，没有对应的属性可供绑定。
Consider the ARIA, SVG, and table span attributes. They are pure attributes. They do not correspond to element properties, and they do not set element properties. There are no property targets to bind to.
如果想写出类似下面这样的东西，就会暴露出痛点了：
This fact becomes painfully obvious when you write something like this.
<tr><td colspan="{{1 + 1}}">Three-Four</td></tr>
会得到这个错误：
And you get this error:
Template parse errors:
Can't bind to 'colspan' since it isn't a known native property
正如提示中所说，<td> 元素没有 colspan 属性。 但是插值表达式和属性绑定只能设置属性，不能设置 attribute。
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.
你需要 attribute 绑定来创建和绑定到这样的 attribute。
You need attribute bindings to create and bind to such attributes.
attribute 绑定的语法与属性绑定类似。 但方括号中的部分不是元素的属性名，而是由attr前缀，一个点 (.) 和 attribute 的名字组成。 可以通过值为字符串的表达式来设置 attribute 的值。
Attribute binding syntax resembles property binding. Instead of an element property between brackets, start with the prefix attr, followed by a dot (.) and the name of the attribute. You then set the attribute value, using an expression that resolves to a string.
这里把 [attr.colspan] 绑定到一个计算值：
Bind [attr.colspan] to a calculated value:
<table border=1>
<!-- expression calculates colspan=2 -->
<tr><td [attr.colspan]="1 + 1">One-Two</td></tr>
<!-- ERROR: There is no `colspan` property to set!
<tr><td colspan="{{1 + 1}}">Three-Four</td></tr>
-->
<tr><td>Five</td><td>Six</td></tr>
</table>
这里是表格渲染出来的样子：
Here's how the table renders:
One-Two | |
Five | Six |
attribute 绑定的主要用例之一是设置 ARIA attribute（译注：ARIA 指可访问性，用于给残障人士访问互联网提供便利）， 就像这个例子中一样：
One of the primary use cases for attribute binding is to set ARIA attributes, as in this example:
<!-- create and set an aria attribute for assistive technology -->
<button [attr.aria-label]="actionName">{{actionName}} with Aria</button>
CSS 类绑定
Class binding
借助 CSS 类绑定，可以从元素的 class attribute 上添加和移除 CSS 类名。
You can add and remove CSS class names from an element's class attribute with a class binding.
CSS 类绑定绑定的语法与属性绑定类似。 但方括号中的部分不是元素的属性名，而是由class前缀，一个点 (.)和 CSS 类的名字组成， 其中后两部分是可选的。形如：[class.class-name]。
Class binding syntax resembles property binding. Instead of an element property between brackets, start with the prefix class, optionally followed by a dot (.) and the name of a CSS class: [class.class-name].
下列例子示范了如何通过 CSS 类绑定来添加和移除应用的 "special" 类。不用绑定直接设置 attribute 时是这样的：
The following examples show how to add and remove the application's "special" class with class bindings. Here's how to set the attribute without binding:
<!-- standard class attribute setting -->
<div class="bad curly special">Bad curly special</div>
可以把它改写为绑定到所需 CSS 类名的绑定；这是一个或者全有或者全无的替换型绑定。 （译注：即当 badCurly 有值时 class 这个 attribute 设置的内容会被完全覆盖）
You can replace that with a binding to a string of the desired class names; this is an all-or-nothing, replacement binding.
<!-- reset/override all class names with a binding -->
<div class="bad curly special"
[class]="badCurly">Bad curly</div>
最后，可以绑定到特定的类名。 当模板表达式的求值结果是真值时，Angular 会添加这个类，反之则移除它。
Finally, you can bind to a specific class name. Angular adds the class when the template expression evaluates to truthy. It removes the class when the expression is falsy.
<!-- toggle the "special" class on/off with a property -->
<div [class.special]="isSpecial">The class binding is special</div>
<!-- binding to `class.special` trumps the class attribute -->
<div class="special"
[class.special]="!isSpecial">This one is not so special</div>
虽然这是切换单一类名的好办法，但人们通常更喜欢使用 NgClass 指令 来同时管理多个类名。
While this is a fine way to toggle a single class name, the NgClass directive is usually preferred when managing multiple class names at the same time.
样式绑定
Style binding
通过样式绑定，可以设置内联样式。
You can set inline styles with a style binding.
样式绑定的语法与属性绑定类似。 但方括号中的部分不是元素的属性名，而由style前缀，一个点 (.)和 CSS 样式的属性名组成。 形如：[style.style-property]。
Style binding syntax resembles property binding. Instead of an element property between brackets, start with the prefix style, followed by a dot (.) and the name of a CSS style property: [style.style-property].
<button [style.color]="isSpecial ? 'red': 'green'">Red</button>
<button [style.background-color]="canSave ? 'cyan': 'grey'" >Save</button>
有些样式绑定中的样式带有单位。在这里，以根据条件用 “em” 和 “%” 来设置字体大小的单位。
Some style binding styles have a unit extension. The following example conditionally sets the font size in “em” and “%” units .
<button [style.font-size.em]="isSpecial ? 3 : 1" >Big</button>
<button [style.font-size.%]="!isSpecial ? 150 : 50" >Small</button>
虽然这是设置单一样式的好办法，但人们通常更喜欢使用 NgStyle 指令 来同时设置多个内联样式。
While this is a fine way to set a single style, the NgStyle directive is generally preferred when setting several inline styles at the same time.
注意，样式属性命名方法可以用中线命名法，像上面的一样 也可以用驼峰式命名法，如 fontSize。
Note that a style property name can be written in either dash-case, as shown above, or camelCase, such as fontSize.
事件绑定 ( (事件名) )
Event binding ( (event) )
前面遇到的绑定的数据流都是单向的：从组件到元素。
The bindings directives you've met so far flow data in one direction: from a 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 a component.
知道用户动作的唯一方式是监听某些事件，如按键、鼠标移动、点击和触摸屏幕。 可以通过 Angular 事件绑定来声明对哪些用户动作感兴趣。
The only way to know about a user action is to listen for certain events such as keystrokes, mouse movements, clicks, and touches. You declare your interest in user actions through Angular event binding.
事件绑定语法由等号左侧带圆括号的目标事件和右侧引号中的模板语句组成。 下面事件绑定监听按钮的点击事件。每当点击发生时，都会调用组件的 onSave() 方法。
Event binding syntax consists of a target event name within parentheses on the left of an equal sign, and a quoted template statement on the right. The following event binding listens for the button's click events, calling the component's onSave() method whenever a click occurs:
<button (click)="onSave()">Save</button>
目标事件
Target event
圆括号中的名称 —— 比如 (click) —— 标记出目标事件。在下面例子中，目标是按钮的 click 事件。
A name between parentheses — for example, (click) — identifies the target event. In the following example, the target is the button's click event.
<button (click)="onSave()">Save</button>
有些人更喜欢带 on- 前缀的备选形式，称之为规范形式：
Some people prefer the on- prefix alternative, known as the canonical form:
<button on-click="onSave()">On Save</button>
元素事件可能是更常见的目标，但 Angular 会先看这个名字是否能匹配上已知指令的事件属性，就像下面这个例子：
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:
<!-- `myClick` is an event on the custom `ClickDirective` -->
<div (myClick)="clickMessage=$event" clickable>click with myClick</div>
更多关于该 myClick 指令的解释，见给输入/输出属性起别名。
The myClick directive is further described in the section on aliasing input/output properties.
如果这个名字没能匹配到元素事件或已知指令的输出属性，Angular 就会报“未知指令”错误。
If the name fails to match an element event or an output property of a known directive, Angular reports an “unknown directive” error.
$event 和事件处理语句
$event and event handling statements
在事件绑定中，Angular 会为目标事件设置事件处理器。
In an event binding, Angular sets up an event handler for the target event.
当事件发生时，这个处理器会执行模板语句。 典型的模板语句通常涉及到响应事件执行动作的接收器，例如从 HTML 控件中取得值，并存入模型。
When the event is raised, the handler executes the template statement. The template statement typically involves a receiver, which performs an action in response to the event, such as storing a value from the HTML control into a model.
绑定会通过名叫 $event 的事件对象传递关于此事件的信息（包括数据值）。
The binding conveys information about the event, including data values, through an event object named $event.
事件对象的形态取决于目标事件。如果目标事件是原生 DOM 元素事件， $event 就是 DOM 事件对象，它有像 target 和 target.value 这样的属性。
The shape of the event object is determined by the target event. If the target event is a native DOM element event, then $event is a DOM event object, with properties such as target and target.value.
考虑这个范例：
Consider this example:
<input [value]="currentHero.name"
(input)="currentHero.name=$event.target.value" >
上面的代码在把输入框的 value 属性绑定到 name 属性。 要监听对值的修改，代码绑定到输入框的 input 事件。 当用户造成更改时，input 事件被触发，并在包含了 DOM 事件对象 ($event) 的上下文中执行这条语句。
This code sets the input box value property by binding to the name property. To listen for changes to the value, the code binds 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.
要更新 name 属性，就要通过路径 $event.target.value 来获取更改后的值。
To update the name property, the changed text is retrieved by following the path $event.target.value.
如果事件属于指令（回想一下，组件是指令的一种），那么 $event 具体是什么由指令决定。
If the event belongs to a directive (recall that components are directives), $event has whatever shape the directive decides to produce.
使用 EventEmitter 实现自定义事件
Custom events with EventEmitter
通常，指令使用 Angular EventEmitter 来触发自定义事件。 指令创建一个 EventEmitter 实例，并且把它作为属性暴露出来。 指令调用 EventEmitter.emit(payload) 来触发事件，可以传入任何东西作为消息载荷。 父指令通过绑定到这个属性来监听事件，并通过 $event 对象来访问载荷。
Directives typically raise custom events with an Angular EventEmitter. The 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, which can be anything. Parent directives listen for the event by binding to this property and accessing the payload through the $event object.
假设 HeroDetailComponent 用于显示英雄的信息，并响应用户的动作。 虽然 HeroDetailComponent 包含删除按钮，但它自己并不知道该如何删除这个英雄。 最好的做法是触发事件来报告“删除用户”的请求。
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：
Here are the pertinent excerpts from that HeroDetailComponent:
template: `
<div>
<img src="{{heroImageUrl}}">
<span [style.text-decoration]="lineThrough">
{{prefix}} {{hero?.name}}
</span>
<button (click)="delete()">Delete</button>
</div>`
// This component makes a request but it can't actually delete a hero.
deleteRequest = new EventEmitter<Hero>();
delete() {
this.deleteRequest.emit(this.hero);
}
组件定义了 deleteRequest 属性，它是 EventEmitter 实例。 当用户点击删除时，组件会调用 delete() 方法，让 EventEmitter 发出一个 Hero 对象。
The component defines a deleteRequest property that returns an EventEmitter. When the user clicks delete, the component invokes the delete() method, telling the EventEmitter to emit a Hero object.
现在，假设有个宿主的父组件，它绑定了 HeroDetailComponent 的 deleteRequest 事件。
Now imagine a hosting parent component that binds to the HeroDetailComponent's deleteRequest event.
<app-hero-detail (deleteRequest)="deleteHero($event)" [hero]="currentHero"></app-hero-detail>
当 deleteRequest 事件触发时，Angular 调用父组件的 deleteHero 方法， 在 $event 变量中传入要删除的英雄（来自 HeroDetail）。
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.
模板语句有副作用
Template statements have side effects
deleteHero 方法有副作用：它删除了一个英雄。 模板语句的副作用不仅没问题，反而正是所期望的。
The deleteHero method has a side effect: it deletes a hero. Template statement side effects are not just OK, but expected.
删除这个英雄会更新模型，还可能触发其它修改，包括向远端服务器的查询和保存。 这些变更通过系统进行扩散，并最终显示到当前以及其它视图中。
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.
双向数据绑定 ( [(...)] )
Two-way binding ( [(...)] )
你经常需要显示数据属性，并在用户作出更改时更新该属性。
You often want to both display a data property and update that property when the user makes changes.
在元素层面上，既要设置元素属性，又要监听元素事件变化。
On the element side that takes a combination of setting a specific element property and listening for an element change event.
Angular 为此提供一种特殊的双向数据绑定语法：[(x)]。 [(x)] 语法结合了属性绑定的方括号 [x] 和事件绑定的圆括号 (x)。
Angular offers a special two-way data binding syntax for this purpose, [(x)]. The [(x)] syntax combines the brackets of property binding, [x], with the parentheses of event binding, (x).
想象盒子里的香蕉来记住方括号套圆括号。
Visualize a banana in a box to remember that the parentheses go inside the brackets.
当一个元素拥有可以设置的属性 x 和对应的事件 xChange 时，解释 [(x)] 语法就容易多了。 下面的 SizerComponent 符合这个模式。它有 size 属性和配套的 sizeChange 事件：
The [(x)] syntax is easy to demonstrate when the element has a settable property called x and a corresponding event named xChange. Here's a SizerComponent that fits the pattern. It has a size value property and a companion sizeChange event:
- import { Component, EventEmitter, Input, Output } from '@angular/core';
-
- @Component({
- selector: 'app-sizer',
- template: `
- <div>
- <button (click)="dec()" title="smaller">-</button>
- <button (click)="inc()" title="bigger">+</button>
- <label [style.font-size.px]="size">FontSize: {{size}}px</label>
- </div>`
- })
- export class SizerComponent {
- @Input() size: number | string;
- @Output() sizeChange = new EventEmitter<number>();
-
- dec() { this.resize(-1); }
- inc() { this.resize(+1); }
-
- resize(delta: number) {
- this.size = Math.min(40, Math.max(8, +this.size + delta));
- this.sizeChange.emit(this.size);
- }
- }
size 的初始值是一个输入值，来自属性绑定。（译注：注意 size 前面的 @Input） 点击按钮，在最小/最大值范围限制内增加或者减少 size。 然后用调整后的 size 触发 sizeChange 事件。
The initial size is an input value from a property binding. Clicking the buttons increases or decreases the size, within min/max values constraints, and then raises (emits) the sizeChange event with the adjusted size.
下面的例子中，AppComponent.fontSize 被双向绑定到 SizerComponent：
Here's an example in which the AppComponent.fontSizePx is two-way bound to the SizerComponent:
<app-sizer [(size)]="fontSizePx"></app-sizer>
<div [style.font-size.px]="fontSizePx">Resizable Text</div>
SizerComponent.size 初始值是 AppComponent.fontSizePx。 点击按钮时，通过双向绑定更新 AppComponent.fontSizePx。 被修改的 AppComponent.fontSizePx 通过样式绑定，改变文本的显示大小。
The AppComponent.fontSizePx establishes the initial SizerComponent.size value. Clicking the buttons updates the AppComponent.fontSizePx via the two-way binding. The revised AppComponent.fontSizePx value flows through to the style binding, making the displayed text bigger or smaller.
双向绑定语法实际上是属性绑定和事件绑定的语法糖。 Angular 将 SizerComponent 的绑定分解成这样：
The two-way binding syntax is really just syntactic sugar for a property binding and an event binding. Angular desugars the SizerComponent binding into this:
<app-sizer [size]="fontSizePx" (sizeChange)="fontSizePx=$event"></app-sizer>
$event 变量包含了 SizerComponent.sizeChange 事件的荷载。 当用户点击按钮时，Angular 将 $event 赋值给 AppComponent.fontSizePx。
The $event variable contains the payload of the SizerComponent.sizeChange event. Angular assigns the $event value to the AppComponent.fontSizePx when the user clicks the buttons.
显然，比起单独绑定属性和事件，双向数据绑定语法显得非常方便。
Clearly the two-way binding syntax is a great convenience compared to separate property and event bindings.
如果能在像 <input> 和 <select> 这样的 HTML 元素上使用双向数据绑定就更好了。 可惜，原生 HTML 元素不遵循 x 值和 xChange 事件的模式。
It would be convenient to use two-way binding with HTML form elements like <input> and <select>. However, no native HTML element follows the x value and xChange event pattern.
幸运的是，Angular 以 NgModel 指令为桥梁，允许在表单元素上使用双向数据绑定。
Fortunately, the Angular NgModel directive is a bridge that enables two-way binding to form elements.
内置指令
Built-in directives
上一版本的 Angular 中包含了超过 70 个内置指令。 社区贡献了更多，这还没算为内部应用而创建的无数私有指令。
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 中不需要那么多指令。 使用更强大、更富有表现力的 Angular 绑定系统，其实可以达到同样的效果。 如果能用简单的绑定达到目的，为什么还要创建指令来处理点击事件呢？
You don't need many of those directives in Angular. You can often achieve the same results with the more capable and expressive Angular binding system. Why create a directive to handle a click when you can write a simple binding such as this?
<button (click)="onSave()">Save</button>
你仍然可以从简化复杂任务的指令中获益。 Angular 发布时仍然带有内置指令，只是没那么多了。 你仍会写自己的指令，只是没那么多了。
You still benefit from directives that simplify complex tasks. Angular still ships with built-in directives; just not as many. You'll write your own directives, just not as many.
下面来看一下那些最常用的内置指令。它们可分为属性型指令 或 结构型指令。
This segment reviews some of the most frequently used built-in directives, classified as either attribute directives or structural directives.
内置属性型指令
Built-in attribute directives
属性型指令会监听和修改其它 HTML 元素或组件的行为、元素属性（Attribute）、DOM 属性（Property）。 它们通常会作为 HTML 属性的名称而应用在元素上。
Attribute directives listen to and modify the behavior of other HTML elements, attributes, properties, and components. They are usually applied to elements as if they were HTML attributes, hence the name.
更多的细节参见属性型指令一章。 很多 NgModules，比如RouterModule和FormsModule都定义了自己的属性型指令。 本节将会介绍几个最常用的属性型指令：
Many details are covered in the Attribute Directives guide. Many NgModules such as the RouterModuleand the FormsModuledefine their own attribute directives. This section is an introduction to the most commonly used attribute directives:
NgClass- 添加或移除一组 CSS 类NgClass- add and remove a set of CSS classesNgStyle- 添加或移除一组 CSS 样式NgStyle- add and remove a set of HTML stylesNgModel- 双向绑定到 HTML 表单元素NgModel- two-way data binding to an HTML form element
NgClass
你经常用动态添加或删除 CSS 类的方式来控制元素如何显示。 通过绑定到 NgClass，可以同时添加或移除多个类。
You typically control how elements appear by adding and removing CSS classes dynamically. You can bind to the ngClass to add or remove several classes simultaneously.
CSS 类绑定 是添加或删除单个类的最佳途径。
A class binding is a good way to add or remove a single class.
<!-- toggle the "special" class on/off with a property -->
<div [class.special]="isSpecial">The class binding is special</div>
当想要同时添加或移除多个 CSS 类时，NgClass 指令可能是更好的选择。
To add or remove many CSS classes at the same time, the NgClass directive may be the better choice.
试试把 ngClass 绑定到一个 key:value 形式的控制对象。这个对象中的每个 key 都是一个 CSS 类名，如果它的 value 是 true，这个类就会被加上，否则就会被移除。
Try binding ngClass 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.
组件方法 setCurrentClasses 可以把组件的属性 currentClasses 设置为一个对象，它将会根据三个其它组件的状态为 true 或 false 而添加或移除三个类。
Consider a setCurrentClasses component method that sets a component property, currentClasses with an object that adds or removes three classes based on the true/false state of three other component properties:
currentClasses: {};
setCurrentClasses() {
// CSS classes: added/removed per current state of component properties
this.currentClasses = {
'saveable': this.canSave,
'modified': !this.isUnchanged,
'special': this.isSpecial
};
}
把 NgClass 属性绑定到 currentClasses，根据它来设置此元素的 CSS 类：
Adding an ngClass property binding to currentClasses sets the element's classes accordingly:
<div [ngClass]="currentClasses">This div is initially saveable, unchanged, and special</div>
你既可以在初始化时调用 setCurrentClasses()，也可以在所依赖的属性变化时调用。
It's up to you to call setCurrentClasses(), both initially and when the dependent properties change.
NgStyle
你可以根据组件的状态动态设置内联样式。 NgStyle 绑定可以同时设置多个内联样式。
You can set inline styles dynamically, based on the state of the component. With NgStyle you can set many inline styles simultaneously.
样式绑定是设置单一样式值的简单方式。
A style binding is an easy way to set a single style value.
<div [style.font-size]="isSpecial ? 'x-large' : 'smaller'" >
This div is x-large or smaller.
</div>
如果要同时设置多个内联样式，NgStyle 指令可能是更好的选择。
To set many inline styles at the same time, the NgStyle directive may be the better choice.
NgStyle 需要绑定到一个 key:value 控制对象。 对象的每个 key 是样式名，它的 value 是能用于这个样式的任何值。
Try binding ngStyle to a key:value control object. Each key of the object is a style name; its value is whatever is appropriate for that style.
来看看组件的 setCurrentStyles 方法，它会根据另外三个属性的状态把组件的 currentStyles 属性设置为一个定义了三个样式的对象：
Consider a setCurrentStyles component method that sets a component property, currentStyles with an object that defines three styles, based on the state of three other component properties:
currentStyles: {};
setCurrentStyles() {
// CSS styles: set per current state of component properties
this.currentStyles = {
'font-style': this.canSave ? 'italic' : 'normal',
'font-weight': !this.isUnchanged ? 'bold' : 'normal',
'font-size': this.isSpecial ? '24px' : '12px'
};
}
把 ngStyle 属性绑定到 currentStyles，来根据它设置此元素的样式：
Adding an ngStyle property binding to currentStyles sets the element's styles accordingly:
<div [ngStyle]="currentStyles">
This div is initially italic, normal weight, and extra large (24px).
</div>
你既可以在初始化时调用 setCurrentStyles()，也可以在所依赖的属性变化时调用。
It's up to you to call setCurrentStyles(), both initially and when the dependent properties change.
NgModel - 使用[(ngModel)]双向绑定到表单元素
NgModel - Two-way binding to form elements with [(ngModel)]
当开发数据输入表单时，你通常都要既显示数据属性又根据用户的更改去修改那个属性。
When developing data entry forms, you often both display a data property and update that property when the user makes changes.
使用 NgModel 指令进行双向数据绑定可以简化这种工作。例子如下：
Two-way data binding with the NgModel directive makes that easy. Here's an example:
<input [(ngModel)]="currentHero.name">
使用 ngModel 时需要 FormsModule
FormsModule is required to use ngModel
在使用 ngModel 指令进行双向数据绑定之前，你必须导入 FormsModule 并把它添加到 NgModule 的 imports 列表中。 要了解 FormsModule 和 ngModel 的更多知识，参见表单一章。
Before using the ngModel directive in a two-way data binding, you must import the FormsModule and add it to the NgModule's imports list. Learn more about the FormsModule and ngModel in the Forms guide.
导入 FormsModule 并让 [(ngModel)] 可用的代码如下：
Here's how to import the FormsModule to make [(ngModel)] available.
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms'; // <--- JavaScript import from Angular
/* Other imports */
@NgModule({
imports: [
BrowserModule,
FormsModule // <--- import into the NgModule
],
/* Other module metadata */
})
export class AppModule { }
[(ngModel)]内幕
Inside [(ngModel)]
回头看看 name 绑定，注意，你可以通过分别绑定到 <input> 元素的 value 属性和 input 事件来达到同样的效果。
Looking back at the name binding, note that you could have achieved the same result with separate bindings to the <input> element's value property and input event.
<input [value]="currentHero.name"
(input)="currentHero.name=$event.target.value" >
那样显得很笨重，谁会记得该设置哪个元素属性以及当用户修改时触发哪个事件？ 你该如何提取输入框中的文本并且更新数据属性？谁会希望每次都去查资料来确定这些？
That's cumbersome. Who can remember which element property to set and which element event emits user changes? How do you extract the currently displayed text from the input box so you can update the data property? Who wants to look that up each time?
ngModel 指令通过自己的输入属性 ngModel 和输出属性 ngModelChange 隐藏了那些细节。
That ngModel directive hides these onerous details behind its own ngModel input and ngModelChange output properties.
<input
[ngModel]="currentHero.name"
(ngModelChange)="currentHero.name=$event">
ngModel 输入属性会设置该元素的值，并通过 ngModelChange 的输出属性来监听元素值的变化。
The ngModel data property sets the element's value property and the ngModelChange event property listens for changes to the element's value.
各种元素都有很多特有的处理细节，因此 NgModel 指令只支持实现了ControlValueAccessor的元素， 它们能让元素适配本协议。 <input> 输入框正是其中之一。 Angular 为所有的基础 HTML 表单都提供了值访问器（Value accessor），表单一章展示了如何绑定它们。
The details are specific to each kind of element and therefore the NgModel directive only works for an element supported by a ControlValueAccessor that adapts an element to this protocol. The <input> box is one of those elements. Angular provides value accessors for all of the basic HTML form elements and the Forms guide shows how to bind to them.
你不能把 [(ngModel)] 用到非表单类的原生元素或第三方自定义组件上，除非写一个合适的值访问器，这种技巧超出了本章的范围。
You can't apply [(ngModel)] to a non-form native element or a third-party custom component until you write a suitable value accessor, a technique that is beyond the scope of this guide.
你自己写的 Angular 组件不需要值访问器，因为你可以让值和事件的属性名适应 Angular 基本的双向绑定语法，而不使用 NgModel。 前面看过的 sizer就是使用这种技巧的例子。
You don't need a value accessor for an Angular component that you write because you can name the value and event properties to suit Angular's basic two-way binding syntax and skip NgModel altogether. The sizer shown above is an example of this technique.
使用独立的 ngModel 绑定优于绑定到该元素的原生属性，你可以做得更好。
Separate ngModel bindings is an improvement over binding to the element's native properties. You can do better.
你不用被迫两次引用这个数据属性，Angular 可以捕获该元素的数据属性，并且通过一个简单的声明来设置它，这样它就可以使用 [(ngModel)] 语法了。
You 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, which it can with the [(ngModel)] syntax:
<input [(ngModel)]="currentHero.name">
[(ngModel)] 就是你需要的一切吗？有没有什么理由回退到它的展开形式？
Is [(ngModel)] all you need? Is there ever a reason to fall back to its expanded form?
[(ngModel)] 语法只能设置数据绑定属性。 如果要做更多或者做点不一样的事，也可以写它的展开形式。
The [(ngModel)] syntax can only set a data-bound property. If you need to do something more or something different, you can write the expanded form.
下面这个生造的例子强制输入框的内容变成大写：
The following contrived example forces the input value to uppercase:
<input
[ngModel]="currentHero.name"
(ngModelChange)="setUppercaseName($event)">
这里是所有这些变体的动画，包括这个大写转换的版本：
Here are all variations in action, including the uppercase version:
内置结构型指令
Built-in structural directives
结构型指令的职责是 HTML 布局。 它们塑造或重塑 DOM 的结构，这通常是通过添加、移除和操纵它们所附加到的宿主元素来实现的。
Structural directives are responsible for HTML layout. They shape or reshape the DOM's structure, typically by adding, removing, and manipulating the host elements to which they are attached.
关于结构型指令的详情参见结构型指令一章，在那里你将学到：
The deep details of structural directives are covered in the Structural Directives guide where you'll learn:
当没有合适的宿主元素放置指令时，可用
<ng-container>对元素进行分组。to use
<ng-container>to group elements when there is no suitable host element for the directive.如何写自己的结构型指令。
how to write your own structural directive.
你只能往一个元素上应用一个结构型指令。
that you can only apply one structural directive to an element.
本节是对常见结构型指令的简介：
This section is an introduction to the common structural directives:
NgIf- 根据条件把一个元素添加到 DOM 中或从 DOM 移除NgIf- conditionally add or remove an element from the DOMNgSwitch一组指令，用来在多个可选视图之间切换。NgSwitch- a set of directives that switch among alternative viewsNgForOf - 对列表中的每个条目重复套用同一个模板
NgForOf - repeat a template for each item in a list
NgIf
通过把 NgIf 指令应用到元素上（称为宿主元素），你可以往 DOM 中添加或从 DOM 中移除这个元素。 在下面的例子中，该指令绑定到了类似于 isActive 这样的条件表达式。
You can add or remove an element from the DOM by applying an NgIf directive to that element (called the host element). Bind the directive to a condition expression like isActive in this example.
<app-hero-detail *ngIf="isActive"></app-hero-detail>
当 isActive 表达式返回真值时，NgIf 把 HeroDetailComponent 添加到 DOM 中；为假时，NgIf 会从 DOM 中移除 HeroDetailComponent，并销毁该组件及其所有子组件。
When the isActive expression returns a truthy value, NgIf adds the HeroDetailComponent to the DOM. When the expression is falsy, NgIf removes the HeroDetailComponent from the DOM, destroying that component and all of its sub-components.
这和显示/隐藏不是一回事
Show/hide is not the same thing
You can control the visibility of an element with a class or style binding:
<!-- isSpecial is true -->
<div [class.hidden]="!isSpecial">Show with class</div>
<div [class.hidden]="isSpecial">Hide with class</div>
<!-- HeroDetail is in the DOM but hidden -->
<app-hero-detail [class.hidden]="isSpecial"></app-hero-detail>
<div [style.display]="isSpecial ? 'block' : 'none'">Show with style</div>
<div [style.display]="isSpecial ? 'none' : 'block'">Hide with style</div>
但隐藏子树和用 NgIf 排除子树是截然不同的。
Hiding an element is quite different from removing an element with NgIf.
当隐藏子树时，它仍然留在 DOM 中。 子树中的组件及其状态仍然保留着。 即使对于不可见属性，Angular 也会继续检查变更。 子树可能占用相当可观的内存和运算资源。
When you hide an element, that element and all of its descendents remain in the DOM. All components for those elements stay in memory and Angular may continue to check for changes. You could be holding onto considerable computing resources and degrading performance, for something the user can't see.
当 NgIf 为 false 时，Angular 从 DOM 中物理地移除了这个元素子树。 它销毁了子树中的组件及其状态，也潜在释放了可观的资源，最终让用户体验到更好的性能。
When NgIf is false, Angular removes the element and its descendents from the DOM. It destroys their components, potentially freeing up substantial resources, resulting in a more responsive user experience.
显示/隐藏的技术对于只有少量子元素的元素是很好用的，但要当心别试图隐藏大型组件树。相比之下，NgIf 则是个更安全的选择。
The show/hide technique is fine for a few elements with few children. You should be wary when hiding large component trees; NgIf may be the safer choice.
防范空指针错误
Guard against null
ngIf 指令通常会用来防范空指针错误。 而显示/隐藏的方式是无法防范的，当一个表达式尝试访问空值的属性时，Angular 就会抛出一个异常。
The ngIf directive is often used to guard against null. Show/hide is useless as a guard. Angular will throw an error if a nested expression tries to access a property of null.
这里我们用 NgIf 来保护了两个 <div> 防范空指针错误。 currentHero 的名字只有当存在 currentHero 时才会显示出来。 而 nullHero 永远不会显示。
Here we see NgIf guarding two <div>s. The currentHero name will appear only when there is a currentHero. The nullHero will never be displayed.
<div *ngIf="currentHero">Hello, {{currentHero.name}}</div>
<div *ngIf="nullHero">Hello, {{nullHero.name}}</div>
参见稍后的安全导航操作符部分。
See also the safe navigation operator described below.
NgForOf
NgFor 是一个重复器指令 —— 自定义数据显示的一种方式。 你的目标是展示一个由多个条目组成的列表。首先定义了一个 HTML 块，它规定了单个条目应该如何显示。 再告诉 Angular 把这个块当做模板，渲染列表中的每个条目。
NgForOf is a repeater directive — a way to present a list of items. You define a block of HTML that defines how a single item should be displayed. You tell Angular to use that block as a template for rendering each item in the list.
下例中，NgFor 应用在一个简单的 <div> 上：
Here is an example of NgForOf applied to a simple <div>:
<div *ngFor="let hero of heroes">{{hero.name}}</div>
也可以把 NgForOf 应用在一个组件元素上，就下例这样：
You can also apply an NgForOf to a component element, as in this example:
<app-hero-detail *ngFor="let hero of heroes" [hero]="hero"></app-hero-detail>
赋值给 *ngFor 的文本是用于指导重复器如何工作的指令。
The text assigned to *ngFor is the instruction that guides the repeater process.
NgFor 微语法
*ngFor microsyntax
赋值给 *ngFor 的字符串不是模板表达式。 它是一个微语法 —— 由 Angular 自己解释的小型语言。在这个例子中，字符串 "let hero of heroes" 的含义是：
The string assigned to *ngFor is not a template expression. It's a microsyntax — a little language of its own that Angular interprets. The string "let hero of heroes" means:
取出
heroes数组中的每个英雄，把它存入局部变量hero中，并在每次迭代时对模板 HTML 可用Take each hero in the
heroesarray, store it in the localherolooping variable, and make it available to the templated HTML for each iteration.
Angular 把这个指令翻译成了一个 <ng-template> 包裹的宿主元素，然后使用这个模板重复创建出一组新元素，并且绑定到列表中的每一个 hero。
Angular translates this instruction into a <ng-template> around the host element, then uses this template repeatedly to create a new set of elements and bindings for each hero in the list.
要了解微语法的更多知识，参见结构型指令一章。
Learn about the microsyntax in the Structural Directives guide.
模板输入变量
Template input variables
hero 前的 let 关键字创建了一个名叫 hero 的模板输入变量。 ngFor 指令在由父组件的 heroes 属性返回的 heroes 数组上迭代，每次迭代都从数组中把当前元素赋值给 hero 变量。
The let keyword before hero creates a template input variable called hero. The NgForOf directive iterates over the heroes array returned by the parent component's heroes property and sets hero to the current item from the array during each iteration.
你可以在 ngFor 的宿主元素（及其子元素）中引用模板输入变量 hero，从而访问该英雄的属性。 这里的第一个语句示范了如何在一个插值表达式中引用它，第二个语句则示范了如何用一个输入绑定把它传给 <hero-detail> 组件的 hero 属性。
You reference the hero input variable within the NgForOf host element (and within its descendants) to access the hero's properties. Here it is referenced first in an interpolation and then passed in a binding to the hero property of the <hero-detail> component.
<div *ngFor="let hero of heroes">{{hero.name}}</div>
<app-hero-detail *ngFor="let hero of heroes" [hero]="hero"></app-hero-detail>
要了解更多模板输入变量的知识，参见结构型指令一章。
Learn more about template input variables in the Structural Directives guide.
带索引的 *ngFor
*ngFor with index
NgFor 指令上下文中的 index 属性返回一个从零开始的索引，表示当前条目在迭代中的顺序。 你可以通过模板输入变量捕获这个 index 值，并把它用在模板中。
The index property of the NgForOf directive context returns the zero-based index of the item in each iteration. You can capture the index in a template input variable and use it in the template.
下面这个例子把 index 捕获到了 i 变量中，并且把它显示在英雄名字的前面。
The next example captures the index in a variable named i and displays it with the hero name like this.
<div *ngFor="let hero of heroes; let i=index">{{i + 1}} - {{hero.name}}</div>
要学习更多的类似 index 的值，例如 last、even 和 odd，请参阅 NgFor API 参考。
NgFor is implemented by the NgForOf directive. Read more about the other NgForOf context values such as last, even, and odd in the NgForOf API reference.
带 trackBy 的 *ngFor
*ngFor with trackBy
ngFor 指令有时候会性能较差，特别是在大型列表中。 对一个条目的一丁点改动、移除或添加，都会导致级联的 DOM 操作。
The NgForOf directive may 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.
例如，重新从服务器查询可以刷新包括所有新英雄在内的英雄列表。
For example, re-querying the server could reset the list with all new hero objects.
他们中的绝大多数（如果不是所有的话）都是以前显示过的英雄。你知道这一点，是因为每个英雄的 id 没有变化。 但在 Angular 看来，它只是一个由新的对象引用构成的新列表， 它没有选择，只能清理旧列表、舍弃那些 DOM 元素，并且用新的 DOM 元素来重建一个新列表。
Most, if not all, are previously displayed heroes. You 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 DOM elements and insert all new DOM elements.
如果给它指定一个 trackBy，Angular 就可以避免这种折腾。 往组件中添加一个方法，它会返回 NgFor应该追踪的值。 在这里，这个值就是英雄的 id。
Angular can avoid this churn with trackBy. Add a method to the component that returns the value NgForOf should track. In this case, that value is the hero's id.
trackByHeroes(index: number, hero: Hero): number { return hero.id; }
在微语法中，把 trackBy 设置为该方法。
In the microsyntax expression, set trackBy to this method.
<div *ngFor="let hero of heroes; trackBy: trackByHeroes">
({{hero.id}}) {{hero.name}}
</div>
这里展示了 trackBy 的效果。 "Reset heroes"会创建一个具有相同 hero.id 的新英雄。 "Change ids"则会创建一个具有新 hero.id 的新英雄。
Here is an illustration of the trackBy effect. "Reset heroes" creates new heroes with the same hero.ids. "Change ids" creates new heroes with new hero.ids.
如果没有
trackBy，这些按钮都会触发完全的 DOM 元素替换。With no
trackBy, both buttons trigger complete DOM element replacement.有了
trackBy，则只有修改了id的按钮才会触发元素替换。With
trackBy, only changing theidtriggers element replacement.
NgSwitch 指令
The NgSwitch directives
NgSwitch 指令类似于 JavaScript 的 switch 语句。 它可以从多个可能的元素中根据switch 条件来显示某一个。 Angular 只会把选中的元素放进 DOM 中。
NgSwitch is like the JavaScript switch statement. It can display one element from among several possible elements, based on a switch condition. Angular puts only the selected element into the DOM.
NgSwitch 实际上包括三个相互协作的指令：NgSwitch、NgSwitchCase 和 NgSwitchDefault，例子如下：
NgSwitch is actually a set of three, cooperating directives: NgSwitch, NgSwitchCase, and NgSwitchDefault as seen in this example.
<div [ngSwitch]="currentHero.emotion">
<app-happy-hero *ngSwitchCase="'happy'" [hero]="currentHero"></app-happy-hero>
<app-sad-hero *ngSwitchCase="'sad'" [hero]="currentHero"></app-sad-hero>
<app-confused-hero *ngSwitchCase="'confused'" [hero]="currentHero"></app-confused-hero>
<app-unknown-hero *ngSwitchDefault [hero]="currentHero"></app-unknown-hero>
</div>
NgSwitch 是主控指令，要把它绑定到一个返回候选值的表达式。 本例子中的 emotion 是个字符串，但实际上这个候选值可以是任意类型。
NgSwitch is the controller directive. Bind it to an expression that returns the switch value. The emotion value in this example is a string, but the switch value can be of any type.
绑定到 [ngSwitch]。如果试图用 *ngSwitch 的形式使用它就会报错，这是因为 NgSwitch 是一个属性型指令，而不是结构型指令。 它要修改的是所在元素的行为，而不会直接接触 DOM 结构。
Bind to [ngSwitch]. You'll get an error if you try to set *ngSwitch because NgSwitch is an attribute directive, not a structural directive. It changes the behavior of its companion directives. It doesn't touch the DOM directly.
绑定到 *ngSwitchCase 和 *ngSwitchDefault NgSwitchCase 和 NgSwitchDefault 指令都是结构型指令，因为它们会从 DOM 中添加或移除元素。
Bind to *ngSwitchCase and *ngSwitchDefault. The NgSwitchCase and NgSwitchDefault directives are structural directives because they add or remove elements from the DOM.
NgSwitchCase会在它绑定到的值等于候选值时，把它所在的元素加入到 DOM 中。NgSwitchCaseadds its element to the DOM when its bound value equals the switch value.NgSwitchDefault会在没有任何一个NgSwitchCase被选中时把它所在的元素加入 DOM 中。NgSwitchDefaultadds its element to the DOM when there is no selectedNgSwitchCase.
这组指令在要添加或移除组件元素时会非常有用。 这个例子会在 hero-switch.components.ts 中定义的四个“感人英雄”组件之间选择。 每个组件都有一个输入属性hero，它绑定到父组件的 currentHero 上。
The switch directives are particularly useful for adding and removing component elements. This example switches among four "emotional hero" components defined in the hero-switch.components.ts file. Each component has a hero input property which is bound to the currentHero of the parent component.
这组指令在原生元素和Web Component上都可以正常工作。 比如，你可以把 <confused-hero> 分支改成这样：
Switch directives work as well with native elements and web components too. For example, you could replace the <confused-hero> switch case with the following.
<div *ngSwitchCase="'confused'">Are you as confused as {{currentHero.name}}?</div>
模板引用变量 ( #var )
Template reference variables ( #var )
模板引用变量通常用来引用模板中的某个 DOM 元素，它还可以引用 Angular 组件或指令或Web Component。
A template reference variable is often a reference to a DOM element within a template. It can also be a reference to an Angular component or directive or a web component.
使用井号 (#) 来声明引用变量。 #phone 的意思就是声明一个名叫 phone 的变量来引用 <input> 元素。
Use the hash symbol (#) to declare a reference variable. The #phone declares a phone variable on an <input> element.
<input #phone placeholder="phone number">
你可以在模板中的任何地方引用模板引用变量。 比如声明在 <input> 上的 phone 变量就是在模板另一侧的 <button> 上使用的。
You can refer to a template reference variable anywhere in the template. The phone variable declared on this <input> is consumed in a <button> on the other side of the template
<input #phone placeholder="phone number">
<!-- lots of other elements -->
<!-- phone refers to the input element; pass its `value` to an event handler -->
<button (click)="callPhone(phone.value)">Call</button>
模板引用变量怎么得到它的值？
How a reference variable gets its value
大多数情况下，Angular 会把模板引用变量的值设置为声明它的那个元素。 在上一个例子中，phone 引用的是表示电话号码的 <input> 框。 "拨号"按钮的点击事件处理器把这个 input 值传给了组件的 callPhone 方法。 不过，指令也可以修改这种行为，让这个值引用到别处，比如它自身。 NgForm 指令就是这么做的。
In most cases, Angular sets the reference variable's value to the element on which it was declared. In the previous example, phone refers to the phone number <input> box. The phone button click handler passes the input value to the component's callPhone method. But a directive can change that behavior and set the value to something else, such as itself. The NgForm directive does that.
下面是表单一章中表单范例的简化版。
The following is a simplified version of the form example in the Forms guide.
<form (ngSubmit)="onSubmit(heroForm)" #heroForm="ngForm">
<div class="form-group">
<label for="name">Name
<input class="form-control" name="name" required [(ngModel)]="hero.name">
</label>
</div>
<button type="submit" [disabled]="!heroForm.form.valid">Submit</button>
</form>
<div [hidden]="!heroForm.form.valid">
{{submitMessage}}
</div>
模板引用变量 heroForm 在这个例子中出现了三次，中间隔着一大堆 HTML。 heroForm 的值是什么？
A template reference variable, heroForm, appears three times in this example, separated by a large amount of HTML. What is the value of heroForm?
如果你没有导入过 FormsModule，Angular 就不会控制这个表单，那么它就是一个HTMLFormElement实例。 这里的 heroForm 实际上是一个 Angular NgForm 指令的引用， 因此具备了跟踪表单中的每个控件的值和有效性的能力。
If Angular hadn't taken it over when you imported the FormsModule, it would be the HTMLFormElement. The heroForm is actually a reference to an Angular NgForm directive with the ability to track the value and validity of every control in the form.
原生的 <form> 元素没有 form 属性，但 NgForm 指令有。这就解释了为何当 heroForm.form.valid 是无效时你可以禁用提交按钮， 并能把整个表单控件树传给父组件的 onSubmit 方法。
The native <form> element doesn't have a form property. But the NgForm directive does, which explains how you can disable the submit button if the heroForm.form.valid is invalid and pass the entire form control tree to the parent component's onSubmit method.
关于模板引用变量的注意事项
Template reference variable warning notes
模板引用变量 (#phone) 和*ngFor部分看到过的模板输入变量 (let phone) 是不同的。 要了解详情，参见结构型指令一章。
A template reference variable (#phone) is not the same as a template input variable (let phone) such as you might see in an *ngFor. Learn the difference in the Structural Directives guide.
模板引用变量的作用范围是整个模板。 不要在同一个模板中多次定义同一个变量名，否则它在运行期间的值是无法确定的。
The scope of a reference variable is the entire template. Do not define the same variable name more than once in the same template. The runtime value will be unpredictable.
你也可以用 ref- 前缀代替 #。 下面的例子中就用把 fax 变量声明成了 ref-fax 而不是 #fax。
You can use the ref- prefix alternative to #. This example declares the fax variable as ref-fax instead of #fax.
<input ref-fax placeholder="fax number">
<button (click)="callFax(fax.value)">Fax</button>
输入和输出属性
Input and Output properties
输入属性是一个带有 @Input 装饰器的可设置属性。当它通过属性绑定的形式被绑定时，值会“流入”这个属性。
An Input property is a settable property annotated with an @Input decorator. Values flow into the property when it is data bound with a property binding
输出属性是一个带有 @Output 装饰器的可观察对象型的属性。 这个属性几乎总是返回 Angular 的EventEmitter。 当它通过事件绑定的形式被绑定时，值会“流出”这个属性。
An Output property is an observable property annotated with an @Output decorator. The property almost always returns an Angular EventEmitter. Values flow out of the component as events bound with an event binding.
你只能通过它的输入和输出属性将其绑定到其它组件或指令。
You can only bind to another component or directive through its Input and Output properties.
记住，所有的组件都是指令。
Remember that all components are directives.
为简洁起见，以下讨论会涉及到组件，因为这个主题主要是组件作者所关心的问题。
The following discussion refers to components for brevity and because this topic is mostly a concern for component authors.
讨论
Discussion
在下面的例子中，iconUrl 和 onSave 是组件的成员，它们在 = 右侧引号语法中被引用了。
You are usually binding a template to its own component class. In such binding expressions, the component's property or method is to the right of the (=).
<img [src]="iconUrl"/>
<button (click)="onSave()">Save</button>
iconUrl 和 onSave 是 AppComponent 类的成员。但它们并没有带 @Input() 或 @Output() 装饰器。 Angular 不在乎。
The iconUrl and onSave are members of the AppComponent class. They are not decorated with @Input() or @Output. Angular does not object.
你总是可以在组件自己的模板中绑定到组件的公共属性，而不用管它们是否输入（Input）属性或输出（Output）属性。
You can always bind to a public property of a component in its own template. It doesn't have to be an Input or Output property
这是因为组件类和模板是紧耦合的，它们是同一个东西的两个部分，合起来构成组件。 组件类及其模板之间的交互属于实现细节。
A component's class and template are closely coupled. They are both parts of the same thing. Together they are the component. Exchanges between a component class and its template are internal implementation details.
绑定到其它组件
Binding to a different component
你也可以绑定到其它组件的属性。 这种绑定形式下，其它组件的属性位于等号（=）的左侧。
You can also bind to a property of a different component. In such bindings, the other component's property is to the left of the (=).
下面的例子中，AppComponent 的模板把 AppComponent 类的成员绑定到了 HeroDetailComponent（选择器为 'app-hero-detail'） 的属性上。
In the following example, the AppComponent template binds AppComponent class members to properties of the HeroDetailComponent whose selector is 'app-hero-detail'.
<app-hero-detail [hero]="currentHero" (deleteRequest)="deleteHero($event)">
</app-hero-detail>
Angular 的编译器可能会对这些绑定报错，就像这样：
The Angular compiler may reject these bindings with errors like this one:
Uncaught Error: Template parse errors:
Can't bind to 'hero' since it isn't a known property of 'app-hero-detail'
你自己知道 HeroDetailComponent 有两个属性 hero 和 detectRequest，但 Angular 编译器并不知道。
You know that HeroDetailComponent has hero and deleteRequest properties. But the Angular compiler refuses to recognize them.
Angular 编译器不会绑定到其它组件的属性上 —— 除非这些属性是输入或输出属性。
The Angular compiler won't bind to properties of a different component unless they are Input or Output properties.
这条规则是有充分理由的。
There's a good reason for this rule.
组件绑定到它自己的属性当然没问题。 该组件的作者对这些绑定有完全的控制权。
It's OK for a component to bind to its own properties. The component author is in complete control of those bindings.
但是，其它组件不应该进行这种毫无限制的访问。 如果任何人都可以绑定到你的组件的任何属性上，那么这个组件就很难维护。 所以，外部组件应该只能绑定到组件的公共（允许绑定） API 上。
But other components shouldn't have that kind of unrestricted access. You'd have a hard time supporting your component if anyone could bind to any of its properties. Outside components should only be able to bind to the component's public binding API.
Angular 要求你显式声明那些 API。 它让你可以自己决定哪些属性是可以被外部组件绑定的。
Angular asks you to be explicit about that API. It's up to you to decide which properties are available for binding by external components.
TypeScript 的 public 是没用的
TypeScript public doesn't matter
你不能用 TypeScript 的 public 和 private 访问控制符来标明组件的公共 API。
You can't use the TypeScript public and private access modifiers to shape the component's public binding API.
所有数据绑定属性必须是 TypeScript 的公共属性，Angular 永远不会绑定到 TypeScript 中的私有属性。
All data bound properties must be TypeScript public properties. Angular never binds to a TypeScript private property.
因此，Angular 需要一些其它方式来标记出那些允许被外部组件绑定到的属性。 这种其它方式，就是 @Input() 和 @Output() 装饰器。
Angular requires some other way to identify properties that outside components are allowed to bind to. That other way is the @Input() and @Output() decorators.
声明输入与输出属性
Declaring Input and Output properties
在本章的例子中，绑定到 HeroDetailComponent 不会失败，这是因为这些要进行数据绑定的属性都带有 @Input() 和 @Output() 装饰器。
In the sample for this guide, the bindings to HeroDetailComponent do not fail because the data bound properties are annotated with @Input() and @Output() decorators.
@Input() hero: Hero;
@Output() deleteRequest = new EventEmitter<Hero>();
另外，还可以在指令元数据的 inputs 或 outputs 数组中标记出这些成员。比如这个例子：
Alternatively, you can identify members in the inputs and outputs arrays of the directive metadata, as in this example:
@Component({
inputs: ['hero'],
outputs: ['deleteRequest'],
})
输入还是输出？
Input or output?
输入属性通常接收数据值。 输出属性暴露事件生产者，如 EventEmitter 对象。
Input properties usually receive data values. Output properties expose event producers, such as EventEmitter objects.
输入和输出这两个词是从目标指令的角度来说的。
The terms input and output reflect the perspective of the target directive.
从 HeroDetailComponent 角度来看，HeroDetailComponent.hero 是个输入属性， 因为数据流从模板绑定表达式流入那个属性。
HeroDetailComponent.hero is an input property from the perspective of HeroDetailComponent because data flows into that property from a template binding expression.
从 HeroDetailComponent 角度来看，HeroDetailComponent.deleteRequest 是个输出属性， 因为事件从那个属性流出，流向模板绑定语句中的处理器。
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.
给输入/输出属性起别名
Aliasing input/output properties
有时需要让输入/输出属性的公共名字不同于内部名字。
Sometimes the public name of an input/output property should be different from the internal name.
这是使用 attribute 指令时的常见情况。 指令的使用者期望绑定到指令名。例如，在 <div> 上用 myClick 选择器应用指令时， 希望绑定的事件属性也叫 myClick。
This is frequently the case with attribute directives. Directive consumers expect to bind to the name of the directive. For example, when you apply a directive with a myClick selector to a <div> tag, you expect to bind to an event property that is also called myClick.
<div (myClick)="clickMessage=$event" clickable>click with myClick</div>
然而，在指令类中，直接用指令名作为自己的属性名通常都不是好的选择。 指令名很少能描述这个属性是干嘛的。 myClick 这个指令名对于用来发出 click 消息的属性就算不上一个好名字。
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 这个别名指向了指令自己的 clicks 属性。
Fortunately, you can have a public name for the property that meets conventional expectations, while using a different name internally. In the example immediately above, you are actually binding through the myClick alias to the directive's own clicks property.
把别名传进@Input/@Output 装饰器，就可以为属性指定别名，就像这样：
You can specify the alias for the property name by passing it into the input/output decorator like this:
@Output('myClick') clicks = new EventEmitter<string>(); // @Output(alias) propertyName = ...
也可在 inputs 和 outputs 数组中为属性指定别名。 可以写一个冒号 (:) 分隔的字符串，左侧是指令中的属性名，右侧则是公共别名。
You can also alias property names in the inputs and outputs arrays. You write a colon-delimited (:) string with the directive property name on the left and the public alias on the right:
@Directive({
outputs: ['clicks:myClick'] // propertyName:alias
})
模板表达式操作符
Template expression operators
模板表达式语言使用了 JavaScript 语法的子集，并补充了几个用于特定场景的特殊操作符。 下面介绍其中的两个：管道和安全导航操作符。
The template expression language employs a subset of JavaScript syntax supplemented with a few special operators for specific scenarios. The next sections cover two of these operators: pipe and safe navigation operator.
管道操作符 ( | )
The pipe operator ( | )
在绑定之前，表达式的结果可能需要一些转换。例如，可能希望把数字显示成金额、强制文本变成大写，或者过滤列表以及进行排序。
The result of an expression might require some transformation before you're ready to use it in a binding. For example, you might display a number as a currency, force text to uppercase, or filter a list and sort it.
Angular 管道对像这样的小型转换来说是个明智的选择。 管道是一个简单的函数，它接受一个输入值，并返回转换结果。 它们很容易用于模板表达式中，只要使用管道操作符 (|) 就行了。
Angular pipes 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 (|):
<div>Title through uppercase pipe: {{title | uppercase}}</div>
管道操作符会把它左侧的表达式结果传给它右侧的管道函数。
The pipe operator passes the result of an expression on the left to a pipe function on the right.
还可以通过多个管道串联表达式：
You can chain expressions through multiple pipes:
<!-- Pipe chaining: convert title to uppercase, then to lowercase -->
<div>
Title through a pipe chain:
{{title | uppercase | lowercase}}
</div>
还能对它们使用参数：
And you can also apply parameters to a pipe:
<!-- pipe with configuration argument => "February 25, 1970" -->
<div>Birthdate: {{currentHero?.birthdate | date:'longDate'}}</div>
json 管道对调试绑定特别有用：
The json pipe is particularly helpful for debugging bindings:
<div>{{currentHero | json}}</div>
它生成的输出是这样的：
The generated output would look something like this
{ "id": 0, "name": "Hercules", "emotion": "happy",
"birthdate": "1970-02-25T08:00:00.000Z",
"url": "http://www.imdb.com/title/tt0065832/",
"rate": 325 }
安全导航操作符 ( ?. ) 和空属性路径
The safe navigation operator ( ?. ) and null property paths
Angular 的安全导航操作符 (?.) 是一种流畅而便利的方式，用来保护出现在属性路径中 null 和 undefined 值。 下例中，当 currentHero 为空时，保护视图渲染器，让它免于失败。
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.
The current hero's name is {{currentHero?.name}}
如果下列数据绑定中 title 属性为空，会发生什么？
What happens when the following data bound title property is null?
The title is {{title}}
这个视图仍然被渲染出来，但是显示的值是空；只能看到 “The title is”，它后面却没有任何东西。 这是合理的行为。至少应用没有崩溃。
The view still renders but the displayed value is blank; you see only "The title is" with nothing after it. That is reasonable behavior. At least the app doesn't crash.
假设模板表达式涉及属性路径，在下例中，显示一个空 (null) 英雄的 firstName。
Suppose the template expression involves a property path, as in this next example that displays the name of a null hero.
The null hero's name is {{nullHero.name}}
JavaScript 抛出了空引用错误，Angular 也是如此：
JavaScript throws a null reference error, and so does Angular:
TypeError: Cannot read property 'name' of null in [null].
晕，整个视图都不见了。
Worse, the entire view disappears.
如果确信 hero 属性永远不可能为空，可以声称这是合理的行为。 如果它必须不能为空，但它仍然是空值，实际上是制造了一个编程错误，它应该被捕获和修复。 这种情况应该抛出异常。
This would be reasonable behavior if the hero property could never be null. If it must never be null and yet it is null, that's a programming error that should be caught and fixed. Throwing an exception is the right thing to do.
另一方面，属性路径中的空值可能会时常发生，特别是数据目前为空但最终会出现。
On the other hand, null values in the property path may be OK from time to time, especially when the data are null now and will arrive eventually.
当等待数据的时候，视图渲染器不应该抱怨，而应该把这个空属性路径显示为空白，就像上面 title 属性那样。
While waiting for data, the view should render without complaint, and the null property path should display as blank just as the title property does.
不幸的是，当 currentHero 为空的时候，应用崩溃了。
Unfortunately, the app crashes when the currentHero is null.
可以通过用NgIf代码环绕它来解决这个问题。
You could code around that problem with *ngIf.
<!--No hero, div not displayed, no error -->
<div *ngIf="nullHero">The null hero's name is {{nullHero.name}}</div>
还可以尝试通过 && 来把属性路径的各部分串起来，让它在遇到第一个空值的时候，就返回空。
You could try to chain parts of the property path with &&, knowing that the expression bails out when it encounters the first null.
The null hero's name is {{nullHero && nullHero.name}}
这些方法都有价值，但是会显得笨重，特别是当这个属性路径非常长的时候。 想象一下在一个很长的属性路径（如 a.b.c.d）中对空值提供保护。
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.
Angular 安全导航操作符 (?.) 是在属性路径中保护空值的更加流畅、便利的方式。 表达式会在它遇到第一个空值的时候跳出。 显示是空的，但应用正常工作，而没有发生错误。
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.
<!-- No hero, no problem! -->
The null hero's name is {{nullHero?.name}}
在像 a?.b?.c?.d 这样的长属性路径中，它工作得很完美。back to top
It works perfectly with long property paths such as a?.b?.c?.d.
非空断言操作符（!）
The non-null assertion operator ( ! )
在 TypeScript 2.0 中，你可以使用 --strictNullChecks 标志强制开启严格空值检查。TypeScript 就会确保不存在意料之外的 null 或 undefined。
As of Typescript 2.0, you can enforce strict null checking with the --strictNullChecks flag. TypeScript then ensures that no variable is unintentionally null or undefined.
在这种模式下，有类型的变量默认是不允许 null 或 undefined 值的，如果有未赋值的变量，或者试图把 null 或 undefined 赋值给不允许为空的变量，类型检查器就会抛出一个错误。
In this mode, typed variables disallow null and undefined by default. The type checker throws an error if you leave a variable unassigned or try to assign null or undefined to a variable whose type disallows null and undefined.
如果类型检查器在运行期间无法确定一个变量是 null 或 undefined，那么它也会抛出一个错误。 你自己可能知道它不会为空，但类型检查器不知道。 所以你要告诉类型检查器，它不会为空，这时就要用到非空断言操作符。
The type checker also throws an error if it can't determine whether a variable will be null or undefined at runtime. You may know that can't happen but the type checker doesn't know. You tell the type checker that it can't happen by applying the post-fix non-null assertion operator (!).
Angular 模板中的**非空断言操作符（!）也是同样的用途。
The Angular non-null assertion operator (!) serves the same purpose in an Angular template.
例如，在用*ngIf来检查过 hero 是已定义的之后，就可以断言 hero 属性一定是已定义的。
For example, after you use *ngIf to check that hero is defined, you can assert that hero properties are also defined.
<!--No hero, no text -->
<div *ngIf="hero">
The hero's name is {{hero!.name}}
</div>
在 Angular 编译器把你的模板转换成 TypeScript 代码时，这个操作符会防止 TypeScript 报告 "hero.name 可能为 null 或 undefined"的错误。
When the Angular compiler turns your template into TypeScript code, it prevents TypeScript from reporting that hero.name might be null or undefined.
与安全导航操作符不同的是，非空断言操作符不会防止出现 null 或 undefined。 它只是告诉 TypeScript 的类型检查器对特定的属性表达式，不做 "严格空值检测"。
Unlike the safe navigation operator, the non-null assertion operator does not guard against null or undefined. Rather it tells the TypeScript type checker to suspend strict null checks for a specific property expression.
如果你打开了严格控制检测，那就要用到这个模板操作符，而其它情况下则是可选的。
You'll need this template operator when you turn on strict null checks. It's optional otherwise.
类型转换函数 $any （$any( <表达式> )）
The $any type cast function ($any( <expression> ))
有时候，绑定表达式可能会报类型错误，并且它不能或很难指定类型。要消除这种报错，你可以使用 $any 转换函数来把表达式转换成 any 类型。
Sometimes a binding expression will be reported as a type error and it is not possible or difficult to fully specify the type. To silence the error, you can use the $any cast function to cast the expression to the any type.
<!-- Accessing an undeclared member -->
<div>
The hero's marker is {{$any(hero).marker}}
</div>
在这个例子中，当 Angular 编译器把模板转换成 TypeScript 代码时，$any 表达式可以防止 TypeScript 编译器报错说 marker 不是 Hero 接口的成员。
In this example, when the Angular compiler turns your template into TypeScript code, it prevents TypeScript from reporting that marker is not a member of the Hero interface.
$any 转换函数可以和 this 联合使用，以便访问组件中未声明过的成员。
The $any cast function can be used in conjunction with this to allow access to undeclared members of the component.
<!-- Accessing an undeclared member -->
<div>
Undeclared members is {{$any(this).member}}
</div>
$any 转换函数可以在绑定表达式中任何可以进行方法调用的地方使用。
The $any cast function can be used anywhere in a binding expression where a method call is valid.
小结
Summary
你完成了模板语法的概述。现在，该把如何写组件和指令的知识投入到实际工作当中了。
You've completed this survey of template syntax. Now it's time to put that knowledge to work on your own components and directives.
