--- highlight: an-old-hope theme: smartblue --- ## 1 Angular的两大表单 ### 1.1 模板驱动表单 🍑 **模板驱动表单**：引入`FormsModule`模块，表单的控制逻辑都是写在模板里的，每一个表单元素都是和一个负责管理内部表单模型的指令关联起来的。 ```js import { Component, OnInit } from '@angular/core'; import { NgForm } from '@angular/forms'; @Component({ selector: 'app-module-form', template:` `, styleUrls: ['./module-form.component.less'] }) export class ModuleFormComponent implements OnInit { constructor() { } ngOnInit() { } OnSubmit(moduleForm:NgForm){ console.log(moduleForm.value); } } ``` ### 1.2 响应式表单 🍑 **响应式表单**：需要引入`ReactiveFormsModule`模块，在响应式表单中，视图中的每个表单元素都直接链接到一个表单模型。 - **FormControl**：是构成表单的基本单位。实例用于追踪`单个表单`控件的值和验证状态 - **FormGroup**：用于追踪一个`表单控件组`的值和状态。 - FormGroup和FormArray的区别：formgroup既可以代表表单一部分也可以代表整个表单；formarray有一个额外的长度属性，它的formControl是没有相关的key的，只能通过访问formarray中的元素。 ```html ``` ```js //原始的定义方法 export class ReactiveRegistComponent implements OnInit { formModel:FormGroup; constructor() { this.formModel=new FormGroup({ username:new FormControl(), mobile:new FormControl(), passwordsGroup: new FormGroup({ password:new FormControl(), pconfirm:new FormControl(), }) }); } } //使用formBuilder后的定义 constructor(fb:FormBuilder) { this.formModel=fb.group({ username:[''], mobile:[''], passwordsGroup: fb.group({ password:[''], pconfirm:[''], }) }); } ``` ```js import { Component, OnInit } from '@angular/core'; import { FormBuilder, FormGroup, NgForm, Validators } from '@angular/forms'; @Component({ selector: 'app-module-form', // templateUrl: './module-form.component.html', template:` `, styleUrls: ['./module-form.component.less'] }) export class ModuleFormComponent implements OnInit { form!: FormGroup; constructor(private fb: FormBuilder) { } ngOnInit() { this.form = this.fb.group({ username:[null,[Validators.required,Validators.maxLength(6)]], password:[null,[Validators.required]], }) } } ``` - 自定义验证器： ```js export function whiteSpaceValidator(): ValidatorFn { // 不能全输入空格，验证 return (control: FormControl): { [s: string]: boolean } => { const reg = new RegExp(/\s/g); if (reg.test(control.value)) { return { required: true }; } }; } ``` ## 2 Angular管道 - **管道**：把数据作为输入，然后转换它并给出输出。 ### 2.1 内置管道 🍑 Angular的一些内置管道：如date、uppercase、lowercase、currency、percent等，不用引入，直接在任何组件中使用。注意：**用date转化的数据不能为字符串，必须为Date类数据**。 ```html

当前时间日期为{{curDate|date}}

当前时间日期为{{curDate|date:"yyyy/MM/dd"}}

转大写{{title|uppercase}}

转小写{{title|lowercase}}

转换金额字符串{{0.259|currency}}

转换金额百分比{{0.259|percent}}

``` ### 2.2 链式管道 🍑 **链式管道**：管道以多个条件指定格式输出。 ```html

当前时间日期为{{curDate|date:'fullDate'|lowercase}}

``` ### 2.3 自定义管道 🍑 **自定义管道**：在app.module文件的declarations中进行声明就可以在任何一个组件中使用了。 ```html

600000毫秒真实时间：{{600000|TimeFormater}}

