深入了解Angular（新手入门指南）

|-- project
	|-- .editorconfig // 用于在不同编辑器中统一代码风格
	|-- .gitignore // git中的忽略文件列表
	|-- README.md // markdown格式的说明文件
	|-- angular.json // angular的配置文件
	|-- browserslist // 用于配置浏览器兼容性的文件
	|-- karma.conf.js // 自动化测试框架Karma的配置文件
	|-- package-lock.json // 依赖包版本锁定文件
	|-- package.json // npm的包定义文件
	|-- tsconfig.app.json // 用于app项目的ts配置文件
	|-- tsconfig.json // 整个工作区的ts配置文件
	|-- tsconfig.spec.json // 用于测试的ts配置文件
	|-- tslint.json // ts的代码静态扫描配置
	|-- e2e // 自动化集成测试目录
	|-- src // 源代码目录
 
|-- src // 源代码目录
	|-- favicon.ico // 收藏图标
	|-- index.html // 单页应用到宿主HTML
	|-- main.ts // 入口 ts 文件
	|-- polyfills.ts // 用于不同浏览器的兼容脚本加载
	|-- styles.css // 整个项目的全局css
	|-- test.ts // 测试入口
	|-- app // 工程源码目录
	|-- assets // 资源目录
	|-- environments // 环境配置
		|-- environments.prod.ts // 生产环境
		|-- environments.ts // 开发环境

@Component({
  selector: 'app-xxx',
  templateUrl: 'XXX',
  styleUrls: ['XXX'],
  encapsulation:ViewEncapsulation.Emulated  // 不写则默认该值，表示该组件样式只作用于组件本身，不影响全局样式，在 head 中生成单独的 style 标签
})

// 父组件调用子组件的时候传入数据
<app-header [msg]="msg"></app-header>

// 子组件引入 Input 模块
import { Component, OnInit ,Input } from &#39;@angular/core&#39;;

// 子组件中 @Input 装饰器接收父组件传过来的数据
export class HeaderComponent implements OnInit {
  @Input() msg:string
	constructor() { }
	ngOnInit() { }
}

// 子组件中使用父组件的数据
<h2>这是头部组件--{{msg}}</h2>

// 子组件引入 Output 和 EventEmitter
import { Component,OnInit,Input,Output,EventEmitter} from '@angular/core';

// 子组件中实例化 EventEmitter
// 用 EventEmitter 和 @Output 装饰器配合使用 <string> 指定类型变量
@Output() private outer=new EventEmitter<string>();

