Angular2 DOC GUIDEを翻訳する[FORMS]

# トピック

[Angular2 CORE DOCUMENTATIONのGUIDE](https://angular.io/docs/ts/latest/guide/)の翻訳です。

- [DOCUMENTATION OVERVIEW - ドキュメント概要 -](http://qiita.com/Yamamoto0525/items/85667d0570d8dab8f95a)
- [ARCHITECTURE OVERVIEW - 構文概要 -](http://qiita.com/Yamamoto0525/items/cc727298fc892c23d99b)
- [DISPLAYING DATA - データ表示 -](http://qiita.com/Yamamoto0525/items/e3dd777dd00b7d2a47c7)
- [USER INPUT - ユーザー入力 -](http://qiita.com/Yamamoto0525/items/2040e8ef4acd296299a2)
- [FORMS - フォーム -](http://qiita.com/Yamamoto0525/items/1765c62e99dfab318660)
- [DEPENDENCY INJECTION - 依存性注入 -](http://qiita.com/Yamamoto0525/items/23a1756e9b32bfb6f328)
- [STYLE GUIDE -　スタイルガイド -](http://qiita.com/Yamamoto0525/items/e59551faf69775a7ad12)

注意1）ここに掲載されていない項目は、[Angular2 CORE DOCUMENTATIONのGUIDE](https://angular.io/docs/ts/latest/guide/)を直接参照してください。


注意2）2016年11月10日時点の翻訳です。翻訳者はTOEICで700点くらいの英語力なので、英訳が間違っている可能性があります。しかもかなり意訳している箇所もあります。もし意訳を通り越して、誤訳になっているような箇所がありましたらご指摘ください。

# FORMS - フォーム -

> フォームは使い勝手がよく、一度にまとめてデータ入力を実行できる強力なツールです。Angularのフォームでは、データとユーザーコントロールを結びつけ、変化を監視し、入力内容を確認してエラーを出すことができます。

フォームはログインやヘルプリクエストの送信、注文や飛行機の予約、会議のスケジュールなど、数えきれないほどの様々なデータ入力タスクで使われています。フォームは業務アプリにとって、なくてはならない存在といえるでしょう。

熟練したweb開発者であれば、HTMLをすべて正しいタグで打つこともできます。しかし、フォームをベースにしたワークフローで、ユーザーに複数のデータ入力を行わせ、効率的、効果的に進めていくことは彼らにとってもなかなか難しいところです。

*その難解さ*はデザインスキルによるところもありますが、今回の章でデザインについては扱いません。

今回扱うAngularフォームの章では、デザインスキルと同様に必要となる**双方向データバインディングや変更の追跡、バリデーション、エラーハンドリング**などのフレームワークによるサポートを取り上げます。

スクラッチで簡単なフォームを一つずつ構築していき、次にあげる手法を学んでいきます。

- コンポーネントとテンプレートでAngularフォームを構築する方法
- `[(ngModel)]`シンタックスを使ってインプットコントロールにある値を読んだり、書き込んだりする双方向データバインディングを行う方法
- フォームと合わせて`ngModel`を使い、フォームコントロールの状態や正当性の変化を追う方法
- コントロールの状態を追跡する特殊なCSSクラスを使って、わかりやすく見た目にフィードバックさせる方法
- ユーザーにバリデーションエラーを表示し、フォームコントロールができるかできないかを示す方法
- [テンプレート参照関数](https://angular.io/docs/ts/latest/guide/template-syntax.html#ref-vars) を使い、HTML要素の情報を共有する方法

[live example](https://angular.io/resources/live-examples/forms/ts/plnkr.html)を動かしてみてください。

##　テンプレート駆動フォーム

私たちの多くはフォームを構築する際、この章で取り上げているフォーム特有のディレクティブや技術を有するAngular[テンプレートシンタックス](https://angular.io/docs/ts/latest/guide/template-syntax.html)を使ってテンプレートを書いています。

> この章で取り上げているのは、フォームを作る方法ではなく、テンプレートシンタックスを扱う方法です。

Angularテンプレートを使えば、必要となりうるほぼすべてのフォーム、たとえばログインフォームやコンタクトフォーム、その他多くの業務用フォームを作ることができます。創造的にコントロールを設計し、それをデータと結びつけ、バリデーションルールを特定してバリデーションエラーを表示し、条件によって特定のコントロールの使用可否を決め、あらかじめ用意された視覚的なフィードバックを引き起こすなど、もう本当に色々なことができるのです。

しかもAngularは、私たちがよく悪戦苦闘する、何度も出てくる面倒臭い処理の多くをやってくれるので、フォームの構築がとても簡単になります。

次のテンプレート駆動フォームで構築方法を検討し、学習していきます。

![Clean Form](https://angular.io/resources/images/devguide/forms/hero-form-1.png)

ここ*ヒーロー職業紹介所*では、私たちが契約しているヒーローの個人情報を管理するため、このフォームを使っています。どんなヒーローでも職は必要です。私たちの社命は、ちゃんとしたヒーローをちゃんとした危機に遭遇させることなのです！※訳者注：原文ママです。

このフォームの３つのフィールドのうち、２つは必須項目です。必須のフィールドは見分けやすくするため、左側に緑色のバーを設けています。

ヒーローの名前を消すと、スタイルと紐づいた注意喚起のバリデーションエラーが表示されます。

![Invalid, Name Required](https://angular.io/resources/images/devguide/forms/hero-form-2.png)

このとき、submitボタンが使えず、インプットコントロールの左側にある"必須"バーが緑から赤に変わることに注意してください。

> 標準的なCSSを使って、"必須"バーの色と表示位置を変更できます。

次から始まる一連の小項目で、このフォームを構築していきます。

1. `Hero`モデルのクラスを作る
2. フォームをコントロールするコンポーネントを作る
3. テンプレートで初期のフォームレイアウトを作る
4. 双方向データバインディングのシンタックスである`ngModel`を使って、各フォームにあるインプットコントロールのデータプロパティを作る
5. 各フォームにあるインプットコントロールに`name`属性を加える
6. 視覚的なフィードバックを付与するため、カスタムCSSを加える
7. バリデーションエラーメッセージを表示、非表示にする
8. **ngSubmit**を使って、フォームの送信を扱う
9. フォームが有効（valid）になるまで、フォームのsubmit ボタンを利用できなくする

### セットアップ

新しいプロジェクトフォルダ（`angular-forms`）を作り、[QuickStart](https://angular.io/docs/ts/latest/quickstart.html)の指示に従って構築してください。

> もしくは、[QuickStartのソースをダウンロード](https://github.com/angular/quickstart/blob/master/README.md)して始めてください。


### `Hero`モデルのクラスを作る

ユーザーがフォームデータを入力するときは、そのデータの変更内容をとらえてモデルのインスタンスを更新します。モデルがどのようになっているかわからないと、フォームを設定することはできません。

モデルは、アプリケーションの重要事項をおさえている"プロパティバッグ"と同じくらいシンプルであるべきです。今回のモデルには、３つの必須フィールド（`id`、 `name`、`power`）と１つのオプションフィールド（`alterEgo`）をもったHeroクラスを書きます。

アプリのフォルダの中に`hero.ts`という新しいファイルを作成し、次のようにクラスを定義します。

```ts:app/hero.ts
export class Hero {
  constructor(
    public id: number,
    public name: string,
    public power: string,
    public alterEgo?: string
  ) {  }
}
```

requireも振舞いもない貧相なモデル。完璧ですね。

TypeScriptのコンパイラは、publicなコンストラクタのパラメータ１つ１つに対してpublicなフィールドを与え、新しいヒーローを作成したときは自動的にパラメータの値をそのフィールドに割り当てます。

`alterEgo`はオプションなので、コンストラクタでは省かれます。※`alterEgo?`の中にある (?)に注意してください。

次のようにして、新しいヒーローを作ることができます。

```ts
let myHero =  new Hero(42, 'SkyDog',
                       'Fetch any object at any distance',
                       'Leslie Rollover');
console.log('My hero is called ' + myHero.name); // "My hero is called SkyDog"
```

### フォームコンポーネントを作る

Angularフォームは２つの構成要素でできています。HTMLをベースにしたテンプレートと、データとユーザーインタラクションを扱うコードをベースにしたコンポーネントです。

まずはヒーロー編集者のできることを簡単に示してくれるコンポーネントから始めます。

`hero-form.component.ts`という新しいファイルを作って、次のように定義します。

```ts:app/hero-form.component.ts
import { Component } from '@angular/core';
import { Hero }    from './hero';
@Component({
  moduleId: module.id,
  selector: 'hero-form',
  templateUrl: 'hero-form.component.html'
})
export class HeroFormComponent {
  powers = ['Really Smart', 'Super Flexible',
            'Super Hot', 'Weather Changer'];
  model = new Hero(18, 'Dr IQ', this.powers[0], 'Chuck Overstreet');
  submitted = false;
  onSubmit() { this.submitted = true; }
  // TODO: Remove this when we're done
  get diagnostic() { return JSON.stringify(this.model); }
}
```

こののコンポーネントに特別なことはなく、フォーム特有のものや、これまでにみてきたコンポーネントと区別できるようなものは何もありません。

前の章で学んだAngularのコンセプトさえわかっていれば、このコンポーネントを理解することができるでしょう。

1. いつものようにAngular のライブラリから`Component`デコレータをインポートする。
2. さきほど作成した`Hero`モデルをインポートする。
3. `@Component`のセレクタにある"hero-form"という値は、親テンプレートに`<hero-form>`タグを使ってこのフォームを配置するということを意味する。
4. `moduleId: module.id`というプロパティは、モジュールに関連する`templateUrl`を読み込むための基盤を設定する。
5. `templateUrl`プロパティは、`hero-form.component.html`というテンプレートHTMLが書かれた別のファイルを指定している。
6. デモ用に`model`と`powers`というダミーのデータを定義。いずれ実データを取得、保存するためのデータサービスを導入するようになれば、おそらくこれらのプロパティは親コンポーネントとバインディングするために[inputsとoutputs](https://angular.io/docs/ts/latest/guide/template-syntax.html#inputs-outputs)を設定することになる。
7. モデルをJSONデータにして返すために、最後のところで`diagnostic`プロパティを設置している。これで開発中の確認作業が楽になる。（後でコードを削除するため、クリーンアップ・メモを残しました）

なぜ、よくほかの開発者用ガイドでやられているように、コンポーネントファイルの中にインラインでテンプレートを書かないのでしょうか。

どんな場面でも通用する"正しい"回答などありません。テンプレートが短いのであれば、テンプレートをインラインにするのもいいと思います。しかし、多くのフォーム用テンプレートは短くありません。TypeScriptやJavaScriptのファイルはたいてい肥大化したHTMLを書く（もしくは読む）ものとしては向いておらず、HTMLとコードが混在したファイルを積極的にサポートしてくれるエディタもほとんどないのです。このようにはっきりと明確な目的があるのであれば、小さなファイルがあったとしても問題ありません。

私たちは、別の場所にHTMLテンプレートを置くことを良い選択肢としました。では、早速テンプレートをそのように書いてみましょう。新しいものを書く前に、少し戻って`app.module.ts`と `app.component.ts`を書き直し、新しく`HeroFormComponent`を作ります。

### *app.module.ts*の書き直し

`app.module.ts`はアプリケーションのルートモジュールを定義しています。その中でアプリケーション内で使用する外部モジュールを特定し、`HeroFormComponent`のようなこのモジュールで使うコンポーネントを宣言しています。

テンプレート駆動フォームはそれ自身がモジュールでもあるので、フォームを使う前にアプリケーションモジュールの`imports`の配列に`FormsModule`を加える必要があります。

"QuickStart"バージョンの内容を次のように書き換えます。

```ts:app/app.module.ts
import { NgModule }      from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule }   from '@angular/forms';
import { AppComponent }  from './app.component';
import { HeroFormComponent } from './hero-form.component';
@NgModule({
  imports: [
    BrowserModule,
    FormsModule
  ],
  declarations: [
    AppComponent,
    HeroFormComponent
  ],
  bootstrap: [ AppComponent ]
})
export class AppModule { }
```

> 3点変更しました。
> 1. `FormsModule`と新規作成した`HeroFormComponent`をインポートしました。
> 2. `ngModule`デコレータで定義された`imports`のリストに`FormsModule`を加えました。これにより、このアプリケーションは`ngModel`を含むすべてのテンプレート駆動フォームの機能にアクセスできるようになります。
> 3. `ngModule`デコレータで定義された`declarations`のリストに`HeroFormComponent`を加えました。これにより、`HeroFormComponent`コンポーネントはこのモジュール全体を通して適用されるようになります。

コンポーネント、ディレクティブ、パイプが`imports`配列にあるモジュールに属している場合、`declarations`配列では宣言しないでください。書き込んだものがこのモジュールに属すべきものであれば、`declarations`配列で宣言してください。

### *app.component.ts*を書き直す

`app.component.ts`はアプリケーションのルートコンポーネントです。そこを新規作成した`HeroFormComponent`のホストにします。


"QuickStart"バージョンの内容を次のように書き換えます。

```ts:app/app.component.ts
import { Component } from '@angular/core';
@Component({
  selector: 'my-app',
  template: '<hero-form></hero-form>'
})
export class AppComponent { }
```

> 変更は1点のみです。
> 1. `template`は、コンポーネントの`selector`プロパティで特定された単なる新しいタグ要素です。これにより、アプリケーションコンポーネントが読み込まれるときにheroフォームが表示されます。

### イニシャルHTMLフォームテンプレートを作る

`hero-form.component.html`という新しいテンプレートファイルを作り、次のように定義してください。

```ts:app/hero-form.component.html
<div class="container">
    <h1>Hero Form</h1>
    <form>
      <div class="form-group">
        <label for="name">Name</label>
        <input type="text" class="form-control" id="name" required>
      </div>
      <div class="form-group">
        <label for="alterEgo">Alter Ego</label>
        <input type="text" class="form-control" id="alterEgo">
      </div>
      <button type="submit" class="btn btn-default">Submit</button>
    </form>
</div>
```

これは普通の古いHTML５で書いたものです。`name`と`alterEgo`の2つの`Hero`フィールドを提示し、インプットボックスを使ったユーザー入力でそれらを展開しています。

*Name* `<input>`コントロールはHTML5の`required`属性を有しています。一方、*Alter Ego* `<input>`はオプションなので、`required`属性は持っていません。

スタイリングするためのクラスをつけた、一番下にある*Submit*ボタンを押してみました。

**Angularはまだ動きません。**この時点では、バインディングもなく、何のディレクティブもついていない、ただのレイアウトです。

 `container`、`form-group`、`form-control`、`btn`は[Twitter Bootstrap](http://getbootstrap.com/css/)由来のもので、純粋に見栄え用です。ちょっと自分のフォームをカッコつけたくて、Bootstrapを使っています。やあ、なんてスタイルの少ないフォームなんだろうか！

#### ANGULAR FORMS DO NOT REQUIRE A STYLE LIBRARY

Angularは`container`、`form-group`、`form-control`、`btn`なんてクラスを使う必要はなく、どんな外部ライブラリのスタイルだって必要ありません。AngularアプリはすべてのCSSライブラリを使用することができますし、何も使わないこともできます。

スタイルシートを加えてみよう。

１． アプリケーションルートフォルダでターミナルウィンドウを開き、次のコマンドを入力します。

```bash
npm install bootstrap --save
```

２．`index.html`を開き、`<head>`に次のリンクを加えます。

```html
<link rel="stylesheet" href="node_modules/bootstrap/dist/css/bootstrap.min.css">
```

### *ngForとPowersを加える
### Add Powers with *ngFor

私たちのヒーローは、紹介所公認のpowersリストの中から、1つのスーパーパワーを選ぶことができます。そのリストは内部的に（`HeroFormComponent`の中で）管理しています。

フォームに`select`を加え、`*ngFor`（ 前に[Displaying Data](https://angular.io/docs/ts/latest/guide/displaying-data.html) の章で確認した技術）を使って `powers`リストにオプションを紐づけていきます。

次のHTMLを*Alter Ego*グループの*直下*に加えてみましょう。

```html:app/hero-form.component.html(excerpt)
<div class="form-group">
  <label for="power">Hero Power</label>
  <select class="form-control" id="power" required>
    <option *ngFor="let p of powers" [value]="p">{{p}}</option>
  </select>
</div>
```

Powersリストの中で、各power用に`<options>`タグが繰り返されています。`p`というテンプレート入力変数は、それぞれのイテレーションの中で異なるpowerの値をとっており、二重引用符がついたインターポレーションのシンタックスを使って、その名称を表示しています。

### ngModelを使った双方向データバインディング

ここですぐにアプリを起動すると、がっかりします。

![Early form with no binding](https://angular.io/resources/images/devguide/forms/hero-form-3.png)

まだヒーローとのバインディングを行っていないので、ヒーローのデータが見えません。以前の章で学んだことを覚えていますね。そう、 [Displaying Data](https://angular.io/docs/ts/latest/guide/displaying-data.html)で、私たちはプロパティバインディングを学習しました。 また、[User Input](https://angular.io/docs/ts/latest/guide/user-input.html) では、イベントバインディングを使ってDOMイベントを読み取る方法や、表示された値を使ってコンポーネントプロパティを更新する方法が示されていました。

今、私たちは表示と読み取りと抽出を一度に行う必要があります。

これらの技術を私たちのフォームに再び使うことで、新しい何かを紹介されるまでもなく、`[(ngModel)]`シンタックスが私たちのフォームとモデルを超簡単にバインディングしてくれるのです。

"Name"を持つ`<input>`タグを見つけて、次のように更新します。

```html:app/hero-form.component.html(excerpt)
<input type="text"  class="form-control" id="name"
       required
       [(ngModel)]="model.name" name="name">
  TODO: remove this: {{model.name}}
```

> 私たちのやっていることを確認できるように、インプットタグの後に診断用のインターポレーションを加えています。確認が終わったときに破棄するための注意書きも残しておきました。

バインディングシンタックス（ `[(ngModel)]="..."`）に焦点を絞ってみます。

アプリを起動し、Nameのインプットボックスにタイピングして、文字を入力したり消したりしてみてください。挿入されたテキストの表示、非表示が確認できます。この時点のものは、次のように見えるはずです。

![ngModel in action](https://angular.io/resources/images/devguide/forms/ng-model-in-action.png)

インターポレーションの診断によって、値がインプットボックスからモデルへと流れ込み、再びビューに反映されていることが証明されました。**これが双方向データバインディングです！**

`name`属性を`<input>`タグに加え、それに"name"をセットしたことにも注意してください（ここでいう"name"とは、ヒーローの`name`のことです）。どんなユニークな値であってもそうですが、説明的な名称を使うことは有効です。`name`属性の定義は、フォームと合わせて`[(ngModel)]`を使うときに必要となります。

> Angularは内部的に`FormControls`を作り、それらをAngularが`<form>`タグに付属させる `NgForm`ディレクティブに登録します。`FormControl`は、name属性に割り当てた`name`の下に登録されます。`NgForm`については、[この章の後の方](http://qiita.com/Yamamoto0525/items/1765c62e99dfab318660#ngsubmit%E3%81%A7%E3%83%95%E3%82%A9%E3%83%BC%E3%83%A0%E3%82%92%E9%80%81%E4%BF%A1%E3%81%99%E3%82%8B)でふれていきます。

同じように、`[(ngModel)]`バインディングと`name`属性を*Alter Ego*と*Hero Power*に加えてみましょう。メッセージと紐づいたインプットボックスを削除し、一番上にコンポーネントの`diagnostic`プロパティとの新しいバインディングを加えます。そして双方向データバインディングが、*ヒーローモデル全体*で動いていることを確認します。

修正後、フォームの核となる部分は、次のような3つの`[(ngModel)]`バインディングと`name`属性になります。

```ts:app/hero-form.component.html(excerpt)
{{diagnostic}}
<div class="form-group">
  <label for="name">Name</label>
  <input type="text" class="form-control" id="name"
         required
         [(ngModel)]="model.name" name="name">
</div>
<div class="form-group">
  <label for="alterEgo">Alter Ego</label>
  <input type="text"  class="form-control" id="alterEgo"
         [(ngModel)]="model.alterEgo" name="alterEgo">
</div>
<div class="form-group">
  <label for="power">Hero Power</label>
  <select class="form-control"  id="power"
          required
          [(ngModel)]="model.power" name="power">
    <option *ngFor="let p of powers" [value]="p">{{p}}</option>
  </select>
</div>
```

> - インプットコントロールとラベルを合わせるため、各インプット要素にはラベル要素の`for`属性に使われている`id`プロパティが配置されています。
> - Angularフォームがフォームにコントロールを組み込むため、各インプット要素には`name`プロパティが配置されています。

ここでアプリを起動し、すべてのヒーローモデルのプロパティを変更してみると、フォームは次のように表示されます。

![ngModel in super action](https://angular.io/resources/images/devguide/forms/ng-model-in-action-2.png)

フォームの一番上の方にある診断を見ると、モデルに行った変更内容がすべて反映されていることが確認できます。

当初の目的が満たされたので、一番上にある`{{diagnostic}}`バインディングを**削除**しておきます。

> #### [(ngModel)]の内側
> *このセクションでは補足として[(ngModel)]を深く追求してみます。興味がなかったら、見送ってどうぞ。*

> バインディングシンタックス[()]という符号は、何が起こっているかを知るためのいい手がかりとなります。

> プロパティバインディングでは、値がモデルから画面上のターゲットとなるプロパティに流れ込みます。ターゲットとなるプロパティは、名前をかぎ括弧[]でくくられて特定されます。これは**モデルからビューへ**の単方向データバインディングです。

> イベントバインディングでは、画面上のターゲットとなるプロパティからモデルへと値が流れ込みます。ターゲットとなるプロパティは、、名前を丸括弧()でくくられて特定されます。これは**ビューからモデルへ**と、逆方向になる単方向データバインディングです。

> なので、Angularが双方向データバインディングを表記し、**両方向へのデータの流れ**を示す方法として[()]という符号で連結することを選んだのは自然な流れといえるでしょう。

> 事実、`NgModel`バインディングを分割し、別々の２つのモードにわけることもできます。その場合、"Name" `<input>`バインディングを書き直すとこのようになります。

> ```html:app/hero-form.component.html(excerpt)
<input type="text" class="form-control" id="name"
       required
       [ngModel]="model.name" name="name"
       (ngModelChange)="model.name = $event" >
  TODO: remove this: {{model.name}}
```

> プロパティバインディングは馴染み深く感じられますが、イベントバインディングはちょっと変な感じがしますね。

> `ngModelChange`は`<input>`要素のイベントではありません。実を言うと、`ngModelChange`は、`NgModel`ディレクティブのイベントプロパティなのです。Angularはform [(x)]の中にあるバインディングのターゲットを確認すると、`x`ディレクティブには`x`インプットプロパティと`xChange`アウトプットプロパティがあると予測します。

> 他で変わっている点といえば、`model.name = $event`というテンプレートの表記でしょうか。DOMイベントから発生した`$event`オブジェクトはよくみることがあります。しかし、`ngModelChange` プロパティはDOMイベントを発生させるわけではありません。Angularの`EventEmitter`が、DOMイベントを発生させ、発火時にインプットボックスの値を返しています（正確にいえば、このとき返す値はモデルの`name`プロパティに割り当てられたものです）。

> さて、知ったはいいですが、これは実践的なことなのでしょうか？私たちはたいていの場合、 `[(ngModel)]`を使うことをよしとしますが、キー操作のデバウンスやスロットル処理のようなイベントバインディングで、特殊な方法を使わざるを得ないケースではバインディングを分割することもありえます。

> `NgModel`や他のテンプレートシンタックスについてもっと学びたいときは、[Template Syntax](https://angular.io/docs/ts/latest/guide/template-syntax.html)の章を参照してください。

### ngModelを使って、状態の変化と正当性を追跡する

フォームはただデータをバインディングさせるたけではありません。フォーム上にあるコントロールの状態を把握しておくことも必要です。

フォームで`ngModel`を使う場合、もたらされるメリットは双方向データバインディングだけてはありません。ユーザーがコントロールを触ったこと、値を変更したこと、または値が不正になったことなどを知らせてくれます。

NgModelディレクティブはただ状態を追跡するたけではありません。状態を反映したAngularの特殊なCSSを使い、コントロールを更新します。そのCSSの名前を入れ込むことで、コントロールの見かけを変更したり、メッセージの表示、非表示を行うことができるようになります。

| 状態| trueの場合のクラス | falseの場合のクラス |
|:-:|:-:|:-:|
|Control has been visited|`ng-touched`|`ng-untouched`|
|Control's value has changed|`ng-dirty`|`ng-pristine`|
|Control's value is valid|`ng-valid`|`ng-invalid`|

一時的に**spy**という名前の[テンプレート参照変数](https://angular.io/docs/ts/latest/guide/template-syntax.html#ref-vars)を"Name" `<input>`タグに加え、クラス名が表示されるspyを使ってみましょう。

```ts:app/hero-form.component.html(excerpt)
<input type="text" class="form-control" id="name"
  required
  [(ngModel)]="model.name" name="name"
  #spy >
<br>TODO: remove this: {{spy.className}}
```

アプリを起動し、Nameインプットボックスを見てみます。次の4つのステップに、*正確に*従ってください。

1. 触らずに、見てみる
2. インプットボックスをクリックし、そのあとテキストインプットボックスの外をクリックする
3. 名前の最後にスラッシュを加える
4. 名前を消す

アクションと効果は次のようになります。

![Control State Transition](https://angular.io/resources/images/devguide/forms/control-state-transitions-anim.gif)

クラスの名前とその変化を、次の4つのセットで確認できるようにしてみました。

![Control State Transitions](https://angular.io/resources/images/devguide/forms/ng-control-class-changes.png)

`ng-valid` と `ng-invalid`のペアは、大変興味深いです。データが不正なときは視覚的に強い信号を送りたいですし、必須フィールドには印をつけておきたいです。なので、視覚的フィードバックのためにカスタムCSSを加えてみます。

当初の目的が満たされたので、`#spy`テンプレート参照変数と`TODO`を**削除**してください。

### 視覚的フィードバックのためにカスタムCSSを加える

必須フィールドと不正なデータに対し、インプットボックスの左側に色のついたバーを同時につけることができます。

![Invalid Form](https://angular.io/resources/images/devguide/forms/validity-required-indicator.png)

プロジェクト上の`index.html`と同階層に`forms.css`という新しいファイルを加え、２つの新しいスタイルを追記することで、この効果を再現してみましょう。

```css:forms.css
.ng-valid[required], .ng-valid.required  {
  border-left: 5px solid #42A948; /* green */
}

.ng-invalid:not(form)  {
  border-left: 5px solid #a94442; /* red */
}
```
これらのスタイルは、Angularの正当性にかかるクラスと、HTML5の"required"属性の2つを選択しています。

これらのスタイルシートを反映するために、`index.html`の`<head>`を更新します。

```html:index.html(excerpt)
<link rel="stylesheet" href="styles.css">
<link rel="stylesheet" href="forms.css">
```
### バリデーションエラーメッセージの表示と非表示

もっとうまくやる方法があります。

"Name"インプットボックスは必須項目です。空欄にすると、赤いバーが表示されます。それは何かが間違っていることを示していますが、何が間違っているのか、何をすべきなのかがわかりません。ヘルプ用のメッセージを表示するために、`ng-invalid`クラスに手を加えます。

ユーザーが名前を削除したとき、ヘルプ用のメッセージが見えるようにしてみました。

![Name required](https://angular.io/resources/images/devguide/forms/name-required-error.png)

この効果を実現させるため、`<input>`タグを次のように拡張しました。

1. [テンプレート参照変数](https://angular.io/docs/ts/latest/guide/template-syntax.html#ref-vars)を加える
2. コントロールが不正な場合のみ`<input>` タグの近くに表示される`<div>`の中に、*"is required"*というメッセージを追加する

nameインプットボックスは次のようになります。

```html:app/hero-form.component.html(excerpt)
        <label for="name">Name</label>
        <input type="text" class="form-control" id="name"
               required
               [(ngModel)]="model.name" name="name"
               #name="ngModel" >
        <div [hidden]="name.valid || name.pristine" 
             class="alert alert-danger">
          Name is required
        </div>
```

テンプレートの中からインプットボックスにあるAngularコントロールにアクセスするためには、テンプレート参照変数が必要になります。ここでは`name`という変数を作り、"ngModel"という値を与えています。

> なぜ"ngModel"なんでしょうか。ディレクティブの [exportAs](https://angular.io/docs/ts/latest/api/core/index/Directive-decorator.html) プロパティは、参照変数をディレクティブにリンクさせる方法をAngularに伝えています。`ngModel`ディレクティブの`exportAs`プロパティが図らずも"ngModel"になったので、`name`に`ngModel`を設定しています。

> `name`コントロールのプロパティと、メッセージを扱う`<div>`要素の`hidden`プロパティをバインディングしたので、"name"にかかるエラーメッセージの視覚化も管理できるようになりました。

```html:app/hero-form.component.html(excerpt)
<div [hidden]="name.valid || name.pristine" 
     class="alert alert-danger">
```

このサンプルの場合、コントロールがvalid、もしくはpristineのときはメッセージが非表示になります。pristineは、このフォームが表示されてからユーザーによって値が変更されていないという意味です。

このUXは開発者の選択次第です。人によっては、常にメッセージを確認できるようにしたいかもしれません。`pristine`という状態を無視すれば、メッセージは値が正当なときのみ隠されるようになります。私たちが新しい（空欄の）ヒーローや不正なヒーローを伴ってこのコンポーネントにたどり着いたとき、何もしないうちにすぐエラーメッセージが表示されます。

しかし一方で、ある人たちはこのフォームのふるまいに面を食らうかもしれません。そういう人は、ユーザーが不正な変更を行ったときのみ、そのメッセージを確認したいと思っています。この場合は、コントロールが"pristine"の間メッセージを隠していれば目的は達成されます。フォームに[新しくヒーローを追加する](http://qiita.com/Yamamoto0525/items/1765c62e99dfab318660#%E3%83%92%E3%83%BC%E3%83%AD%E3%83%BC%E3%82%92%E8%BF%BD%E5%8A%A0%E3%81%97%E3%83%95%E3%82%A9%E3%83%BC%E3%83%A0%E3%82%92%E3%83%AA%E3%82%BB%E3%83%83%E3%83%88%E3%81%99%E3%82%8B)とき、この選択肢が重要となってきます。

ヒーローの`Alter Ego`はオプションなので、そのままにしておいて構いません。

ヒーローの`Power`というセレクションは必須項目です。必要であれば同様に`<select>`に対してエラーハンドリングを行うこともできますが、セレクションボックスはpowerに対し正当な値で制限されているので、あまり意味がありません。

### ヒーローを追加し、フォームをリセットする 

このフォームで新しいヒーローを追加しましょう。"New Hero"ボタンをフォームの底部に設置し、そのクリックイベントをコンポーネントのメソッドに紐づけます。

```html:app/hero-form.component.html(New_Hero_button)
<button type="button" class="btn btn-default" (click)="newHero()">New Hero</button>
```
```ts:app/hero-form.component.ts(New_Hero_method-v1)
newHero() {
  this.model = new Hero(42, '', '');
}
```

アプリケーションを再起動し、New Heroボタンをクリックするとフォームがクリアになります。インプットボックスの左にある`required`バーが赤くなり、`name`と`power`のプロパティが不正であることを示しています。これらは必須フィールドなので当然といえば当然ですが、まだフォームは初期状態（この部分は何も変更していません）なので、エラーメッセージは隠れたままです。

名前でエンターを押して、再度*New Hero*をクリックしてみましょう。今度はエラーメッセージが表示されました！なぜでしょうか。新しい（空欄の）ヒーローを表示するとき、そのような挙動は望ましくありません。

ブラウザツールで要素を調査してみると、nameインプットボックスがもはや初期状態ではなくなっていることがわかります。ヒーローを置き換えても、コントロールの*初期状態を復元するわけではありません*。

> この反応で、Angularはヒーローそのものを置き換えているのか、`name`プロパティをクリアにしているのかをプログラム上では区別できないことがわかります。Angularは仮定を行わず、コントローラを現在の、dirtyな状態のままにしておきます。

小技を使って、フォームコントロールを手動でリセットしなければいけません。コンポーネントに初期状態が`true`の`active`フラグを加えます。新しいヒーローを加えるときは、`active`をfalse に切り替え、さっと`setTimeout`を使ってすぐにtrueへ戻します。

```ts:app/hero-form.component.ts(New_Hero_method-final)
  active = true;

  newHero() {
    this.model = new Hero(42, '', '');
    this.active = false;
    setTimeout(() => this.active = true, 0);
  }
```

そのあと、フォーム要素をこの`active`フラグに紐づけます。

```html:app/hero-form.component.html(Form_tag)
<form *ngIf="active">
```

`NgIf`を`active`フラグと紐づければ、"New Hero"をクリックしたときにDOMからフォームを削除して瞬く間に再構築を行います。再構築されたフォームは初期状態となっており、エラーメッセージは隠れたままです。

> これは適切なフォームリセット機能を実装するまでの、一時的な措置です。

### ngSubmitでフォームを送信する

ユーザーがデータをフォームに入力したあとは、その内容を送信できないといけません。フォームの一番下にあるSubmitボタンそれ自体は特になんでもないですが、type (`type="submit"`)によってフォーム送信のトリガーとなります。

"form submit"は今のところ役に立ちません。有効にするには、もう一つのAngularディレクティブである`NgSubmit`を使って`<form>`を更新し、イベントバインディングを使って`HeroFormComponent.submit()`メソッドと紐づけます。

```html
<form *ngIf="active" (ngSubmit)="onSubmit()" #heroForm="ngForm">
```

最後のところに余分なものが入りました！`#heroForm`というテンプレート参照変数を定義し、"ngForm"という値を使って初期値を設定しています。

`heroForm`という変数は、フォーム全体を管理する`NgForm`ディレクティブを参照します。

> #### NgFormディレクティブ

> `NgForm`とは何でしょうか？結局、私たちは[NgForm](https://angular.io/docs/ts/latest/api/forms/index/NgForm-directive.html) ディレクティブは追加しませんでした。

> ただし、AngularはNgFormを追加しています。Angularは`NgForm`ディレクティブを作成し、`<form> `タグに対して自動的に付加します。

> `NgForm`ディレクティブは`form`要素を追加機能で補います。`ngModel`ディレクティブや`name`属性を伴う要素のコントロールをもち、その正当性も含めて、プロパティの監視を行います。すべてのコントロールが正当であると判断されたときのみ、trueである`valid`プロパティを自身が持つようになります。

テンプレートの後半で、`heroForm`変数を経由してボタンの`disabled`プロパティとフォーム全体の正当性を紐づけています。ここで少しマークアップしてみます。

```html
<button type="submit" class="btn btn-default" [disabled]="!heroForm.form.valid">Submit</button>
```

アプリケーションを再起動してください。フォームが正当な状態で開かれると、ボタンも使用可能になります。

では、`Name`を削除してください。以前と同様、エラーメッセージの中に"name required"ルールがちゃんと表示されますが、それを無視します。そのとき、Submitボタンもまたdisabledになっています。

すごくないですか？ちょっと考えてみてください。Angularの助けなくフォームの正当性をボタンのenable/disableに割り当てようとすると、どれだけのことをしないといけなくなるでしょうか。

ここで行った作業は単純です。

1. （拡張した）フォーム要素に、テンプレート参照変数を定義する
2. 50行程度離れたボタンにある変数を参照する

#### ２つのフォームの範囲を切り替える（特別クレジット）

フォーム送信は、もうそれほど劇的なものではありません。

> デモを見ていても驚きはありません。正直なところ、フォームに関してちょっと色をつけたところで、新しく学ぶものは何もないのです。しかしこれは新しく、成功するためのバインディングスキルを身に着ける絶好の機会といえます。もし興味がなければ、この章の総論は飛ばして、うまくやってください。

さあ、もう少し視覚的なことをやっていきましょう。データ入力エリアを隠し、ほかの何かを表示させてみます。

`<div>`でフォームを入れ子にしてから開始し、`hidden`プロパティと`HeroFormComponent.submitted`プロパティを紐づけます。

```html:app/hero-form.component.html(excerpt)
  <div  [hidden]="submitted">
    <h1>Hero Form</h1>
    <form *ngIf="active" (ngSubmit)="onSubmit()" #heroForm="ngForm">

       <!-- ... all of the form ... -->

    </form>
  </div>
```

`submitted`プロパティはフォームが送信されるまではfalse なので、メインフォームは最初から視覚化されています。この`HeroFormComponent`からのフラグは覚えておきましょう。

```ts
submitted = false;

onSubmit() { this.submitted = true; }
```

Submitボタンをクリックすると、`submitted`フラグがtrueになり、formが予定通り非表示になります。

フォームが送信済の間、何かを表示しておく必要があるでしょう。今作成した`<div>`ラッパーの下に次のHTMLブロックを追加してください。

```html:app/hero-form.component.html(excerpt)
<div [hidden]="!submitted">
  <h2>You submitted the following:</h2>
  <div class="row">
    <div class="col-xs-3">Name</div>
    <div class="col-xs-9  pull-left">{{ model.name }}</div>
  </div>
  <div class="row">
    <div class="col-xs-3">Alter Ego</div>
    <div class="col-xs-9 pull-left">{{ model.alterEgo }}</div>
  </div>
  <div class="row">
    <div class="col-xs-3">Power</div>
    <div class="col-xs-9 pull-left">{{ model.power }}</div>
  </div>
  <br>
  <button class="btn btn-default" (click)="submitted=false">Edit</button>
</div>
```

私たちのヒーローが、インターポレーションバインディングによって閲覧用に再表示されました。
このHTMLのコードはコンポーネントが送信済のときのみ表示されます。

Editボタンを加え、そのクリックイベントと`submitted`フラグを削除する動作を紐づけます。

それをクリックすると、このブロックは非表示になり、編集可能なフォームが再表示されます。

これでだいぶ気持ちが昂ぶってきたんじゃないでしょうか。

## 総論

この章で論じられたAngularフォームのテクニックは、次のようなフレームワークの機能で有効です。データ修正やバリーデーションなどのサポートを提供してくれます。

- AngularのHTMLフォームテンプレート
- `Component`デコレータを伴うフォームコンポーネントクラス
- フォーム送信を扱う`ngSubmit`ディレクティブ
- `#heroForm`、`#name`、`#power`のようなテンプレート参照変数
- 双方向データバインディング、バリデーション、変更監視で使う`[(ngModel)]`シンタックスと`name`属性
- コントロールが正当であり、エラーメッセージの表示なのか、非表示なのかをチェックする、インプットコントロール上にある参照変数の`valid`プロパティ
- `NgForm`の正当性とバインディングして、submitボタンが利用可能かどうかを管理する
- ユーザーに不正なコントロールに関する視覚的フィードバックを行うカスタムCSSクラス

最終的なプロジェクトのフォルダ構成は次のようになりました。

angular-forms
├ app
│ ├ app.component.ts
│ ├ app.module.ts
│ ├ hero.ts
│ ├ hero-form.component.html
│ ├ hero-form.component.ts
│ └ main.ts
├ node_modules ...
├ index.html
├ package.json
└ tsconfig.json


ソースの最終版は次の通りです。

```ts:hero-form.component.ts
import { Component } from '@angular/core';
import { Hero }    from './hero';
@Component({
  moduleId: module.id,
  selector: 'hero-form',
  templateUrl: 'hero-form.component.html'
})
export class HeroFormComponent {
  powers = ['Really Smart', 'Super Flexible',
            'Super Hot', 'Weather Changer'];
  model = new Hero(18, 'Dr IQ', this.powers[0], 'Chuck Overstreet');
  submitted = false;
  onSubmit() { this.submitted = true; }
  // Reset the form with a new hero AND restore 'pristine' class state
  // by toggling 'active' flag which causes the form
  // to be removed/re-added in a tick via NgIf
  // TODO: Workaround until NgForm has a reset method (#6822)
  active = true;
  newHero() {
    this.model = new Hero(42, '', '');
    this.active = false;
    setTimeout(() => this.active = true, 0);
  }
}
```

```html:hero-form.component.html
<div class="container">
  <div  [hidden]="submitted">
    <h1>Hero Form</h1>
    <form *ngIf="active" (ngSubmit)="onSubmit()" #heroForm="ngForm">
      <div class="form-group">
        <label for="name">Name</label>
        <input type="text" class="form-control" id="name"
               required
               [(ngModel)]="model.name" name="name"
               #name="ngModel" >
        <div [hidden]="name.valid || name.pristine" 
             class="alert alert-danger">
          Name is required
        </div>
      </div>
      <div class="form-group">
        <label for="alterEgo">Alter Ego</label>
        <input type="text" class="form-control" id="alterEgo"
               [(ngModel)]="model.alterEgo" name="alterEgo" >
      </div>
      <div class="form-group">
        <label for="power">Hero Power</label>
        <select class="form-control" id="power"
                required
                [(ngModel)]="model.power" name="power" 
                #power="ngModel" >
          <option *ngFor="let p of powers" [value]="p">{{p}}</option>
        </select>
        <div [hidden]="power.valid || power.pristine" class="alert alert-danger">
          Power is required
        </div>
      </div>
      <button type="submit" class="btn btn-default" [disabled]="!heroForm.form.valid">Submit</button>
      <button type="button" class="btn btn-default" (click)="newHero()">New Hero</button>
    </form>
  </div>
  <div [hidden]="!submitted">
    <h2>You submitted the following:</h2>
    <div class="row">
      <div class="col-xs-3">Name</div>
      <div class="col-xs-9  pull-left">{{ model.name }}</div>
    </div>
    <div class="row">
      <div class="col-xs-3">Alter Ego</div>
      <div class="col-xs-9 pull-left">{{ model.alterEgo }}</div>
    </div>
    <div class="row">
      <div class="col-xs-3">Power</div>
      <div class="col-xs-9 pull-left">{{ model.power }}</div>
    </div>
    <br>
    <button class="btn btn-default" (click)="submitted=false">Edit</button>
  </div>
</div>
```
```ts:hero.ts
export class Hero {
  constructor(
    public id: number,
    public name: string,
    public power: string,
    public alterEgo?: string
  ) {  }
}
```

```ts:app.module.ts
import { NgModule }      from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule }   from '@angular/forms';
import { AppComponent }  from './app.component';
import { HeroFormComponent } from './hero-form.component';
@NgModule({
  imports: [
    BrowserModule,
    FormsModule
  ],
  declarations: [
    AppComponent,
    HeroFormComponent
  ],
  bootstrap: [ AppComponent ]
})
export class AppModule { }
```

```ts:app.component.ts
import { Component } from '@angular/core';
@Component({
  selector: 'my-app',
  template: '<hero-form></hero-form>'
})
export class AppComponent { }
```

```ts:main.ts
import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
import { AppModule } from './app.module';
// Compiles the module (asynchronously) with the runtime compiler
// which generates a compiled module factory in memory.
// Then bootstraps with that factory, targeting the browser.
platformBrowserDynamic().bootstrapModule(AppModule);
```

```html:index.html
<html>
  <head>
    <title>Hero Form</title>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="stylesheet" 
          href="node_modules/bootstrap/dist/css/bootstrap.min.css">
    <link rel="stylesheet" href="styles.css">
    <link rel="stylesheet" href="forms.css">
    <!-- Polyfill(s) for older browsers -->
    <script src="node_modules/core-js/client/shim.min.js"></script>
    <script src="node_modules/zone.js/dist/zone.js"></script>
    <script src="node_modules/reflect-metadata/Reflect.js"></script>
    <script src="node_modules/systemjs/dist/system.src.js"></script>
    <script src="systemjs.config.js"></script>
    <script>
      System.import('app').catch(function(err){ console.error(err); });
    </script>
  </head>
  <body>
    <my-app>Loading...</my-app>
  </body>
</html>
```

```css:forms.css
.ng-valid[required], .ng-valid.required  {
  border-left: 5px solid #42A948; /* green */
}
.ng-invalid:not(form)  {
  border-left: 5px solid #a94442; /* red */
}
```

> **Next Step**
> [DEPENDENCY INJECTION - 依存性注入 -](http://qiita.com/Yamamoto0525/items/23a1756e9b32bfb6f328)