``` ```js import { PipeTransform, Pipe } from '@angular/core'; @Pipe({ name: 'TimeFormater', }) export class TimeFormaterPipe implements PipeTransform { // // 传入的是一个一毫秒为单位的时间数 transform(value) { if (!value || value <= 0) { return '00天00时00分00秒'; } const time = Math.abs(value); const transecond = Math.round(time / 1000); // 转化为秒 const day = Math.floor(transecond / 3600 / 24); // 获取天数 const hour = Math.floor((transecond / 3600) % 24); // 获取小时，取余代表不满一天那部分 const minute = Math.floor((transecond / 60) % 60); // 获取分，取余代表不满小时那部分 const second = transecond % 60; return `${this.formatTime(day)}天${this.formatTime(hour)}时${this.formatTime(minute)}分${this.formatTime(second)}秒`; } formatTime(t) { return t < 10 ? '0' + t : '' + t; } } ``` ## 3 Angular的三大绑定 ### 3.1属性绑定 🍑 **属性绑定**的属性指的是元素、组件、指令的属性。属性的绑定是单向绑定，从组件的属性流动到目标元素的属性。 ```html ``` ### 3.2 attribute、class和style绑定 🍑**attribute绑定**：并非所有属性都有可供属性绑定。是HTML标签上的**特性**，它的值只能够是字符串。通过`attr.特性名`绑定。而比如标签中的id、src等这些属于`Property（属性，DOM中的属性，是JavaScript里的对象）`，这些可以直接绑定就可。而attribute绑定如下： ```html

One-Two
Five	Six

``` 🍑**class的绑定**：静态绑定、单一属性动态绑定方式、多属性动态绑定方式、ngCLass指令绑定。 ```css .test1{ width: 100px; height: 100px; border: 1px solid; } .test2{ width: 100px; height: 100px; background-color: yellowgreen; } ``` （1）静态绑定：可以是一个，也可以是多个，多个的class就会融合起来。 ```html

``` ```html

``` （2）单一属性动态绑定方式：取在css文件中定义好的样式进行绑定，`class.样式的class名`。 ```html

``` （3）多属性动态绑定方式：class的绑定 ```html

``` ```js moreClass:object = { 'test1':true, 'test2':true } ``` 🍑**style的绑定**：单一样式绑定、带单位的单一样式绑定、多个样式绑定。（1）单一样式的绑定 ```html

``` （2）带单位的单一样式绑定 ```html

``` （3）多个样式绑定 ```html `

绑定多个形式的style

` ``` ```js moreStyle:string = 'width: 100px;height: 200px'; ``` ### 3.3 事件绑定 🍑事件绑定：带`()`的特性就是事件绑定。括号内代表的是目标事件。而下面例子的事件绑定就是点击事件的绑定。 ```html ``` （1）目标事件是原生DOM元素事件，input是DOM元素input的原生事件。 ```js //html //js currentUser={ 'name':'' } getValue(ev:any){ this.currentUser.name = ev.target.value; console.log(this.currentUser.name); } ``` （2）目标事件是指令：比如**ngClick**、**ngDblclick**等。（3）目标事件是自定义事件。目标事件 **(子组件的EventEmitter实例变量)="父组件的方法(子组件数据)"** 下文的父子组件通信已经有详解👇。 ## 4 Angular的三大指令 ### 4.1 属性型指令 🍑 **属性型指令**：该指令可改变元素、组件或其他指令的外观和行为。比如： - ngClass指令：可以通过动态地添加或移除css类来控制css来如何显示。 - ngStyle指令：可以同时设置多个内联样式。 - ngModel指令：可以双向绑定到HTML表单中的元素。 - 创建属性型指令：在app.module文件中的declarations数组中进行声明就可以在任何组件的标签元素中调用，如下： ```html

看一下指令

``` ```js // Directive:在declarations import { Directive, ElementRef } from '@angular/core'; @Directive({ selector: '[appHighlight]' }) export class HighlightDirective { constructor(el:ElementRef) { el.nativeElement.style.backgroundColor = 'yellow'; } } ``` ```js import { Directive, ElementRef, HostListener } from '@angular/core'; @Directive({ selector: '[appHighlight]' }) export class HighlightDirective { constructor(private el:ElementRef) { } // 监听鼠标悬浮背景颜色设置 @HostListener('mouseenter') onMouseEnter(){ this.hightlight('yellow'); } // 监听鼠标离开背景颜色设置 @HostListener('mouseleave') onMouseLeave(){ this.hightlight(''); } private hightlight(color:string){ this.el.nativeElement.style.backgroundColor = color; } } ``` ### 4.2 结构型指令 🍑 **结构型指令**：该指令通过添加或移除DOM元素来改变DOM布局。每一个宿主元素都只能有一个结构型指令。比如ngif和ngfor不能在同一元素出现。如ngif、ngfor、ngSwitch（本身是**属性型指令**，它控制了两个结构型指令**ngSwitchCase和ngSwitchDefault**），结构型指令一般都是带**`*符号`的**。 - 自定义结构型指令： ```js import { Directive, Input, TemplateRef, ViewContainerRef } from '@angular/core'; @Directive({ selector: '[appTagdisplay]' }) export class TagdisplayDirective { private hasView = false; // ViewContainerRef访问视图容器 constructor(private templateRef:TemplateRef,private viewContainer:ViewContainerRef) { } @Input() set appTagdisplay(condition:boolean){ if(!condition&&!this.hasView){ // 视图容器创建一个内嵌的视图 this.viewContainer.createEmbeddedView(this.templateRef); this.hasView = true; }else if(condition&&this.hasView){ // 清除该容器，销毁该视图 this.viewContainer.clear(); this.hasView = false; } } } ``` ```html

自定义结构指令

该段显示，因为appTagdisplay为false

该段不显示，因为appTagdisplay为true

``` ### 4.3 组件 🍑 **组件**：也是一种指令，该指令拥有模板。 ## 5 Angular的五大组件通信 ### 5.1 Input与Output实现父子组件通信通过下面的例子我们会发现`Input和Output的操作都在子组件中`。父传子：在父组件中动态绑定属性，在子组件中Input获取父组件传来的属性。子传父：子组件创建一个实例化EventEmitter对象，EventEmitter 的核心就是事件触发与事件监听器功能的封装；父组件：通过事件绑定调用带参自定义函数接受子组件传来的数据（自定义函数的参数）。 🍑 **父组件**：双向绑定fatherData也就是当前输入框输入的信息，点击发送事件触发传给子组件的currentData添加数据并清空当前输入框的信息。 ```html

``` ```js import { Component, OnInit } from '@angular/core'; export class FatherComponent implements OnInit { isClear:boolean=false; fatherData:any; currentData:Array=[]; constructor() { } ngOnInit() { this.fatherData = this.currentData; } send(){ this.currentData.push("我是父组件的数据："+this.fatherData); this.fatherData=''; } getSonInfo(event:any){ this.currentData.push("我是子组件的数据："+event); } } ``` 🍑 **子组件**：输入框输入sonData，点击发送事件触发子组件事件发射数据，然后父组件就可以通过子组件绑定的事件发射从父组件通过事件方法获取当前子组件发送的数据。 ```html

``` ```js import { OnInit } from '@angular/core'; export class SonComponent implements OnInit{ @Input() dataSource:any=0; @Output() sonSend = new EventEmitter(); isClear:boolean=false; sonData:any; currentData:Array=[]; constructor() { } ngOnInit(): void { this.currentData = this.dataSource; } send(){ this.sonSend.emit(this.sonData); // this.currentData.push("我是子组件的数据："+this.sonData); this.sonData=''; } } ``` ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4aefd1aeb295424ba8e8720977c244ed~tplv-k3u1fbpfcp-watermark.image?) ### 5.2 通过本地变量实现父子组件的通信在父组件的模板中创建一个代表子组件的本地变量，通过调用这个变量就可以调用子组件中的属性和方法。 ```html

我是父组件

子组件：{{sonTpl.myName}}

``` ### 5.3 通过@ViewChild实现父子组件的通信父组件的js中定义`@ViewChild(SonComponent) childTpl: any;`，注意在html必须要调用子组件元素，不然会直接报错，且不能直接调用childTpl.myName获取子组件中的变量。 ```html

我是父组件

``` ```js // 子组件中的getName getName(){ console.log('我是子组件的getName方法'); } ``` ### 5.4 通过共享服务Service实现非父子组件通信栗子来自`书籍《Angular企业级应用开发实战》`-p143： ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/448e12f94e944f3db46497c44e9c02f1~tplv-k3u1fbpfcp-watermark.image?) 🍑 **Service服务**：主要控制准备开始、和确认按钮的动作进行消息的传递。注意这个服务的定义一定是共享的，不要在各个组件下独自注入`providers`中，因为单独引入service只是在当前组件有效，每个组件调用一次都是独立的，互不影响，这就不是组件通信需要的。 ```js import { Injectable } from '@angular/core'; import { Subject } from 'rxjs'; @Injectable({ providedIn: 'root' }) export class MissionService { // 源 private missionAnnounceSource = new Subject(); private misssionConfirmedSource = new Subject(); // 流 // asObservable:可观察的序列，隐藏源序列的身份。 missionAnnounce$ = this.missionAnnounceSource.asObservable(); missionConfirm$ = this.misssionConfirmedSource.asObservable(); constructor() {} announceMission(mission:string){ this.missionAnnounceSource.next(mission); } confirmMission(astronaut:string){ this.misssionConfirmedSource.next(astronaut); } } ``` 🍑 **MissioncontrolComponent**：这是一个主要界面的组件，在界面中调用了**astronaut组件**。当前组件就是父组件，而astronaut组件就是一个子组件。 ```js import { Component, OnInit } from '@angular/core'; import { MissionService } from 'src/app/service/mission.service'; @Component({ selector: 'app-missioncontrol', template: `

导弹控制器

日志

{{event}}

`, }) export class MissioncontrolComponent implements OnInit { astronauts = ['操作员1','操作员2','操作员3']; history:string[] = []; missions = ['发射导弹']; nextMession = 0; constructor(private misssionSvc:MissionService) { // 获取子组件保存的信息，获取是哪一个操作员点击确认了 misssionSvc.missionConfirm$.subscribe((astronaut)=>{ this.history.push(`${astronaut}已经确认`); }) } announce(){ let mission = this.missions[this.nextMession++]; this.misssionSvc.announceMission(mission); this.history.push(`任务"${mission}"进入准备`); if(this.nextMession>=this.missions.length){ this.nextMession = 0; } } ngOnInit(): void { } } ``` 🍑 **AstronautComponent**：点击确认，向父组件传递确认的操作员信息。 ```js import { Component, Input, OnInit, OnDestroy } from '@angular/core'; import { Subscription } from 'rxjs'; import { MissionService } from 'src/app/service/mission.service'; @Component({ selector: 'app-astronaut', template: `

{{astronaut}}:{{mission}}

`, }) export class AstronautComponent implements OnInit,OnDestroy{ @Input() astronaut:string=''; mission = '<没有任务>'; confirmed = false; announced = false; subscription:Subscription; constructor(private missionSvc:MissionService) { // 获取父组件的数据 this.subscription = missionSvc.missionAnnounce$.subscribe((mission)=>{ this.mission = mission;// 发射导弹 this.announced = true;// 激活确认按钮 this.confirmed = false; }) } confirm(){ // 禁用按钮 this.confirmed = true; // 点击确认，保存当前的操作员数据 this.missionSvc.confirmMission(this.astronaut); } ngOnDestroy(): void { // 防止内存泄漏 this.subscription.unsubscribe(); } ngOnInit() { } } ``` ### 5.5 路由传值 🍑 按钮点击跳转：路由传参数由分号隔开。 ```js import { Component, OnInit } from '@angular/core'; import { Router } from '@angular/router'; @Component({ selector: 'app-father', template:`` }) export class FatherComponent implements OnInit { obj:any=[ '书悟空', '唐僧', ]; constructor(private router:Router) {} ngOnInit() {} linkSon(){ this.router.navigate(['/son',{ name:this.obj,id:10010}]); //http://localhost:4209/son;name=书悟空,唐僧;id=10010 } } ``` ```js // private route:ActivatedRoute this.route.params.subscribe((route)=>{ console.log(route); }) ``` 🍑 链接点击跳转：路由传参通过queryParams属性控制，由?、&符号分隔开。 ```html 链接跳到儿子组件中 // http://localhost:4209/son?id=10010&name=书悟空&name=唐僧 ``` ```js // private route:ActivatedRoute this.route.queryParams.subscribe((route)=>{ console.log(route); }) ``` 🍑 链接点击跳转：直接是用/分割路由传参。 ```js { path: 'son/:id', component: SonComponent }, ``` ```html 链接跳到儿子组件中 // http://localhost:4209/son/10010 ``` ```js // private route:ActivatedRoute this.route.params.subscribe((route)=>{ console.log(route); }) ``` 还有其他通信方式：浏览器本地传值（localStorge、SessionStorge）、cookie ## 6 Angular的五大路由守卫 | 守卫接口 | 守卫作用 |应用场景| | --- | --- |---| | CanActivate | 控制是否导航到某路由 |该用户可能无权导航到目标组件| | CanActivateChild | 控制是否导航到某子路由 || | CanDeactivate | 控制从当前路由离开的情况 |在离开组件前，你可能要先保存修改| | Resolve | 在路由激活之前获取路由数据 |在现实目标组件前，你可能得先获取某些数据| | CanLoad | 来处理异步导航到某特性模块，保护对特性模块的未授权加载| 🍑 **CanActivate**：控制是否导航到某个路由的一个属性。 🍑 **CanActivateChild**：有一些业务是只是控制当前路由下的一些子路由，如果用`CanActivate`来控制路由的就要每个子路由都要加CanActivate，而用`CanActivateChild`的话只是在当前路由下添加就行。 ```ts const routes: Routes = [ { path: '', redirectTo: 'login', pathMatch: 'full' }, { path: 'login', component: LoginComponent }, { path: 'admin', component: AdminComponent, canActivate: [AuthGuard], children: [ { path: '', canActivateChild: [AuthGuard], children: [ { path: 'daughter', component: AdminDaughterComponent }, { path: 'son', component: AdminSonComponent, }, ], }, ], }, ]; ``` **等价于：** ```js const routes: Routes = [ { path: '', redirectTo: 'login', pathMatch: 'full' }, { path: 'login', component: LoginComponent }, { path: 'admin', component: AdminComponent, canActivate: [AuthGuard], children: [ { path: '', children: [ { path: 'daughter', canActivate: [AuthGuard], component: AdminDaughterComponent }, { path: 'son', canActivate: [AuthGuard], component: AdminSonComponent, }, ], }, ], }, ]; ``` 其他的核心代码如下，`ActivatedRouteSnapshot`包含url、params、queryParams等参数；`RouterStateSnapshot`主要包含一个url属性和toString()函数。 ```ts export class AuthGuard implements CanActivate { constructor(private authService: AuthService, private router: Router) {} canActivate( route: ActivatedRouteSnapshot, state: RouterStateSnapshot ): true | UrlTree { const url: string = state.url; return this.checkLogin(url); } canActivateChild( route: ActivatedRouteSnapshot, state: RouterStateSnapshot ): true | UrlTree { // 从这里可以看出调用canActivate就简化了每个子路由都要加 return this.canActivate(route, state); } checkLogin(url: string): true | UrlTree { if (this.authService.isLoggedIn) { return true; } // 存下当前路由 this.authService.redirectUrl = url; // 如果未登录定向到login return this.router.parseUrl('/login'); } ``` ```ts export class AuthService { // 是否登录 isLoggedIn = false; // store the URL so we can redirect after logging in redirectUrl: string | null = null; // 登录 login(): Observable { return of(true).pipe( // 延迟加载 delay(1000), // Observable对象源的副作用，只要调用这个函数，就会触发 tap(() => (this.isLoggedIn = true)) ); } // 退出登录 logout(): void { this.isLoggedIn = false; } } ``` 🍑 **CanDeactivate**：当我们在一个编辑表单的页面的时候，我们不小心点击其他导航了，这是就会在离开当前导航前会提示用户一些信息。比如编辑页面是通过监听当前编辑页面是否有变动输入属性或绑定属性是否变化，当路由变化判断监听事件是否触发来是否设置提示信息。 ```ts export class LeaveGuard implements CanDeactivate { canDeactivate( component: AdminSonComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot ): Observable | Promise | boolean { // return false; return window.confirm('还没保存，确定离开！'); } } ``` ```ts { path: 'admin', component: AdminComponent, canActivate: [AuthGuard], children: [ { path: '', canActivateChild: [AuthGuard], children: [ { path: 'daughter', component: AdminDaughterComponent }, { path: 'son', component: AdminSonComponent, canDeactivate: [LeaveGuard], }, ], }, ], }, ``` 🍑 **Resolve**：使用解析器预先从服务器上获取数据。这样在路由激活的那一刻数据就准备好了，还要在路由到此组件之前处理好错误。也就希望只有当所有必要数据都已经拿到之后，才渲染这个路由组件。 ```ts // user.ts，创建一个User对象 export class User { constructor(public id: number, public login: string) {} } ``` 创建resolve守卫文件，对预先获取数据的请求做相关的操作。 ```ts export class ResolveGuard implements Resolve { constructor(private router: Router) {} resolve( route: ActivatedRouteSnapshot, state: RouterStateSnapshot ): Observable | Promise | User { // route.paramMap.get('id')可以这样获取路由id return ajax.getJSON('https://api.github.com/users?per_page=5').pipe( mergeMap((user) => { if (user) { return of(user); } else { this.router.navigateByUrl('/'); return EMPTY; } }) ); } } ``` 在路由中定义守卫，在有需要的组件路由加载前获取到当前组件需要的数据。 ```ts { path: 'admin', component: AdminComponent, canActivate: [AuthGuard], children: [ { path: '', canActivateChild: [AuthGuard], children: [ { path: 'daughter', component: AdminDaughterComponent }, { path: 'son', component: AdminSonComponent, resolve: { user: ResolveGuard, }, }, ], }, ``` 在当前组件获取组件路由加载前获取到的数据。 ```ts constructor(private route: ActivatedRoute) {} ngOnInit() { this.route.data.subscribe((item) => { console.log(item);// user数据 }); } ``` 🍑 **CanLoad**：比如使用canActivate保护登录组件的访问，它会阻止未授权用户访问管理特性区，如果用户未登录，它就会跳转到登录页。理想情况下，只有用户已登录的情况下才去加载登录组件 ```js canLoad(route: Route): boolean { let url = `/${route.path}`; return this.checkLogin(url); } ``` ## 7 Angular的八大生命周期 ### 7.1 ngOnChanges() 当angular检测到`组件（或指令）`重新设置数据绑定输入属性时响应。在被绑定的输入属性的值发生变化时调用，首次调用一定会`发生在`**ngOnInit()**`之前`，每一次改变绑定数据就调用一次这个钩子。**OnChanges()** 对应的函数 **ngOnChanges()**，该函数获取了一个对象，对象把每个发生变化的属性名映射在SimpleChange对象中，对象有属性`当前值currentValue`和`前一个值previousValue`。 🍑 **父组件**： ```html

我是父组件： {{dataSource}}

``` 🍑 **子组件**： ```html

我是子组件： {{data}}

``` ```js import { Component, Input, OnInit, SimpleChanges, OnChanges } from '@angular/core'; // 子组件js export class TwoComponent implements OnInit,OnChanges { @Input() data:any=0; constructor() { } ngOnInit(): void { console.log('ngOnInit',this.data); } increment(){ this.data++; } decrement(){ this.data--; } ngOnChanges(changes: SimpleChanges): void { console.log("previousValue：",changes['data'].previousValue); console.log("currentValue：",changes['data'].currentValue); } } ``` **注意地，在子组件中操作是不能触发Onchanges钩子函数地，它是控制组件上属性的改变而触发**。 ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/0f7175694874451b8f445f4cc5d79f4f~tplv-k3u1fbpfcp-watermark.image?) ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ba457c7b72b4490bbb3454812f416b45~tplv-k3u1fbpfcp-watermark.image?) ### 7.2 ngOnInit() 在Angular第一次显示数据绑定和设置指令/组件的输入属性之后，初始化指令/组件，在第一轮**ngOnChanges()完成之后**调用，`只调用一次`。 ### 7.3 ngDoCheck() 检测变化，在每一个Angular变更检测周期（变化监测）中调用，在执行`ngOnChanges`和`ngOnInit()`方法之后调用。不管是数据绑定还是鼠标的点击事件，只要触发了都会触发这个钩子的调用。 ```html

``` ```js import { DoCheck,OnInit } from '@angular/core'; export class SonComponent implements OnInit,DoCheck { dataSource:any; constructor() { } ngOnInit(): void { console.log("ngOnInit!"); } ngDoCheck(): void { console.log("DoCheck：",this.dataSource); } } ``` ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/db25580b3ca04390a24683938dde0551~tplv-k3u1fbpfcp-watermark.image?) ### 7.4 ngAfterContentInit() 把内容投影进组件之后调用，在第一次执行ngDoCheck方法之后调用，`只调用一次`。 ```js import { AfterContentChecked, AfterContentInit,DoCheck, Input, OnInit } from '@angular/core'; export class SonComponent implements OnInit,DoCheck,AfterContentInit{ @Input() data:any=0; dataSource:any; constructor() { } ngOnInit(): void { console.log("ngOnInit!"); } ngAfterContentInit(): void { console.log("ngAfterContentInit!",this.dataSource); } ngDoCheck(): void { console.log("DoCheck：",this.dataSource); } } ``` ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ebe4aa9b2dd24b039634e1817e4509ba~tplv-k3u1fbpfcp-watermark.image?) ### 7.5 ngAfterContentChecked() 在每次完成被投影组件内容的变更检测之后调用。在执行`ngAfterContentInit()`和`ngDoCheck()`方法之后调用。 ```js import { AfterContentChecked, AfterContentInit, DoCheck, Input, OnInit } from '@angular/core'; export class SonComponent implements OnInit,DoCheck,AfterContentInit,AfterContentChecked{ @Input() data:any=0; dataSource:any; constructor() { } ngOnInit(): void { console.log("ngOnInit!"); } ngAfterContentInit(): void { console.log("ngAfterContentInit!",this.dataSource); } ngAfterContentChecked(): void { console.log("ngAfterContentChecked!",this.dataSource); } ngDoCheck(): void { console.log("DoCheck：",this.dataSource); } } ``` ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6a13c011e8b84552b918b7c8c9cd5713~tplv-k3u1fbpfcp-watermark.image?) ### 7.6 ngAfterViewInit() 在初始化完组件视图及其子视图之后调用，在第一次执行ngAfterContentChecked()方法之后调用，`只调用一次`。 ```js export class SonComponent implements OnInit,DoCheck,AfterContentInit,AfterContentChecked,AfterViewInit{ dataSource:any; constructor() { } ngOnInit(): void { console.log("ngOnInit!"); } ngAfterContentInit(): void { console.log("ngAfterContentInit!",this.dataSource); } ngAfterContentChecked(): void { console.log("ngAfterContentChecked!",this.dataSource); } ngAfterViewInit(): void { console.log("ngAfterViewInit!"); } ngDoCheck(): void { console.log("DoCheck：",this.dataSource); } } ``` ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ac92f0cec2b944fdb9b9bda07c121383~tplv-k3u1fbpfcp-watermark.image?) ### 7.7 ngAfterViewChecked() 在每次完成组件视图和子视图的变更检测之后调用。在执行`ngAfterViewInit()`和`ngAfterContentChecked()`方法之后调用。 ![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2a9c05322d9a497096f327d5b7fa640b~tplv-k3u1fbpfcp-watermark.image?) ### 7.8 ngOnDestroy() 在Angular每次销毁指令/组件之前调用并清扫，在这里反订阅可观察对象和分离事件处理器，以防内存泄漏。什么时候会调用这个生命周期呢？也就是平时我们`切换组件或从一个组件跳转到另一个组件`的时候，这时候就会触发组件的销毁。