angular-cn/public/docs/ts/_cache/glossary.jade

block includes
  include _util-fns

//- current.path = ['docs', lang, 'latest', ...]
- var lang = current.path[1]
- var docsPath='/' + current.path[0]
- var docsLatest='/' + current.path.slice(0,3).join('/');
- var _at = lang === 'js' ? '' : '@'
- var _decoratorLink = '<a href="#' + _decorator + '">' + _decorator + '</a>'

:marked
  Angular has a vocabulary of its own.
  Most Angular terms are everyday English words
  with a specific meaning within the Angular system.

  This glossary lists the most prominent terms
  and a few less familiar ones that have unusual or
  unexpected definitions.

  [A](#A) [B](#B) [C](#C) [D](#D) [E](#E) [F](#F) [G](#G) [H](#H) [I](#I)
  [J](#J) [K](#K) [L](#L) [M](#M) [N](#N) [O](#O) [P](#P) [Q](#Q) [R](#R)
  [S](#S) [T](#T) [U](#U) [V](#V) [W](#W) [X](#X) [Y](#Y) [Z](#Z)

.l-main-section#A

a#aot
:marked
  ## Ahead-of-Time (AoT) compilation
.l-sub-section
  :marked
    You can compile Angular applications at build-time.
    By compiling your application<span if-docs="ts"> using the compiler-cli, `ngc`</span>, you can bootstrap directly
    to a<span if-docs="ts"> module</span> factory, meaning you don't need to include the Angular compiler in your JavaScript bundle.
    Ahead-of-time compiled applications also benefit from decreased load time and increased performance.

+ifDocsFor('ts')
  :marked
    ## Angular module
  .l-sub-section
    :marked
      Helps you organize an application into cohesive blocks of functionality.
      An Angular module identifies the components, directives, and pipes that the application uses along with the list of external Angular modules that the application needs, such as `FormsModule`.

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

      For details and examples, see the [Angular Module](!{docsLatest}/guide/ngmodule.html) page.

+ifDocsFor('ts|dart')
  :marked
    ## Annotation
  .l-sub-section
    block annotation-defn
      :marked
        In practice, a synonym for [Decoration](#decorator).

:marked
  ## Attribute directive
.l-sub-section
  :marked
    A category of [directive](#directive) that can listen to and modify the behavior of
    other HTML elements, attributes, properties, and components. They are usually represented
    as HTML attributes, hence the name.

    A good example of an attribute directive is the `ngClass` directive for adding and removing CSS class names.

.l-main-section#B

+ifDocsFor('ts|js')
  :marked
    ## Barrel
  .l-sub-section
    :marked
      A barrel is a way to *rollup exports* from several ES2015 modules into a single convenient ES2015 module.
      The barrel itself is an ES2015 module file that re-exports *selected* exports of other ES2015 modules.

      Imagine three ES2015 modules in a `heroes` folder:
    code-example.
      // heroes/hero.component.ts
      export class HeroComponent {}

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

      // heroes/hero.service.ts
      export class HeroService {}
    :marked
      Without a barrel, a consumer would need three import statements:
    code-example.
      import { HeroComponent } from '../heroes/hero.component.ts';
      import { Hero }          from '../heroes/hero.model.ts';
      import { HeroService }   from '../heroes/hero.service.ts';
    :marked
      You can add a barrel to the `heroes` folder (called `index`, by convention) that exports all of these items:
    code-example.
      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
    :marked
      Now a consumer can import what it needs from the barrel.
    code-example.
      import { Hero, HeroService } from '../heroes'; // index is implied
    :marked
      The Angular [scoped packages](#scoped-package) each have a barrel named `index`.

    .alert.is-important
      :marked
        Note that you can often achieve this using [Angular modules](#angular-module) instead.

:marked
  ## Binding
.l-sub-section
  :marked
    Almost always refers to [Data Binding](#data-binding) and the act of
    binding an HTML object property to a data object property.

    May refer to a [dependency injection](#dependency-injection) binding
    between a "token", also referred to as a "key", and a dependency [provider](#provider).
    This more rare usage should be clear in context.

:marked
  ## Bootstrap
.l-sub-section
  block bootstrap-defn-top
    :marked
      You launch an Angular application by "bootstrapping" it using the application root Angular module (`AppModule`). Bootstrapping identifies an application's top level "root" [component](#component), which is the first component that is loaded for the application. 
      For more information, see the [Setup](!{docsLatest}/guide/setup.html) page.
  :marked
    You can bootstrap multiple apps in the same `index.html`, each with its own top level root.

.l-main-section#C
:marked
  ## camelCase
.l-sub-section
  :marked
    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_.

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

    This form is also known as **lower camel case**, to distinguish it from **upper camel case**, which is [PascalCase](#pascalcase).
    When you see "camelCase" in this documentation it always means *lower camel case*.

:marked
  ## Component
.l-sub-section
  :marked
    An Angular class responsible for exposing data to a [view](#view) and handling most of the view’s display and user-interaction logic.

    The *component* is one of the most important building blocks in the Angular system.
    It is, in fact, an Angular [directive](#directive) with a companion [template](#template).

    You apply the `!{_at}Component` !{_decoratorLink} to
    the component class, thereby attaching to the class the essential component metadata
    that Angular needs to create a component instance and render it with its template
    as a view.

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

.l-main-section#D
:marked
  ## dash-case
.l-sub-section
  :marked
    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](#kebab-case).

    [Directive](#directive) selectors (like `my-app`) <span if-docs="ts">and
    the root of filenames (such as `hero-list.component.ts`)</span> are often
    spelled in dash-case.

:marked
  ## Data binding
.l-sub-section
  :marked
    Applications display data values to a user and respond to user
    actions (clicks, touches, keystrokes).

    Instead of manually pushing application data values into HTML, attaching
    event listeners, pulling changed values from the screen, and
    updating application data values, you can use data binding by declaring the relationship between an HTML widget and data source and let the
    framework handle the details.

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

     Read about the forms of binding in the [Template Syntax](!{docsLatest}/guide/template-syntax.html#data-binding) page:
     * [Interpolation](!{docsLatest}/guide/template-syntax.html#interpolation).
     * [Property binding](!{docsLatest}/guide/template-syntax.html#property-binding).
     * [Event binding](!{docsLatest}/guide/template-syntax.html#event-binding).
     * [Attribute binding](!{docsLatest}/guide/template-syntax.html#attribute-binding).
     * [Class binding](!{docsLatest}/guide/template-syntax.html#class-binding).
     * [Style binding](!{docsLatest}/guide/template-syntax.html#style-binding).
     * [Two-way data binding with ngModel](!{docsLatest}/guide/template-syntax.html#ngModel).


+ifDocsFor('ts|dart')
  a#decorator
  a#decoration
  :marked
    ## Decorator | decoration
  .l-sub-section
    block decorator-defn
      :marked
        A decorator is a **function** that adds metadata to a class, its members (properties, methods) and function arguments.

        Decorators are a JavaScript language [feature](https://github.com/wycats/javascript-decorators), implemented in TypeScript and proposed for ES2016 (AKA ES7).

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

        Angular has its own set of decorators to help it interoperate with your application parts.
        Here is an example of a `@Component` decorator that identifies a
        class as an Angular [component](#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.
        ```
        @Component({...})
        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 appearing below it in the file.

      .alert.is-important
        :marked
          Always include parentheses `()` when applying a decorator.

:marked
  ## Dependency injection
.l-sub-section
  :marked
    Dependency injection is both a design pattern and a mechanism
    for creating and delivering parts of an application to other
    parts of an application that request them.

    Angular developers prefer to build applications by defining many simple parts
    that each do one thing well and then wiring them together at runtime.

    These parts often rely on other parts. An Angular [component](#component)
    part might rely on a service part to get data or perform a calculation. When
    part "A" relies on another part "B", you say that "A" depends on "B" and
    that "B" is a dependency of "A".

    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 provides and relies upon its own sophisticated
    [dependency injection](dependency-injection.html) system
    to assemble and run applications by "injecting" application parts
    into other application parts where and when needed.

    At the core there is an [`injector`](#injector) that returns dependency values on request.
    The expression `injector.get(token)` returns the value associated with the given token.

    A token is an Angular type (`OpaqueToken`). You rarely deal with tokens directly; most
    methods accept a class name (`Foo`) or a string ("foo") and Angular converts it
    to a token. When you write `injector.get(Foo)`, the injector returns
    the value associated with the token for the `Foo` class, typically an instance of `Foo` itself.

    During many of its operations, Angular makes similar requests internally, such as when it creates a [`component`](#component) for display.

    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.

    A [provider](#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 registers some of its own providers with every injector.
    We can register our own providers.

    Read more in the [Dependency Injection](!{docsLatest}/guide/dependency-injection.html) page.
:marked
  ## Directive
.l-sub-section
  :marked
    An Angular class responsible for creating, reshaping, and interacting with HTML elements
    in the browser DOM. Directives are Angular's most fundamental feature.

    A Directive is almost always associated with an HTML element or attribute.
    We often refer to such an element or attribute as the directive itself.
    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.

    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 three categories:

    1. [Components](#component) that 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 and the
    developer can expect to write a lot of them.

    1. [Attribute directives](#attribute-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.

    1. [Structural directives](#structural-directive), a directive responsible for
    shaping or reshaping HTML layout, typically by adding, removing, or manipulating
    elements and their children.

.l-main-section#E

:marked
  ## ECMAScript
.l-sub-section
  :marked
    The [official JavaScript language specification](https://en.wikipedia.org/wiki/ECMAScript).

    The latest approved version of JavaScript is
    [ECMAScript 2016](http://www.ecma-international.org/ecma-262/7.0/)
    (AKA "ES2016" or "ES7") and many Angular developers write their applications
    either in this version of the language or a dialect that strives to be
    compatible with it, such as [TypeScript](#typescript).

    Most modern browsers today only support the much older "ECMAScript 5" (AKA ES5) standard.
    Applications written in ES2016, ES2015 or one of their dialects must be "[transpiled](#transpile)"
    to ES5 JavaScript.

    Angular developers may choose to write in ES5 directly.

:marked
  ## ES2015
.l-sub-section
  :marked
    Short hand for [ECMAScript](#ecmascript) 2015.
:marked
  ## ES6
.l-sub-section
  :marked
    Short hand for [ECMAScript](#ecmascript) 2015.
:marked
  ## ES5
.l-sub-section
  :marked
    Short hand for [ECMAScript](#ecmascript) 5, the version of JavaScript run by most modern browsers.
    See [ECMAScript](#ecmascript).

a#F
a#G
a#H
.l-main-section#I
:marked
  ## Injector
.l-sub-section
  :marked
    An object in the Angular [dependency injection system](#dependency-injection)
    that can find a named "dependency" in its cache or create such a thing
    with a registered [provider](#provider).

:marked
  ## Input
.l-sub-section
  :marked
    A directive property that can be the ***target*** of a
    [property binding](!{docsLatest}/guide/template-syntax.html#property-binding) (explained in detail in the [Template Syntax](!{docsLatest}/guide/template-syntax.html) 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](!{docsLatest}/guide/template-syntax.html#inputs-outputs) section of the [Template Syntax](!{docsLatest}/guide/template-syntax.html) page.

:marked
  ## Interpolation
.l-sub-section
  :marked
    A form of [property data binding](#data-binding) in which a
    [template expression](#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.

  code-example(language="html" escape="html").
    <label>My current hero is {{hero.name}}</label>

  :marked
    Read more about [interpolation](!{docsLatest}/guide/template-syntax.html#interpolation) in the
    [Template Syntax](!{docsLatest}/guide/template-syntax.html) page.

.l-main-section#J

a#jit
:marked
  ## Just-in-Time (JiT) compilation
.l-sub-section
  :marked
    With Angular _just-in-time_  bootstrapping you compile your components<span if-docs="ts"> and modules</span> in the browser
    and launch the application dynamically. This is a good choice during development.
    Consider using the [ahead-of-time](#aot) mode for production apps.

.l-main-section#K
:marked
  ## kebab-case
.l-sub-section
  :marked
    See [dash-case](#dash-case).

.l-main-section#L
:marked
  ## Lifecycle hooks
.l-sub-section
  :marked
    [Directives](#directive) and [components](#component) 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.

    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 calls these hook methods in the following order:
    * `ngOnChanges` - when an [input](#input)/[output](#output) binding value changes.
    * `ngOnInit` - after the first `ngOnChanges`.
    * `ngDoCheck` - developer's custom change detection.
    * `ngAfterContentInit` - after component content initialized.
    * `ngAfterContentChecked` - after every check of component content.
    * `ngAfterViewInit` - after component's view(s) are initialized.
    * `ngAfterViewChecked` - after every check of a component's view(s).
    * `ngOnDestroy` - just before the directive is destroyed.

    Read more in the [Lifecycle Hooks](!{docsLatest}/guide/lifecycle-hooks.html) page.

.l-main-section#M

:marked
  ## Module
.l-sub-section
  block module-defn
    .alert.is-important
      :marked
       In Angular, there are two types of modules:
       - [Angular modules](#angular-module).
       For details and examples, see the [Angular Modules](!{docsLatest}/guide/ngmodule.html) page.
       - ES2015 modules, as described in this section.

    :marked
      Angular apps are modular.

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

      A typical module is a cohesive block of code dedicated to a single purpose.

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

      The structure of Angular modules and the import/export syntax
      is based on the [ES2015 module standard](http://www.2ality.com/2014/09/es6-modules-final.html).

      An application that adheres to this standard requires a module loader to
      load modules on request, and resolve inter-module dependencies.
      Angular does not ship with a module loader and does not have a preference
      for any particular 3rd party library (although most examples use SystemJS).
      You may pick any module library that conforms to the standard.

      Modules are typically named after the file in which the exported thing is defined.
      The Angular [DatePipe](https://github.com/angular/angular/blob/master/modules/@angular/common/src/pipes/date_pipe.ts)
      class belongs to a feature module named `date_pipe` in the file `date_pipe.ts`.

      You rarely access Angular feature modules directly. You usually import them from one of the Angular [scoped packages](#scoped-package) such as `@angular/core`.

a#N
.l-main-section#O

+ifDocsFor('ts|js')
  :marked
    ## Observable
  .l-sub-section
    :marked
      You can think of an observable as 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.

      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.

:marked
  ## Output
.l-sub-section
  :marked
    A directive property that can be the ***target*** of
    [event binding](!{docsLatest}/guide/template-syntax.html#event-binding).
    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](!{docsLatest}/guide/template-syntax.html#inputs-outputs) section of the [Template Syntax](!{docsLatest}/guide/template-syntax.html) page.

.l-main-section#P

:marked
  ## PascalCase
.l-sub-section
  :marked
    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. Examples include: `Person` and `HeroDetailComponent`.

    This form is also known as **upper camel case** to distinguish it from **lower camel case**, which is simply called [camelCase](#camelcase). In this documentation, "PascalCase" means *upper camel case* and  "camelCase" means *lower camel case*.

:marked
  ## Pipe
.l-sub-section
  :marked
    An Angular pipe is a function that transforms input values to output values for
    display in a [view](#view). Use the `!{_at}Pipe` !{_decoratorLink}
    to associate the pipe function with a name. You then use that
    name in your HTML to declaratively transform values on screen.

    Here's an example that uses the built-in `currency` pipe to display
    a numeric value in the local currency.

  code-example(language="html" escape="html").
    <label>Price: </label>{{product.price | currency}}
  :marked
    Read more in the page on [pipes](!{docsLatest}/guide/pipes.html).

:marked
  ## Provider
.l-sub-section
  :marked
    A _provider_ creates a new instance of a dependency for the
    [dependency injection](#dependency-injection) system.
    It relates a lookup token to code&mdash;sometimes called a "recipe"&mdash;that can create a dependency value.

a#Q
.l-main-section#R

+ifDocsFor('ts|js')
  :marked
    ## Reactive forms
  .l-sub-section
    :marked
      A technique for building Angular forms through code in a component.
      The alternate technique is [Template-Driven Forms](#template-driven-forms).

      When building reactive forms:
      - The "source of truth" is the component. The validation is defined using code in the component.
      - Each control is explicitly created in the component class with `new FormControl()` or with `FormBuilder`.
      - The template input elements do *not* use `ngModel`.
      - The associated Angular directives are all prefixed with `Form` such as `FormGroup`, `FormControl`, and `FormControlName`.

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

:marked
  ## Router
.l-sub-section
  :marked
    Most applications consist of many screens or [views](#view).
    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.

    The Angular [component router](!{docsLatest}/guide/router.html) is a richly featured mechanism for configuring and managing the entire view navigation process including the creation and destruction
    of views.
  +ifDocsFor('ts|js')
    :marked
      In most cases, components become attached to a [router](#router) by means
      of a `RouterConfig` that defines routes to views.

      A [routing component's](#routing-component) template has a `RouterOutlet` element
      where it can display views produced by the router.

      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](!{docsLatest}/guide/router.html) page.

+ifDocsFor('ts|js')
  :marked
    ## Router module
  .l-sub-section
    :marked
      A separate [Angular module](#angular-module) that provides the necessary service providers and directives for navigating through application views.

      For more information, see the [Routing & Navigation](!{docsLatest}/guide/router.html) page.

:marked
  ## Routing component
.l-sub-section
  :marked
    An Angular [component](#component) with a `RouterOutlet` that displays views based on router navigations.

    For more information, see the [Routing & Navigation](!{docsLatest}/guide/router.html) page.

.l-main-section#S

+ifDocsFor('ts|js')
  :marked
    ## Scoped package
  .l-sub-section
    :marked
      Angular modules are delivered within *scoped packages* such as `@angular/core`, `@angular/common`, `@angular/platform-browser-dynamic`,
      `@angular/http`, and `@angular/router`.

      A [*scoped package*](https://docs.npmjs.com/misc/scope) is a way to group related *npm* packages.

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

    +makeExcerpt('architecture/ts/app/app.component.ts', 'import', '')

a#snake-case
:marked
  ## snake_case

.l-sub-section
  block snake-case-defn
    :marked
      The practice of writing compound words or phrases such that an
      underscore (`_`) separates one word from the next. This form is also known as **underscore case**.

:marked
  ## Service
.l-sub-section
  :marked
    For data or logic that is not associated
    with a specific view or that you want to share across components, build services.

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

    A service is a class with a focused purpose.
    We often create a service to implement features that are
    independent from any specific view,
    provide shared data or logic across components, or encapsulate external interactions.

    For more information, see the [Services](!{docsLatest}/tutorial/toh-pt4.html) page of the [Tour of Heroes](!{docsLatest}/tutorial/) tutorial.

:marked
  ## Structural directive
.l-sub-section
  :marked
    A category of [directive](#directive) that can
    shape or reshape HTML layout, typically by adding, removing, or manipulating
    elements and their children; for example, the `ngIf` "conditional element" directive and the `ngFor` "repeater" directive.

    Read more in the [Structural Directives](!{docsLatest}/guide/structural-directives.html) page.

.l-main-section#T
:marked
  ## Template
.l-sub-section
  :marked
    A template is a chunk of HTML that Angular uses to render a [view](#view) with
    the support and continuing guidance of an Angular [directive](#directive),
    most notably a [component](#component).


+ifDocsFor('ts|js')
  :marked
    ## Template-driven forms
  .l-sub-section
    :marked
      A technique for building Angular forms using HTML forms and input elements in the view.
      The alternate technique is [Reactive Forms](#reactive-forms).

      When building template-driven forms:
      - The "source of truth" is the template. The validation is defined using attributes on the individual input elements.
      - [Two-way binding](#data-binding) with `ngModel` keeps the component model in synchronization with the user's entry into the input elements.
      - 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.
      - 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](!{docsLatest}/guide/forms.html) page.

:marked
  ## Template expression
.l-sub-section
  :marked
    An expression is a !{_Lang}-like syntax that Angular evaluates within
    a [data binding](#data-binding).

    Read about how to write template expressions
    in the [Template Syntax](!{docsLatest}/guide/template-syntax.html#template-expressions) page.

:marked
  ## Transpile
.l-sub-section
  :marked
    The process of transforming code written in one form of JavaScript
    (for example, TypeScript) into another form of JavaScript  (for example, [ES5](#es5)).

 :marked
  ## TypeScript
.l-sub-section
  :marked
    A version of JavaScript that supports most [ECMAScript 2015](#es2015)
    language features such as [decorators](#decorator).

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

    TypeScript is the preferred language for Angular development although
    you can use other JavaScript dialects such as [ES5](#es5).

    Read more about TypeScript at [typescript.org](http://www.typescriptlang.org/).

a#U
.l-main-section#V

:marked
  ## View
.l-sub-section
  :marked
    A view is a portion of the screen that displays information and responds
    to user actions such as clicks, mouse moves, and keystrokes.

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

    Views often contain other views and any view might be loaded and unloaded
    dynamically as the user navigates through the application, typically
    under the control of a [router](#router).

a#W
a#X
a#Y
.l-main-section#Z

:marked
  ## Zone
.l-sub-section
  block zone-defn
    :marked
      Zones are a mechanism for encapsulating and intercepting
      a JavaScript application's asynchronous activity.

      The browser DOM and JavaScript have a limited number
      of asynchronous activities, activities such as DOM events (for example, clicks),
      [promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), and
      [XHR](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest)
      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 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](#data-binding).

      Learn more about zones in this
      [Brian Ford video](https://www.youtube.com/watch?v=3IqtmUscE_U).