// 子组件通过 EventEmitter 对象 outer 实例广播数据
sendParent(){
  this.outer.emit(&#39;msg from child&#39;)
}

// 父组件调用子组件的时候，定义接收事件，outer 就是子组件的 EventEmitter 对象 outer
<app-header (outer)="runParent($event)"></app-header>

// 父组件接收到数据会调用自己的 runParent, 这个时候就能拿到子组件的数据
// 接收子组件传递过来的数据
  runParent(msg:string){
   alert(msg);
}

// 给子组件定义一个名称
<app-footer #footerChild></app-footer>

// 引入 ViewChild
import { Component, OnInit ,ViewChild} from &#39;@angular/core&#39;;

// ViewChild 和子组件关联起来
@ViewChild(&#39;footerChild&#39;) footer;

// 调用子组件
run(){
   this.footer.footerRun();
}

// 表现形式： <ng-content select="样式类/HTML标签/指令"></ng-content>

<ng-content select="[appGridItem]"></ng-content>

<div [ngClass]="{&#39;red&#39;: true, &#39;blue&#39;: false}">
  这是一个 div
</div>

<div [ngStyle]="{&#39;background-color&#39;:&#39;green&#39;}">你好 ngStyle</div>

// 注意引入：FormsModule
import { FormsModule } from '@angular/forms';

<input type="text" [(ngModel)]="inputValue"/> {{inputValue}}

<p *ngIf="list.length > 3">这是 ngIF 判断是否显示</p>

<div *ngIf="show else ElseContent">这是 ngIF 内容</div>
<ng-template #ElseContent>
  <h2>这是 else 内容</h2>
</ng-template>

// 结构性指令都依赖于 ng-template，*ngIf 实际上就是 ng-template 指令的 [ngIf] 属性。

<ul>
  <li *ngFor="let item of list;let i = index;">
     {{item}} --{{i}}
  </li>
</ul>

<ul [ngSwitch]="score">
   <li *ngSwitchCase="1">已支付</li>
   <li *ngSwitchCase="2">已确认</li>
   <li *ngSwitchCase="3">已发货</li>
   <li *ngSwitchDefault>已失效</li>
</ul>

@HostBinding('style.display') display = "grid";

// 用样式绑定代替rd2的 this.setStyle('display','grid');

@HostListener('click',['$event.target'])

// 第一个参数是事件名，第二个是事件携带参数

/**
 * 在功能模块中定义子路由后，只要导入该模块，等同于在根路由中直接定义
 * 也就是说在 AppModule 中导入 HomeModule 的时候，
 * 由于 HomeModule 中导入了 HomeRouting Module
 * 在 HomeRoutingModule 中定义的路由会合并到根路由表
 * 相当于直接在根模块中定义下面的数组。
 * const routes = [{
 *   path: 'home',
 *   component: HomeContainerComponent
 * }]
 */

const routes: Routes = [
  {path: 'home', component: HomeComponent},
  {path: 'news', component: NewsComponent},
  {path: 'newscontent/:id', component: NewscontentComponent},  // 配置动态路由
  {
    path: '',
    redirectTo: '/home',  // 重定向
    pathMatch: 'full'
	},
  //匹配不到路由的时候加载的组件 或者跳转的路由
  {
     path: '**', /*任意的路由*/
     // component:HomeComponent
     redirectTo:'home'
  }
]

@NgModule({
  /**
   * 根路由使用 `RouterModule.forRoot(routes)` 形式。
   * 而功能模块中的路由模块使用 `outerModule.forChild(routes)` 形式。
   * 启用路由的 debug 跟踪模式，需要在根模块中设置 `enableTracing: true`
   */
  imports: [RouterModule.forRoot(routes, { enableTracing: true })],
  exports: [RouterModule]
})
export class AppRoutingModule { }

<h1>
  <a [routerLink]="[&#39;/home&#39;]">首页</a>
  <a [routerLink]="[&#39;/home&#39;,tab.link]">首页</a><!-- 路径参数 -->
  <a [routerLink]="[&#39;/home&#39;,tab.link,{name:&#39;val1&#39;}]">首页</a> <!-- 路径对象参数 -->
  <a [routerLink]="[&#39;/home&#39;]" [queryParams]="{name:&#39;val1&#39;}">首页</a> <!-- 查询参数 -->
</h1>
<router-outlet></router-outlet>  <!-- 路由插座，占位标签 -->
<!--
  路由显示的内容是插入到 router-outlet 的同级的下方节点
  而不是在 router-outlet 中包含
-->
<!--
  当事件处理或者达到某个条件时，可以使用手动跳转
	this.router.navigate([&#39;home&#39;]); 
	this.router.navigate([&#39;home&#39;,tab.link]); 
	this.router.navigate([&#39;home&#39;,tab.link，{name:&#39;val1&#39;}]); 
	this.router.navigate([&#39;home&#39;],{queryParams:{name:&#39;val1&#39;}}); 
-->

<h1>
    <a routerLink="/home" routerLinkActive="active">首页</a>
    <a routerLink="/news" routerLinkActive="active">新闻</a>
</h1>

<h1>
   <a [routerLink]="[ &#39;/home&#39; ]" routerLinkActive="active">首页</a>
   <a [routerLink]="[ &#39;/news&#39; ]" routerLinkActive="active">新闻</a>
</h1>

.active{
   color:red;
}

this.route.paramsMap.subscribe(params => {...})

this.route.queryParamsMap.subscribe(params => {...})

constructor(private routerInfo: ActivatedRoute){}
ngOnInit(){
	this.routerInfo.snapshot.params['id']
}

constructor(private routerInfo: ActivatedRoute){}
ngOnInit(){
	this.routerInfo.snapshot.params['id']
	this.routerInfo.snapshot.params['name']
}

const routes: Routes = [
    {path:'user',loadChildren:'./module/user/user.module#UserModule' },
    {path:'product',loadChildren:'./module/product/product.module#ProductModule'},
    {path:'article',loadChildren:'./module/article/article.module#ArticleModule'},
    {path:'**',redirectTo:'user'}
];

// 上面好像会报错 Error find module 
// 配置懒加载
const routes: Routes = [
    {path:'user',loadChildren:()=>import('./module/user/user.module').then(mod=>mod.UserModule)},
    {path:'article',loadChildren:()=>import('./module/article/article.module').then(mod=>mod.ArticleModule)},
    {path:'product',loadChildren:()=>import('./module/product/product.module').then(mod=>mod.ProductModule)},
    {path:'**',redirectTo:'user'}
];

import { Injectable } from '@angular/core';
@Injectable({
  providedIn: 'root',
})
export class HeroService {
  aa = 'abc';
  constructor(){ }
  ngOnInit(){ }
}

import { HeroService } from '../../../services/hero/hero.service';
export class AComponent implements OnInit{
  constructor(private heroService : HeroService) {} //实例化
  ngOnInit(){
    console.log(this.heroService.aa)
  }
}

  constructor(private heroService : HeroService) {} // 依赖注入

// 首先写 @injectable 我们需要注入的东西，比如说 product
@Injectable()
class Product {
  constructor(
    private name: string,
    private color: string,
    private price: number,
  ) { }
}

class PurchaseOrder {
  constructor(private product: Product){ }
}
 
export class HomeGrandComponent implements OnInit {
  constructor() { }
  ngOnInit() {
    // 构造一个 injector 用 create 方法 里面 providers 数组中写我们需要构造的东西
    const injector = Injector.create({
      providers: [
        {
          provide: Product,
          // 构造 Product 在 useFactory 中就会把上面定义的 product 注入到这里
          useFactory: () => {
            return new Product('大米手机', '黑色', 2999);
          },
          deps: []
        },
        {
          provide: PurchaseOrder,
          deps: [Product]
        },
        {
          provide: token,
          useValue: { baseUrl: 'http://local.dev' }
        }
      ]
    }); 
    console.log('injector获取product', injector.get(PurchaseOrder).getProduct);
    console.log(injector.get(token));
  }

// .service.ts 中 @Injectable () 依赖注入
@Injectable()
export class HomeService {
  imageSliders: ImageSlider[] = [
    {
      imgUrl:'',
      link: '',
      caption: ''
    }
  ]
  getBanners() {
    return this.imageSliders;
  }
}

// 使用模块对应的.module.ts 中
@NgModule({
  declarations: [
    HomeDetailComponent,
  ],
  providers:[HomeService], // 在 providers 直接写对应服务，直接将服务注入模块
  imports: [SharedModule, HomeRoutingModule]
})

<div>{{ &#39;Angular&#39; | uppercase }}</div>  <!-- Output: ANGULAR -->

<div>{{ data | date:&#39;yyyy-MM-dd&#39; }}</div>  <!-- Output: 2022-05-17 -->

<div>{{ { name: &#39;ccc&#39; } | json }}</div>  <!-- Output: { "name": "ccc" } -->

<!-- 
	管道可以接收任意数量的参数，使用方式是在管道名称后面添加: 和参数值
	若需要传递多个参数则参数之间用冒号隔开 
-->

<!-- 可以将多个管道连接在一起，组成管道链对数据进行处理 -->
<div>{{ &#39;ccc&#39; | slice:0:1 | uppercase }}</div>

// 引入PipeTransform是为了继承transform方法
import { Pipe, PipeTransform } form '@angular/core'; 
// name属性值惯用小驼峰写法, name的值为html中 | 后面的名称
@Pipe({ name: 'sexReform' }) 
export class SexReformPipe implements PipeTransform {
    transform(value: string, args?: any): string {
    // value的值为html中 | 前面传入的值， args为名称后传入的参数
        switch(value){
            case 'male': return '男';
            case 'female': return '女';
            default: return '雌雄同体';
        } 
    }
}

// demo.component.ts
export Class DemoComponent {
    sexValue = 'female';
}

// demo.component.html
<span>{{ sexValue | sexReform }}</span>

// 浏览器输出
女

// 管道可以链式使用，还可以传参
<span> {{date | date: &#39;fullDate&#39; | uppercase}} </span>
// 每一个自定义管道都需要实现 PipeTransform 接口，这个接口非常简单，只需要实现 transform 方法即可。
// transform()方法参数格式 - transform(value: string, args1: any, args2?: any): 
// value为传入的值（即为需要用此管道处理的值， | 前面的值）; 
// args 为传入的参数(?:代表可选)；
// html 中使用管道格式 - {{ 数据 | 管道名 : 参数1 : 参数2 }}
// 与 component 一样,pipe 需要先在 declarations 数组中声明后使用

ngAfterViewInit(){
   var boxDom:any=document.getElementById('box');
   boxDom.style.color='red';
}

class ElementRef<T> {
  constructor(nativeElement: T)
  nativeElement: T  //背后的原生元素，如果不支持直接访问原生元素，则为 null（比如：在 Web Worker 环境下运行此应用的时候）。
}

// 模版中给 DOM 起一个引用名字，以便可以在组件类或模版中进行引用 <div #myattr></div>

// 引入 ViewChild
import { ViewChild,ElementRef } from &#39;@angular/core&#39;;

// 用 ViewChild 绑定 DOM	
@ViewChild(&#39;myattr&#39;) myattr: ElementRef;

// 在 ngAfterViewInit 生命周期函数里可以很安全的获取 ViewChild 引用的 DOM
ngAfterViewInit(){
   let attrEl = this.myattr.nativeElement;
}

// 给子组件定义一个名称
<app-footer #footerChild></app-footer>

// 引入 ViewChild
import { Component, OnInit ,ViewChild} from &#39;@angular/core&#39;;

// ViewChild 和子组件关联起来 
// 如果想引用模版中的 Angular 组件，ViewChild 中可以使用引用名，也可以使用组件类型
@ViewChild(&#39;footerChild&#39;) footer;

// @ViewChild(&#39;imageSlider&#39;, { static: true }) // static指定是动态还是静态，在*ngFor或者*ngIf中是动态，否则即为静态，动态为 true

// 调用子组件
run(){
   this.footer.footerRun();
}

<img
  #img
  *ngFor="let slider of sliders"
  [src]="slider.imgUrl"
  [alt]="slider.capiton"
>

// 使用 ViewChildren 引用获取
@ViewChildren（’img‘）;

// 使用类型引用获取
imgs: QueryList<ElementRef>;

import { Directive, Renderer2, ElementRef, OnInit } from '@angular/core';

@Directive({
    selector: '[testRenderer2]'
})

export class TestRenderer2Directive implements OnInit {
    constructor(private renderer: Renderer2, private el: ElementRef) {} // 实例化

    ngOnInit() {
    this.renderer.addClass(this.el.nativeElement, 'test-renderer2');
    // this.renderer.removeClass(this.el.nativeElement, 'old-class');
    }
}

import { Directive, Renderer2, ElementRef, OnInit } from '@angular/core';

constructor(private renderer: Renderer2, private el: ElementRef) {}

ngOnInit() {
    const div = this.renderer.createElement('div');
    const text = this.renderer.createText('Hello world!');
    
    this.renderer.appendChild(div, text);
    this.renderer.appendChild(this.el.nativeElement, div);
}

import { Directive, Renderer2, ElementRef, OnInit } from '@angular/core';

constructor(private renderer: Renderer2, private el: ElementRef) {}

ngOnInit() {
    this.renderer.setAttribute(this.el.nativeElement, 'aria-hidden', 'true');
}

import { Directive, Renderer2, ElementRef, OnInit } from '@angular/core';

constructor(private renderer: Renderer2, private el: ElementRef) {}

ngOnInit() {
    this.renderer.setStyle(
        this.el.nativeElement,
        'border-left',
        '2px dashed olive'
    );
}

constructor(private renderer: Renderer2, private el: ElementRef) {}

ngOnInit() {
    this.renderer.removeStyle(this.el.nativeElement, 'border-left');
}

constructor(private renderer: Renderer2, private el: ElementRef) {}

ngOnInit() {
    this.renderer.setProperty(this.el.nativeElement, 'alt', 'Cute alligator');
}

import {
  Component,
  OnInit,
  Renderer2,
  ViewChild,
} from '@angular/core';
import { AboxItemComponent } from './abox-item/abox-item.component';
 
@Component({
  selector: 'app-abox',
  templateUrl: './abox.component.html',
  styleUrls: ['./abox.component.less'],
})
export class AboxComponent implements OnInit {
  private container;
  activeIndex: number;
  @ViewChild('containers') containers: any;
  constructor(private rd2: Renderer2) {}
 
  ngOnInit(): void {}
 
  ngAfterViewInit(): void {
    this.container = this.containers.nativeElement;
    this.initCarouselWidth();
  }
    
  initCarouselWidth() {
    this.rd2.setStyle(this.container, 'width', '100px');
  }
}

// 在 app.module.ts 中引入 HttpClientModule 并注入
import {HttpClientModule} from '@angular/common/http';
imports: [
  BrowserModule,
  HttpClientModule
]

// 在用到的地方引入 HttpClient 并在构造函数声明
import {HttpClient} from "@angular/common/http";
constructor(private http: HttpClient,private cd: ChangeDetectorRef) { } // 依赖注入

// get 请求数据
var api = "http://baidu.com/api/productlist";
this.http.get(api).subscribe(response => {
  console.log(response);
  this.cd.markForCheck()；
  // 如果改变了脏值检测的变更原则 changeDetection: ChangeDetectionStrategy.OnPush
  // 则需要使用 this.cd.markForCheck() 手动提醒 Angular 这里需要进行脏值检测
});

// 在 app.module.ts 中引入 HttpClientModule 并注入
import {HttpClientModule} from '@angular/common/http';
imports: [
   BrowserModule,
   HttpClientModule
]

// 在用到的地方引入 HttpClient 、HttpHeaders 并在构造函数声明 HttpClient
import {HttpClient,HttpHeaders} from "@angular/common/http";
constructor(private http:HttpClient) { } // 实例化

// post 提交数据
const httpOptions = {
    headers: new HttpHeaders({ 'Content-Type': 'application/json' })
};
var api = "http://127.0.0.1:4200/doLogin";
this.http.post(api,{username:'瑞萌萌',age:'22'},httpOptions).subscribe(response => {
		console.log(response);
});

// 在 app.module.ts 中引入 HttpClientModule、HttpClientJsonpModule 并注入
import {HttpClientModule,HttpClientJsonpModule} from'@angular/common/http';
imports: [
   BrowserModule,
   HttpClientModule,
   HttpClientJsonpModule
]

// 在用到的地方引入 HttpClient 并在构造函数声明
import {HttpClient} from "@angular/common/http";
constructor(private http:HttpClient) { } // 实例化

// jsonp 请求数据
var api = "http://baidu.com/api/productlist";
this.http.jsonp(api,'callback').subscribe(response => {
   console.log(response);
});

// 使用命令 ng g interceptor name，在这里创建拦截器 ng g interceptor LanJieQi
// cli 生成拦截器是没有简写方式的

import { Injectable } from '@angular/core';
import {
  HttpRequest,
  HttpHandler,
  HttpEvent,
  HttpInterceptor
} from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable()
export class LanJieQiInterceptor implements HttpInterceptor {
  constructor() {}
  // 默认的 intercept() 方法只是单纯的将请求转发给下一个拦截器（如果有），并最终返回 HTTP 响应体的 Observable
  // request: HttpRequest<unknown> 表示请求对象，包含了请求相关的所有信息,unknown指定请求体body的类型
  // next: HttpHandler 请求对象修改完成，将修改后的请求对象通过next中的handle方法传回真正发送请求的方法中
  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> 	{
    // next 对象表示拦截器链表中的下一个拦截器（在应用中可以设置多个拦截器）
    return next.handle(request);
  }
}

// 在 @NgModule 模块中注入拦截器
// 拦截器也是一个由 Angular 依赖注入 (DI) 系统管理的服务，也必须先提供这个拦截器类，才能使用它
// 由于拦截器是 HttpClient 服务的依赖，所以必须在提供 HttpClient 的同一个（或其各级父注入器）注入器中提供这些拦截器
@NgModule({
  imports: [
    HttpClientModule
    // others...
  ],
  providers: [
    {
      provide: HTTP_INTERCEPTORS,
      useClass: LanJieQiInterceptor,
      // multi: true 表明 HTTP_INTERCEPTORS 是一个多重提供者的令牌，表示这个令牌可以注入多个拦截器
      multi: true
    },
  ],
  bootstrap: [AppComponent]
})

export class AppModule { }

@Injectable()export class LanJieQiInterceptor implements HttpInterceptor {
  constructor() {}
  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> 	{
    // 为了统一设置请求头，需要修改请求
    // 但 HttpRequest 和 HttpResponse 实例的属性却是只读（readonly）的
    // 所以修改前需要先 clone 一份，修改这个克隆体后再把它传给 next.handle()
    let req = request.clone({
    	setHeaders:{
      	token:"123456" // 在请求头中增加 token：123456
    	}
			// setHeaders 和 headers: request.headers.set(&#39;token&#39;, &#39;123456&#39;) 一致
  	})
  	return next.handle(req)// 将修改后的请求返回给应用
  }}

@Injectable()
export class LanJieQiInterceptor implements HttpInterceptor {
  constructor() {}
  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> 	{
    // 为了统一设置请求头，需要修改请求
    // 但 HttpRequest 和 HttpResponse 实例的属性却是只读（readonly）的
    // 所以修改前需要先 clone 一份，修改这个克隆体后再把它传给 next.handle()
    let req = request.clone({
    	setHeaders:{
      	token:"123456" // 在请求头中增加 token：123456
    	}
			// setHeaders 和 headers: request.headers.set(&#39;token&#39;, &#39;123456&#39;) 一致
  	})
  	return next.handle(req)// 将修改后的请求返回给应用
  }
}

// 先在 NgModule 中导入了 FormsModule 表单库
// FormsModule 为我们提供了一些模板驱动的指令，例如：ngModel、NgForm
import { 
  FormsModule
} from '@angular/forms'; 

@NgModule({ 
  declarations: [ 
    FormsDemoApp, 
    DemoFormSku, 
    // ... our declarations here 
  ], 
  imports: [ 
    BrowserModule, 
    FormsModule,
  ], 
  bootstrap: [ FormsDemoApp ] 
}) 
class FormsDemoAppModule {}

 <div>
      <h2>基础表单:商品名称</h2>
      <form #f="ngForm" (ngSubmit)="onSubmit(f.value)">
        <div class="sku">
          <label for="skuInput">商品名称:</label>
          <input
            type="text"
            id="skuInput"
            placeholder="商品名称"
            name="sku" //使用form时必须定义，可以理解为当前控件的名字
            ngModel
          />
        </div>
        <button>提交</button>
      </form>
    </div>

 <form #f="ngForm" (ngSubmit)="onSubmit(f.value)" >
 <!-- 
	这里使用了 #f=“ngForm”，#v=thing 的意思是我们希望在当前视图中创建一个局部变量
	这里为视图中的 ngForm 创建了一个别名，并绑定到变量 #f
	这个 ngForm 是由 NgForm 指令导出的
	ngForm 的类型的对象是 FormGroup 类型的
	这意味着可以在视图中把变量 f 当作 FormGroup 使用，而这也正是我们在输出事件 (ngSubmit) 中的使用方法
	在表单中绑定 ngSubmit 事件 (ngSubmit)=“onSubmit (f.value)“
	(ngSubmit) 来自 NgForm 指令
	onSubmit() 将会在组件类中进行定义
	f 就是 FormGroup ，而 .value 会以键值对的形式返回 FormGroup 中所有控件的值
	
	总结：当提交表单时，将会以该表单的值作为参数，调用组件实例上的 `onSubmit` 方法
-->

// 先在 NgModule 中导入了 ReactiveFormsModule 表单库
import { 
  ReactiveFormsModule 
} from '@angular/forms'; 
@NgModule({
  imports: [
    FormsModule,
    ReactiveFormsModule
  ]
}) 

// 使用 formGroup 和 formControl 指令来构建这个组件，需要导入相应的类
import { 
  FormBuilder, 
  FormGroup,
  ReactiveFormsModule
} from '@angular/forms'; 

// 在组件类上注入一个从 FormBuilder 类创建的对象实例，并把它赋值给 fb 变量（来自构造函数）
export class DemoFormSkuBuilder { 
  myForm: FormGroup;  // myForm 是 FormGroup 类型
  constructor(fb: FormBuilder) { 
    // FormBuilder 中的 group 方法用于创建一个新的 FormGroup
    // group 方法的参数是代表组内各个 FormControl 的键值对
    this.myForm = fb.group({  // 调用 fb.group () 来创建 FormGroup
      // 设置一个名为 sku 的控件，控件的默认值为 "123456"
      'sku': ['123456'] 
    }); 
  }
  onSubmit(value: string): void { 
    console.log('submit value:', value); 
  } 
}

<h2 class="ui header">Demo Form: Sku with Builder</h2>
<!--  
	当导入 FormsModule 时，ngForm 就会自动创建它自己的 FormGroup
	但这里不希望使用外部的 FormGroup，而是使用 FormBuilder 创建这个 myForm 实例变量
	Angular提供了 formGroup 指令，能让我们使用现有的 FormGroup
	NgForm 不会应用到带 formGroup 属性的节点上
	这里我们告诉Angular，想用 myForm 作为这个表单的 FormGroup
-->
<form [formGroup]="myForm" 
  <label for="skuInput"> SKU </label> 
  <input type="text" 
     id="skuInput" 
     placeholder="SKU" 
     [formControl]="myForm.controls[&#39;sku&#39;]">
<!--  
	将 FormControl 绑定到 input 标签上 : 
	ngModel 会创建一个新的 FormControl 对象并附加到父 FormGroup 中
	但在例子中，我们已经用 FormBuilder 创建了自己的 FormControl
	要将现有的 FormControl 绑定到 input 上，可以用 formControl 指令
	将 input 标签上的 formControl 指令指向 myForm.controls 上现有的 FormControl 控件 sku  
-->

const control = new FormControl('name', Validators.required);

// 在组件定义类中使用 FormBuilder
  constructor(fb: FormBuilder) { 
    this.myForm = fb.group({ 
      'name': ['',Validators.required] 
    }); 
    this.name = this.myForm.controls['name']; 
  }

template:`<div>
      <h2>商品表单:商品名称</h2>
      <form [formGroup]="myForm" (ngSubmit)="onSubmit(myForm)">
        <div>
          <label for="nameInput">商品名称：</label>
          <input
            type="text"
            id="nameInput"
            placeholder="请输入名称"
            [formControl]="myForm.controls[&#39;name&#39;]"
          />
          <div style="color:red" *ngIf="!name.valid">
            名称无效
          </div>
          <div style="color:red" *ngIf="name.hasError(&#39;textinvalid&#39;)">
            名称不是以“123”开头
          </div>
          <div *ngIf="name.dirty">
            数据已变动
          </div>
        </div>
        <div>
          <label for="codeInput">商品料号：</label>
          <input
            type="text"
            id="codeInput"
            placeholder="请输入料号"
            [formControl]="myForm.controls[&#39;code&#39;]"
          />
          <div
            style="color:red"
            *ngIf="myForm.controls.code.hasError(&#39;required&#39;)"
          >
            该项必填
          </div>
          <div
            style="color:red"
            *ngIf="myForm.controls.code.hasError(&#39;pattern&#39;)"
          >
            只可输入数字和英文
          </div>
        </div>
        <div style="color:green" *ngIf="myForm.isvalid">
          表单无效
        </div>
        <div style="color:green" *ngIf="myForm.valid">
          表单有效
        </div>
        <button type="submit">提交</button>
      </form>
    </div>`
export class NonInWarehouseComponent implements OnInit {
  myForm: FormGroup;
  name: AbstractControl;
  constructor(fb: FormBuilder) {
    this.myForm = fb.group({
      name: [&#39;牛奶&#39;, Validators.compose([Validators.required, textValidator])],
      code: [&#39;&#39;, [Validators.required, Validators.pattern(&#39;^[A-Za-z0-9]*$&#39;)]],
    });
    this.name = this.myForm.controls.name;
  }
  ngOnInit() {
    const nameControl = new FormControl(&#39;nate&#39;);
    console.log(&#39;nameControl&#39;, nameControl);
  }
  onSubmit(a: any) {
    console.log(&#39;a&#39;, a);
  }
}

// angular 源代码中实现 Validators.required 
export class Validators {
  // 接收一个 AbstractControl 对象作为输入
	static required(control: AbstractControl): ValidationErrors | null;
}
// 当验证器失败时，会返回一个 String Map<string,any> 对象，他的键是” 错误代码 “，它的值是 true
export declare type ValidationErrors = {
    [key: string]: any;
};

// 自定义验证器
function textValidator(
  controls: FormControl // 因为FormControl继承于 AbstractControl 所以也可以写成FormControl对象
): {
  [s: string]: boolean;
} {
  if (!controls.value.match(/^123/)) {
    return { textinvalid: true };
  }
}

Validators.compose([Validators.required, textValidator])
// 不用compose   [Validators.required, textValidator]
// 保留 compose 是为了向以前历史版本进行兼容，不用 compose 也可实现

export class ReativeFormsComponent implements OnInit {
  ngOnInit() {
    this.addContact()
  }
  //动态表单
  personMess: FormGroup = new FormGroup({
    //生成动态表单数组
    contacts: new FormArray([]) 
  })
  //获取数组对象
  get contacts(){
    return this.personMess.get('contacts') as FormArray
  }
  //增加一个表单组
  addContact(){
    let myContact = new FormGroup({
      name: new FormControl(),
      phone: new FormControl()
    })
    this.contacts.push(myContact)
  }
   //删除一个表单组
  deleteContact(i:number){
    this.contacts.removeAt(i)
  }
  //提交表单
  OnSubmit() {
    console.log(this.personMess.value)
  }
}

<form [formGroup]="personMess" (submit)="OnSubmit()">
  <div formArrayName="contacts">
    <!-- 注意：这里遍历的时contacts.controls -->
    <div *ngFor="let contact of contacts.controls;let i =index" [formGroupName]="i">
      <input type="text" formControlName="name">
      <input type="text" formControlName="phone">
      <button (click)="deleteContact(i)">删除信息</button>
    </div>
  </div>
  <button (click)="addContact()">添加信息</button><br>
  <input type="submit">
</form>