Angular 速查手册
适用版本:Angular 16,standalone 组件(没有 NgModule)。 每个知识点独立成篇:都包含「import → HTML → TS → 注意点」,单独看一篇就能用。 示例代码取自本项目,
src/app/...为对应文件位置。
目录
- FormGroup(响应式表单)
- ngModel(模板驱动表单)
- Service 的用法
- BehaviorSubject
- app.config.ts 一般包含什么
- app.component.ts 一般包含什么
- paramMap(读取路由参数)
- getter 的用法
- HttpClient 的用法(next / error)
- asObservable 的用法
- authInterceptor(HTTP 拦截器)
- 补充:校验器 Validators 与错误显示
- 补充:自定义/跨字段校验(密码一致)
- 补充:路由表 app.routes.ts
- 补充:路由守卫 authGuard
- 补充:async 管道
- 补充:*ngIf / *ngFor / trackBy
- 补充:Router 编程式跳转与 routerLink
- 补充:ngOnInit 生命周期
- 补充:main.ts 启动入口
- 补充:把服务端校验错误写回表单
- 补充:form.value 与 getRawValue()
1. FormGroup(响应式表单)
作用:在 TS 里定义表单的结构、初始值、校验规则;HTML 只负责绑定。适合字段多、有校验的表单(登录、注册、商品编辑)。
import
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common'; // *ngIf 等
import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
@Component({
standalone: true,
imports: [CommonModule, ReactiveFormsModule], // ← 用 [formGroup] 必须导入 ReactiveFormsModule
// ...
})
HTML
<!-- [formGroup] 绑定 TS 里的 form;(ngSubmit) 在点提交按钮/回车时触发 -->
<form [formGroup]="form" (ngSubmit)="submit()">
<!-- formControlName 的值 = form 里的 key,不是变量,所以不加方括号 -->
<input type="email" formControlName="email" />
<div class="error" *ngIf="form.controls.email.touched && form.controls.email.invalid">
<span *ngIf="form.controls.email.hasError('required')">请输入邮箱</span>
<span *ngIf="form.controls.email.hasError('email')">邮箱格式不正确</span>
</div>
<input type="password" formControlName="password" />
<button type="submit" [disabled]="loading">登录</button>
</form>
TS
export class LoginComponent {
loading = false;
constructor(private fb: FormBuilder) {}
// 每个控件:[初始值, 同步校验器(单个或数组)]
// nonNullable:值类型是 string 而不是 string | null,reset() 也回到初始值
form = this.fb.nonNullable.group({
email: ['', [Validators.required, Validators.email]],
password: ['', Validators.required],
});
submit() {
if (this.form.invalid) {
this.form.markAllAsTouched(); // 让没碰过的控件也显示错误
return;
}
const { email, password } = this.form.getRawValue(); // 取值:{ email, password }
console.log(email, password);
}
}
常用 API
| 写法 | 作用 |
|---|---|
form.value / form.getRawValue() | 取整个表单的值(区别见第 22 节) |
form.controls.email.value | 取单个控件的值 |
form.invalid / form.valid | 整个表单是否通过校验 |
form.setValue({...}) | 整体赋值(必须给齐所有字段) |
form.patchValue({...}) | 部分赋值(只给想改的字段) |
form.reset() | 重置为初始值(配合 nonNullable) |
form.markAllAsTouched() | 标记全部控件为"碰过",触发错误显示 |
form.controls.x.disable() / .enable() | 禁用/启用控件 |
form.get('email') | 用字符串名取控件(字符串可能写错,没有类型提示) |
注意点
formControlName只能写在[formGroup]包裹的范围内,否则报错。- 点提交按钮必须是
type="submit",(ngSubmit)才会触发。 - 嵌套分组:
this.fb.group({ address: this.fb.group({ city: [''] }) }),HTML 里用formGroupName="address"再套formControlName="city"。
2. ngModel(模板驱动表单)
作用:用 [(ngModel)] 把输入框和组件属性做双向绑定,不需要在 TS 里建 FormGroup。适合只有一两个输入框的简单场景(如搜索框)。
import
import { Component } from '@angular/core';
import { FormsModule } from '@angular/forms'; // ← 注意是 FormsModule,不是 ReactiveFormsModule
@Component({
standalone: true,
imports: [FormsModule],
// ...
})
HTML
<form (ngSubmit)="search()">
<!-- 在 <form> 里使用 ngModel,必须写 name,否则报错 NG01352 -->
<input name="q" [(ngModel)]="q" placeholder="搜索商品名" />
<button type="submit">搜索</button>
</form>
<!-- 不在 <form> 里时,不需要 name -->
<input [(ngModel)]="keyword" (keyup.enter)="search()" />
TS
export class ProductsComponent {
q = ''; // 输入框的内容会实时同步到这里,反过来改 q 输入框也会变
keyword = '';
search() {
console.log(this.q.trim());
}
}
注意点
[(ngModel)]是[ngModel]="q"(属性→输入框)+(ngModelChange)="q = $event"(输入框→属性)的合写,俗称"香蕉盒子"。name和绑定的属性名不必相同:name="q"只是控件在表单里的 key,[(ngModel)]="q"才是绑定的属性。- 不想写
name:加[ngModelOptions]="{ standalone: true }",或把输入框放到<form>外。 - 同一个组件里不要混用
formControlName(响应式)和ngModel(模板驱动)绑定同一个输入框。 - 其他常见控件:
<input type="checkbox" [(ngModel)]="agree" name="agree">(值为 boolean),<select [(ngModel)]="country" name="country">。
3. Service 的用法
作用:把"和后端通信、跨组件共享的逻辑"从组件里抽出来。组件只负责展示和交互,service 负责拿数据。
import / 定义
// src/app/services/product.service.ts
import { HttpClient, HttpParams } from '@angular/common/http';
import { Injectable } from '@angular/core';
@Injectable({ providedIn: 'root' }) // root:全局单例,不需要在任何地方再注册
export class ProductService {
constructor(private http: HttpClient) {} // 构造函数注入:Angular 自动给你 HttpClient 实例
list(q = '') {
let params = new HttpParams();
if (q) params = params.set('q', q);
return this.http.get<Product[]>('http://localhost:8081/api/products', { params });
}
get(id: number) {
return this.http.get<Product>(`http://localhost:8081/api/products/${id}`);
}
}
在组件里使用
import { Component, OnInit } from '@angular/core';
import { ProductService } from '../services/product.service';
@Component({
standalone: true,
selector: 'app-products',
template: `<p *ngFor="let p of products">{{ p.name }}</p>`,
imports: [CommonModule],
})
export class ProductsComponent implements OnInit {
products: Product[] = [];
// 构造函数参数写上类型,Angular 就会自动注入(这里 private 同时声明了属性 this.productService)
constructor(private productService: ProductService) {}
ngOnInit() {
this.productService.list().subscribe((list) => (this.products = list));
}
}
其他注入方式(函数里没有构造函数时)
import { inject } from '@angular/core';
export const authGuard: CanActivateFn = () => {
const auth = inject(AuthService); // 只能在"注入上下文"里调用(守卫、拦截器、构造函数、字段初始化)
return !!auth.token;
};
注意点
providedIn: 'root'使它是单例:所有组件拿到的是同一个实例,所以 service 里的变量可以跨页面共享数据。- service 里的 HTTP 方法只返回 Observable,不发请求;组件里
.subscribe()才真正发出(见第 9 节)。 - 构造函数参数加
public,模板里才能直接访问:constructor(public auth: AuthService)→ 模板里auth.loggedIn$;private则模板读不到。
4. BehaviorSubject
作用:一个"带当前值的广播器"。可以随时 .next(新值) 推送,所有订阅者都会收到;新订阅者订阅时立刻拿到最新值。用来在多个组件之间共享状态(登录状态、购物车)。
import
import { BehaviorSubject } from 'rxjs';
TS(service 中定义)
@Injectable({ providedIn: 'root' })
export class CartService {
// 必须给初始值(这里是空数组)
private items = new BehaviorSubject<CartItem[]>([]);
// 对外暴露只读版本(见第 10 节 asObservable)
items$ = this.items.asObservable();
setItems(list: CartItem[]) {
this.items.next(list); // 推送新值:所有订阅者立刻收到
}
reset() {
this.items.next([]);
}
}
TS(组件中订阅)
export class AppComponent implements OnInit {
cartCount = 0;
constructor(private cart: CartService) {}
ngOnInit() {
this.cart.items$.subscribe((items) => {
this.cartCount = items.reduce((n, i) => n + i.quantity, 0); // 每次购物车变化都会重新算
});
}
}
HTML(用 async 管道订阅,更省事)
<ng-container *ngIf="cart.items$ | async as items">
<p *ngFor="let it of items">{{ it.product.name }} × {{ it.quantity }}</p>
</ng-container>
取当前值(不订阅)
const current = this.items.value; // 同步读当前值(只有 BehaviorSubject 有 .value)
与其他 Subject 的区别
| 类型 | 初始值 | 新订阅者能拿到什么 |
|---|---|---|
Subject | 无 | 只收到订阅之后的值 |
BehaviorSubject | 必须有 | 立刻收到最新一个值,之后每次更新 |
ReplaySubject(n) | 无 | 重放最近 n 个值 |
注意点
- 命名习惯:Subject 用普通名(
items),对外的 Observable 加$后缀(items$)。 - 用
.next()的人应该只有 service 自己;组件通过 service 的方法来改,不要直接next。 - 订阅后在组件销毁时要取消订阅(或用
async管道自动处理),否则有内存泄漏风险。AppComponent是根组件不会销毁,所以可以直接订阅。
5. app.config.ts 一般包含什么
作用:standalone 项目没有 AppModule,全局 provider 都集中在这里注册,然后在 main.ts 里传给 bootstrapApplication。
import + 完整示例
// src/app/app.config.ts
import { ApplicationConfig } from '@angular/core';
import { provideHttpClient, withInterceptors } from '@angular/common/http';
import { provideRouter } from '@angular/router';
import { routes } from './app.routes';
import { authInterceptor } from './services/auth.interceptor';
export const appConfig: ApplicationConfig = {
providers: [
// 1. 路由:注册路由表
provideRouter(routes),
// 2. HttpClient:不注册的话,注入 HttpClient 会报 NullInjectorError
// withInterceptors:拦截器按数组顺序依次处理每个请求
provideHttpClient(withInterceptors([authInterceptor])),
],
};
常见的 provider 一览
| provider | 作用 |
|---|---|
provideRouter(routes) | 路由(必备) |
provideHttpClient(...) | 使用 HttpClient(调后端必备) |
withInterceptors([...]) | provideHttpClient 的参数,注册函数式拦截器 |
provideAnimations() | 动画(用 Angular Material 时需要) |
provideRouter(routes, withComponentInputBinding()) | 把路由参数直接绑定到组件的 @Input |
{ provide: TOKEN, useValue: xxx } | 注册自定义的注入值(如 API 地址) |
importProvidersFrom(SomeModule) | 引入老式 NgModule 提供的 provider(如部分第三方库) |
在 main.ts 使用
// src/main.ts
import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { AppComponent } from './app/app.component';
bootstrapApplication(AppComponent, appConfig).catch((err) => console.error(err));
注意点
app.config.ts只放全局的、整个应用共用的东西。组件自己用的imports写在组件的@Component里,不是这里。- 忘了
provideHttpClient是最常见的错误之一:现象是NullInjectorError: No provider for HttpClient。
6. app.component.ts 一般包含什么
作用:根组件,整个应用的"外壳"。一般放:导航栏、全局布局、<router-outlet>(路由出口)、以及启动时要做的全局初始化。
import
import { CommonModule } from '@angular/common';
import { Component, OnInit } from '@angular/core';
import { Router, RouterLink, RouterLinkActive, RouterOutlet } from '@angular/router';
import { AuthService } from './services/auth.service';
import { CartService } from './services/cart.service';
HTML + TS
@Component({
selector: 'app-root', // 对应 index.html 里的 <app-root></app-root>
standalone: true,
// 模板里用到的指令/管道/组件,必须全部列在这里
imports: [CommonModule, RouterOutlet, RouterLink, RouterLinkActive],
template: `
<nav>
<!-- routerLink:站内跳转不刷新页面;routerLinkActive:匹配当前路由时加 active 类 -->
<a routerLink="/products" routerLinkActive="active">商品</a>
<ng-container *ngIf="auth.loggedIn$ | async; else guest">
<a routerLink="/cart" routerLinkActive="active">购物车 ({{ cartCount }})</a>
<a href="#" (click)="logout($event)">退出</a>
</ng-container>
<ng-template #guest>
<a routerLink="/login">登录</a>
<a routerLink="/register">注册</a>
</ng-template>
</nav>
<!-- 路由出口:当前路由对应的组件渲染在这里 -->
<main><router-outlet /></main>
`,
})
export class AppComponent implements OnInit {
cartCount = 0;
// public:模板里要访问 auth.loggedIn$
constructor(public auth: AuthService, private cart: CartService, private router: Router) {}
ngOnInit() {
// 全局初始化:订阅购物车变化,算角标
this.cart.items$.subscribe((items) => {
this.cartCount = items.reduce((n, i) => n + i.quantity, 0);
});
// 刷新页面时如果已登录,拉一次购物车
if (this.auth.token) {
this.cart.load().subscribe({
next: (list) => this.cart.setItems(list),
error: () => {},
});
}
}
logout(e: Event) {
e.preventDefault(); // 阻止 <a href="#"> 的默认跳转
this.auth.logout();
this.cart.reset();
this.router.navigate(['/login']);
}
}
根组件一般包含的内容
| 内容 | 说明 |
|---|---|
<router-outlet> | 必须有,否则路由跳转后看不到页面 |
| 导航栏/页脚 | 所有页面共用的布局 |
| 全局初始化 | 例如恢复登录状态、拉取全局数据 |
| 退出登录 | 清理 token 和全局缓存,跳转登录页 |
注意点
- 页面级业务逻辑不要放根组件,放各自的页面组件。
- 用到
routerLink/router-outlet就必须在imports里导入RouterLink/RouterOutlet,漏了会报"不是已知元素/属性"。
7. paramMap(读取路由参数)
作用:读取 URL 里的路径参数(如 /products/5/edit 里的 5)。
路由表配置
// app.routes.ts
{ path: 'products/:id/edit', component: ProductFormComponent },
// ^^^ 冒号开头的是"参数",名字叫 id
import
import { Component, OnInit } from '@angular/core';
import { ActivatedRoute } from '@angular/router';
TS:snapshot 写法(进入页面后 id 不会变)
export class ProductFormComponent implements OnInit {
id: number | null = null;
constructor(private route: ActivatedRoute) {}
ngOnInit() {
const idParam = this.route.snapshot.paramMap.get('id'); // string | null
if (idParam) {
this.id = Number(idParam); // URL 里取出的永远是字符串,需要自己转数字
}
}
}
TS:订阅写法(同一个组件实例内 id 会变化)
ngOnInit() {
// 场景:从 /products/1/edit 直接跳到 /products/2/edit,组件会被复用,不会重新创建
this.route.paramMap.subscribe((params) => {
const id = params.get('id');
if (id) this.load(Number(id));
});
}
HTML:生成带参数的链接
<a [routerLink]="['/products', p.id, 'edit']">编辑</a> <!-- → /products/5/edit -->
其他相关 API
| 写法 | 读取的是 |
|---|---|
route.snapshot.paramMap.get('id') | 路径参数 /products/:id |
route.snapshot.queryParamMap.get('q') | 查询参数 /products?q=abc |
paramMap.has('id') | 是否存在该参数 |
注意点
snapshot只在组件创建时取一次;若同一组件内参数会变,要用订阅写法。- 同一个组件配两条路由(
products/new和products/:id/edit),靠有没有id参数区分"新增"和"编辑"。
8. getter 的用法
作用:TS 的 get 访问器——像属性一样读取,背后其实是个函数。读取时才计算,保证拿到的总是最新值。
TS(本项目:读取 localStorage 里的 token)
const TOKEN_KEY = 'token';
@Injectable({ providedIn: 'root' })
export class AuthService {
// 注意前面是 get,没有括号参数;返回类型写在后面
get token(): string | null {
return localStorage.getItem(TOKEN_KEY);
}
}
使用(不加括号!)
if (this.auth.token) { ... } // ✅ 像属性一样用
const t = this.auth.token; // ✅
// this.auth.token() // ❌ 加了括号会报错:token 不是函数
与普通属性的区别
// 普通属性:赋值那一刻就固定了,之后 localStorage 变了它也不变
token = localStorage.getItem('token');
// getter:每次读取都重新执行,拿到的永远是最新值
get token() { return localStorage.getItem('token'); }
其他常见场景:组件里的计算属性
export class CartComponent {
items: CartItem[] = [];
// 总价:items 变了,total 读到的就是新的
get total(): number {
return this.items.reduce((sum, it) => sum + it.product.price * it.quantity, 0);
}
}
<!-- 模板里同样不加括号 -->
<p>合计:{{ total | currency }}</p>
带 setter 的写法(少用)
private _name = '';
get name() { return this._name; }
set name(v: string) { this._name = v.trim(); } // 赋值时自动 trim
注意点
- getter 在模板里每次变更检测都会执行,所以里面不要写耗时的计算或有副作用的代码。
- getter 只读(没写
set)时,给它赋值会报错。 - 本项目
CartComponent里用的是total(items)方法而不是 getter,因为数据来自async管道的items,需要传参。
9. HttpClient 的用法(next / error)
作用:调用后端 REST 接口。返回 Observable,subscribe 之后才真正发请求。
前置:app.config.ts 里要注册
// app.config.ts
import { provideHttpClient } from '@angular/common/http';
providers: [provideHttpClient()]
import(service 里)
import { HttpClient, HttpParams } from '@angular/common/http';
import { Injectable } from '@angular/core';
TS:service 里写方法(只返回 Observable)
@Injectable({ providedIn: 'root' })
export class ProductService {
constructor(private http: HttpClient) {}
// GET 带查询参数: /products?q=abc (HttpParams 会自动 URL 编码)
list(q = '') {
let params = new HttpParams();
if (q) params = params.set('q', q);
return this.http.get<Product[]>(`${API_URL}/products`, { params });
}
// GET 带路径参数: /products/5
get(id: number) {
return this.http.get<Product>(`${API_URL}/products/${id}`);
}
// POST:第二个参数是请求体,自动序列化成 JSON
create(input: ProductInput) {
return this.http.post<Product>(`${API_URL}/products`, input);
}
// PUT / DELETE 同理
// this.http.put<Product>(url, body);
// this.http.delete<void>(url);
}
TS:组件里 subscribe(next + error)
export class ProductsComponent implements OnInit {
products: Product[] = [];
loading = false;
error = '';
constructor(private productService: ProductService) {}
ngOnInit() { this.search(); }
search() {
this.loading = true;
this.error = '';
this.productService.list('abc').subscribe({
// next:请求成功(HTTP 2xx),参数是后端返回的数据
next: (list) => {
this.products = list;
this.loading = false;
},
// error:请求失败(4xx/5xx/网络断开),参数是 HttpErrorResponse
error: (err) => {
this.error = '加载失败';
this.loading = false;
},
// complete:(可选)请求结束后调用。HTTP 请求成功后只会触发一次,一般不需要写
});
}
}
HTML
<p *ngIf="loading">加载中…</p>
<p class="error" *ngIf="error">{{ error }}</p>
<div *ngFor="let p of products">{{ p.name }}</div>
读取错误信息:HttpErrorResponse
error: (err: HttpErrorResponse) => {
err.status; // 状态码:0=连不上服务器,401=未登录,404,409,422,500...
err.error; // 后端返回的响应体(如 { message: '库存不足' })
err.error?.message; // 取后端的错误提示;用 ?. 防止 err.error 为 null
err.message; // Angular 生成的通用错误消息
}
// 常见写法:优先显示后端的提示,没有就用默认文案
error: (err) => (this.error = err.error?.message ?? '加入失败'),
简写:只关心成功
this.cart.remove(id).subscribe((list) => this.cart.setItems(list)); // 等同于只写 next
⚠️ 简写会漏掉错误处理:请求失败时用户看不到任何反馈,控制台还会报 unhandled error。有可能失败的请求,建议写完整的
{ next, error }。
常用状态码
| status | 含义 | 本项目的处理 |
|---|---|---|
| 0 | 连不上服务器 | 提示"确认后端已启动" |
| 401 | 未登录/token 失效 | 拦截器统一处理(见第 11 节) |
| 409 | 冲突(如库存不足) | 显示 err.error.message |
| 422 | 字段校验失败 | 写回表单(见第 21 节) |
注意点
- 不 subscribe 就不会发请求(Observable 是"冷"的)。
- 每 subscribe 一次发一次请求;同一个 Observable 订阅两次 = 请求两次。
- HTTP 的 Observable 完成后会自动结束,不需要手动取消订阅。
- 模板里用
async管道时不用写subscribe,但也就没有error回调了(见第 16 节)。
10. asObservable 的用法
作用:把 BehaviorSubject(可读可写)转成只读的 Observable,对外只暴露"订阅",不暴露 .next(),防止别处乱改状态。
import
import { BehaviorSubject } from 'rxjs';
TS(service 里)
@Injectable({ providedIn: 'root' })
export class AuthService {
// 私有:可以 next(),只有 service 内部能用
private loggedIn = new BehaviorSubject<boolean>(false);
// 公开:只读,外部只能订阅
loggedIn$ = this.loggedIn.asObservable();
saveToken(token: string) {
localStorage.setItem('token', token);
this.loggedIn.next(true); // ✅ service 内部修改状态
}
logout() {
localStorage.removeItem('token');
this.loggedIn.next(false);
}
}
使用方(组件)
constructor(public auth: AuthService) {}
// 订阅 ✅
this.auth.loggedIn$.subscribe((v) => console.log(v));
// 修改 ❌ 编译报错:Observable 上没有 next 方法
// this.auth.loggedIn$.next(true);
<a *ngIf="auth.loggedIn$ | async">退出</a>
对比:不用 asObservable 会怎样
// ❌ 直接公开 BehaviorSubject,任何组件都能随手 next(),状态来源混乱
loggedIn$ = new BehaviorSubject<boolean>(false);
// 某个组件里:this.auth.loggedIn$.next(true); ← 绕过了 saveToken,token 没存却显示已登录
命名约定
| 写法 | 含义 |
|---|---|
private items = new BehaviorSubject(...) | 私有的可写 Subject,不带 $ |
items$ = this.items.asObservable() | 公开的只读流,以 $ 结尾 |
注意点
asObservable()返回的流依然是实时的,不是快照;items.next()之后订阅者照样收到新值。- 它只是类型层面的封装(去掉
.next等方法),不会复制数据。 - 需要同步读取当前值时,在 service 里通过方法暴露,例如
get current() { return this.items.value; }。
11. authInterceptor(HTTP 拦截器)
作用:所有 HttpClient 请求都会先经过它。常用于:① 自动给请求加 Authorization 头;② 统一处理 401(token 失效就跳登录页)。这样每个 service 方法不用自己带 token。
import
// src/app/services/auth.interceptor.ts
import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
import { inject } from '@angular/core';
import { Router } from '@angular/router';
import { catchError, throwError } from 'rxjs';
import { AuthService } from './auth.service';
TS:定义拦截器(函数式,Angular 15+)
export const authInterceptor: HttpInterceptorFn = (req, next) => {
// 函数里没有构造函数,用 inject() 拿依赖
const auth = inject(AuthService);
const router = inject(Router);
const token = auth.token;
// 请求对象不可变,必须 clone 一份再改
const authReq = token
? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
: req;
// next(...) 把请求交给下一个拦截器/真正发出;返回的 Observable 就是响应流
return next(authReq).pipe(
catchError((err: HttpErrorResponse) => {
// 带了 token 却 401 => token 失效:清掉登录状态并回登录页
// 没带 token 的 401(如登录时密码错)不处理,交给调用方显示错误
if (err.status === 401 && token) {
auth.logout();
router.navigate(['/login']);
}
return throwError(() => err); // 把错误继续往外抛,调用方的 error 回调仍会触发
})
);
};
注册(必须!否则拦截器不生效)
// src/app/app.config.ts
import { provideHttpClient, withInterceptors } from '@angular/common/http';
export const appConfig: ApplicationConfig = {
providers: [
provideHttpClient(withInterceptors([authInterceptor])), // 多个拦截器按数组顺序执行
],
};
HTML
拦截器没有 HTML。效果体现在 Network 面板:所有请求自动带上
Authorization: Bearer eyJhbGciOi...
只拦截特定请求(可选)
export const authInterceptor: HttpInterceptorFn = (req, next) => {
// 只给自己后端的请求加 token,不要把 token 发给第三方域名
if (!req.url.startsWith(API_URL)) return next(req);
// ...
};
注意点
- 拦截器收到的
req是只读的,修改必须req.clone({...})。 catchError里必须return throwError(...),否则调用方的error回调不会触发,也拿不到错误。- 拦截器里用
inject(),不能用构造函数注入。 - 老写法是基于 class 的
HttpInterceptor+HTTP_INTERCEPTORS,新项目用函数式即可。
12. 补充:校验器 Validators 与错误显示
作用:给表单控件加校验规则,并在模板里按错误类型显示提示。
import
import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
import { CommonModule } from '@angular/common';
TS
export class ProductFormComponent {
constructor(private fb: FormBuilder) {}
form = this.fb.nonNullable.group({
name: ['', Validators.required],
email: ['', [Validators.required, Validators.email]], // 多个校验器用数组
password: ['', [Validators.required, Validators.minLength(6)]],
price: [0, [Validators.required, Validators.min(0)]],
stock: [0, [Validators.required, Validators.pattern(/^\d+$/)]], // 整数
});
// 封装:控件"被碰过或改过"且"无效"时才显示错误
show(name: 'name' | 'email' | 'password' | 'price' | 'stock') {
const c = this.form.controls[name];
return c.invalid && (c.touched || c.dirty);
}
}
HTML
<form [formGroup]="form">
<input formControlName="email" />
<div class="error" *ngIf="show('email')">
<!-- hasError('校验器名') 判断具体是哪条规则没过 -->
<span *ngIf="form.controls.email.hasError('required')">请输入邮箱</span>
<span *ngIf="form.controls.email.hasError('email')">邮箱格式不正确</span>
</div>
<input formControlName="password" type="password" />
<div class="error" *ngIf="show('password')">
<span *ngIf="form.controls.password.hasError('minlength')">至少 6 位</span>
</div>
</form>
常用校验器与错误名
| 校验器 | hasError 用的名字 |
|---|---|
Validators.required | 'required' |
Validators.email | 'email' |
Validators.minLength(n) / maxLength(n) | 'minlength' / 'maxlength'(全小写) |
Validators.min(n) / max(n) | 'min' / 'max' |
Validators.pattern(regex) | 'pattern' |
控件状态
| 属性 | 含义 |
|---|---|
touched | 用户点进去又离开过(失焦) |
dirty | 用户修改过值 |
invalid / valid | 校验是否通过 |
errors | 错误对象,如 { required: true } |
注意点
- 不要一进页面就显示错误,所以要结合
touched || dirty。 - 点提交时调用
form.markAllAsTouched(),让没碰过的控件也显示错误。 - 前端校验只是体验优化,后端必须再校验一次。
13. 补充:自定义/跨字段校验(密码一致)
作用:校验"确认密码是否等于密码"。这里给出简单版(推荐入门)和校验器版。
import
import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
// 校验器版额外需要:AbstractControl, ValidationErrors
简单版:在模板和 submit 里直接比较
export class RegisterComponent {
constructor(private fb: FormBuilder) {}
form = this.fb.nonNullable.group({
password: ['', [Validators.required, Validators.minLength(6)]],
confirm: ['', Validators.required],
});
passwordMismatch() {
const { password, confirm } = this.form.getRawValue();
return password !== confirm;
}
submit() {
if (this.form.invalid || this.passwordMismatch()) {
this.form.markAllAsTouched();
return;
}
// 发请求...
}
}
<form [formGroup]="form" (ngSubmit)="submit()">
<input type="password" formControlName="password" />
<input type="password" formControlName="confirm" />
<div class="error" *ngIf="form.controls.confirm.touched && passwordMismatch()">
两次密码不一致
</div>
<button type="submit">注册</button>
</form>
校验器版:让 form.invalid 也包含"不一致"
import { AbstractControl, ValidationErrors } from '@angular/forms';
// 挂在 FormGroup 上的校验器:参数是整个 group
function passwordsMatch(group: AbstractControl): ValidationErrors | null {
const p = group.get('password')?.value;
const c = group.get('confirm')?.value;
return p === c ? null : { mismatch: true }; // null=通过;对象=失败,key 是错误名
}
form = this.fb.nonNullable.group(
{
password: ['', Validators.required],
confirm: ['', Validators.required],
},
{ validators: passwordsMatch } // 第二个参数
);
<!-- 错误在 form 本身上,不是某个控件上 -->
<div class="error" *ngIf="form.hasError('mismatch') && form.controls.confirm.touched">
两次密码不一致
</div>
两种写法对比
| 简单版 | 校验器版 | |
|---|---|---|
| 代码量 | 少,好懂 | 多一个函数 |
form.invalid 是否包含不一致 | 否(要在 submit 里手动判断) | 是 |
| 提交按钮能否因此自动禁用 | 否 | 可以 [disabled]="form.invalid" |
14. 补充:路由表 app.routes.ts
作用:定义"URL → 组件"的映射。
import + TS
// src/app/app.routes.ts
import { Routes } from '@angular/router';
import { authGuard } from './guards/auth.guard';
import { ProductsComponent } from './pages/products.component';
import { ProductFormComponent } from './pages/product-form.component';
import { LoginComponent } from './pages/login.component';
export const routes: Routes = [
// 重定向:pathMatch:'full' 表示 URL 必须完全等于 ''
{ path: '', redirectTo: 'products', pathMatch: 'full' },
{ path: 'login', component: LoginComponent },
{ path: 'products', component: ProductsComponent },
// :id 是路径参数,在组件里用 paramMap 读取(见第 7 节)
{ path: 'products/:id/edit', component: ProductFormComponent, canActivate: [authGuard] },
// 通配:必须放最后,否则会吞掉后面的路由
{ path: '**', redirectTo: 'products' },
];
注册 + 出口
// app.config.ts
providers: [provideRouter(routes)]
<!-- app.component 模板里,路由匹配到的组件渲染在这里 -->
<router-outlet />
注意点
- 路由按从上到下顺序匹配,第一个命中的生效。
canActivate: [守卫]守卫返回true才能进入页面(见第 15 节)。''的重定向要加pathMatch: 'full',否则所有路径都会被匹配并重定向。
15. 补充:路由守卫 authGuard
作用:进入某个路由前先检查(如是否登录),不满足就重定向。
import + TS(函数式守卫)
// src/app/guards/auth.guard.ts
import { inject } from '@angular/core';
import { CanActivateFn, Router } from '@angular/router';
import { AuthService } from '../services/auth.service';
export const authGuard: CanActivateFn = () => {
const auth = inject(AuthService);
const router = inject(Router);
// true:放行;UrlTree:重定向;false:原地不动
return auth.token ? true : router.createUrlTree(['/login']);
};
使用:挂在路由上
{ path: 'cart', component: CartComponent, canActivate: [authGuard] },
HTML
无。用户未登录访问 /cart 会被直接带到 /login。
注意点
- 守卫只能保护前端页面,真正的权限控制必须在后端做(前端的 token 检查可以被绕过)。
- 重定向推荐返回
UrlTree,而不是在守卫里调用router.navigate()再返回 false。
16. 补充:async 管道
作用:在模板里自动订阅 Observable,值变化时自动刷新视图,组件销毁时自动取消订阅。省去手写 subscribe 和 unsubscribe。
import
import { CommonModule } from '@angular/common'; // async 管道在这里
@Component({
standalone: true,
imports: [CommonModule],
// ...
})
HTML
<!-- 1. 配合 *ngIf:有值(truthy)才显示 -->
<a routerLink="/orders" *ngIf="auth.loggedIn$ | async">订单</a>
<!-- 2. else 分支 -->
<ng-container *ngIf="auth.loggedIn$ | async; else guest">已登录</ng-container>
<ng-template #guest>请登录</ng-template>
<!-- 3. as 起别名:把结果存成模板变量,避免在同一个模板里重复订阅 -->
<ng-container *ngIf="cart.items$ | async as items">
<p *ngFor="let it of items">{{ it.product.name }}</p>
<p>共 {{ items.length }} 件</p>
</ng-container>
<!-- 4. 直接显示值 -->
<p>{{ count$ | async }}</p>
TS
export class CartComponent {
// 模板里要访问,所以 public(或自己是属性)
constructor(public cart: CartService, public auth: AuthService) {}
}
注意点
- 每写一次
| async就订阅一次。若 Observable 是 HTTP 请求,写两次就发两次请求,所以多处使用时用as起别名。 *ngIf="x$ | async"对空数组[]是 truthy(数组对象),但对0、''、false、null是 falsy。- 用
async就没有error回调;需要处理错误请用subscribe({ next, error })。 BehaviorSubject配async最合适:订阅时立刻有值。
17. 补充:*ngIf / *ngFor / trackBy
作用:模板里的条件渲染和列表渲染。
import
import { CommonModule } from '@angular/common';
@Component({ standalone: true, imports: [CommonModule], /* ... */ })
HTML
<!-- 条件渲染 -->
<p *ngIf="loading">加载中…</p>
<p *ngIf="!loading && products.length === 0">没有商品</p>
<!-- if-else -->
<div *ngIf="list.length; else empty">有数据</div>
<ng-template #empty>暂无数据</ng-template>
<!-- 列表渲染:trackBy 让数据刷新时按 id 复用 DOM,避免整列重建 -->
<div *ngFor="let p of products; trackBy: trackById; let i = index">
{{ i + 1 }}. {{ p.name }} - {{ p.price | currency }}
</div>
<!-- ng-container:不产生额外 DOM 的"逻辑容器" -->
<ng-container *ngIf="error">
<p class="error">{{ error }}</p>
</ng-container>
TS
export class ProductsComponent {
products: Product[] = [];
loading = false;
error = '';
trackById(_: number, p: Product) { // 第一个参数是下标,用不到写 _
return p.id;
}
}
注意点
- 同一个元素上不能同时写
*ngIf和*ngFor,需要时外面套一层<ng-container>。 - 事件绑定
(click)="add(p)",属性绑定[disabled]="p.stock === 0",插值{{ }}。 - Angular 17+ 有新语法
@if/@for,本项目是 16,仍用*ngIf/*ngFor。
18. 补充:Router 编程式跳转与 routerLink
作用:页面跳转。HTML 里用 routerLink,TS 里用 router.navigate。
import
import { Router, RouterLink } from '@angular/router';
@Component({
standalone: true,
imports: [RouterLink], // 模板里用 routerLink 必须导入
// ...
})
HTML
<!-- 固定路径 -->
<a routerLink="/products">商品</a>
<!-- 带参数:数组每一项是路径的一段 → /products/5/edit -->
<a [routerLink]="['/products', p.id, 'edit']">编辑</a>
<!-- 带查询参数 → /products?q=abc -->
<a routerLink="/products" [queryParams]="{ q: 'abc' }">搜索</a>
TS
export class LoginComponent {
constructor(private router: Router) {}
onSuccess() {
this.router.navigate(['/products']); // 跳转
this.router.navigate(['/products', 5, 'edit']); // 带路径参数
this.router.navigate(['/products'], { queryParams: { q: 'a' } }); // 带查询参数
}
}
注意点
routerLink站内跳转不刷新页面;普通<a href="/products">会整页刷新、丢失内存里的状态。<a href="#" (click)="logout($event)">要在方法里e.preventDefault(),否则#会触发跳转。- 登录成功先保存 token 再跳转,否则守卫会把你拦回登录页。
19. 补充:ngOnInit 生命周期
作用:组件创建、输入属性就绪后调用一次。初始化逻辑(拉数据、读路由参数)放这里,不放构造函数。
import
import { Component, OnInit } from '@angular/core';
TS
export class ProductsComponent implements OnInit { // implements OnInit 让 TS 检查你写了 ngOnInit
products: Product[] = [];
constructor(private productService: ProductService) {} // 构造函数:只做依赖注入
ngOnInit() {
// 进入页面时执行一次:拉数据
this.productService.list().subscribe((list) => (this.products = list));
}
}
常见生命周期
| 钩子 | 时机 |
|---|---|
ngOnInit | 组件初始化后,最常用 |
ngOnDestroy | 组件销毁前,用于取消订阅、清理定时器 |
ngOnChanges | @Input 变化时 |
ngAfterViewInit | 视图渲染完成后(需要操作 DOM 时) |
注意点
- 构造函数里只做依赖注入、字段初始化,不要发请求。
- 有订阅需要手动清理时,实现
OnDestroy:ngOnDestroy() { this.sub.unsubscribe(); }。
20. 补充:main.ts 启动入口
作用:启动应用:指定根组件和全局配置。
TS
// src/main.ts
import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { AppComponent } from './app/app.component';
bootstrapApplication(AppComponent, appConfig)
.catch((err) => console.error(err));
HTML
<!-- src/index.html:根组件的 selector 对应这里 -->
<body>
<app-root></app-root>
</body>
注意点
- 启动流程:
main.ts→bootstrapApplication(根组件, 全局配置)→ 渲染<app-root>。 - 全局 provider 在
app.config.ts(第 5 节),根组件见第 6 节。
21. 补充:把服务端校验错误写回表单
作用:后端校验失败(422)返回 { errors: { 字段: 消息 } },把消息写到对应控件上,和前端校验错误一样显示。
import
// src/app/utils/form-errors.ts
import { HttpErrorResponse } from '@angular/common/http';
import { FormGroup } from '@angular/forms';
TS:工具函数
export function applyServerErrors(form: FormGroup, err: HttpErrorResponse): string {
const body = err.error as { message?: string; errors?: Record<string, string> } | null;
if (err.status === 0) return '无法连接服务器,请确认后端已启动';
if (err.status === 422 && body?.errors) {
for (const [field, msg] of Object.entries(body.errors)) {
form.get(field)?.setErrors({ server: msg }); // 控件上出现 errors['server']
}
return ''; // 字段级错误已处理,没有通用提示
}
return body?.message ?? '未知错误'; // 返回"通用错误"给表单顶部
}
TS:组件中使用
formError = '';
submit() {
this.auth.register(email, password).subscribe({
next: () => this.router.navigate(['/products']),
error: (err) => {
this.loading = false;
this.formError = applyServerErrors(this.form, err);
},
});
}
HTML
<input type="email" formControlName="email" />
<div class="error" *ngIf="form.controls.email.touched && form.controls.email.invalid">
<span *ngIf="form.controls.email.hasError('required')">请输入邮箱</span>
<!-- 后端返回的错误,如"邮箱已被注册" -->
<span *ngIf="form.controls.email.hasError('server')">
{{ form.controls.email.getError('server') }}
</span>
</div>
<!-- 不属于某个字段的通用错误 -->
<div class="error" *ngIf="formError">{{ formError }}</div>
注意点
setErrors设置的错误会在用户下次修改该控件值时被清掉(重新校验),符合预期。- 后端返回的字段名要和表单控件名一致,才能对上。
22. 补充:form.value 与 getRawValue()
作用:取表单的值。两者的差别只在被 disable 的控件。
TS
form = this.fb.nonNullable.group({
id: [{ value: 1, disabled: true }], // 禁用的控件
name: ['Tom'],
price: [10],
});
this.form.value; // { name: 'Tom', price: 10 } ← 不含 disabled 的 id
this.form.getRawValue(); // { id: 1, name: 'Tom', price: 10 } ← 含全部字段
提交时
submit() {
if (this.form.invalid) {
this.form.markAllAsTouched();
return;
}
const payload = this.form.getRawValue(); // 没有 disabled 控件时,两者结果相同
this.http.post('/api/xxx', payload).subscribe();
}
选哪个
| 情况 | 用 |
|---|---|
| 没有 disabled 控件 | 都行;本项目统一用 getRawValue() |
| 有 disabled 控件,且要提交 | getRawValue() |
| 有 disabled 控件,且不想提交 | form.value |
值的类型
getRawValue() 里每个字段的类型由控件决定,不是全是字符串:
| 控件 | 值类型 |
|---|---|
<input type="text"> | string |
<input type="number"> | number(清空为 null) |
<input type="checkbox"> | boolean |
<select> + [ngValue]="对象" | 该对象(value="x" 则为字符串) |
radio + [value]="true" | boolean(value="x" 则为字符串) |
注意点
- 校验时 disabled 的控件不参与,所以
form.valid可能为 true,而getRawValue()里却有未校验的值。 - 注册表单里
confirm(确认密码)不应发给后端:const { email, password } = this.form.getRawValue();只解构需要的字段。