路由与导航
Routing and navigation
在用户使用应用程序时，Angular 的路由器能让用户从一个视图导航到另一个视图。
The Angular Routerenables navigation from one view to the next as users perform application tasks.
本章涵盖了该路由器的主要特性，通过一个小型应用的成长演进来讲解它。参见
This guide covers the router's primary features, illustrating them through the evolution of a small application that you can
概览
Overview
浏览器具有熟悉的导航模式：
The browser is a familiar model of application navigation:
在地址栏输入 URL，浏览器就会导航到相应的页面。
Enter a URL in the address bar and the browser navigates to a corresponding page.
在页面中点击链接，浏览器就会导航到一个新页面。
Click links on the page and the browser navigates to a new page.
点击浏览器的前进和后退按钮，浏览器就会在你的浏览历史中向前或向后导航。
Click the browser's back and forward buttons and the browser navigates backward and forward through the history of pages you've seen.
Angular 的 Router（即“路由器”）借鉴了这个模型。它把浏览器中的 URL 看做一个操作指南， 据此导航到一个由客户端生成的视图，并可以把参数传给支撑视图的相应组件，帮它决定具体该展现哪些内容。 你可以为页面中的链接绑定一个路由，这样，当用户点击链接时，就会导航到应用中相应的视图。 当用户点击按钮、从下拉框中选取，或响应来自任何地方的事件时，你也可以在代码控制下进行导航。 路由器还在浏览器的历史日志中记录下这些活动，这样浏览器的前进和后退按钮也能照常工作。
The Angular Router ("the router") borrows from this model. It can interpret a browser URL as an instruction to navigate to a client-generated view. It can pass optional parameters along to the supporting view component that help it decide what specific content to present. You can bind the router to links on a page and it will navigate to the appropriate application view when the user clicks a link. You can navigate imperatively when the user clicks a button, selects from a drop box, or in response to some other stimulus from any source. And the router logs activity in the browser's history journal so the back and forward buttons work as well.
基础知识
The Basics
本章包括一系列里程碑，从一个单模块、两个页面的简单程序逐步走向带有多个子路由的多视图设计。
This guide proceeds in phases, marked by milestones, starting from a simple two-pager and building toward a modular, multi-view design with child routes.
先对路由的一些核心概念做一个介绍，它能帮你逐步过渡到细节。
An introduction to a few core router concepts will help orient you to the details that follow.
<base href> 元素
<base href>
大多数带路由的应用都要在index.html的 <head> 标签下先添加一个 <base> 元素，来告诉路由器该如何合成导航用的 URL。
Most routing applications should add a <base> element to the index.html as the first child in the <head> tag to tell the router how to compose navigation URLs.
如果 app 文件夹是该应用的根目录（就像范例应用中一样），那就把 href 的值设置为下面这样：
If the app folder is the application root, as it is for the sample application, set the href value exactly as shown here.
<base href="/">
从路由库中导入
Router imports
Angular 的路由器是一个可选的服务，它用来呈现指定的 URL 所对应的视图。 它并不是 Angular 核心库的一部分，而是在它自己的 @angular/router 包中。 像其它 Angular 包一样，你可以从它导入所需的一切。
The Angular Router is an optional service that presents a particular component view for a given URL. It is not part of the Angular core. It is in its own library package, @angular/router. Import what you need from it as you would from any other Angular package.
import { RouterModule, Routes } from '@angular/router';
你将会在后面学到更多选项。
You'll learn about more options in the details below.
配置
Configuration
每个带路由的 Angular 应用都有一个Router（路由器）服务的单例对象。 当浏览器的 URL 变化时，路由器会查找对应的 Route（路由），并据此决定该显示哪个组件。
A routed Angular application has one singleton instance of the Routerservice. When the browser's URL changes, that router looks for a corresponding Route from which it can determine the component to display.
路由器需要先配置才会有路由信息。 下面的例子创建了五个路由定义，并用 RouterModule.forRoot() 方法来配置路由器， 并把它的返回值添加到 AppModule 的 imports 数组中。
A router has no routes until you configure it. The following example creates five route definitions, configures the router via the RouterModule.forRoot() method, and adds the result to the AppModule's imports array.
const appRoutes: Routes = [
{ path: 'crisis-center', component: CrisisListComponent },
{ path: 'hero/:id', component: HeroDetailComponent },
{
path: 'heroes',
component: HeroListComponent,
data: { title: 'Heroes List' }
},
{ path: '',
redirectTo: '/heroes',
pathMatch: 'full'
},
{ path: '**', component: PageNotFoundComponent }
];
@NgModule({
imports: [
RouterModule.forRoot(
appRoutes,
{ enableTracing: true } // <-- debugging purposes only
)
// other imports here
],
...
})
export class AppModule { }
这里的路由数组 appRoutes 描述如何进行导航。 把它传给 RouterModule.forRoot() 方法并传给本模块的 imports 数组就可以配置路由器。
The appRoutes array of routes describes how to navigate. Pass it to the RouterModule.forRoot() method in the module imports to configure the router.
每个 Route 都会把一个 URL 的 path 映射到一个组件。 注意，path 不能以斜杠（/）开头。 路由器会为解析和构建最终的 URL，这样当你在应用的多个视图之间导航时，可以任意使用相对路径和绝对路径。
Each Route maps a URL path to a component. There are no leading slashes in the path. The router parses and builds the final URL for you, allowing you to use both relative and absolute paths when navigating between application views.
第二个路由中的 :id 是一个路由参数的令牌(Token)。比如 /hero/42 这个 URL 中，“42”就是 id 参数的值。 此 URL 对应的 HeroDetailComponent 组件将据此查找和展现 id 为 42 的英雄。 在本章中稍后的部分，你将会学习关于路由参数的更多知识。
The :id in the second route is a token for a route parameter. In a URL such as /hero/42, "42" is the value of the id parameter. The corresponding HeroDetailComponent will use that value to find and present the hero whose id is 42. You'll learn more about route parameters later in this guide.
第三个路由中的 data 属性用来存放于每个具体路由有关的任意信息。该数据可以被任何一个激活路由访问，并能用来保存诸如 页标题、面包屑以及其它静态只读数据。本章稍后的部分，你将使用resolve 守卫来获取动态数据。
The data property in the third route is a place to store arbitrary data associated with this specific route. The data property is accessible within each activated route. Use it to store items such as page titles, breadcrumb text, and other read-only, static data. You'll use the resolve guard to retrieve dynamic data later in the guide.
第四个路由中的空路径（''）表示应用的默认路径，当 URL 为空时就会访问那里，因此它通常会作为起点。 这个默认路由会重定向到 URL /heroes，并显示 HeroesListComponent。
The empty path in the fourth route represents the default path for the application, the place to go when the path in the URL is empty, as it typically is at the start. This default route redirects to the route for the /heroes URL and, therefore, will display the HeroesListComponent.
最后一个路由中的 ** 路径是一个通配符。当所请求的 URL 不匹配前面定义的路由表中的任何路径时，路由器就会选择此路由。 这个特性可用于显示“404 - Not Found”页，或自动重定向到其它路由。
The ** path in the last route is a wildcard. The router will select this route if the requested URL doesn't match any paths for routes defined earlier in the configuration. This is useful for displaying a "404 - Not Found" page or redirecting to another route.
这些路由的定义顺序是刻意如此设计的。路由器使用先匹配者优先的策略来匹配路由，所以，具体路由应该放在通用路由的前面。在上面的配置中，带静态路径的路由被放在了前面，后面是空路径路由，因此它会作为默认路由。而通配符路由被放在最后面，这是因为它能匹配上每一个 URL，因此应该只有在前面找不到其它能匹配的路由时才匹配它。
The order of the routes in the configuration matters and this is by design. The router uses a first-match wins strategy when matching routes, so more specific routes should be placed above less specific routes. In the configuration above, routes with a static path are listed first, followed by an empty path route, that matches the default route. The wildcard route comes last because it matches every URL and should be selected only if no other routes are matched first.
如果你想要看到在导航的生命周期中发生过哪些事件，可以使用路由器默认配置中的 enableTracing 选项。它会把每个导航生命周期中的事件输出到浏览器的控制台。 这应该只用于调试。你只需要把 enableTracing: true 选项作为第二个参数传给 RouterModule.forRoot() 方法就可以了。
If you need to see what events are happening during the navigation lifecycle, there is the enableTracing option as part of the router's default configuration. This outputs each router event that took place during each navigation lifecycle to the browser console. This should only be used for debugging purposes. You set the enableTracing: true option in the object passed as the second argument to the RouterModule.forRoot() method.
路由出口
Router outlet
RouterOutlet 是一个来自路由模块中的指令，它的用法类似于组件。 它扮演一个占位符的角色，用于在模板中标出一个位置，路由器将会把要显示在这个出口处的组件显示在这里。
The RouterOutlet is a directive from the router library that is used like a component. It acts as a placeholder that marks the spot in the template where the router should display the components for that outlet.
<router-outlet></router-outlet>
<!-- Routed components go here -->
有了这份配置，当本应用在浏览器中的 URL 变为 /heroes 时，路由器就会匹配到 path 为 heroes 的 Route，并在宿主视图中的RouterOutlet之后显示 HeroListComponent 组件。
Given the configuration above, when the browser URL for this application becomes /heroes, the router matches that URL to the route path /heroes and displays the HeroListComponent as a sibling element to the RouterOutlet that you've placed in the host component's template.
路由器链接
Router links
现在，你已经有了配置好的一些路由，还找到了渲染它们的地方，但又该如何导航到它呢？固然，从浏览器的地址栏直接输入 URL 也能做到，但是大多数情况下，导航是某些用户操作的结果，比如点击一个 A 标签。
Now you have routes configured and a place to render them, but how do you navigate? The URL could arrive directly from the browser address bar. But most of the time you navigate as a result of some user action such as the click of an anchor tag.
考虑下列模板：
Consider the following template:
<h1>Angular Router</h1>
<nav>
<a routerLink="/crisis-center" routerLinkActive="active">Crisis Center</a>
<a routerLink="/heroes" routerLinkActive="active">Heroes</a>
</nav>
<router-outlet></router-outlet>
a 标签上的 RouterLink 指令让路由器得以控制这个 a 元素。 这里的导航路径是固定的，因此可以把一个字符串赋给 routerLink（“一次性”绑定）。
The RouterLink directives on the anchor tags give the router control over those elements. The navigation paths are fixed, so you can assign a string to the routerLink (a "one-time" binding).
如果需要更加动态的导航路径，那就把它绑定到一个返回链接参数数组的模板表达式。 路由器会把这个数组解析成完整的 URL。
Had the navigation path been more dynamic, you could have bound to a template expression that returned an array of route link parameters (the link parameters array). The router resolves that array into a complete URL.
路由链接的激活状态
Active router links
RouterLinkActive 指令会基于当前的 RouterState 为活动的 RouterLink 切换所绑定的 css 类。
The RouterLinkActive directive toggles css classes for active RouterLink bindings based on the current RouterState.
在每个 A 标签上，你会看到一个到 RouterLinkActive 的属性绑定，形如 routerLinkActive="..."。
On each anchor tag, you see a property binding to the RouterLinkActive directive that look like routerLinkActive="...".
等号右边的模板表达式包含一些用空格分隔的 CSS 类名，当这个链接激活时，路由器将会把它们加上去（并在处于非活动状态时移除）。你还可以把 RouterLinkActive 设置为一个类组成的字符串，如 [routerLinkActive]="'active fluffy'"，或把它绑定到一个返回类似字符串的组件属性。
The template expression to the right of the equals (=) contains a space-delimited string of CSS classes that the Router will add when this link is active (and remove when the link is inactive). You set the RouterLinkActive directive to a string of classes such as [routerLinkActive]="'active fluffy'" or bind it to a component property that returns such a string.
路由链接的激活状态会向下级联到路由树中的每个层级，所以，父子路由链接可能会同时激活。要覆盖这种行为，可以把 [routerLinkActiveOptions] 绑定为 { exact: true } 表达式，这样 RouterLink 只有当 URL 与当前 URL 精确匹配时才会激活。
Active route links cascade down through each level of the route tree, so parent and child router links can be active at the same time. To override this behavior, you can bind to the [routerLinkActiveOptions] input binding with the { exact: true } expression. By using { exact: true }, a given RouterLink will only be active if its URL is an exact match to the current URL.
路由器状态
Router state
在导航时的每个生命周期成功完成时，路由器会构建出一个 ActivatedRoute 组成的树，它表示路由器的当前状态。 你可以在应用中的任何地方用 Router 服务及其 routerState 属性来访问当前的 RouterState 值。
After the end of each successful navigation lifecycle, the router builds a tree of ActivatedRoute objects that make up the current state of the router. You can access the current RouterState from anywhere in the application using the Router service and the routerState property.
RouterState 中的每个 ActivatedRoute 都提供了从任意激活路由开始向上或向下遍历路由树的一种方式，以获得关于父、子、兄弟路由的信息。
Each ActivatedRoute in the RouterState provides methods to traverse up and down the route tree to get information from parent, child and sibling routes.
激活的路由
Activated route
该路由的路径和参数可以通过注入进来的一个名叫ActivatedRoute的路由服务来获取。 它有一大堆有用的信息，包括：
The route path and parameters are available through an injected router service called the ActivatedRoute. It has a great deal of useful information including:
属性 Property | 说明 Description |
|---|---|
| 路由路径的 An |
| 一个 An |
| 一个 An |
| 一个 An |
| 一个适用于所有路由的 URL 的 fragment（片段）的 An |
| 要把该路由渲染到的 The name of the |
| 用于该路由的路由配置信息，其中包含原始路径。 The route configuration used for the route that contains the origin path. |
| 当该路由是一个子路由时，表示该路由的父级 The route's parent |
| 包含该路由的子路由列表中的第一个 Contains the first |
| 包含当前路由下所有已激活的子路由。 Contains all the child routes activated under the current route. |
有两个旧式属性仍然是有效的，但它们不如其替代品那样强力，建议不再用它们，它们还将在未来的 Angular 版本中废弃。
Two older properties are still available. They are less capable than their replacements, discouraged, and may be deprecated in a future Angular version.
params—— 一个 Observable 对象，其中包含当前路由的必要参数和可选参数。请改用 paramMap。
params—An Observable that contains the required and optional parameters specific to the route. Use paramMap instead.
queryParams—— 一个 Observable 对象，其中包含对所有路由都有效的查询参数。请改用 queryParamMap。
queryParams—An Observable that contains the query parameters available to all routes. Use queryParamMap instead.
路由事件
Router events
在每次导航中，Router 都会通过 Router.events 属性发布一些导航事件。这些事件的范围涵盖了从开始导航到结束导航之间的很多时间点。下表中列出了全部导航事件：
During each navigation, the Router emits navigation events through the Router.events property. These events range from when the navigation starts and ends to many points in between. The full list of navigation events is displayed in the table below.
路由器事件 Router Event | 说明 Description |
|---|---|
本事件会在导航开始时触发。 An event triggered when navigation starts. | |
RouteConfigLoadStart | An event triggered before the |
RouteConfigLoadEnd | 本事件会在惰性加载了某个路由后触发。 An event triggered after a route has been lazy loaded. |
本事件会在路由器解析完 URL，并识别出了相应的路由时触发 An event triggered when the Router parses the URL and the routes are recognized. | |
本事件会在路由器开始 Guard 阶段之前触发。 An event triggered when the Router begins the Guards phase of routing. | |
ChildActivationStart | 本事件会在路由器开始激活路由的子路由时触发。 An event triggered when the Router begins activating a route's children. |
ActivationStart | 本事件会在路由器开始激活某个路由时触发。 An event triggered when the Router begins activating a route. |
GuardsCheckEnd | 本事件会在路由器成功完成了 Guard 阶段时触发。 An event triggered when the Router finishes the Guards phase of routing successfully. |
ResolveStart | 本事件会在 An event triggered when the Router begins the Resolve phase of routing. |
本事件会在路由器成功完成了路由的解析（Resolve）阶段时触发。 An event triggered when the Router finishes the Resolve phase of routing successfuly. | |
ChildActivationEnd | 本事件会在路由器激活了路由的子路由时触发。 An event triggered when the Router finishes activating a route's children. |
ActivationEnd | 本事件会在路由器激活了某个路由时触发。 An event triggered when the Router finishes activating a route. |
本事件会在导航成功结束之后触发。 An event triggered when navigation ends successfully. | |
本事件会在导航被取消之后触发。 这可能是因为在导航期间某个路由守卫返回了 An event triggered when navigation is canceled. This can happen when a Route Guard returns false during navigation, or redirects by returning a | |
这个事件会在导航由于意料之外的错误而失败时触发。 An event triggered when navigation fails due to an unexpected error. | |
Scroll | 本事件代表一个滚动事件。 An event that represents a scrolling event. |
当启用了 enableTracing 选项时，这些事件也同时会记录到控制台中。要想查看对路由导航事件进行过滤的例子，请访问 Angular 中的可观察对象一章的路由器部分
These events are logged to the console when the enableTracing option is enabled also. For an example of filtering router navigation events, visit the router section of the Observables in Angular guide.
总结一下
Summary
该应用有一个配置过的路由器。 外壳组件中有一个 RouterOutlet，它能显示路由器所生成的视图。 它还有一些 RouterLink，用户可以点击它们，来通过路由器进行导航。
The application has a configured router. The shell component has a RouterOutlet where it can display views produced by the router. It has RouterLinks that users can click to navigate via the router.
下面是一些路由器中的关键词汇及其含义：
Here are the key Router terms and their meanings:
路由器部件 Router Part | 含义 Meaning |
|---|---|
| 为激活的 URL 显示应用组件。管理从一个组件到另一个组件的导航 Displays the application component for the active URL. Manages navigation from one component to the next. |
一个独立的 NgModule，用于提供所需的服务提供者，以及用来在应用视图之间进行导航的指令。 A separate NgModule that provides the necessary service providers and directives for navigating through application views. | |
| 定义了一个路由数组，每一个都会把一个 URL 路径映射到一个组件。 Defines an array of Routes, each mapping a URL path to a component. |
| 定义路由器该如何根据 URL 模式（pattern）来导航到组件。大多数路由都由路径和组件类构成。 Defines how the router should navigate to a component based on a URL pattern. Most routes consist of a path and a component type. |
| 该指令（ The directive ( |
| 这个指令把可点击的 HTML 元素绑定到某个路由。点击带有 The directive for binding a clickable HTML element to a route. Clicking an element with a |
| 当 HTML 元素上或元素内的 The directive for adding/removing classes from an HTML element when an associated |
| 为每个路由组件提供的一个服务，它包含特定于路由的信息，比如路由参数、静态数据、解析数据、全局查询参数和全局碎片（fragment）。 A service that is provided to each route component that contains route specific information such as route parameters, static data, resolve data, global query params, and the global fragment. |
| 路由器的当前状态包含了一棵由程序中激活的路由构成的树。它包含一些用于遍历路由树的快捷方法。 The current state of the router including a tree of the currently activated routes together with convenience methods for traversing the route tree. |
链接参数数组 Link parameters array | 这个数组会被路由器解释成一个路由操作指南。你可以把一个 An array that the router interprets as a routing instruction. You can bind that array to a |
路由组件 Routing component | 一个带有 An Angular component with a |
范例应用
The sample application
本章要讲的是如何开发一个带路由的多页面应用。 接下来会重点讲它的设计决策，并描述路由的关键特性，比如：
This guide describes development of a multi-page routed sample application. Along the way, it highlights design decisions and describes key features of the router such as:
把应用的各个特性组织成模块。
Organizing the application features into modules.
导航到组件（Heroes 链接到“英雄列表”组件）。
Navigating to a component (Heroes link to "Heroes List").
包含一个路由参数（当路由到“英雄详情”时，把该英雄的
id传进去）。Including a route parameter (passing the Hero
idwhile routing to the "Hero Detail").子路由（危机中心特性有一组自己的路由）。
Child routes (the Crisis Center has its own routes).
CanActivate守卫（检查路由的访问权限）。The
CanActivateguard (checking route access).CanActivateChild守卫（检查子路由的访问权限）。The
CanActivateChildguard (checking child route access).CanDeactivate守卫（询问是否丢弃未保存的更改）。The
CanDeactivateguard (ask permission to discard unsaved changes).Resolve守卫（预先获取路由数据）。The
Resolveguard (pre-fetching route data).惰性加载特性模块。
Lazy loading feature modules.
CanLoad守卫（在加载特性模块之前进行检查）。The
CanLoadguard (check before loading feature module assets).
如果打算一步步构建出本应用，本章就会经过一系列里程碑。 但是，本章并不是一个教程，它隐藏了构造 Angular 应用的细节，那些细节会在本文档的其它地方展开。
The guide proceeds as a sequence of milestones as if you were building the app step-by-step. But, it is not a tutorial and it glosses over details of Angular application construction that are more thoroughly covered elsewhere in the documentation.
本应用的最终版源码可以在
The full source for the final version of the app can be seen and downloaded from the
范例程序的动图
The sample application in action
假设本程序会用来帮助“英雄管理局”运行他们的业务。 英雄们需要找工作，而“英雄管理局”为他们寻找待解决的危机。
Imagine an application that helps the Hero Employment Agency run its business. Heroes need work and the agency finds crises for them to solve.
本应用具有三个主要的特性区：
The application has three main feature areas:
危机中心用于维护要指派给英雄的危机列表。
A Crisis Center for maintaining the list of crises for assignment to heroes.
英雄区用于维护管理局雇佣的英雄列表。
A Heroes area for maintaining the list of heroes employed by the agency.
管理区会管理危机和英雄的列表。
An Admin area to manage the list of crises and heroes.
点击
Try it by clicking on this
等应用热身完毕，你就会看到一排导航按钮，以及一个英雄列表视图。
Once the app warms up, you'll see a row of navigation buttons and the Heroes view with its list of heroes.
选择其中之一，该应用就会把你带到此英雄的编辑页面。
Select one hero and the app takes you to a hero editing screen.
修改完名字，再点击“后退”按钮，应用又回到了英雄列表页，其中显示的英雄名已经变了。注意，对名字的修改会立即生效。
Alter the name. Click the "Back" button and the app returns to the heroes list which displays the changed hero name. Notice that the name change took effect immediately.
另外你也可以点击浏览器本身的后退按钮，这样也同样会回到英雄列表页。 在 Angular 应用中导航也会和标准的 Web 导航一样更新浏览器中的历史。
Had you clicked the browser's back button instead of the "Back" button, the app would have returned you to the heroes list as well. Angular app navigation updates the browser history as normal web navigation does.
现在，点击危机中心链接，前往危机列表页。
Now click the Crisis Center link for a list of ongoing crises.
选择其中之一，该应用就会把你带到此危机的编辑页面。 危机详情是当前页的子组件，就在列表的紧下方。
Select a crisis and the application takes you to a crisis editing screen. The Crisis Detail appears in a child component on the same page, beneath the list.
修改危机的名称。 注意，危机列表中的相应名称并没有修改。
Alter the name of a crisis. Notice that the corresponding name in the crisis list does not change.
这和英雄详情页略有不同。英雄详情会立即保存你所做的更改。 而危机详情页中，你的更改都是临时的 —— 除非按“保存”按钮保存它们，或者按“取消”按钮放弃它们。 这两个按钮都会导航回危机中心，显示危机列表。
Unlike Hero Detail, which updates as you type, Crisis Detail changes are temporary until you either save or discard them by pressing the "Save" or "Cancel" buttons. Both buttons navigate back to the Crisis Center and its list of crises.
先不要点击这些按钮。 而是点击浏览器的后退按钮，或者点击“Heroes”链接。
Do not click either button yet. Click the browser back button or the "Heroes" link instead.
这时会弹出一个对话框。
Up pops a dialog box.
你可以回答“确定”以放弃这些更改，或者回答“取消”来继续编辑。
You can say "OK" and lose your changes or click "Cancel" and continue editing.
这种行为的幕后是路由器的 CanDeactivate 守卫。 该守卫让你有机会进行清理工作或在离开当前视图之前请求用户的许可。
Behind this behavior is the router's CanDeactivate guard. The guard gives you a chance to clean-up or ask the user's permission before navigating away from the current view.
Admin 和 Login 按钮用于演示路由器的其它能力，本章稍后的部分会讲解它们。这里只是个简短的讲解。
The Admin and Login buttons illustrate other router capabilities to be covered later in the guide. This short introduction will do for now.
这就开始本应用的第一个里程碑。
Proceed to the first application milestone.
里程碑 1：起步
Milestone 1: Getting started
开始本应用的一个简版，它在两个空路由之间导航。
Begin with a simple version of the app that navigates between two empty views.
遵循这些步骤生成一个范例应用。
Generate a sample application to follow the walkthrough.
ng new angular-router-sample
定义路由
Define Routes
路由器必须用“路由定义”的列表进行配置。
A router must be configured with a list of route definitions.
每个定义都被翻译成了一个Route对象。该对象有一个 path 字段，表示该路由中的 URL 路径部分，和一个 component 字段，表示与该路由相关联的组件。
Each definition translates to a Route object which has two things: a path, the URL path segment for this route; and a component, the component associated with this route.
当浏览器的 URL 变化时或在代码中告诉路由器导航到一个路径时，路由器就会翻出它用来保存这些路由定义的注册表。
The router draws upon its registry of definitions when the browser URL changes or when application code tells the router to navigate along a route path.
直白的说，你可以这样解释第一个路由：
In simpler terms, you might say this of the first route:
当浏览器地址栏的 URL 变化时，如果它匹配上了路径部分
/crisis-center，路由器就会激活一个CrisisListComponent的实例，并显示它的视图。When the browser's location URL changes to match the path segment
/crisis-center, then the router activates an instance of theCrisisListComponentand displays its view.当应用程序请求导航到路径
/crisis-center时，路由器激活一个CrisisListComponent的实例，显示它的视图，并将该路径更新到浏览器地址栏和历史。When the application requests navigation to the path
/crisis-center, the router activates an instance ofCrisisListComponent, displays its view, and updates the browser's address location and history with the URL for that path.
第一个配置定义了由两个路由构成的数组，它们用简单的路径指向了 CrisisListComponent 和 HeroListComponent。来生成 CrisisList 和 HeroList。
The first configuration defines an array of two routes with simple paths leading to the CrisisListComponent and HeroListComponent. Generate the CrisisList and HeroList components.
ng generate component crisis-list
ng generate component hero-list
把每个组件的内容都替换成下列范例 HTML。
Replace the contents of each component with the sample HTML below.
<h2>CRISIS CENTER</h2>
<p>Get your crisis here</p>
注册路由器与路由定义
Register Router and Routes
要使用路由器，必须先注册来自 @angular/router 包中的 RouterModule。 定义一个路由数组 appRoutes 并把它传给 RouterModule.forRoot() 方法。 它会返回一个模块，其中包含配置好的 Router 服务提供者，以及路由库所需的其它提供者。 一旦启动了应用，Router 就会根据当前的浏览器 URL 进行首次导航。
In order to use the Router, you must first register the RouterModule from the @angular/router package. Define an array of routes, appRoutes, and pass them to the RouterModule.forRoot() method. It returns a module, containing the configured Router service provider, plus other providers that the routing library requires. Once the application is bootstrapped, the Router performs the initial navigation based on the current browser URL.
注意： RouterModule.forRoot 方法是用于注册全应用级提供者的编码模式。要详细了解全应用级提供者，参见单例服务 一章。
Note: The RouterModule.forRoot method is a pattern used to register application-wide providers. Read more about application-wide providers in the Singleton services guide.
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms';
import { RouterModule, Routes } from '@angular/router';
import { AppComponent } from './app.component';
import { CrisisListComponent } from './crisis-list/crisis-list.component';
import { HeroListComponent } from './hero-list/hero-list.component';
const appRoutes: Routes = [
{ path: 'crisis-center', component: CrisisListComponent },
{ path: 'heroes', component: HeroListComponent },
];
@NgModule({
imports: [
BrowserModule,
FormsModule,
RouterModule.forRoot(
appRoutes,
{ enableTracing: true } // <-- debugging purposes only
)
],
declarations: [
AppComponent,
HeroListComponent,
CrisisListComponent,
],
bootstrap: [ AppComponent ]
})
export class AppModule { }
作为简单的路由配置，将添加配置好的 RouterModule 到 AppModule 中就足够了。 随着应用的成长，你将需要将路由配置重构到单独的文件中，并创建路由模块 - 一种特别的、专门为特性模块的路由器服务的服务模块。
Adding the configured RouterModule to the AppModule is sufficient for simple route configurations. As the application grows, you'll want to refactor the routing configuration into a separate file and create a Routing Module, a special type of Service Module dedicated to the purpose of routing in feature modules.
把 RouterModule.forRoot() 注册到 AppModule 的 imports 中，能让该 Router 服务在应用的任何地方都能使用。
Registering the RouterModule.forRoot() in the AppModule imports makes the Router service available everywhere in the application.
添加路由出口
Add the Router Outlet
根组件 AppComponent 是本应用的壳。它在顶部有一个标题、一个带两个链接的导航条，在底部有一个路由器出口，路由器会在它所指定的位置上把组件切入或调出页面。就像下图中所标出的：
The root AppComponent is the application shell. It has a title, a navigation bar with two links, and a router outlet where the router swaps components on and off the page. Here's what you get:
路由出口扮演一个占位符的角色，路由组件将会渲染在它的下方。
The router outlet serves as a placeholder when the routed components will be rendered below it.
该组件所对应的模板是这样的：
The corresponding component template looks like this:
<h1>Angular Router</h1>
<nav>
<a routerLink="/crisis-center" routerLinkActive="active">Crisis Center</a>
<a routerLink="/heroes" routerLinkActive="active">Heroes</a>
</nav>
<router-outlet></router-outlet>
定义通配符路由
Define a Wildcard route
你以前在应用中创建过两个路由，一个是 /crisis-center，另一个是 /heroes。 所有其它 URL 都会导致路由器抛出错误，并让应用崩溃。
You've created two routes in the app so far, one to /crisis-center and the other to /heroes. Any other URL causes the router to throw an error and crash the app.
可以添加一个通配符路由来拦截所有无效的 URL，并优雅的处理它们。 通配符路由的 path 是两个星号（**），它会匹配任何 URL。 当路由器匹配不上以前定义的那些路由时，它就会选择这个路由。 通配符路由可以导航到自定义的“404 Not Found”组件，也可以重定向到一个现有路由。
Add a wildcard route to intercept invalid URLs and handle them gracefully. A wildcard route has a path consisting of two asterisks. It matches every URL. The router will select this route if it can't match a route earlier in the configuration. A wildcard route can navigate to a custom "404 Not Found" component or redirect to an existing route.
路由器使用先匹配者优先的策略来选择路由。 通配符路由是路由配置中最没有特定性的那个，因此务必确保它是配置中的最后一个路由。
The router selects the route with a first match wins strategy. Wildcard routes are the least specific routes in the route configuration. Be sure it is the last route in the configuration.
要测试本特性，请往 HeroListComponent 的模板中添加一个带 RouterLink 的按钮，并且把它的链接设置为 "/sidekicks"。
To test this feature, add a button with a RouterLink to the HeroListComponent template and set the link to "/sidekicks".
<h2>HEROES</h2>
<p>Get your heroes here</p>
<button routerLink="/sidekicks">Go to sidekicks</button>
当用户点击该按钮时，应用就会失败，因为你尚未定义过 "/sidekicks" 路由。
The application will fail if the user clicks that button because you haven't defined a "/sidekicks" route yet.
不要添加 "/sidekicks" 路由，而是定义一个“通配符”路由，让它直接导航到 PageNotFoundComponent 组件。
Instead of adding the "/sidekicks" route, define a wildcard route instead and have it navigate to a simple PageNotFoundComponent.
{ path: '**', component: PageNotFoundComponent }
创建 PageNotFoundComponent，以便在用户访问无效网址时显示它。
Create the PageNotFoundComponent to display when users visit invalid URLs.
ng generate component page-not-found
<h2>Page not found</h2>
现在，当用户访问 /sidekicks 或任何无效的 URL 时，浏览器就会显示“Page not found”。 浏览器的地址栏仍指向无效的 URL。
Now when the user visits /sidekicks, or any other invalid URL, the browser displays "Page not found". The browser address bar continues to point to the invalid URL.
设置跳转
Set up redirects
应用启动时，浏览器地址栏中的初始 URL 是这样的：
When the application launches, the initial URL in the browser bar is something like:
localhost:4200
它不能匹配上任何具体的路由，于是就会走到通配符路由中去，并且显示 PageNotFoundComponent。
That doesn't match any of the concrete configured routes which means the router falls through to the wildcard route and displays the PageNotFoundComponent.
这个应用需要一个有效的默认路由，在这里应该用英雄列表作为默认页。当用户点击"Heroes"链接或把 localhost:4200/heroes 粘贴到地址栏时，它应该导航到列表页。
The application needs a default route to a valid page. The default page for this app is the list of heroes. The app should navigate there as if the user clicked the "Heroes" link or pasted localhost:4200/heroes into the address bar.
首选方案是添加一个 redirect 路由来把最初的相对路径（''）转换成期望的默认路径（/heroes）。 浏览器地址栏会显示 .../heroes，就像你直接导航到那里一样。
The preferred solution is to add a redirect route that translates the initial relative URL ('') to the desired default path (/heroes). The browser address bar shows .../heroes as if you'd navigated there directly.
在通配符路由上方添加一个默认路由。 在下方的代码片段中，它出现在通配符路由的紧上方，展示了这个里程碑的完整 appRoutes。
Add the default route somewhere above the wildcard route. It's just above the wildcard route in the following excerpt showing the complete appRoutes for this milestone.
const appRoutes: Routes = [
{ path: 'crisis-center', component: CrisisListComponent },
{ path: 'heroes', component: HeroListComponent },
{ path: '', redirectTo: '/heroes', pathMatch: 'full' },
{ path: '**', component: PageNotFoundComponent }
];
重定向路由需要一个 pathMatch 属性，来告诉路由器如何用 URL 去匹配路由的路径，否则路由器就会报错。 在本应用中，路由器应该只有在完整的 URL等于 '' 时才选择 HeroListComponent 组件，因此要把 pathMatch 设置为 'full'。
A redirect route requires a pathMatch property to tell the router how to match a URL to the path of a route. The router throws an error if you don't. In this app, the router should select the route to the HeroListComponent only when the entire URL matches '', so set the pathMatch value to 'full'.
从技术角度说，pathMatch = 'full' 导致 URL 中剩下的、未匹配的部分必须等于 ''。 在这个例子中，跳转路由在一个顶层路由中，因此剩下的URL 和完整的URL 是一样的。
Technically, pathMatch = 'full' results in a route hit when the remaining, unmatched segments of the URL match ''. In this example, the redirect is in a top level route so the remaining URL and the entire URL are the same thing.
pathMatch 的另一个可能的值是 'prefix'，它会告诉路由器：当剩下的URL 以这个跳转路由中的 prefix 值开头时，就会匹配上这个跳转路由。
The other possible pathMatch value is 'prefix' which tells the router to match the redirect route when the remaining URL begins with the redirect route's prefix path.
在这里不能这么做！如果 pathMatch 的值是 'prefix'，那么每个URL 都会匹配上 ''。
Don't do that here. If the pathMatch value were 'prefix', every URL would match ''.
尝试把它设置为 'prefix'，然后点击 Go to sidekicks 按钮。别忘了，它是一个无效 URL，本应显示“Page not found”页。 但是，你仍然在“英雄列表”页中。在地址栏中输入一个无效的 URL，你又被路由到了 /heroes。 每一个 URL，无论有效与否，都会匹配上这个路由定义。
Try setting it to 'prefix' then click the Go to sidekicks button. Remember that's a bad URL and you should see the "Page not found" page. Instead, you're still on the "Heroes" page. Enter a bad URL in the browser address bar. You're instantly re-routed to /heroes. Every URL, good or bad, that falls through to this route definition will be a match.
默认路由应该只有在整个URL 等于 '' 时才重定向到 HeroListComponent，别忘了把重定向路由设置为 pathMatch = 'full'。
The default route should redirect to the HeroListComponent only when the entire url is ''. Remember to restore the redirect to pathMatch = 'full'.
要了解更多，参见 Victor Savkin 的帖子关于重定向。
Learn more in Victor Savkin's post on redirects.
“起步阶段”总结
Basics wrap up
你得到了一个非常基本的、带导航的应用，当用户点击链接时，它能在两个视图之间切换。
You've got a very basic navigating app, one that can switch between two views when the user clicks a link.
你学到了如何：
You've learned how to do the following:
加载路由库
Load the router library.
往壳组件的模板中添加一个导航条，导航条中有一些 A 标签、
routerLink指令和routerLinkActive指令Add a nav bar to the shell template with anchor tags,
routerLinkandrouterLinkActivedirectives.往壳组件的模板中添加一个
router-outlet指令，视图将会被显示在那里Add a
router-outletto the shell template where views will be displayed.用
RouterModule.forRoot()配置路由器模块Configure the router module with
RouterModule.forRoot().设置路由器，使其合成 HTML5 模式的浏览器 URL
Set the router to compose HTML5 browser URLs.
使用通配符路由来处理无效路由
handle invalid routes with a
wildcardroute.当应用在空路径下启动时，导航到默认路由
navigate to the default route when the app launches with an empty path.
这个初学者应用的结构是这样的：
The starter app's structure looks like this:
angular-router-sample
src
app
crisis-list
crisis-list.component.css
crisis-list.component.html
crisis-list.component.ts
hero-list
hero-list.component.css
hero-list.component.html
hero-list.component.ts
page-not-found.component.css
page-not-found.component.html
page-not-found.component.ts
app.module.ts
main.ts
index.html
styles.css
tsconfig.json
node_modules ...
package.json
下面是当前里程碑中讨论过的文件列表：
Here are the files discussed in this milestone.
<h1>Angular Router</h1>
<nav>
<a routerLink="/crisis-center" routerLinkActive="active">Crisis Center</a>
<a routerLink="/heroes" routerLinkActive="active">Heroes</a>
</nav>
<router-outlet></router-outlet>
里程碑 2：路由模块
Milestone 2: Routing module
在原始的路由配置中，你提供了仅有两个路由的简单配置来设置应用的路由。对于简单的路由，这没有问题。 随着应用的成长，你用到了更多路由器特性，比如守卫、解析器和子路由等，你会很自然地想要重构路由。 我们建议将路由信息移到一个单独的特殊用途的模块，叫做路由模块。
In the initial route configuration, you provided a simple setup with two routes used to configure the application for routing. This is perfectly fine for simple routing. As the application grows and you make use of more Router features, such as guards, resolvers, and child routing, you'll naturally want to refactor the routing configuration into its own file. We recommend moving the routing information into a special-purpose module called a Routing Module.
路由模块有一系列特性：
The Routing Module has several characteristics:
把路由这个关注点从其它应用类关注点中分离出去。
Separates routing concerns from other application concerns.
测试特性模块时，可以替换或移除路由模块。
Provides a module to replace or remove when testing the application.
为路由服务提供者（包括守卫和解析器等）提供一个共同的地方。
Provides a well-known location for routing service providers including guards and resolvers.
不要声明组件。
Does not declare components.
把路由集成到应用中
Integrate routing with your app
路由应用范例中默认不包含路由。 要想在使用 Angular CLI 创建项目时支持路由，请为项目或应用的每个 NgModule 设置 --routing 选项。 当你用 CLI 命令 ng new创建新项目或用 ng generate app命令创建新应用，请指定 --routing 选项。这会告诉 CLI 包含上 @angular/router 包，并创建一个名叫 app-routing.module.ts 的文件。 然后你就可以在添加到项目或应用中的任何 NgModule 中使用路由功能了。
The sample routing application does not include routing by default. When you use the Angular CLI to create a project that will use routing, set the --routing option for the project or app, and for each NgModule. When you create or initialize a new project (using the CLI ng newcommand) or a new app (using the ng generate appcommand), specify the --routing option. This tells the CLI to include the @angular/router npm package and create a file named app-routing.module.ts. You can then use routing in any NgModule that you add to the project or app.
比如，可以用下列命令生成带路由的 NgModule。
For example, the following command generates an NgModule that can use routing.
ng generate module my-module --routing
这将创建一个名叫 my-module-routing.module.ts 的独立文件，来保存这个 NgModule 的路由信息。 该文件包含一个空的 Routes 对象，你可以使用一些指向各个组件和 NgModule 的路由来填充该对象。
This creates a separate file named my-module-routing.module.ts to store the NgModule's routes. The file includes an empty Routes object that you can fill with routes to different components and NgModules.
将路由配置重构为路由模块
Refactor the routing configuration into a routing module
在 /app 目录下创建一个 AppRouting 模块，以包含路由配置。
Create an AppRouting module in the /app folder to contain the routing configuration.
ng generate module app-routing --module app --flat
导入 CrisisListComponent、HeroListComponent 和 PageNotFoundCompponent 组件，就像 app.module.ts 中那样。然后把 Router 的导入语句和路由配置以及 RouterModule.forRoot() 移入这个路由模块中。
Import the CrisisListComponent, HeroListComponent, and PageNotFoundComponent symbols just like you did in the app.module.ts. Then move the Router imports and routing configuration, including RouterModule.forRoot(), into this routing module.
把 Angular 的 RouterModule添加到该模块的 exports 数组中，以便再次导出它 。 通过再次导出 RouterModule，当在 AppModule 中导入了 AppRoutingModule 之后，那些声明在 AppModule 中的组件就可以访问路由指令了，比如 RouterLink 和 RouterOutlet。
Re-export the Angular RouterModule by adding it to the module exports array. By re-exporting the RouterModule here the components declared in AppModule will have access to router directives such as RouterLink and RouterOutlet.
做完这些之后，该文件变成了这样：
After these steps, the file should look like this.
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { CrisisListComponent } from './crisis-list/crisis-list.component';
import { HeroListComponent } from './hero-list/hero-list.component';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
const appRoutes: Routes = [
{ path: 'crisis-center', component: CrisisListComponent },
{ path: 'heroes', component: HeroListComponent },
{ path: '', redirectTo: '/heroes', pathMatch: 'full' },
{ path: '**', component: PageNotFoundComponent }
];
@NgModule({
imports: [
RouterModule.forRoot(
appRoutes,
{ enableTracing: true } // <-- debugging purposes only
)
],
exports: [
RouterModule
]
})
export class AppRoutingModule {}
接下来，修改 app.module.ts 文件，从 imports 数组中移除 RouterModule.forRoot。
Next, update the app.module.ts file, removing RouterModule.forRoot in the imports array.
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms';
import { AppComponent } from './app.component';
import { AppRoutingModule } from './app-routing.module';
import { CrisisListComponent } from './crisis-list/crisis-list.component';
import { HeroListComponent } from './hero-list/hero-list.component';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
@NgModule({
imports: [
BrowserModule,
FormsModule,
AppRoutingModule
],
declarations: [
AppComponent,
HeroListComponent,
CrisisListComponent,
PageNotFoundComponent
],
bootstrap: [ AppComponent ]
})
export class AppModule { }
本章稍后的部分，你将创建一个多路由模块，并揭示你为何必须以正确的顺序导入那些路由模块。
Later in this guide you will create multiple routing modules and discover that you must import those routing modules in the correct order.
应用继续照常运行，你可以把路由模块作为将来每个模块维护路由配置的中心位置。
The application continues to work just the same, and you can use AppRoutingModule as the central place to maintain future routing configuration.
你需要路由模块吗？
Do you need a Routing Module?
路由模块在根模块或者特性模块替换了路由配置。在路由模块或者在模块内部配置路由，但不要同时在两处都配置。
The Routing Module replaces the routing configuration in the root or feature module. Either configure routes in the Routing Module or within the module itself but not in both.
路由模块是设计选择，它的价值在配置很复杂，并包含专门守卫和解析器服务时尤其明显。 在配置很简单时，它可能看起来很多余。
The Routing Module is a design choice whose value is most obvious when the configuration is complex and includes specialized guard and resolver services. It can seem like overkill when the actual configuration is dead simple.
在配置很简单时，一些开发者跳过路由模块（例如 AppRoutingModule），并将路由配置直接混合在关联模块中（比如 AppModule ）。
Some developers skip the Routing Module (for example, AppRoutingModule) when the configuration is simple and merge the routing configuration directly into the companion module (for example, AppModule).
从中选择一种模式，并坚持模式的一致性。
Choose one pattern or the other and follow that pattern consistently.
大多数开发者都应该采用路由模块，以保持一致性。 它在配置复杂时，能确保代码干净。 它让测试特性模块更加容易。 它的存在让人一眼就能看出这个模块是带路由的。 开发者可以很自然的从路由模块中查找和扩展路由配置。
Most developers should always implement a Routing Module for the sake of consistency. It keeps the code clean when configuration becomes complex. It makes testing the feature module easier. Its existence calls attention to the fact that a module is routed. It is where developers expect to find and expand routing configuration.
里程碑 3: 英雄特征区
Milestone 3: Heroes feature
你刚刚学习了如何用 RouterLink 指令进行导航。接下来要：
You've seen how to navigate using the RouterLink directive. Now you'll learn the following:
用模块把应用和路由组织为一些特性区
Organize the app and routes into feature areas using modules.
命令式的从一个组件导航到另一个
Navigate imperatively from one component to another.
通过路由传递必要信息和可选信息
Pass required and optional information in route parameters.
这个例子重写了《英雄指南》的“服务”部分的英雄列表特性，你可以从
This example recreates the heroes feature in the "Services" episode of the Tour of Heroes tutorial, and you'll be copying much of the code from the
下面是用户将看到的版本：
Here's how the user will experience this version of the app:
典型的应用具有多个特性区，每个特性区都专注于特定的业务用途。
A typical application has multiple feature areas, each dedicated to a particular business purpose.
虽然你也可以把文件都放在 src/app/ 目录下，但那样是不现实的，而且很难维护。 大部分开发人员更喜欢把每个特性区都放在它自己的目录下。
While you could continue to add files to the src/app/ folder, that is unrealistic and ultimately not maintainable. Most developers prefer to put each feature area in its own folder.
你准备把应用拆分成多个不同的特性模块，每个特有模块都有自己的关注点。 然后，你就会把它们导入到主模块中，并且在它们之间导航。
You are about to break up the app into different feature modules, each with its own concerns. Then you'll import into the main module and navigate among them.
添加英雄管理功能
Add heroes functionality
遵循下列步骤：
Follow these steps:
在
heroes目录下创建一个带路由的HeroesModule，并把它注册进AppModule中。 这里就是你实现英雄管理特性的地方。Create a
HeroesModulewith routing in the heroes folder and register it with the rootAppModule. This is where you'll be implementing the hero management.
ng generate module heroes/heroes --module app --flat --routing
把
app下占位用的hero-list移到heroes目录中。Move the placeholder
hero-listfolder that's in theappinto theheroesfolder.从
教程的 "服务" 部分 / 下载范例 把heroes/heroes.component.html的内容复制到hero-list.component.html模板中。Copy the contents of the
heroes/heroes.component.htmlfrom the"Services" tutorial / 下载范例 into thehero-list.component.htmltemplate.给
<h2>加文字，改成<h2>HEROES</h2>。Relabel the
<h2>to<h2>HEROES</h2>.删除模板底部的
<app-hero-detail>组件。Delete the
<app-hero-detail>component at the bottom of the template.
把现场演练中
heroes/heroes.component.css文件的内容复制到hero-list.component.css文件中。Copy the contents of the
heroes/heroes.component.cssfrom the live example into thehero-list.component.cssfile.把现场演练中
heroes/heroes.component.ts文件的内容复制到hero-list.component.ts文件中。Copy the contents of the
heroes/heroes.component.tsfrom the live example into thehero-list.component.tsfile.把组件类名改为
HeroListComponent。Change the component class name to
HeroListComponent.把
selector改为app-hero-list。Change the
selectortoapp-hero-list.
对于路由组件来说，这些选择器不是必须的，因为这些组件是在渲染页面时动态插入的，不过选择器对于在 HTML 元素树中标记和选中它们是很有用的。
Selectors are not required for routed components due to the components are dynamically inserted when the page is rendered, but are useful for identifying and targeting them in your HTML element tree.
把
hero-detail目录中的hero.ts、hero.service.ts和mock-heroes.ts文件复制到heroes子目录下。Copy the
hero-detailfolder, thehero.ts,hero.service.ts, andmock-heroes.tsfiles into theheroessubfolder.把
message.service.ts文件复制到src/app目录下。Copy the
message.service.tsinto thesrc/appfolder.在
hero.service.ts文件中修改导入message.service的相对路径。Update the relative path import to the
message.servicein thehero.service.tsfile.
接下来，还要修改 HeroesModule 的元数据。
Next, you'll update the HeroesModule metadata.
导入
HeroDetailComponent和HeroListComponent，并添加到HeroesModule模块的declarations数组中。Import and add the
HeroDetailComponentandHeroListComponentto thedeclarationsarray in theHeroesModule.
import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
import { HeroListComponent } from './hero-list/hero-list.component';
import { HeroDetailComponent } from './hero-detail/hero-detail.component';
import { HeroesRoutingModule } from './heroes-routing.module';
@NgModule({
imports: [
CommonModule,
FormsModule,
HeroesRoutingModule
],
declarations: [
HeroListComponent,
HeroDetailComponent
]
})
export class HeroesModule {}
做完这些，你就有了四个英雄管理特性区的文件：
When you're done, you'll have these hero management files:
src/app/heroes
hero.service.ts
heroes.module.ts
英雄特性区的路由需求
Hero feature routing requirements
“英雄”特性有两个相互协作的组件，列表和详情。 列表视图是自给自足的，你导航到它，它会自行获取英雄列表并显示他们。
The heroes feature has two interacting components, the hero list and the hero detail. The list view is self-sufficient; you navigate to it, it gets a list of heroes and displays them.
详情视图就不同了。它要显示一个特定的英雄，但是它本身却无法知道显示哪一个，此信息必须来自外部。
The detail view is different. It displays a particular hero. It can't know which hero to show on its own. That information must come from outside.
当用户从列表中选择了一个英雄时，应用就导航到详情页以显示那个英雄。 通过把所选英雄的 id 编码进路由的 URL 中，就能告诉详情视图该显示哪个英雄。
When the user selects a hero from the list, the app should navigate to the detail view and show that hero. You tell the detail view which hero to display by including the selected hero's id in the route URL.
从新位置 src/app/heroes/ 目录中导入英雄相关的组件，定义两个“英雄管理”路由。
Import the hero components from their new locations in the src/app/heroes/ folder, define the two hero routes.
现在，你有了 Heroes 模块的路由，还得在 RouterModule 中把它们注册给路由器，和 AppRoutingModule 中的做法几乎完全一样。
Now that you have routes for the Heroes module, register them with the Router via the RouterModule almost as you did in the AppRoutingModule.
这里有少量但是关键的不同点。 在 AppRoutingModule 中，你使用了静态的 RouterModule.forRoot方法来注册路由和全应用级服务提供者。 在特性模块中，你要改用forChild静态方法。
There is a small but critical difference. In the AppRoutingModule, you used the static RouterModule.forRoot()method to register the routes and application level service providers. In a feature module you use the static forChildmethod.
只在根模块 AppRoutingModule 中调用 RouterModule.forRoot()（如果在 AppModule 中注册应用的顶层路由，那就在 AppModule 中调用）。 在其它模块中，你就必须调用RouterModule.forChild方法来注册附属路由。
Only call RouterModule.forRoot() in the root AppRoutingModule (or the AppModule if that's where you register top level application routes). In any other module, you must call the RouterModule.forChildmethod to register additional routes.
修改后的 HeroesRoutingModule 是这样的：
The updated HeroesRoutingModule looks like this:
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { HeroListComponent } from './hero-list/hero-list.component';
import { HeroDetailComponent } from './hero-detail/hero-detail.component';
const heroesRoutes: Routes = [
{ path: 'heroes', component: HeroListComponent },
{ path: 'hero/:id', component: HeroDetailComponent }
];
@NgModule({
imports: [
RouterModule.forChild(heroesRoutes)
],
exports: [
RouterModule
]
})
export class HeroesRoutingModule { }
考虑让每个特性模块都有自己的路由配置文件。 在特性路由非常简单的早期阶段它看起来可能有点过度设计，但是，路由很容易变得更复杂，随着时间的推移，保持一致的模式会让你得到回报。
Consider giving each feature module its own route configuration file. It may seem like overkill early when the feature routes are simple. But routes have a tendency to grow more complex and consistency in patterns pays off over time.
移除重复的“英雄管理”路由
Remove duplicate hero routes
英雄类的路由目前定义在两个地方：HeroesRoutingModule 中（并最终给 HeroesModule）和 AppRoutingModule 中。
The hero routes are currently defined in two places: in the HeroesRoutingModule, by way of the HeroesModule, and in the AppRoutingModule.
由特性模块提供的路由会被路由器再组合上它们所导入的模块的路由。 这让你可以继续定义特性路由模块中的路由，而不用修改主路由配置。
Routes provided by feature modules are combined together into their imported module's routes by the router. This allows you to continue defining the feature module routes without modifying the main route configuration.
移除 HeroListComponent 的导入和来自 app-routing.module.ts 中的 /heroes 路由。
Remove the HeroListComponent import and the /heroes route from the app-routing.module.ts.
保留默认路由和通配符路由！ 它们是应用程序顶层该自己处理的关注点。
Leave the default and the wildcard routes! These are concerns at the top level of the application itself.
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { CrisisListComponent } from './crisis-list/crisis-list.component';
// import { HeroListComponent } from './hero-list/hero-list.component'; // <-- delete this line
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
const appRoutes: Routes = [
{ path: 'crisis-center', component: CrisisListComponent },
// { path: 'heroes', component: HeroListComponent }, // <-- delete this line
{ path: '', redirectTo: '/heroes', pathMatch: 'full' },
{ path: '**', component: PageNotFoundComponent }
];
@NgModule({
imports: [
RouterModule.forRoot(
appRoutes,
{ enableTracing: true } // <-- debugging purposes only
)
],
exports: [
RouterModule
]
})
export class AppRoutingModule {}
移除英雄列表的声明
Remove heroes declarations
从 AppModule 的 declarations 中移除 HeroListComponent，因为它现在已经改由 HeroesModule 提供了。 你可以让“英雄”特性独立演化，添加更多的组件或各种各样的路由。 这就是为每个特性区创建独立模块后获得的核心优势。
Remove the HeroListComponent from the AppModule's declarations because it's now provided by the HeroesModule. You can evolve the hero feature with more components and different routes. That's a key benefit of creating a separate module for each feature area.
经过这些步骤，AppModule 变成了这样：
After these steps, the AppModule should look like this:
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms';
import { AppComponent } from './app.component';
import { AppRoutingModule } from './app-routing.module';
import { HeroesModule } from './heroes/heroes.module';
import { CrisisListComponent } from './crisis-list/crisis-list.component';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
@NgModule({
imports: [
BrowserModule,
FormsModule,
HeroesModule,
AppRoutingModule
],
declarations: [
AppComponent,
CrisisListComponent,
PageNotFoundComponent
],
bootstrap: [ AppComponent ]
})
export class AppModule { }
导入模块的顺序很重要
Module import order matters
看看该模块的 imports 数组。注意，AppRoutingModule 是最后一个。最重要的是，它位于 HeroesModule 之后。
Look at the module imports array. Notice that the AppRoutingModule is last. Most importantly, it comes after the HeroesModule.
imports: [
BrowserModule,
FormsModule,
HeroesModule,
AppRoutingModule
],
路由配置的顺序很重要。 路由器会接受第一个匹配上导航所要求的路径的那个路由。
The order of route configuration matters. The router accepts the first route that matches a navigation request path.
当所有路由都在同一个 AppRoutingModule 时，你要把默认路由和通配符路由放在最后（这里是在 /heroes 路由后面）， 这样路由器才有机会匹配到 /heroes 路由，否则它就会先遇到并匹配上该通配符路由，并导航到“页面未找到”路由。
When all routes were in one AppRoutingModule, you put the default and wildcard routes last, after the /heroes route, so that the router had a chance to match a URL to the /heroes route before hitting the wildcard route and navigating to "Page not found".
这些路由不再位于单一文件中。他们分布在两个不同的模块中：AppRoutingModule 和 HeroesRoutingModule。
The routes are no longer in one file. They are distributed across two modules, AppRoutingModule and HeroesRoutingModule.
每个路由模块都会根据导入的顺序把自己的路由配置追加进去。 如果你先列出了 AppRoutingModule，那么通配符路由就会被注册在“英雄管理”路由之前。 通配符路由（它匹配任意URL）将会拦截住每一个到“英雄管理”路由的导航，因此事实上屏蔽了所有“英雄管理”路由。
Each routing module augments the route configuration in the order of import. If you list AppRoutingModule first, the wildcard route will be registered before the hero routes. The wildcard route—which matches every URL—will intercept the attempt to navigate to a hero route.
反转路由模块的导入顺序，你就会看到当点击英雄相关的链接时被导向了“页面未找到”路由。 要学习如何在运行时查看路由器配置，参见稍后的内容。
Reverse the routing modules and see for yourself that a click of the heroes link results in "Page not found". Learn about inspecting the runtime router configuration below.
路由参数
Route Parameters
带参数的路由定义
Route definition with a parameter
回到 HeroesRoutingModule 并再次检查这些路由定义。 HeroDetailComponent 的路由有点特殊。
Return to the HeroesRoutingModule and look at the route definitions again. The route to HeroDetailComponent has a twist.
{ path: 'hero/:id', component: HeroDetailComponent }
注意路径中的 :id 令牌。它为路由参数在路径中创建一个“空位”。在这里，路由器把英雄的 id 插入到那个“空位”中。
Notice the :id token in the path. That creates a slot in the path for a Route Parameter. In this case, the router will insert the id of a hero into that slot.
如果要告诉路由器导航到详情组件，并让它显示“Magneta”，你会期望这个英雄的 id 像这样显示在浏览器的 URL 中：
If you tell the router to navigate to the detail component and display "Magneta", you expect a hero id to appear in the browser URL like this:
localhost:4200/hero/15
如果用户把此 URL 输入到浏览器的地址栏中，路由器就会识别出这种模式，同样进入“Magneta”的详情视图。
If a user enters that URL into the browser address bar, the router should recognize the pattern and go to the same "Magneta" detail view.
在这个场景下，把路由参数的令牌 :id 嵌入到路由定义的 path 中是一个好主意，因为对于 HeroDetailComponent 来说 id 是必须的， 而且路径中的值 15 已经足够把到“Magneta”的路由和到其它英雄的路由明确区分开。
Embedding the route parameter token, :id, in the route definition path is a good choice for this scenario because the id is required by the HeroDetailComponent and because the value 15 in the path clearly distinguishes the route to "Magneta" from a route for some other hero.
在列表视图中设置路由参数
Setting the route parameters in the list view
然后导航到 HeroDetailComponent 组件。在那里，你期望看到所选英雄的详情，这需要两部分信息：导航目标和该英雄的 id。
After navigating to the HeroDetailComponent, you expect to see the details of the selected hero. You need two pieces of information: the routing path to the component and the hero's id.
因此，这个链接参数数组中有两个条目：目标路由的path（路径），和一个用来指定所选英雄 id 的路由参数。
Accordingly, the link parameters array has two items: the routing path and a route parameter that specifies the id of the selected hero.
<a [routerLink]="['/hero', hero.id]">
路由器从该数组中组合出了目标 URL： localhost:3000/hero/15。
The router composes the destination URL from the array like this: localhost:4200/hero/15.
目标组件 HeroDetailComponent 该怎么知道这个 id 参数呢？ 当然不会是自己去分析 URL 了！那是路由器的工作。
How does the target HeroDetailComponent learn about that id? Don't analyze the URL. Let the router do it.
路由器从 URL 中解析出路由参数（id:15），并通过 ActivatedRoute 服务来把它提供给 HeroDetailComponent 组件。
The router extracts the route parameter (id:15) from the URL and supplies it to the HeroDetailComponent via the ActivatedRoute service.
Activated Route 实战
Activated Route in action
从路由器（router）包中导入 Router、ActivatedRoute 和 Params 类。
Import the Router, ActivatedRoute, and ParamMap tokens from the router package.
import { Router, ActivatedRoute, ParamMap } from '@angular/router';
这里导入 switchMap 操作符是因为你稍后将会处理路由参数的可观察对象 Observable。
Import the switchMap operator because you need it later to process the Observable route parameters.
import { switchMap } from 'rxjs/operators';
通常，你会直接写一个构造函数，让 Angular 把组件所需的服务注入进来，自动定义同名的私有变量，并把它们存进去。
As usual, you write a constructor that asks Angular to inject services that the component requires and reference them as private variables.
constructor(
private route: ActivatedRoute,
private router: Router,
private service: HeroService
) {}
然后，在 ngOnInit 方法中，你用 ActivatedRoute 服务来接收路由的参数，从参数中取得该英雄的 id，并接收此英雄用于显示。
Later, in the ngOnInit method, you use the ActivatedRoute service to retrieve the parameters for the route, pull the hero id from the parameters and retrieve the hero to display.
ngOnInit() {
this.hero$ = this.route.paramMap.pipe(
switchMap((params: ParamMap) =>
this.service.getHero(params.get('id')))
);
}
paramMap 的处理过程有点稍复杂。当这个 map 的值变化时，你可以从变化之后的参数中 get() 到其 id 参数。
The paramMap processing is a bit tricky. When the map changes, you get() the id parameter from the changed parameters.
然后，让 HeroService 去获取一个具有此 id 的英雄，并返回这个 HeroService 请求的结果。
Then you tell the HeroService to fetch the hero with that id and return the result of the HeroService request.
你可能想使用 RxJS 的 map 操作符。 但 HeroService 返回的是一个 Observable<Hero>。 所以你要改用 switchMap 操作符来打平这个 Observable。
You might think to use the RxJS map operator. But the HeroService returns an Observable<Hero>. So you flatten the Observable with the switchMap operator instead.
switchMap 操作符还会取消以前未完成的在途请求。如果用户使用新的 id 再次导航到该路由，而 HeroService 仍在接受老 id 对应的英雄，那么 switchMap 就会抛弃老的请求，并返回这个新 id 的英雄信息。
The switchMap operator also cancels previous in-flight requests. If the user re-navigates to this route with a new id while the HeroService is still retrieving the old id, switchMap discards that old request and returns the hero for the new id.
这个可观察对象的 Subscription（订阅）将会由 AsyncPipe 处理，并且组件的 hero 属性将会设置为刚刚接收到的这个英雄。
The observable Subscription will be handled by the AsyncPipe and the component's hero property will be (re)set with the retrieved hero.
ParamMap API
ParamMap API 是参照URLSearchParams 接口来设计的。它提供了一些方法来处理对路由参数（paramMap）和查询参数(queryParamMap)中的参数访问。
The ParamMap API is inspired by the URLSearchParams interface. It provides methods to handle parameter access for both route parameters (paramMap) and query parameters (queryParamMap).
成员 Member | 说明 Description |
|---|---|
| 如果参数名位于参数列表中，就返回 Returns |
| 如果这个 map 中有参数名对应的参数值（字符串），就返回它，否则返回 Returns the parameter name value (a |
| 如果这个 map 中有参数名对应的值，就返回一个字符串数组，否则返回空数组。当一个参数名可能对应多个值的时候，请使用 Returns a |
返回这个 map 中的所有参数名组成的字符串数组。 Returns a |
参数的可观察对象（Observable）与组件复用
Observable paramMap and component reuse
在这个例子中，你接收了路由参数的 Observable 对象。 这种写法暗示着这些路由参数在该组件的生存期内可能会变化。
In this example, you retrieve the route parameter map from an Observable. That implies that the route parameter map can change during the lifetime of this component.
确实如此！默认情况下，如果它没有访问过其它组件就导航到了同一个组件实例，那么路由器倾向于复用组件实例。如果复用，这些参数可以变化。
They might. By default, the router re-uses a component instance when it re-navigates to the same component type without visiting a different component first. The route parameters could change each time.
假设父组件的导航栏有“前进”和“后退”按钮，用来轮流显示英雄列表中中英雄的详情。 每次点击都会强制导航到带前一个或后一个 id 的 HeroDetailComponent 组件。
Suppose a parent component navigation bar had "forward" and "back" buttons that scrolled through the list of heroes. Each click navigated imperatively to the HeroDetailComponent with the next or previous id.
你不希望路由器仅仅从 DOM 中移除当前的 HeroDetailComponent 实例，并且用下一个 id 重新创建它。 那可能导致界面抖动。 更好的方式是复用同一个组件实例，并更新这些参数。
You don't want the router to remove the current HeroDetailComponent instance from the DOM only to re-create it for the next id. That could be visibly jarring. Better to simply re-use the same component instance and update the parameter.
不幸的是，ngOnInit 对每个实例只调用一次。 你需要一种方式来检测在同一个实例中路由参数什么时候发生了变化。 而 params 属性这个可观察对象（Observable）干净漂亮地处理了这种情况。
Unfortunately, ngOnInit is only called once per component instantiation. You need a way to detect when the route parameters change from within the same instance. The observable paramMap property handles that beautifully.
当在组件中订阅一个可观察对象时，你通常总是要在组件销毁时取消这个订阅。
When subscribing to an observable in a component, you almost always arrange to unsubscribe when the component is destroyed.
但是也有少数例外情况不需要取消订阅。 ActivateRoute 中的各种可观察对象就是属于这种情况。
There are a few exceptional observables where this is not necessary. The ActivatedRoute observables are among the exceptions.
ActivateRoute 及其可观察对象都是由 Router 本身负责管理的。 Router 会在不再需要时销毁这个路由组件，而注入进去的 ActivateRoute 也随之销毁了。
The ActivatedRoute and its observables are insulated from the Router itself. The Router destroys a routed component when it is no longer needed and the injected ActivatedRoute dies with it.
不过，你仍然可以随意取消订阅，这不会造成任何损害，而且也不是一项坏的实践。
Feel free to unsubscribe anyway. It is harmless and never a bad practice.
Snapshot（快照）：当不需要 Observable 时的替代品
Snapshot: the no-observable alternative
本应用不需要复用 HeroDetailComponent。 用户总是会先返回英雄列表，再选择另一位英雄。 所以，不存在从一个英雄详情导航到另一个而不用经过英雄列表的情况。 这意味着路由器每次都会创建一个全新的 HeroDetailComponent 实例。
This application won't re-use the HeroDetailComponent. The user always returns to the hero list to select another hero to view. There's no way to navigate from one hero detail to another hero detail without visiting the list component in between. Therefore, the router creates a new HeroDetailComponent instance every time.
假如你很确定这个 HeroDetailComponent 组件的实例永远、永远不会被复用，那就可以使用快照来简化这段代码。
When you know for certain that a HeroDetailComponent instance will never, never, ever be re-used, you can simplify the code with the snapshot.
route.snapshot 提供了路由参数的初始值。 你可以通过它来直接访问参数，而不用订阅或者添加 Observable 的操作符。 这样在读写时就会更简单：
The route.snapshot provides the initial value of the route parameter map. You can access the parameters directly without subscribing or adding observable operators. It's much simpler to write and read:
ngOnInit() {
let id = this.route.snapshot.paramMap.get('id');
this.hero$ = this.service.getHero(id);
}
记住：，用这种技巧，你只得到了这些参数的初始值。 如果有可能连续多次导航到此组件，那么就该用 paramMap 可观察对象的方式。 这个例子中仍然使用了 paramMap 的可观察对象策略。
Remember: you only get the initial value of the parameter map with this technique. Stick with the observable paramMap approach if there's even a chance that the router could re-use the component. This sample stays with the observable paramMap strategy just in case.
导航回列表组件
Navigating back to the list component
HeroDetailComponent 组件有一个“Back”按钮，关联到它的 gotoHeroes 方法，该方法会导航回 HeroListComponent 组件。
The HeroDetailComponent has a "Back" button wired to its gotoHeroes method that navigates imperatively back to the HeroListComponent.
路由的 navigate 方法同样接受一个单条目的链接参数数组，你也可以把它绑定到 [routerLink] 指令上。 它保存着到 HeroListComponent 组件的路径：
The router navigate method takes the same one-item link parameters array that you can bind to a [routerLink] directive. It holds the path to the HeroListComponent:
gotoHeroes() {
this.router.navigate(['/heroes']);
}
路由参数：必须还是可选？
Route Parameters: Required or optional?
如果想导航到 HeroDetailComponent 以对 id 为 15 的英雄进行查看并编辑，就要在路由的 URL 中使用路由参数来指定必要参数值。
Use route parameters to specify a required parameter value within the route URL as you do when navigating to the HeroDetailComponent in order to view the hero with id 15:
localhost:4200/hero/15
你也能在路由请求中添加可选信息。 比如，当从 hero-detail.component.ts 返回到列表时，如果能自动选中刚刚查看过的英雄就好了。
You can also add optional information to a route request. For example, when returning to the hero-detail.component.ts list from the hero detail view, it would be nice if the viewed hero was preselected in the list.
当从 HeroDetailComponent 返回时，你很快就会通过把正在查看的英雄的 id 作为可选参数包含在 URL 中来实现这个特性。
You'll implement this feature in a moment by including the viewed hero's id in the URL as an optional parameter when returning from the HeroDetailComponent.
可选信息有很多种形式。搜索条件通常就不是严格结构化的，比如 name='wind*'；有多个值也很常见，如 after='12/31/2015'&before='1/1/2017'； 而且顺序无关，如 before='1/1/2017'&after='12/31/2015'，还可能有很多种变体格式，如 during='currentYear'。
Optional information takes other forms. Search criteria are often loosely structured, e.g., name='wind*'. Multiple values are common—after='12/31/2015' & before='1/1/2017'—in no particular order—before='1/1/2017' & after='12/31/2015'— in a variety of formats—during='currentYear'.
这么多种参数要放在 URL 的路径中可不容易。即使你能制定出一个合适的 URL 方案，实现起来也太复杂了，得通过模式匹配才能把 URL 翻译成命名路由。
These kinds of parameters don't fit easily in a URL path. Even if you could define a suitable URL token scheme, doing so greatly complicates the pattern matching required to translate an incoming URL to a named route.
可选参数是在导航期间传送任意复杂信息的理想载体。 可选参数不涉及到模式匹配并在表达上提供了巨大的灵活性。
Optional parameters are the ideal vehicle for conveying arbitrarily complex information during navigation. Optional parameters aren't involved in pattern matching and afford flexibility of expression.
和必要参数一样，路由器也支持通过可选参数导航。 在你定义完必要参数之后，再通过一个独立的对象来定义可选参数。
The router supports navigation with optional parameters as well as required route parameters. Define optional parameters in a separate object after you define the required route parameters.
通常，对于强制性的值（比如用于区分两个路由路径的）使用必备参数；当这个值是可选的、复杂的或多值的时，使用可选参数。
In general, prefer a required route parameter when the value is mandatory (for example, if necessary to distinguish one route path from another); prefer an optional parameter when the value is optional, complex, and/or multivariate.
英雄列表：选定一个英雄（也可不选）
Heroes list: optionally selecting a hero
当导航到 HeroDetailComponent 时，你可以在路由参数中指定一个所要编辑的英雄 id，只要把它作为链接参数数组中的第二个条目就可以了。
When navigating to the HeroDetailComponent you specified the required id of the hero-to-edit in the route parameter and made it the second item of the link parameters array.
<a [routerLink]="['/hero', hero.id]">
路由器在导航 URL 中内嵌了 id 的值，这是因为你把它用一个 :id 占位符当做路由参数定义在了路由的 path 中：
The router embedded the id value in the navigation URL because you had defined it as a route parameter with an :id placeholder token in the route path:
{ path: 'hero/:id', component: HeroDetailComponent }
当用户点击后退按钮时，HeroDetailComponent 构造了另一个链接参数数组，可以用它导航回 HeroListComponent。
When the user clicks the back button, the HeroDetailComponent constructs another link parameters array which it uses to navigate back to the HeroListComponent.
gotoHeroes() {
this.router.navigate(['/heroes']);
}
该数组缺少一个路由参数，这是因为你那时没有理由往 HeroListComponent 发送信息。
This array lacks a route parameter because you had no reason to send information to the HeroListComponent.
但现在有了。你要在导航请求中同时发送当前英雄的 id，以便 HeroListComponent 可以在列表中高亮这个英雄。 这是一个有更好，没有也无所谓的特性，就算没有它，列表照样能显示得很完美。
Now you have a reason. You'd like to send the id of the current hero with the navigation request so that the HeroListComponent can highlight that hero in its list. This is a nice-to-have feature; the list will display perfectly well without it.
传送一个包含可选id 参数的对象。 为了演示，这里还在对象中定义了一个没用的额外参数（foo），HeroListComponent 应该忽略它。 下面是修改过的导航语句：
Send the id with an object that contains an optional id parameter. For demonstration purposes, there's an extra junk parameter (foo) in the object that the HeroListComponent should ignore. Here's the revised navigation statement:
gotoHeroes(hero: Hero) {
let heroId = hero ? hero.id : null;
// Pass along the hero id if available
// so that the HeroList component can select that hero.
// Include a junk 'foo' property for fun.
this.router.navigate(['/heroes', { id: heroId, foo: 'foo' }]);
}
该应用仍然能工作。点击“back”按钮返回英雄列表视图。
The application still works. Clicking "back" returns to the hero list view.
注意浏览器的地址栏。
Look at the browser address bar.
它应该是这样的，不过也取决于你在哪里运行它：
It should look something like this, depending on where you run it:
localhost:4200/heroes;id=15;foo=foo
id 的值像这样出现在 URL 中（;id=15;foo=foo），但不在 URL 的路径部分。 “Heroes”路由的路径部分并没有定义 :id。
The id value appears in the URL as (;id=15;foo=foo), not in the URL path. The path for the "Heroes" route doesn't have an :id token.
可选的路由参数没有使用“？”和“&”符号分隔，因为它们将用在 URL 查询字符串中。 它们是用“;”分隔的。 这是矩阵 URL标记法 —— 你以前可能从未见过。
The optional route parameters are not separated by "?" and "&" as they would be in the URL query string. They are separated by semicolons ";" This is matrix URL notation—something you may not have seen before.
Matrix URL写法首次提出是在1996 提案中，提出者是 Web 的奠基人：Tim Berners-Lee。
Matrix URL notation is an idea first introduced in a 1996 proposal by the founder of the web, Tim Berners-Lee.
虽然 Matrix 写法未曾进入过 HTML 标准，但它是合法的。而且在浏览器的路由系统中，它作为从父路由和子路由中单独隔离出参数的方式而广受欢迎。Angular 的路由器正是这样一个路由系统，并支持跨浏览器的 Matrix 写法。
Although matrix notation never made it into the HTML standard, it is legal and it became popular among browser routing systems as a way to isolate parameters belonging to parent and child routes. The Router is such a system and provides support for the matrix notation across browsers.
这种语法对你来说可能有点奇怪，不过用户不会在意这一点，因为该 URL 可以正常的通过邮件发出去或粘贴到浏览器的地址栏中。
The syntax may seem strange to you but users are unlikely to notice or care as long as the URL can be emailed and pasted into a browser address bar as this one can.
ActivatedRoute 服务中的路由参数
Route parameters in the ActivatedRoute service
英雄列表仍没有改变，没有哪个英雄列被加亮显示。
The list of heroes is unchanged. No hero row is highlighted.
The
HeroListComponent 还完全不需要任何参数，也不知道该怎么处理它们。你可以改变这一点。
The HeroListComponent isn't expecting any parameters at all and wouldn't know what to do with them. You can change that.
以前，当从 HeroListComponent 导航到 HeroDetailComponent 时，你通过 ActivatedRoute 服务订阅了路由参数这个 Observable，并让它能用在 HeroDetailComponent 中。 你把该服务注入到了 HeroDetailComponent 的构造函数中。
Previously, when navigating from the HeroListComponent to the HeroDetailComponent, you subscribed to the route parameter map Observable and made it available to the HeroDetailComponent in the ActivatedRoute service. You injected that service in the constructor of the HeroDetailComponent.
这次，你要进行反向导航，从 HeroDetailComponent 到 HeroListComponent。
This time you'll be navigating in the opposite direction, from the HeroDetailComponent to the HeroListComponent.
首先，你扩展该路由的导入语句，以包含进 ActivatedRoute 服务的类；
First you extend the router import statement to include the ActivatedRoute service symbol:
import { ActivatedRoute } from '@angular/router';
导入 switchMap 操作符，在路由参数的 Observable 对象上执行操作。
Import the switchMap operator to perform an operation on the Observable of route parameter map.
import { Observable } from 'rxjs';
import { switchMap } from 'rxjs/operators';
接着，你注入 ActivatedRoute 到 HeroListComponent 的构造函数中。
Then you inject the ActivatedRoute in the HeroListComponent constructor.
export class HeroListComponent implements OnInit {
heroes$: Observable<Hero[]>;
selectedId: number;
constructor(
private service: HeroService,
private route: ActivatedRoute
) {}
ngOnInit() {
this.heroes$ = this.route.paramMap.pipe(
switchMap(params => {
// (+) before `params.get()` turns the string into a number
this.selectedId = +params.get('id');
return this.service.getHeroes();
})
);
}
}
ActivatedRoute.paramMap 属性是一个路由参数的可观察对象。当用户导航到这个组件时，paramMap 会发射一个新值，其中包含 id。 在 ngOnInit 中，你订阅了这些值，设置到 selectedId，并获取英雄数据。
The ActivatedRoute.paramMap property is an Observable map of route parameters. The paramMap emits a new map of values that includes id when the user navigates to the component. In ngOnInit you subscribe to those values, set the selectedId, and get the heroes.
用 CSS 类绑定更新模板，把它绑定到 isSelected 方法上。 如果该方法返回 true，此绑定就会添加 CSS 类 selected，否则就移除它。 在 <li> 标记中找到它，就像这样：
Update the template with a class binding. The binding adds the selected CSS class when the comparison returns true and removes it when false. Look for it within the repeated <li> tag as shown here:
<h2>HEROES</h2>
<ul class="heroes">
<li *ngFor="let hero of heroes$ | async"
[class.selected]="hero.id === selectedId">
<a [routerLink]="['/hero', hero.id]">
<span class="badge">{{ hero.id }}</span>{{ hero.name }}
</a>
</li>
</ul>
<button routerLink="/sidekicks">Go to sidekicks</button>
当选中列表条目时，要添加一些样式。
Add some styles to apply when the list item is selected.
.heroes li.selected {
background-color: #CFD8DC;
color: white;
}
.heroes li.selected:hover {
background-color: #BBD8DC;
}
当用户从英雄列表导航到英雄“Magneta”并返回时，“Magneta”看起来是选中的：
When the user navigates from the heroes list to the "Magneta" hero and back, "Magneta" appears selected:
这儿可选的 foo 路由参数人畜无害，并继续被忽略。
The optional foo route parameter is harmless and continues to be ignored.
添加路由动画
Adding routable animations
为路由组件添加动画
Adding animations to the routed component
这个“英雄”特性模块就要完成了，但这个特性还没有平滑的转场效果。
The heroes feature module is almost complete, but what is a feature without some smooth transitions?
在这一节，你将为英雄详情组件添加一些动画。
This section shows you how to add some animations to the HeroDetailComponent.
首先导入 BrowserAnimationsModule，并添加到 imports 数组中：
First import the BrowserAnimationsModule and add it to the imports array:
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
@NgModule({
imports: [
BrowserAnimationsModule,
],
})
接下来，为指向 HeroListComponent 和 HeroDetailComponent 的路由定义添加一个 data 对象。 转场是基于 states 的，你将使用来自路由的 animation 数据为转场提供一个有名字的动画 state。
Next, add a data object to the routes for HeroListComponent and HeroDetailComponent. Transitions are based on states and you'll use the animation data from the route to provide a named animation state for the transitions.
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { HeroListComponent } from './hero-list/hero-list.component';
import { HeroDetailComponent } from './hero-detail/hero-detail.component';
const heroesRoutes: Routes = [
{ path: 'heroes', component: HeroListComponent, data: { animation: 'heroes' } },
{ path: 'hero/:id', component: HeroDetailComponent, data: { animation: 'hero' } }
];
@NgModule({
imports: [
RouterModule.forChild(heroesRoutes)
],
exports: [
RouterModule
]
})
export class HeroesRoutingModule { }
在根目录 src/app/ 下创建一个 animations.ts。内容如下：
Create an animations.ts file in the root src/app/ folder. The contents look like this:
import {
trigger, animateChild, group,
transition, animate, style, query
} from '@angular/animations';
// Routable animations
export const slideInAnimation =
trigger('routeAnimation', [
transition('heroes <=> hero', [
style({ position: 'relative' }),
query(':enter, :leave', [
style({
position: 'absolute',
top: 0,
left: 0,
width: '100%'
})
]),
query(':enter', [
style({ left: '-100%'})
]),
query(':leave', animateChild()),
group([
query(':leave', [
animate('300ms ease-out', style({ left: '100%'}))
]),
query(':enter', [
animate('300ms ease-out', style({ left: '0%'}))
])
]),
query(':enter', animateChild()),
])
]);
该文件做了如下工作：
This file does the following:
导入动画符号以构建动画触发器、控制状态并管理状态之间的过渡。
Imports the animation symbols that build the animation triggers, control state, and manage transitions between states.
导出了一个名叫
slideInAnimation的常量，并把它设置为一个名叫*routeAnimation的动画触发器。Exports a constant named
slideInAnimationset to an animation trigger namedrouteAnimation;定义一个转场动画，当在
heroes和hero路由之间来回切换时，如果进入（:enter）应用视图则让组件从屏幕的左侧滑入，如果离开（:leave）应用视图则让组件从右侧划出。Defines one transition when switching back and forth from the
heroesandheroroutes to ease the component in from the left of the screen as it enters the application view (:enter), the other to animate the component to the right as it leaves the application view (:leave).
你还可以为其它路由组件用不同的转场效果创建更多触发器。现在这个触发器已经足够当前的里程碑用了。
You could also create more transitions for other routes. This trigger is sufficient for the current milestone.
回到 AppComponent，从 @angular/router 中导入 RouterOutlet 令牌，并从 './animations.ts 中导入 slideInDownAnimation。
Back in the AppComponent, import the RouterOutlet token from the @angular/router package and the slideInAnimation from './animations.ts.
把一个包含 slideInDownAnimation 的 animations 数组添加到 @Component 的元数据中。
Add an animations array to the @Component metadata's that contains the slideInAnimation.
import { RouterOutlet } from '@angular/router';
import { slideInAnimation } from './animations';
@Component({
selector: 'app-root',
templateUrl: 'app.component.html',
styleUrls: ['app.component.css'],
animations: [ slideInAnimation ]
})
为了使用路由动画，你需要把 RouterOutlet 包装到一个元素中。你要把 @routeAnimation 触发器绑定到该元素上。
In order to use the routable animations, you'll need to wrap the RouterOutlet inside an element. You'll use the @routeAnimation trigger and bind it to the element.
为了把 @routeAnimation 转场转场到指定的状态，你需要从 ActivatedRoute 的 data 中提供它。 RouterOutlet 导出成了一个模板变量 outlet，这样你就可以绑定一个到路由出口的引用了。给这个变量取名做 routerOutlet 是一个理想的选择。
For the @routeAnimation transitions to key off states, you'll need to provide it with the data from the ActivatedRoute. The RouterOutlet is exposed as an outlet template variable, so you bind a reference to the router outlet. A variable of routerOutlet is an ideal choice.
<h1>Angular Router</h1>
<nav>
<a routerLink="/crisis-center" routerLinkActive="active">Crisis Center</a>
<a routerLink="/heroes" routerLinkActive="active">Heroes</a>
</nav>
<div [@routeAnimation]="getAnimationData(routerOutlet)">
<router-outlet #routerOutlet="outlet"></router-outlet>
</div>
@routeAnimation 属性使用所提供的 routerOutlet 引用来绑定到 getAnimationData，因此你需要在 AppComponent 中定义那个函数。getAnimationData 函数会根据 ActivatedRoute 所提供的 data 对象返回动画的属性。animation 属性会根据你在 animations.ts 中定义 slideInAnimation 时使用的 transition 名称进行匹配。
The @routeAnimation property is bound to the getAnimationData with the provided routerOutlet reference, so you'll need to define that function in the AppComponent. The getAnimationData function returns the animation property from the data provided through the ActivatedRoute. The animation property matches the transition names you used in the slideInAnimation defined in animations.ts.
export class AppComponent {
getAnimationData(outlet: RouterOutlet) {
return outlet && outlet.activatedRouteData && outlet.activatedRouteData['animation'];
}
}
如果在两个路由之间切换，导航进来时，HeroDetailComponent 和 HeroListComponent 会从左侧滑入；导航离开时将会从右侧划出。
When switching between the two routes, the HeroDetailComponent and HeroListComponent will ease in from the left when routed to and will slide to the right when navigating away.
里程碑 3 的总结
Milestone 3 wrap up
你学到了如何：
You've learned how to do the following:
把应用组织成特性区
Organize the app into feature areas.
命令式的从一个组件导航到另一个
Navigate imperatively from one component to another.
通过路由参数传递信息，并在组件中订阅它们
Pass information along in route parameters and subscribe to them in the component.
把这个特性分区模块导入根模块
AppModuleImport the feature area NgModule into the
AppModule.把动画应用到路由组件上
Applying routable animations based on the page.
做完这些修改之后，目录结构是这样的：
After these changes, the folder structure looks like this:
angular-router-sample
app
crisis-list
heroes
hero-detail
hero-list
hero.service.ts
heroes.module.ts
mock-heroes.ts
page-not-found.component.css
page-not-found.component.html
page-not-found.component.ts
app.component.ts
app.module.ts
app-routing.module.ts
main.ts
message.service.ts
index.html
styles.css
tsconfig.json
node_modules ...
package.json
这里是当前版本的范例程序相关文件。
Here are the relevant files for this version of the sample application.
import {
trigger, animateChild, group,
transition, animate, style, query
} from '@angular/animations';
// Routable animations
export const slideInAnimation =
trigger('routeAnimation', [
transition('heroes <=> hero', [
style({ position: 'relative' }),
query(':enter, :leave', [
style({
position: 'absolute',
top: 0,
left: 0,
width: '100%'
})
]),
query(':enter', [
style({ left: '-100%'})
]),
query(':leave', animateChild()),
group([
query(':leave', [
animate('300ms ease-out', style({ left: '100%'}))
]),
query(':enter', [
animate('300ms ease-out', style({ left: '0%'}))
])
]),
query(':enter', animateChild()),
])
]);
里程碑 4：危机中心
Milestone 4: Crisis center feature
是时候往该应用的危机中心（现在是占位符）中添加一些真实的特性了。
It's time to add real features to the app's current placeholder crisis center.
先从模仿“英雄管理”中的特性开始：
Begin by imitating the heroes feature:
在
src/app目录下创建一个crisis-center子目录。Create a
crisis-centersubfolder in thesrc/appfolder.把
app/heroes中的文件和目录复制到新的crisis-center文件夹中。Copy the files and folders from
app/heroesinto the newcrisis-centerfolder.在这些新建的文件中，把每个 "hero" 都改成 "crisis"，每个 "heroes" 都改成 "crises"。
In the new files, change every mention of "hero" to "crisis", and "heroes" to "crises".
把这些 NgModule 文件改名为
crisis-center.module.ts和crisis-center-routing.module.ts。Rename the NgModule files to
crisis-center.module.tsandcrisis-center-routing.module.ts.
你还要用模拟的危机列表替换模拟的英雄列表：
You'll use mock crises instead of mock heroes:
import { Crisis } from './crisis';
export const CRISES: Crisis[] = [
{ id: 1, name: 'Dragon Burning Cities' },
{ id: 2, name: 'Sky Rains Great White Sharks' },
{ id: 3, name: 'Giant Asteroid Heading For Earth' },
{ id: 4, name: 'Procrastinators Meeting Delayed Again' },
]
最终的危机中心可以作为引入子路由这个新概念的基础。 你可以把英雄管理保持在当前状态，以便和危机中心进行对比，以后再根据这些差异是否有价值来决定后续行动。
The resulting crisis center is a foundation for introducing a new concept—child routing. You can leave Heroes in its current state as a contrast with the Crisis Center and decide later if the differences are worthwhile.
遵循关注点分离（Separation of Concerns）原则， 对危机中心的修改不会影响 AppModule 或其它特性模块中的组件。
In keeping with the Separation of Concerns principle, changes to the Crisis Center won't affect the AppModule or any other feature's component.
带有子路由的危机中心
A crisis center with child routes
本节会展示如何组织危机中心，来满足 Angular 应用所推荐的模式：
This section shows you how to organize the crisis center to conform to the following recommended pattern for Angular applications:
把每个特性放在自己的目录中。
Each feature area resides in its own folder.
每个特性都有自己的 Angular 特性模块。
Each feature has its own Angular feature module.
每个特性区都有自己的根组件。
Each area has its own area root component.
每个特性区的根组件中都有自己的路由出口及其子路由。
Each area root component has its own router outlet and child routes.
特性区的路由很少（或完全不）与其它特性区的路由交叉。
Feature area routes rarely (if ever) cross with routes of other features.
如果你还有更多特性区，它们的组件树是这样的：
If your app had many feature areas, the app component trees might look like this:
子路由组件
Child routing component
在 crisis-center 目录下生成一个 CrisisCenter 组件：
Generate a CrisisCenter component in the crisis-center folder:
ng generate component crisis-center/crisis-center
把组件模板修改成这样：
Update the component template to look like this:
<h2>CRISIS CENTER</h2>
<router-outlet></router-outlet>
CrisisCenterComponent 和 AppComponent 有下列共同点：
The CrisisCenterComponent has the following in common with the AppComponent:
它是危机中心特性区的根，正如
AppComponent是整个应用的根。It is the root of the crisis center area, just as
AppComponentis the root of the entire application.它是危机管理特性区的壳，正如
AppComponent是管理高层工作流的壳。It is a shell for the crisis management feature area, just as the
AppComponentis a shell to manage the high-level workflow.
就像大多数的壳一样，CrisisCenterComponent 类也非常简单，甚至比 AppComponent 更简单： 它没有业务逻辑，它的模板中没有链接，只有一个标题和用于放置危机中心的子组件的 <router-outlet>。
Like most shells, the CrisisCenterComponent class is very simple, simpler even than AppComponent: it has no business logic, and its template has no links, just a title and <router-outlet> for the crisis center child component.
子路由配置
Child route configuration
在 crisis-center 目录下生成一个 CrisisCenterHome 组件，作为 "危机中心" 特性的宿主页面。
As a host page for the "Crisis Center" feature, generate a CrisisCenterHome component in the crisis-center folder.
ng generate component crisis-center/crisis-center-home
用一条欢迎信息修改 Crisis Center 中的模板。
Update the template with a welcome message to the Crisis Center.
<p>Welcome to the Crisis Center</p>
把 heroes-routing.module.ts 文件复制过来，改名为 crisis-center-routing.module.ts，并修改它。 这次你要把子路由定义在父路由 crisis-center 中。
Update the crisis-center-routing.module.ts you renamed after copying it from heroes-routing.module.ts file. This time, you define child routes within the parent crisis-center route.
const crisisCenterRoutes: Routes = [
{
path: 'crisis-center',
component: CrisisCenterComponent,
children: [
{
path: '',
component: CrisisListComponent,
children: [
{
path: ':id',
component: CrisisDetailComponent
},
{
path: '',
component: CrisisCenterHomeComponent
}
]
}
]
}
];
注意，父路由 crisis-center 有一个 children 属性，它有一个包含 CrisisListComponent 的路由。 CrisisListModule 路由还有一个带两个路由的 children 数组。
Notice that the parent crisis-center route has a children property with a single route containing the CrisisListComponent. The CrisisListComponent route also has a children array with two routes.
这两个路由导航到了危机中心的两个子组件：CrisisCenterHomeComponent 和 CrisisDetailComponent。
These two routes navigate to the crisis center child components, CrisisCenterHomeComponent and CrisisDetailComponent, respectively.
对这些路由的处理中有一些重要的不同。
There are important differences in the way the router treats these child routes.
路由器会把这些路由对应的组件放在 CrisisCenterComponent 的 RouterOutlet 中，而不是 AppComponent 壳组件中的。
The router displays the components of these routes in the RouterOutlet of the CrisisCenterComponent, not in the RouterOutlet of the AppComponent shell.
CrisisListComponent 包含危机列表和一个 RouterOutlet，用以显示 Crisis Center Home 和 Crisis Detail 这两个路由组件。
The CrisisListComponent contains the crisis list and a RouterOutlet to display the Crisis Center Home and Crisis Detail route components.
Crisis Detail 路由是 Crisis List 的子路由。由于路由器默认会复用组件，因此当你选择了另一个危机时，CrisisDetailComponent 会被复用。
作为对比，回头看看 Hero Detail 路由，每当你从列表中选择了不同的英雄时，都会重新创建该组件。
The Crisis Detail route is a child of the Crisis List. The router reuses components by default, so the Crisis Detail component will be re-used as you select different crises. In contrast, back in the Hero Detail route, the component was recreated each time you selected a different hero from the list of heroes.
在顶层，以 / 开头的路径指向的总是应用的根。 但这里是子路由。 它们是在父路由路径的基础上做出的扩展。 在路由树中每深入一步，你就会在该路由的路径上添加一个斜线 /（除非该路由的路径是空的）。
At the top level, paths that begin with / refer to the root of the application. But child routes extend the path of the parent route. With each step down the route tree, you add a slash followed by the route path, unless the path is empty.
如果把该逻辑应用到危机中心中的导航，那么父路径就是 /crisis-center。
Apply that logic to navigation within the crisis center for which the parent path is /crisis-center.
要导航到
CrisisCenterHomeComponent，完整的 URL 是/crisis-center(/crisis-center+''+'')。To navigate to the
CrisisCenterHomeComponent, the full URL is/crisis-center(/crisis-center+''+'').要导航到
CrisisDetailComponent以展示id=2的危机，完整的 URL 是/crisis-center/2(/crisis-center+''+'/2')。To navigate to the
CrisisDetailComponentfor a crisis withid=2, the full URL is/crisis-center/2(/crisis-center+''+'/2').
本例子中包含站点部分的绝对 URL，就是：
The absolute URL for the latter example, including the localhost origin, is
localhost:4200/crisis-center/2
这里是完整的 crisis-center.routing.ts 及其导入语句。
Here's the complete crisis-center-routing.module.ts file with its imports.
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { CrisisCenterHomeComponent } from './crisis-center-home/crisis-center-home.component';
import { CrisisListComponent } from './crisis-list/crisis-list.component';
import { CrisisCenterComponent } from './crisis-center/crisis-center.component';
import { CrisisDetailComponent } from './crisis-detail/crisis-detail.component';
const crisisCenterRoutes: Routes = [
{
path: 'crisis-center',
component: CrisisCenterComponent,
children: [
{
path: '',
component: CrisisListComponent,
children: [
{
path: ':id',
component: CrisisDetailComponent
},
{
path: '',
component: CrisisCenterHomeComponent
}
]
}
]
}
];
@NgModule({
imports: [
RouterModule.forChild(crisisCenterRoutes)
],
exports: [
RouterModule
]
})
export class CrisisCenterRoutingModule { }
把危机中心模块导入到 AppModule 的路由中
Import crisis center module into the AppModule routes
就像 HeroesModule 模块中一样，你必须把 CrisisCenterModule 添加到 AppModule 的 imports 数组中，就在 AppRoutingModule 前面：
As with the HeroesModule, you must add the CrisisCenterModule to the imports array of the AppModule before the AppRoutingModule:
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { CommonModule } from '@angular/common';
import { CrisisCenterHomeComponent } from './crisis-center-home/crisis-center-home.component';
import { CrisisListComponent } from './crisis-list/crisis-list.component';
import { CrisisCenterComponent } from './crisis-center/crisis-center.component';
import { CrisisDetailComponent } from './crisis-detail/crisis-detail.component';
import { CrisisCenterRoutingModule } from './crisis-center-routing.module';
@NgModule({
imports: [
CommonModule,
FormsModule,
CrisisCenterRoutingModule
],
declarations: [
CrisisCenterComponent,
CrisisListComponent,
CrisisCenterHomeComponent,
CrisisDetailComponent
]
})
export class CrisisCenterModule {}
从 app.routing.ts 中移除危机中心的初始路由。 这些特性路由现在是由 HeroesModule 和 CrisisCenter 特性模块提供的。
Remove the initial crisis center route from the app-routing.module.ts. The feature routes are now provided by the HeroesModule and the CrisisCenter modules.
app-routing.module.ts 文件中只有应用的顶层路由，比如默认路由和通配符路由。
The app-routing.module.ts file retains the top-level application routes such as the default and wildcard routes.
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
const appRoutes: Routes = [
{ path: '', redirectTo: '/heroes', pathMatch: 'full' },
{ path: '**', component: PageNotFoundComponent }
];
@NgModule({
imports: [
RouterModule.forRoot(
appRoutes,
{ enableTracing: true } // <-- debugging purposes only
)
],
exports: [
RouterModule
]
})
export class AppRoutingModule {}
相对导航
Relative navigation
虽然构建出了危机中心特性区，你却仍在使用以斜杠开头的绝对路径来导航到危机详情的路由。
While building out the crisis center feature, you navigated to the crisis detail route using an absolute path that begins with a slash.
路由器会从路由配置的顶层来匹配像这样的绝对路径。
The router matches such absolute paths to routes starting from the top of the route configuration.
你固然可以继续像危机中心特性区一样使用绝对路径，但是那样会把链接钉死在特定的父路由结构上。 如果你修改了父路径 /crisis-center，那就不得不修改每一个链接参数数组。
You could continue to use absolute paths like this to navigate inside the Crisis Center feature, but that pins the links to the parent routing structure. If you changed the parent /crisis-center path, you would have to change the link parameters array.
通过改成定义相对于当前 URL 的路径，你可以把链接从这种依赖中解放出来。 当你修改了该特性区的父路由路径时，该特性区内部的导航仍然完好无损。
You can free the links from this dependency by defining paths that are relative to the current URL segment. Navigation within the feature area remains intact even if you change the parent route path to the feature.
例子如下：
Here's an example:
路由器支持在链接参数数组中使用“目录式”语法来为查询路由名提供帮助：
The router supports directory-like syntax in a link parameters list to help guide route name lookup:
./ 或 无前导斜线 形式是相对于当前级别的。
./ or no leading slash is relative to the current level.
../ 会回到当前路由路径的上一级。
../ to go up one level in the route path.
你可以把相对导航语法和一个祖先路径组合起来用。 如果不得不导航到一个兄弟路由，你可以用 ../<sibling> 来回到上一级，然后进入兄弟路由路径中。
You can combine relative navigation syntax with an ancestor path. If you must navigate to a sibling route, you could use the ../<sibling> convention to go up one level, then over and down the sibling route path.
用 Router.navigate 方法导航到相对路径时，你必须提供当前的 ActivatedRoute，来让路由器知道你现在位于路由树中的什么位置。
To navigate a relative path with the Router.navigate method, you must supply the ActivatedRoute to give the router knowledge of where you are in the current route tree.
在链接参数数组后面，添加一个带有 relativeTo 属性的对象，并把它设置为当前的 ActivatedRoute。 这样路由器就会基于当前激活路由的位置来计算出目标 URL。
After the link parameters array, add an object with a relativeTo property set to the ActivatedRoute. The router then calculates the target URL based on the active route's location.
当调用路由器的 navigateByUrl 时，总是要指定完整的绝对路径。
Always specify the complete absolute path when calling router's navigateByUrl method.
使用相对 URL 导航到危机列表
Navigate to crisis list with a relative URL
你已经注入过了 ActivatedRoute，你需要把它来和相对导航路径组合在一起。
You've already injected the ActivatedRoute that you need to compose the relative navigation path.
如果用 RouterLink 来代替 Router 服务进行导航，就要使用相同的链接参数数组，不过不再需要提供 relativeTo 属性。 ActivatedRoute 已经隐含在了 RouterLink 指令中。
When using a RouterLink to navigate instead of the Router service, you'd use the same link parameters array, but you wouldn't provide the object with the relativeTo property. The ActivatedRoute is implicit in a RouterLink directive.
修改 CrisisDetailComponent 的 gotoCrises 方法，来使用相对路径返回危机中心列表。
Update the gotoCrises method of the CrisisDetailComponent to navigate back to the Crisis Center list using relative path navigation.
// Relative navigation back to the crises
this.router.navigate(['../', { id: crisisId, foo: 'foo' }], { relativeTo: this.route });
注意这个路径使用了 ../ 语法返回上一级。 如果当前危机的 id 是 3，那么最终返回到的路径就是 /crisis-center/;id=3;foo=foo。
Notice that the path goes up a level using the ../ syntax. If the current crisis id is 3, the resulting path back to the crisis list is /crisis-center/;id=3;foo=foo.
用命名出口（outlet）显示多重路由
Displaying multiple routes in named outlets
你决定给用户提供一种方式来联系危机中心。 当用户点击“Contact”按钮时，你要在一个弹出框中显示一条消息。
You decide to give users a way to contact the crisis center. When a user clicks a "Contact" button, you want to display a message in a popup view.
即使在应用中的不同页面之间切换，这个弹出框也应该始终保持打开状态，直到用户发送了消息或者手动取消。 显然，你不能把这个弹出框跟其它放到页面放到同一个路由出口中。
The popup should stay open, even when switching between pages in the application, until the user closes it by sending the message or canceling. Clearly you can't put the popup in the same outlet as the other pages.
迄今为止，你只定义过单路由出口，并且在其中嵌套了子路由以便对路由分组。 在每个模板中，路由器只能支持一个无名主路由出口。
Until now, you've defined a single outlet and you've nested child routes under that outlet to group routes together. The router only supports one primary unnamed outlet per template.
模板还可以有多个命名的路由出口。 每个命名出口都自己有一组带组件的路由。 多重出口可以在同一时间根据不同的路由来显示不同的内容。
A template can also have any number of named outlets. Each named outlet has its own set of routes with their own components. Multiple outlets can be displaying different content, determined by different routes, all at the same time.
在 AppComponent 中添加一个名叫“popup”的出口，就在无名出口的下方。
Add an outlet named "popup" in the AppComponent, directly below the unnamed outlet.
<div [@routeAnimation]="getAnimationData(routerOutlet)">
<router-outlet #routerOutlet="outlet"></router-outlet>
</div>
<router-outlet name="popup"></router-outlet>
一旦你学会了如何把一个弹出框组件路由到该出口，那里就是将会出现弹出框的地方。
That's where a popup will go, once you learn how to route a popup component to it.
第二路由
Secondary routes
命名出口是第二路由的目标。
Named outlets are the targets of secondary routes.
第二路由很像主路由，配置方式也一样。它们只有一些关键的不同点：
Secondary routes look like primary routes and you configure them the same way. They differ in a few key respects.
它们彼此互不依赖。
They are independent of each other.
它们与其它路由组合使用。
They work in combination with other routes.
它们显示在命名出口中。
They are displayed in named outlets.
生成一个新的组件来组合这个消息。
Generate a new component to compose the message.
ng generate component compose-message
它显示一个简单的表单，包括一个头、一个消息输入框和两个按钮：“Send”和“Cancel”。
It displays a simple form with a header, an input box for the message, and two buttons, "Send" and "Cancel".
下面是该组件及其模板和样式：
Here's the component, its template and styles:
它看起来几乎和你以前见过其它组件一样，但有两个值得注意的区别。
It looks about the same as any other component you've seen in this guide. There are two noteworthy differences.
注意，send() 方法在发送消息和关闭弹出框之前通过等待模拟了一秒钟的延迟。
Note that the send() method simulates latency by waiting a second before "sending" the message and closing the popup.
closePopup() 方法用把 popup 出口导航到 null 的方式关闭了弹出框。 这个奇怪的用法在稍后的部分有讲解。
The closePopup() method closes the popup view by navigating to the popup outlet with a null. That's a peculiarity covered below.
添加第二路由
Add a secondary route
打开 AppRoutingModule，并把一个新的 compose 路由添加到 appRoutes 中。
Open the AppRoutingModule and add a new compose route to the appRoutes.
{
path: 'compose',
component: ComposeMessageComponent,
outlet: 'popup'
},
对 path 和 component 属性应该很熟悉了吧。 注意这个新的属性 outlet 被设置成了 'popup'。 这个路由现在指向了 popup 出口，而 ComposeMessageComponent 也将显示在那里。
The path and component properties should be familiar. There's a new property, outlet, set to 'popup'. This route now targets the popup outlet and the ComposeMessageComponent will display there.
用户需要某种途径来打开这个弹出框。 打开 AppComponent，并添加一个“Contact”链接。
The user needs a way to open the popup. Open the AppComponent and add a "Contact" link.
<a [routerLink]="[{ outlets: { popup: ['compose'] } }]">Contact</a>
虽然 compose 路由被钉死在了 popup 出口上，但这仍然不足以向 RouterLink 指令表明要加载该路由。 你还要在链接参数数组中指定这个命名出口，并通过属性绑定的形式把它绑定到 RouterLink 上。
Although the compose route is pinned to the "popup" outlet, that's not sufficient for wiring the route to a RouterLink directive. You have to specify the named outlet in a link parameters array and bind it to the RouterLink with a property binding.
链接参数数组包含一个只有一个 outlets 属性的对象，它的值是另一个对象，这个对象以一个或多个路由的出口名作为属性名。 在这里，它只有一个出口名“popup”，它的值则是另一个链接参数数组，用于指定 compose 路由。
The link parameters array contains an object with a single outlets property whose value is another object keyed by one (or more) outlet names. In this case there is only the "popup" outlet property and its value is another link parameters array that specifies the compose route.
意思是，当用户点击此链接时，在路由出口 popup 中显示与 compose 路由相关联的组件。
You are in effect saying, when the user clicks this link, display the component associated with the compose route in the popup outlet.
当只需要考虑一个路由和一个无名出口时，外部对象中的这个 outlets 对象是完全不必要的。
This outlets object within an outer object was completely unnecessary when there was only one route and one unnamed outlet to think about.
路由器假设这个路由指向了无名的主出口，并为你创建这些对象。
The router assumed that your route specification targeted the unnamed primary outlet and created these objects for you.
路由到一个命名出口就会揭示一个以前被隐藏的真相： 你可以在同一个 RouterLink 指令中为多个路由出口指定多个路由。
Routing to a named outlet has revealed a previously hidden router truth: you can target multiple outlets with multiple routes in the same RouterLink directive.
这里你实际上没能这样做。要想指向命名出口，你就得使用一种更强大也更啰嗦的语法。
You're not actually doing that here. But to target a named outlet, you must use the richer, more verbose syntax.
第二路由导航：在导航期间合并路由
Secondary route navigation: merging routes during navigation
导航到危机中心并点击“Contact”，你将会在浏览器的地址栏看到如下 URL：
Navigate to the Crisis Center and click "Contact". you should see something like the following URL in the browser address bar.
http://.../crisis-center(popup:compose)
这个 URL 中有意思的部分是 ... 后面的这些：
The interesting part of the URL follows the ...:
crisis-center是主导航。The
crisis-centeris the primary navigation.圆括号包裹的部分是第二路由。
Parentheses surround the secondary route.
第二路由包括一个出口名称（
popup）、一个冒号分隔符和第二路由的路径（compose）。The secondary route consists of an outlet name (
popup), acolonseparator, and the secondary route path (compose).
点击 Heroes 链接，并再次查看 URL：
Click the Heroes link and look at the URL again.
http://.../heroes(popup:compose)
主导航的部分变化了，而第二路由没有变。
The primary navigation part has changed; the secondary route is the same.
路由器在导航树中对两个独立的分支保持追踪，并在 URL 中对这棵树进行表达。
The router is keeping track of two separate branches in a navigation tree and generating a representation of that tree in the URL.
你还可以添加更多出口和更多路由（无论是在顶层还是在嵌套的子层）来创建一个带有多个分支的导航树。 路由器将会生成相应的 URL。
You can add many more outlets and routes, at the top level and in nested levels, creating a navigation tree with many branches. The router will generate the URL to go with it.
通过像前面那样填充 outlets 对象，你可以告诉路由器立即导航到一棵完整的树。 然后把这个对象通过一个链接参数数组传给 router.navigate 方法。
You can tell the router to navigate an entire tree at once by filling out the outlets object mentioned above. Then pass that object inside a link parameters array to the router.navigate method.
有空的时候你可以自行试验这些可能性。
Experiment with these possibilities at your leisure.
清除第二路由
Clearing secondary routes
正如你刚刚学到的，除非导航到新的组件，否则路由出口中的组件会始终存在。 这里涉及到的第二出口也同样如此。
As you've learned, a component in an outlet persists until you navigate away to a new component. Secondary outlets are no different in this regard.
每个第二出口都有自己独立的导航，跟主出口的导航彼此独立。 修改主出口中的当前路由并不会影响到 popup 出口中的。 这就是为什么在危机中心和英雄管理之间导航时，弹出框始终都是可见的。
Each secondary outlet has its own navigation, independent of the navigation driving the primary outlet. Changing a current route that displays in the primary outlet has no effect on the popup outlet. That's why the popup stays visible as you navigate among the crises and heroes.
点击“send”或“cancel”按钮，则会清除弹出框视图。 为何如此？再看看 closePopup() 方法：
Clicking the "send" or "cancel" buttons does clear the popup view. To see how, look at the closePopup() method again:
closePopup() {
// Providing a `null` value to the named outlet
// clears the contents of the named outlet
this.router.navigate([{ outlets: { popup: null }}]);
}
它使用 Router.navigate() 方法进行强制导航，并传入了一个链接参数数组。
It navigates imperatively with the Router.navigate() method, passing in a link parameters array.
就像在 AppComponent 中绑定到的 Contact RouterLink 一样，它也包含了一个带 outlets 属性的对象。 outlets 属性的值是另一个对象，该对象用一些出口名称作为属性名。 唯一的命名出口是 'popup'。
Like the array bound to the Contact RouterLink in the AppComponent, this one includes an object with an outlets property. The outlets property value is another object with outlet names for keys. The only named outlet is 'popup'.
但这次，'popup' 的值是 null。null 不是一个路由，但却是一个合法的值。 把 popup 这个 RouterOutlet 设置为 null 会清除该出口，并且从当前 URL 中移除第二路由 popup。
This time, the value of 'popup' is null. That's not a route, but it is a legitimate value. Setting the popup RouterOutlet to null clears the outlet and removes the secondary popup route from the current URL.
里程碑 5：路由守卫
Milestone 5: Route guards
现在，任何用户都能在任何时候导航到任何地方。 但有时候这样是不对的。
At the moment, any user can navigate anywhere in the application anytime. That's not always the right thing to do.
该用户可能无权导航到目标组件。
Perhaps the user is not authorized to navigate to the target component.
可能用户得先登录（认证）。
Maybe the user must login (authenticate) first.
在显示目标组件前，你可能得先获取某些数据。
Maybe you should fetch some data before you display the target component.
在离开组件前，你可能要先保存修改。
You might want to save pending changes before leaving a component.
你可能要询问用户：你是否要放弃本次更改，而不用保存它们？
You might ask the user if it's OK to discard pending changes rather than save them.
你可以往路由配置中添加守卫，来处理这些场景。
You add guards to the route configuration to handle these scenarios.
守卫返回一个值，以控制路由器的行为：
A guard's return value controls the router's behavior:
如果它返回
true，导航过程会继续If it returns
true, the navigation process continues.如果它返回
false，导航过程就会终止，且用户留在原地。If it returns
false, the navigation process stops and the user stays put.如果它返回
UrlTree，则取消当前的导航，并且开始导航到返回的这个UrlTree.If it returns a
UrlTree, the current navigation cancels and a new navigation is initiated to theUrlTreereturned.
注意：守卫还可以告诉路由器导航到别处，这样也会取消当前的导航。要想在守卫中这么做，就要返回 false；
Note: The guard can also tell the router to navigate elsewhere, effectively canceling the current navigation. When doing so inside a guard, the guard should return false;
守卫可以用同步的方式返回一个布尔值。但在很多情况下，守卫无法用同步的方式给出答案。 守卫可能会向用户问一个问题、把更改保存到服务器，或者获取新数据，而这些都是异步操作。
The guard might return its boolean answer synchronously. But in many cases, the guard can't produce an answer synchronously. The guard could ask the user a question, save changes to the server, or fetch fresh data. These are all asynchronous operations.
因此，路由的守卫可以返回一个 Observable<boolean> 或 Promise<boolean>，并且路由器会等待这个可观察对象被解析为 true 或 false。
Accordingly, a routing guard can return an Observable<boolean> or a Promise<boolean> and the router will wait for the observable to resolve to true or false.
注意： 提供给路由器的可观察对象还必须能结束（complete）。否则，导航就不会继续。
Note: The observable provided to the Router must also complete. If the observable does not complete, the navigation will not continue.
路由器可以支持多种守卫接口：
The router supports multiple guard interfaces:
用
CanActivate来处理导航到某路由的情况。CanActivateto mediate navigation to a route.用
CanActivateChild来处理导航到某子路由的情况。CanActivateChildto mediate navigation to a child route.用
CanDeactivate来处理从当前路由离开的情况.CanDeactivateto mediate navigation away from the current route.用
Resolve在路由激活之前获取路由数据。Resolveto perform route data retrieval before route activation.用
CanLoad来处理异步导航到某特性模块的情况。CanLoadto mediate navigation to a feature module loaded asynchronously.
在分层路由的每个级别上，你都可以设置多个守卫。 路由器会先按照从最深的子路由由下往上检查的顺序来检查 CanDeactivate() 和 CanActivateChild() 守卫。 然后它会按照从上到下的顺序检查 CanActivate() 守卫。 如果特性模块是异步加载的，在加载它之前还会检查 CanLoad() 守卫。 如果任何一个守卫返回 false，其它尚未完成的守卫会被取消，这样整个导航就被取消了。
You can have multiple guards at every level of a routing hierarchy. The router checks the CanDeactivate and CanActivateChild guards first, from the deepest child route to the top. Then it checks the CanActivate guards from the top down to the deepest child route. If the feature module is loaded asynchronously, the CanLoad guard is checked before the module is loaded. If any guard returns false, pending guards that have not completed will be canceled, and the entire navigation is canceled.
接下来的小节中有一些例子。
There are several examples over the next few sections.
CanActivate: 要求认证
CanActivate: requiring authentication
应用程序通常会根据访问者来决定是否授予某个特性区的访问权。 你可以只对已认证过的用户或具有特定角色的用户授予访问权，还可以阻止或限制用户访问权，直到用户账户激活为止。
Applications often restrict access to a feature area based on who the user is. You could permit access only to authenticated users or to users with a specific role. You might block or limit access until the user's account is activated.
CanActivate 守卫是一个管理这些导航类业务规则的工具。
The CanActivate guard is the tool to manage these navigation business rules.
添加一个“管理”特性模块
Add an admin feature module
在下一节，你将会使用一些新的管理特性来扩展危机中心。 那些特性尚未定义，但是你可以先从添加一个名叫 AdminModule 的特性模块开始。
In this next section, you'll extend the crisis center with some new administrative features. Those features aren't defined yet. But you can start by adding a new feature module named AdminModule.
生成一个带有特性模块文件和路由配置文件的 admin 目录。
Generate an admin folder with a feature module file and a routing configuration file.
ng generate module admin --routing
接下来，生成一些支持性组件。
Next, generate the supporting components.
ng generate component admin/admin-dashboard
ng generate component admin/admin
ng generate component admin/manage-crises
ng generate component admin/manage-heroes
管理特性区的文件是这样的：
The admin feature file structure looks like this:
src/app/admin
管理特性模块包含 AdminComponent，它用于在特性模块内的仪表盘路由以及两个尚未完成的用于管理危机和英雄的组件之间进行路由。
The admin feature module contains the AdminComponent used for routing within the feature module, a dashboard route and two unfinished components to manage crises and heroes.
<h3>ADMIN</h3>
<nav>
<a routerLink="./" routerLinkActive="active"
[routerLinkActiveOptions]="{ exact: true }">Dashboard</a>
<a routerLink="./crises" routerLinkActive="active">Manage Crises</a>
<a routerLink="./heroes" routerLinkActive="active">Manage Heroes</a>
</nav>
<router-outlet></router-outlet>
虽然管理仪表盘中的 RouterLink 只包含一个没有其它 URL 段的斜杠 /，但它能匹配管理特性区下的任何路由。 但你只希望在访问 Dashboard 路由时才激活该链接。 往 Dashboard 这个 routerLink 上添加另一个绑定 [routerLinkActiveOptions]="{ exact: true }"， 这样就只有当用户导航到 /admin 这个 URL 时才会激活它，而不会在导航到它的某个子路由时。
Although the admin dashboard RouterLink only contains a relative slash without an additional URL segment, it is considered a match to any route within the admin feature area. You only want the Dashboard link to be active when the user visits that route. Adding an additional binding to the Dashboard routerLink,[routerLinkActiveOptions]="{ exact: true }", marks the ./ link as active when the user navigates to the /admin URL and not when navigating to any of the child routes.
无组件路由：分组路由，而不需要组件
Component-less route: grouping routes without a component
最初的管理路由配置如下：
The initial admin routing configuration:
const adminRoutes: Routes = [
{
path: 'admin',
component: AdminComponent,
children: [
{
path: '',
children: [
{ path: 'crises', component: ManageCrisesComponent },
{ path: 'heroes', component: ManageHeroesComponent },
{ path: '', component: AdminDashboardComponent }
]
}
]
}
];
@NgModule({
imports: [
RouterModule.forChild(adminRoutes)
],
exports: [
RouterModule
]
})
export class AdminRoutingModule {}
来看 AdminComponent 下的子路由，这里有一个带 path 和 children 的子路由， 但它没有使用 component。这并不是配置中的失误，而是在使用无组件路由。
Looking at the child route under the AdminComponent, there is a path and a children property but it's not using a component. You haven't made a mistake in the configuration. You've defined a component-less route.
这里的目标是对 admin 路径下的 危机中心 管理类路由进行分组，但并不需要另一个仅用来分组路由的组件。 一个无组件的路由能让守卫子路由变得更容易。
The goal is to group the Crisis Center management routes under the admin path. You don't need a component to do it. A component-less route makes it easier to guard child routes.
接下来，把 AdminModule 导入到 app.module.ts 中，并把它加入 imports 数组中来注册这些管理类路由。
Next, import the AdminModule into app.module.ts and add it to the imports array to register the admin routes.
import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
import { AppComponent } from './app.component';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
import { ComposeMessageComponent } from './compose-message/compose-message.component';
import { AppRoutingModule } from './app-routing.module';
import { HeroesModule } from './heroes/heroes.module';
import { CrisisCenterModule } from './crisis-center/crisis-center.module';
import { AdminModule } from './admin/admin.module';
@NgModule({
imports: [
CommonModule,
FormsModule,
HeroesModule,
CrisisCenterModule,
AdminModule,
AppRoutingModule
],
declarations: [
AppComponent,
ComposeMessageComponent,
PageNotFoundComponent
],
bootstrap: [ AppComponent ]
})
export class AppModule { }
然后往壳组件 AppComponent 中添加一个链接，让用户能点击它，以访问该特性。
Add an "Admin" link to the AppComponent shell so that users can get to this feature.
<h1 class="title">Angular Router</h1>
<nav>
<a routerLink="/crisis-center" routerLinkActive="active">Crisis Center</a>
<a routerLink="/heroes" routerLinkActive="active">Heroes</a>
<a routerLink="/admin" routerLinkActive="active">Admin</a>
<a [routerLink]="[{ outlets: { popup: ['compose'] } }]">Contact</a>
</nav>
<div [@routeAnimation]="getAnimationData(routerOutlet)">
<router-outlet #routerOutlet="outlet"></router-outlet>
</div>
<router-outlet name="popup"></router-outlet>
守护“管理特性”区
Guard the admin feature
现在“危机中心”的每个路由都是对所有人开放的。这些新的管理特性应该只能被已登录用户访问。
Currently every route within the Crisis Center is open to everyone. The new admin feature should be accessible only to authenticated users.
你可以在用户登录之前隐藏这些链接，但这样会有点复杂并难以维护。
You could hide the link until the user logs in. But that's tricky and difficult to maintain.
你可以换种方式：写一个 CanActivate() 守卫，将正在尝试访问管理组件匿名用户重定向到登录页。
Instead you'll write a canActivate() guard method to redirect anonymous users to the login page when they try to enter the admin area.
这是一个通用的守卫（你可以假设另外一些特性区也要求已认证过的用户才能访问），所以你可以在 auth 目录下生成一个 AuthGuard。
This is a general purpose guard—you can imagine other features that require authenticated users—so you generate an AuthGuard in the auth folder.
ng generate guard auth/auth
此刻，你的兴趣在于看看守卫是如何工作的，所以第一个版本没做什么有用的事情。它只是往控制台写日志，并且立即返回 true，让导航继续：
At the moment you're interested in seeing how guards work so the first version does nothing useful. It simply logs to console and returns true immediately, allowing navigation to proceed:
import { Injectable } from '@angular/core';
import { CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
@Injectable({
providedIn: 'root',
})
export class AuthGuard implements CanActivate {
canActivate(
next: ActivatedRouteSnapshot,
state: RouterStateSnapshot): boolean {
console.log('AuthGuard#canActivate called');
return true;
}
}
接下来，打开 admin-routing.module.ts，导入 AuthGuard 类，修改管理路由并通过 CanActivate() 守卫来引用 AuthGuard：
Next, open admin-routing.module.ts, import the AuthGuard class, and update the admin route with a canActivate guard property that references it:
import { AuthGuard } from '../auth/auth.guard';
const adminRoutes: Routes = [
{
path: 'admin',
component: AdminComponent,
canActivate: [AuthGuard],
children: [
{
path: '',
children: [
{ path: 'crises', component: ManageCrisesComponent },
{ path: 'heroes', component: ManageHeroesComponent },
{ path: '', component: AdminDashboardComponent }
],
}
]
}
];
@NgModule({
imports: [
RouterModule.forChild(adminRoutes)
],
exports: [
RouterModule
]
})
export class AdminRoutingModule {}
管理特性区现在受此守卫保护了，不过这样的保护还不够。
The admin feature is now protected by the guard, albeit protected poorly.
教 AuthGuard 进行认证
Teach AuthGuard to authenticate
先让 AuthGuard 至少能“假装”进行认证。
Make the AuthGuard at least pretend to authenticate.
AuthGuard 可以调用应用中的一项服务，该服务能让用户登录，并且保存当前用户的信息。在 admin 目录下生成一个新的 AuthService：
The AuthGuard should call an application service that can login a user and retain information about the current user. Generate a new AuthService in the auth folder:
ng generate service auth/auth
修改 AuthService 以登入此用户：
Update the AuthService to log in the user:
import { Injectable } from '@angular/core';
import { Observable, of } from 'rxjs';
import { tap, delay } from 'rxjs/operators';
@Injectable({
providedIn: 'root',
})
export class AuthService {
isLoggedIn = false;
// store the URL so we can redirect after logging in
redirectUrl: string;
login(): Observable<boolean> {
return of(true).pipe(
delay(1000),
tap(val => this.isLoggedIn = true)
);
}
logout(): void {
this.isLoggedIn = false;
}
}
虽然它不会真的进行登录，但足够让你进行这个讨论了。 它有一个 isLoggedIn 标志，用来标识是否用户已经登录过了。 它的 login 方法会仿真一个对外部服务的 API 调用，返回一个可观察对象（observable）。在短暂的停顿之后，这个可观察对象就会解析成功。 redirectUrl 属性将会保存在 URL 中，以便认证完之后导航到它。
Although it doesn't actually log in, it has what you need for this discussion. It has an isLoggedIn flag to tell you whether the user is authenticated. Its login method simulates an API call to an external service by returning an observable that resolves successfully after a short pause. The redirectUrl property will store the attempted URL so you can navigate to it after authenticating.
这就修改 AuthGuard 来调用它。
Revise the AuthGuard to call it.
import { Injectable } from '@angular/core';
import { CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot, Router } from '@angular/router';
import { AuthService } from './auth.service';
@Injectable({
providedIn: 'root',
})
export class AuthGuard implements CanActivate {
constructor(private authService: AuthService, private router: Router) {}
canActivate(
next: ActivatedRouteSnapshot,
state: RouterStateSnapshot): boolean {
let url: string = state.url;
return this.checkLogin(url);
}
checkLogin(url: string): boolean {
if (this.authService.isLoggedIn) { return true; }
// Store the attempted URL for redirecting
this.authService.redirectUrl = url;
// Navigate to the login page with extras
this.router.navigate(['/login']);
return false;
}
}
注意，你把 AuthService 和 Router 服务注入到构造函数中。 你还没有提供 AuthService，这里要说明的是：可以往路由守卫中注入有用的服务。
Notice that you inject the AuthService and the Router in the constructor. You haven't provided the AuthService yet but it's good to know that you can inject helpful services into routing guards.
该守卫返回一个同步的布尔值。如果用户已经登录，它就返回 true，导航会继续。
This guard returns a synchronous boolean result. If the user is logged in, it returns true and the navigation continues.
这个 ActivatedRouteSnapshot 包含了即将被激活的路由，而 RouterStateSnapshot 包含了该应用即将到达的状态。 你应该通过守卫进行检查。
The ActivatedRouteSnapshot contains the future route that will be activated and the RouterStateSnapshot contains the future RouterState of the application, should you pass through the guard check.
如果用户还没有登录，你就会用 RouterStateSnapshot.url 保存用户来自的 URL 并让路由器导航到登录页（你尚未创建该页）。 这间接导致路由器自动中止了这次导航，checkLogin() 返回 false 并不是必须的，但这样可以更清楚的表达意图。
If the user is not logged in, you store the attempted URL the user came from using the RouterStateSnapshot.url and tell the router to navigate to a login page—a page you haven't created yet. This secondary navigation automatically cancels the current navigation; checkLogin() returns false just to be clear about that.
添加 LoginComponent
Add the LoginComponent
你需要一个 LoginComponent 来让用户登录进这个应用。在登录之后，你就会跳转到前面保存的 URL，如果没有，就跳转到默认 URL。 该组件没有什么新内容，你把它放进路由配置的方式也没什么新意。
You need a LoginComponent for the user to log in to the app. After logging in, you'll redirect to the stored URL if available, or use the default URL. There is nothing new about this component or the way you wire it into the router configuration.
ng generate component auth/login
在 auth/auth-routing.module.ts 文件中注册一个 /login 路由。在 app.module.ts 中，导入 AuthModule 并且添加到 AppModule 的 imports 中。
Register a /login route in the auth/auth-routing.module.ts. In app.module.ts, import and add the AuthModule to the AppModule imports.
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import { AppComponent } from './app.component';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
import { ComposeMessageComponent } from './compose-message/compose-message.component';
import { AppRoutingModule } from './app-routing.module';
import { HeroesModule } from './heroes/heroes.module';
import { AuthModule } from './auth/auth.module';
@NgModule({
imports: [
BrowserModule,
BrowserAnimationsModule,
FormsModule,
HeroesModule,
AuthModule,
AppRoutingModule,
],
declarations: [
AppComponent,
ComposeMessageComponent,
PageNotFoundComponent
],
bootstrap: [ AppComponent ]
})
export class AppModule {
}
CanActivateChild：保护子路由
CanActivateChild: guarding child routes
你还可以使用 CanActivateChild 守卫来保护子路由。 CanActivateChild 守卫和 CanActivate 守卫很像。 它们的区别在于，CanActivateChild 会在任何子路由被激活之前运行。
You can also protect child routes with the CanActivateChild guard. The CanActivateChild guard is similar to the CanActivate guard. The key difference is that it runs before any child route is activated.
你要保护管理特性模块，防止它被非授权访问，还要保护这个特性模块内部的那些子路由。
You protected the admin feature module from unauthorized access. You should also protect child routes within the feature module.
扩展 AuthGuard 以便在 admin 路由之间导航时提供保护。 打开 auth.guard.ts 并从路由库中导入 CanActivateChild 接口。
Extend the AuthGuard to protect when navigating between the admin routes. Open auth.guard.ts and add the CanActivateChild interface to the imported tokens from the router package.
接下来，实现 CanActivateChild 方法，它所接收的参数与 CanActivate 方法一样：一个 ActivatedRouteSnapshot 和一个 RouterStateSnapshot。 CanActivateChild 方法可以返回 Observable<boolean> 或 Promise<boolean> 来支持异步检查，或 boolean 来支持同步检查。 这里返回的是 boolean：
Next, implement the canActivateChild() method which takes the same arguments as the canActivate() method: an ActivatedRouteSnapshot and RouterStateSnapshot. The canActivateChild() method can return an Observable<boolean> or Promise<boolean> for async checks and a boolean for sync checks. This one returns a boolean:
import { Injectable } from '@angular/core';
import {
CanActivate, Router,
ActivatedRouteSnapshot,
RouterStateSnapshot,
CanActivateChild
} from '@angular/router';
import { AuthService } from './auth.service';
@Injectable({
providedIn: 'root',
})
export class AuthGuard implements CanActivate, CanActivateChild {
constructor(private authService: AuthService, private router: Router) {}
canActivate(
route: ActivatedRouteSnapshot,
state: RouterStateSnapshot): boolean {
let url: string = state.url;
return this.checkLogin(url);
}
canActivateChild(
route: ActivatedRouteSnapshot,
state: RouterStateSnapshot): boolean {
return this.canActivate(route, state);
}
/* . . . */
}
同样把这个 AuthGuard 添加到“无组件的”管理路由，来同时保护它的所有子路由，而不是为每个路由单独添加这个 AuthGuard。
Add the same AuthGuard to the component-less admin route to protect all other child routes at one time instead of adding the AuthGuard to each route individually.
const adminRoutes: Routes = [
{
path: 'admin',
component: AdminComponent,
canActivate: [AuthGuard],
children: [
{
path: '',
canActivateChild: [AuthGuard],
children: [
{ path: 'crises', component: ManageCrisesComponent },
{ path: 'heroes', component: ManageHeroesComponent },
{ path: '', component: AdminDashboardComponent }
]
}
]
}
];
@NgModule({
imports: [
RouterModule.forChild(adminRoutes)
],
exports: [
RouterModule
]
})
export class AdminRoutingModule {}
CanDeactivate：处理未保存的更改
CanDeactivate: handling unsaved changes
回到“Heroes”工作流，该应用毫不犹豫的接受对英雄的任何修改，不作任何校验。
Back in the "Heroes" workflow, the app accepts every change to a hero immediately without hesitation or validation.
在现实世界中，你得先把用户的改动积累起来。 你可能不得不进行跨字段的校验，可能要找服务器进行校验，可能得把这些改动保存成一种待定状态，直到用户或者把这些改动作为一组进行确认或撤销所有改动。
In the real world, you might have to accumulate the users changes. You might have to validate across fields. You might have to validate on the server. You might have to hold changes in a pending state until the user confirms them as a group or cancels and reverts all changes.
当用户要导航到外面时，该怎么处理这些既没有审核通过又没有保存过的改动呢？ 你不能马上离开，不在乎丢失这些改动的风险，那显然是一种糟糕的用户体验。
What do you do about unapproved, unsaved changes when the user navigates away? You can't just leave and risk losing the user's changes; that would be a terrible experience.
最好能暂停，并让用户决定该怎么做。 如果用户选择了取消，你就留下来，并允许更多改动。 如果用户选择了确认，那就进行保存。
It's better to pause and let the user decide what to do. If the user cancels, you'll stay put and allow more changes. If the user approves, the app can save.
在保存成功之前，你还可以继续推迟导航。如果你让用户立即移到下一个界面，而保存却失败了（可能因为数据不符合有效性规则），你就会丢失该错误的上下文环境。
You still might delay navigation until the save succeeds. If you let the user move to the next screen immediately and the save were to fail (perhaps the data are ruled invalid), you would lose the context of the error.
在等待服务器的答复时，你没法阻塞它 —— 这在浏览器中是不可能的。 你只能用异步的方式在等待服务器答复之前先停止导航。
You can't block while waiting for the server—that's not possible in a browser. You need to stop the navigation while you wait, asynchronously, for the server to return with its answer.
你需要 CanDeactivate 守卫。
You need the CanDeactivate guard.
取消与保存
Cancel and save
这个范例应用不会与服务器通讯。 幸运的是，你有另一种方式来演示异步的路由器钩子。
The sample application doesn't talk to a server. Fortunately, you have another way to demonstrate an asynchronous router hook.
用户在 CrisisDetailComponent 中更新危机信息。 与 HeroDetailComponent 不同，用户的改动不会立即更新危机的实体对象。当用户按下了 Save 按钮时，应用就更新这个实体对象；如果按了 Cancel 按钮，那就放弃这些更改。
Users update crisis information in the CrisisDetailComponent. Unlike the HeroDetailComponent, the user changes do not update the crisis entity immediately. Instead, the app updates the entity when the user presses the Save button and discards the changes when the user presses the Cancel button.
这两个按钮都会在保存或取消之后导航回危机列表。
Both buttons navigate back to the crisis list after save or cancel.
cancel() {
this.gotoCrises();
}
save() {
this.crisis.name = this.editName;
this.gotoCrises();
}
如果用户尝试不保存或撤销就导航到外面该怎么办？ 用户可以按浏览器的后退按钮，或点击英雄的链接。 这些操作都会触发导航。本应用应该自动保存或取消吗？
What if the user tries to navigate away without saving or canceling? The user could push the browser back button or click the heroes link. Both actions trigger a navigation. Should the app save or cancel automatically?
都不行。应用应该弹出一个确认对话框来要求用户明确做出选择，该对话框会用异步的方式等用户做出选择。
This demo does neither. Instead, it asks the user to make that choice explicitly in a confirmation dialog box that waits asynchronously for the user's answer.
你也能用同步的方式等用户的答复，阻塞代码。但如果能用异步的方式等待用户的答复，应用就会响应性更好，也能同时做别的事。异步等待用户的答复和等待服务器的答复是类似的。
You could wait for the user's answer with synchronous, blocking code. The app will be more responsive—and can do other work—by waiting for the user's answer asynchronously. Waiting for the user asynchronously is like waiting for the server asynchronously.
生成一个 Dialog 服务，以处理用户的确认操作。
Generate a Dialog service to handle user confirmation.
ng generate service dialog
为 DialogService 添加一个 confirm() 方法，以提醒用户确认。window.confirm 是一个阻塞型操作，它会显示一个模态对话框，并等待用户的交互。
Add a confirm() method to the DialogService to prompt the user to confirm their intent. The window.confirm is a blocking action that displays a modal dialog and waits for user interaction.
import { Injectable } from '@angular/core';
import { Observable, of } from 'rxjs';
/**
* Async modal dialog service
* DialogService makes this app easier to test by faking this service.
* TODO: better modal implementation that doesn't use window.confirm
*/
@Injectable({
providedIn: 'root',
})
export class DialogService {
/**
* Ask user to confirm an action. `message` explains the action and choices.
* Returns observable resolving to `true`=confirm or `false`=cancel
*/
confirm(message?: string): Observable<boolean> {
const confirmation = window.confirm(message || 'Is it OK?');
return of(confirmation);
};
}
它返回observable，当用户最终决定了如何去做时，它就会被解析 —— 或者决定放弃更改直接导航离开（true），或者保留未完成的修改，留在危机编辑器中（false）。
It returns an Observable that resolves when the user eventually decides what to do: either to discard changes and navigate away (true) or to preserve the pending changes and stay in the crisis editor (false).
生成一个守卫（guard），以检查组件（任意组件均可）中是否存在 canDeactivate() 方法。
Generate a guard that checks for the presence of a canDeactivate() method in a component—any component.
ng generate guard can-deactivate
创建了一个 Guard，它将检查这个（任意）组件中是否有 canDeactivate() 函数。 CrisisDetailComponent 就会有这个方法。 但是该守卫并不需要知道 CrisisDetailComponent 确认退出激活状态的详情。 它只需要检查该组件是否有一个 canDeactivate() 方法，并调用它。 这就让该守卫可以复用。
The CrisisDetailComponent will have this method. But the guard doesn't have to know that. The guard shouldn't know the details of any component's deactivation method. It need only detect that the component has a canDeactivate() method and call it. This approach makes the guard reusable.
import { Injectable } from '@angular/core';
import { CanDeactivate } from '@angular/router';
import { Observable } from 'rxjs';
export interface CanComponentDeactivate {
canDeactivate: () => Observable<boolean> | Promise<boolean> | boolean;
}
@Injectable({
providedIn: 'root',
})
export class CanDeactivateGuard implements CanDeactivate<CanComponentDeactivate> {
canDeactivate(component: CanComponentDeactivate) {
return component.canDeactivate ? component.canDeactivate() : true;
}
}
另外，你也可以为 CrisisDetailComponent 创建一个特定的 CanDeactivate 守卫。 在需要访问外部信息时，canDeactivate() 方法为你提供了组件、ActivatedRoute 和 RouterStateSnapshot 的当前实例。 如果只想为这个组件使用该守卫，并且需要获取该组件属性或确认路由器是否允许从该组件导航出去时，这会非常有用。
Alternatively, you could make a component-specific CanDeactivate guard for the CrisisDetailComponent. The canDeactivate() method provides you with the current instance of the component, the current ActivatedRoute, and RouterStateSnapshot in case you needed to access some external information. This would be useful if you only wanted to use this guard for this component and needed to get the component's properties or confirm whether the router should allow navigation away from it.
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { CanDeactivate,
ActivatedRouteSnapshot,
RouterStateSnapshot } from '@angular/router';
import { CrisisDetailComponent } from './crisis-center/crisis-detail/crisis-detail.component';
@Injectable({
providedIn: 'root',
})
export class CanDeactivateGuard implements CanDeactivate<CrisisDetailComponent> {
canDeactivate(
component: CrisisDetailComponent,
route: ActivatedRouteSnapshot,
state: RouterStateSnapshot
): Observable<boolean> | boolean {
// Get the Crisis Center ID
console.log(route.paramMap.get('id'));
// Get the current URL
console.log(state.url);
// Allow synchronous navigation (`true`) if no crisis or the crisis is unchanged
if (!component.crisis || component.crisis.name === component.editName) {
return true;
}
// Otherwise ask the user with the dialog service and return its
// observable which resolves to true or false when the user decides
return component.dialogService.confirm('Discard changes?');
}
}
看看 CrisisDetailComponent 组件，它已经实现了对未保存的更改进行确认的工作流。
Looking back at the CrisisDetailComponent, it implements the confirmation workflow for unsaved changes.
canDeactivate(): Observable<boolean> | boolean {
// Allow synchronous navigation (`true`) if no crisis or the crisis is unchanged
if (!this.crisis || this.crisis.name === this.editName) {
return true;
}
// Otherwise ask the user with the dialog service and return its
// observable which resolves to true or false when the user decides
return this.dialogService.confirm('Discard changes?');
}
注意，canDeactivate 方法可以同步返回，如果没有危机，或者没有未定的修改，它就立即返回 true。但是它也可以返回一个承诺（Promise）或可观察对象（Observable），路由器将等待它们被解析为真值（继续导航）或假值（留下）。
Notice that the canDeactivate() method can return synchronously; it returns true immediately if there is no crisis or there are no pending changes. But it can also return a Promise or an Observable and the router will wait for that to resolve to truthy (navigate) or falsy (stay put).
往 crisis-center.routing.module.ts 的危机详情路由中用 canDeactivate 数组添加一个 Guard（守卫）。
Add the Guard to the crisis detail route in crisis-center-routing.module.ts using the canDeactivate array property.
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { CrisisCenterHomeComponent } from './crisis-center-home/crisis-center-home.component';
import { CrisisListComponent } from './crisis-list/crisis-list.component';
import { CrisisCenterComponent } from './crisis-center/crisis-center.component';
import { CrisisDetailComponent } from './crisis-detail/crisis-detail.component';
import { CanDeactivateGuard } from '../can-deactivate.guard';
const crisisCenterRoutes: Routes = [
{
path: 'crisis-center',
component: CrisisCenterComponent,
children: [
{
path: '',
component: CrisisListComponent,
children: [
{
path: ':id',
component: CrisisDetailComponent,
canDeactivate: [CanDeactivateGuard]
},
{
path: '',
component: CrisisCenterHomeComponent
}
]
}
]
}
];
@NgModule({
imports: [
RouterModule.forChild(crisisCenterRoutes)
],
exports: [
RouterModule
]
})
export class CrisisCenterRoutingModule { }
现在，你已经给了用户一个能保护未保存更改的安全守卫。
Now you have given the user a safeguard against unsaved changes.
Resolve: 预先获取组件数据
Resolve: pre-fetching component data
在 Hero Detail 和 Crisis Detail 中，它们等待路由读取完对应的英雄和危机。
In the Hero Detail and Crisis Detail, the app waited until the route was activated to fetch the respective hero or crisis.
这种方式没有问题，但是它们还有进步的空间。 如果你在使用真实 api，很有可能数据返回有延迟，导致无法即时显示。 在这种情况下，直到数据到达前，显示一个空的组件不是最好的用户体验。
This worked well, but there's a better way. If you were using a real world API, there might be some delay before the data to display is returned from the server. You don't want to display a blank component while waiting for the data.
最好预先从服务器上获取完数据，这样在路由激活的那一刻数据就准备好了。 还要在路由到此组件之前处理好错误。 但当某个 id 无法对应到一个危机详情时，就没办法处理它。 这时最好把用户带回到“危机列表”中，那里显示了所有有效的“危机”。
It's preferable to pre-fetch data from the server so it's ready the moment the route is activated. This also allows you to handle errors before routing to the component. There's no point in navigating to a crisis detail for an id that doesn't have a record. It'd be better to send the user back to the Crisis List that shows only valid crisis centers.
总之，你希望的是只有当所有必要数据都已经拿到之后，才渲染这个路由组件。
In summary, you want to delay rendering the routed component until all necessary data have been fetched.
你需要 Resolve 守卫。
You need a resolver.
导航前预先加载路由信息
Fetch data before navigating
目前，CrisisDetailComponent 会接收选中的危机。 如果该危机没有找到，它就会导航回危机列表视图。
At the moment, the CrisisDetailComponent retrieves the selected crisis. If the crisis is not found, it navigates back to the crisis list view.
如果能在该路由将要激活时提前处理了这个问题，那么用户体验会更好。 CrisisDetailResolver 服务可以接收一个 Crisis，而如果这个 Crisis 不存在，就会在激活该路由并创建 CrisisDetailComponent 之前先行离开。
The experience might be better if all of this were handled first, before the route is activated. A CrisisDetailResolver service could retrieve a Crisis or navigate away if the Crisis does not exist before activating the route and creating the CrisisDetailComponent.
在 Crisis Center 特性区生成一个 CrisisDetailResolver 服务文件。
Generate a CrisisDetailResolver service file within the Crisis Center feature area.
ng generate service crisis-center/crisis-detail-resolver
import { Injectable } from '@angular/core';
@Injectable({
providedIn: 'root',
})
export class CrisisDetailResolverService {
constructor() { }
}
在 CrisisDetailComponent.ngOnInit 中拿到相关的危机检索逻辑，并且把它们移到 CrisisDetailResolverService 中。 导入 Crisis 模型、CrisisService 和 Router 以便让你可以在找不到指定的危机时导航到别处。
Take the relevant parts of the crisis retrieval logic in CrisisDetailComponent.ngOnInit and move them into the CrisisDetailResolverService. Import the Crisis model, CrisisService, and the Router so you can navigate elsewhere if you can't fetch the crisis.
为了更明确一点，可以实现一个带有 Crisis 类型的 Resolve 接口。
Be explicit. Implement the Resolve interface with a type of Crisis.
注入 CrisisService 和 Router，并实现 resolve() 方法。 该方法可以返回一个 Promise、一个 Observable 来支持异步方式，或者直接返回一个值来支持同步方式。
Inject the CrisisService and Router and implement the resolve() method. That method could return a Promise, an Observable, or a synchronous return value.
CrisisService.getCrisis 方法返回一个可观察对象，以防止在数据获取完之前加载本路由。 Router 守卫要求这个可观察对象必须可结束（complete），也就是说它已经发出了所有值。 你可以为 take 操作符传入一个参数 1，以确保这个可观察对象会在从 getCrisis 方法所返回的可观察对象中取到第一个值之后就会结束。
The CrisisService.getCrisis method returns an observable, in order to prevent the route from loading until the data is fetched. The Router guards require an observable to complete, meaning it has emitted all of its values. You use the take operator with an argument of 1 to ensure that the Observable completes after retrieving the first value from the Observable returned by the getCrisis method.
如果它没有返回有效的 Crisis，就会返回一个 Observable，以取消以前到 CrisisDetailComponent 的在途导航，并把用户导航回 CrisisListComponent。修改后的 resolver 服务是这样的：
If it doesn't return a valid Crisis, return an empty Observable, canceling the previous in-flight navigation to the CrisisDetailComponent and navigate the user back to the CrisisListComponent. The updated resolver service looks like this:
import { Injectable } from '@angular/core';
import {
Router, Resolve,
RouterStateSnapshot,
ActivatedRouteSnapshot
} from '@angular/router';
import { Observable, of, EMPTY } from 'rxjs';
import { mergeMap, take } from 'rxjs/operators';
import { CrisisService } from './crisis.service';
import { Crisis } from './crisis';
@Injectable({
providedIn: 'root',
})
export class CrisisDetailResolverService implements Resolve<Crisis> {
constructor(private cs: CrisisService, private router: Router) {}
resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<Crisis> | Observable<never> {
let id = route.paramMap.get('id');
return this.cs.getCrisis(id).pipe(
take(1),
mergeMap(crisis => {
if (crisis) {
return of(crisis);
} else { // id not found
this.router.navigate(['/crisis-center']);
return EMPTY;
}
})
);
}
}
把这个解析器（resolver）导入到 crisis-center-routing.module.ts 中，并往 CrisisDetailComponent 的路由配置中添加一个 resolve 对象。
Import this resolver in the crisis-center-routing.module.ts and add a resolve object to the CrisisDetailComponent route configuration.
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { CrisisCenterHomeComponent } from './crisis-center-home/crisis-center-home.component';
import { CrisisListComponent } from './crisis-list/crisis-list.component';
import { CrisisCenterComponent } from './crisis-center/crisis-center.component';
import { CrisisDetailComponent } from './crisis-detail/crisis-detail.component';
import { CanDeactivateGuard } from '../can-deactivate.guard';
import { CrisisDetailResolverService } from './crisis-detail-resolver.service';
const crisisCenterRoutes: Routes = [
{
path: 'crisis-center',
component: CrisisCenterComponent,
children: [
{
path: '',
component: CrisisListComponent,
children: [
{
path: ':id',
component: CrisisDetailComponent,
canDeactivate: [CanDeactivateGuard],
resolve: {
crisis: CrisisDetailResolverService
}
},
{
path: '',
component: CrisisCenterHomeComponent
}
]
}
]
}
];
@NgModule({
imports: [
RouterModule.forChild(crisisCenterRoutes)
],
exports: [
RouterModule
]
})
export class CrisisCenterRoutingModule { }
CrisisDetailComponent 不应该再去获取这个危机的详情。 把 CrisisDetailComponent 改成从 ActivatedRoute.data.crisis 属性中获取危机详情，这正是你重新配置路由的恰当时机。 当 CrisisDetailComponent 要求取得危机详情时，它就已经在那里了。
The CrisisDetailComponent should no longer fetch the crisis. Update the CrisisDetailComponent to get the crisis from the ActivatedRoute.data.crisis property instead; that's where you said it should be when you re-configured the route. It will be there when the CrisisDetailComponent ask for it.
ngOnInit() {
this.route.data
.subscribe((data: { crisis: Crisis }) => {
this.editName = data.crisis.name;
this.crisis = data.crisis;
});
}
两个关键点
Two critical points
路由器的这个
Resolve接口是可选的。CrisisDetailResolverService没有继承自某个基类。路由器只要找到了这个方法，就会调用它。The router's
Resolveinterface is optional. TheCrisisDetailResolverServicedoesn't inherit from a base class. The router looks for that method and calls it if found.要依赖路由器调用此守卫。不必关心用户用哪种方式导航离开，这是路由器的工作。你只要写出这个类，等路由器从那里取出它就可以了。
Rely on the router to call the resolver. Don't worry about all the ways that the user could navigate away. That's the router's job. Write this class and let the router take it from there.
本里程碑中与危机中心有关的代码如下：
The relevant Crisis Center code for this milestone follows.
<h1 class="title">Angular Router</h1>
<nav>
<a routerLink="/crisis-center" routerLinkActive="active">Crisis Center</a>
<a routerLink="/superheroes" routerLinkActive="active">Heroes</a>
<a routerLink="/admin" routerLinkActive="active">Admin</a>
<a routerLink="/login" routerLinkActive="active">Login</a>
<a [routerLink]="[{ outlets: { popup: ['compose'] } }]">Contact</a>
</nav>
<div [@routeAnimation]="getAnimationData(routerOutlet)">
<router-outlet #routerOutlet="outlet"></router-outlet>
</div>
<router-outlet name="popup"></router-outlet>
路由守卫
Guards
import { Injectable } from '@angular/core';
import {
CanActivate, Router,
ActivatedRouteSnapshot,
RouterStateSnapshot,
CanActivateChild
} from '@angular/router';
import { AuthService } from './auth.service';
@Injectable({
providedIn: 'root',
})
export class AuthGuard implements CanActivate, CanActivateChild {
constructor(private authService: AuthService, private router: Router) {}
canActivate(
route: ActivatedRouteSnapshot,
state: RouterStateSnapshot): boolean {
let url: string = state.url;
return this.checkLogin(url);
}
canActivateChild(
route: ActivatedRouteSnapshot,
state: RouterStateSnapshot): boolean {
return this.canActivate(route, state);
}
checkLogin(url: string): boolean {
if (this.authService.isLoggedIn) { return true; }
// Store the attempted URL for redirecting
this.authService.redirectUrl = url;
// Navigate to the login page
this.router.navigate(['/login']);
return false;
}
}
查询参数及片段
Query parameters and fragments
在这个查询参数例子中，你只为路由指定了参数，但是该如何定义一些所有路由中都可用的可选参数呢？ 这就该“查询参数”登场了。
In the route parameters example, you only dealt with parameters specific to the route, but what if you wanted optional parameters available to all routes? This is where query parameters come into play.
片段可以引用页面中带有特定 id 属性的元素.
Fragments refer to certain elements on the page identified with an id attribute.
修改 AuthGuard 以提供 session_id 查询参数，在导航到其它路由后，它还会存在。
Update the AuthGuard to provide a session_id query that will remain after navigating to another route.
再添加一个锚点（A）元素，来让你能跳转到页面中的正确位置。
Add an anchor element so you can jump to a certain point on the page.
为 router.navigate() 方法添加一个 NavigationExtras 对象，用来导航到 /login 路由。
Add the NavigationExtras object to the router.navigate() method that navigates you to the /login route.
import { Injectable } from '@angular/core';
import {
CanActivate, Router,
ActivatedRouteSnapshot,
RouterStateSnapshot,
CanActivateChild,
NavigationExtras
} from '@angular/router';
import { AuthService } from './auth.service';
@Injectable({
providedIn: 'root',
})
export class AuthGuard implements CanActivate, CanActivateChild {
constructor(private authService: AuthService, private router: Router) {}
canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean {
let url: string = state.url;
return this.checkLogin(url);
}
canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean {
return this.canActivate(route, state);
}
checkLogin(url: string): boolean {
if (this.authService.isLoggedIn) { return true; }
// Store the attempted URL for redirecting
this.authService.redirectUrl = url;
// Create a dummy session id
let sessionId = 123456789;
// Set our navigation extras object
// that contains our global query params and fragment
let navigationExtras: NavigationExtras = {
queryParams: { 'session_id': sessionId },
fragment: 'anchor'
};
// Navigate to the login page with extras
this.router.navigate(['/login'], navigationExtras);
return false;
}
}
还可以在导航之间保留查询参数和片段，而无需再次在导航中提供。在 LoginComponent 中的 router.navigateUrl() 方法中，添加一个对象作为第二个参数，该对象提供了 queryParamsHandling 和 preserveFragment，用于传递当前的查询参数和片段到下一个路由。
You can also preserve query parameters and fragments across navigations without having to provide them again when navigating. In the LoginComponent, you'll add an object as the second argument in the router.navigateUrl() function and provide the queryParamsHandling and preserveFragment to pass along the current query parameters and fragment to the next route.
// Set our navigation extras object
// that passes on our global query params and fragment
let navigationExtras: NavigationExtras = {
queryParamsHandling: 'preserve',
preserveFragment: true
};
// Redirect the user
this.router.navigateByUrl(redirect, navigationExtras);
queryParamsHandling 特性还提供了 merge 选项，它将会在导航时保留当前的查询参数，并与其它查询参数合并。
The queryParamsHandling feature also provides a merge option, which will preserve and combine the current query parameters with any provided query parameters when navigating.
由于要在登录后导航到危机管理特征区的路由，所以你还得修改它，来处理这些全局查询参数和片段。
As you'll be navigating to the Admin Dashboard route after logging in, you'll update it to handle the query parameters and fragment.
import { Component, OnInit } from '@angular/core';
import { ActivatedRoute } from '@angular/router';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';
@Component({
selector: 'app-admin-dashboard',
templateUrl: './admin-dashboard.component.html',
styleUrls: ['./admin-dashboard.component.css']
})
export class AdminDashboardComponent implements OnInit {
sessionId: Observable<string>;
token: Observable<string>;
constructor(private route: ActivatedRoute) {}
ngOnInit() {
// Capture the session ID if available
this.sessionId = this.route
.queryParamMap
.pipe(map(params => params.get('session_id') || 'None'));
// Capture the fragment if available
this.token = this.route
.fragment
.pipe(map(fragment => fragment || 'None'));
}
}
查询参数和片段可通过 Router 服务的 routerState 属性使用。和路由参数类似，全局查询参数和片段也是 Observable 对象。 在修改过的英雄管理组件中，你将借助 AsyncPipe 直接把 Observable 传给模板。
Query parameters and fragments are also available through the ActivatedRoute service. Just like route parameters, the query parameters and fragments are provided as an Observable. The updated Crisis Admin component feeds the Observable directly into the template using the AsyncPipe.
按照下列步骤试验下：点击Crisis Admin按钮，它会带着你提供的 queryParamMap 和 fragment 跳转到登录页。 点击登录按钮，你就会被重定向到 Admin Dashboard 页。 注意，它仍然带着上一步提供的 queryParamMap 和 fragment。
Now, you can click on the Admin button, which takes you to the Login page with the provided queryParamMap and fragment. After you click the login button, notice that you have been redirected to the Admin Dashboard page with the query parameters and fragment still intact in the address bar.
你可以用这些持久化信息来携带需要为每个页面都提供的信息，如认证令牌或会话的 ID 等。
You can use these persistent bits of information for things that need to be provided across pages like authentication tokens or session ids.
“查询参数”和“片段”也可以分别用 RouterLink 中的 queryParamsHandling 和 preserveFragment 保存。
The query params and fragment can also be preserved using a RouterLink with the queryParamsHandling and preserveFragment bindings respectively.
里程碑 6：异步路由
Milestone 6: Asynchronous routing
完成上面的里程碑后，应用程序很自然地长大了。在继续构建特征区的过程中，应用的尺寸将会变得更大。在某一个时间点，你将达到一个顶点，应用将会需要过多的时间来加载。
As you've worked through the milestones, the application has naturally gotten larger. As you continue to build out feature areas, the overall application size will continue to grow. At some point you'll reach a tipping point where the application takes a long time to load.
如何才能解决这个问题呢？通过引进异步路由，可以获得在请求时才惰性加载特性模块的能力。 惰性加载有多个优点：
How do you combat this problem? With asynchronous routing, which loads feature modules lazily, on request. Lazy loading has multiple benefits.
你可以只在用户请求时才加载某些特性区。
You can load feature areas only when requested by the user.
对于那些只访问应用程序某些区域的用户，这样能加快加载速度。
You can speed up load time for users that only visit certain areas of the application.
你可以持续扩充惰性加载特性区的功能，而不用增加初始加载的包体积。
You can continue expanding lazy loaded feature areas without increasing the size of the initial load bundle.
你已经完成了一部分。通过把应用组织成一些模块：AppModule、HeroesModule、AdminModule 和 CrisisCenterModule， 你已经有了可用于实现惰性加载的候选者。
You're already part of the way there. By organizing the application into modules—AppModule, HeroesModule, AdminModule and CrisisCenterModule—you have natural candidates for lazy loading.
有些模块（比如 AppModule）必须在启动时加载，但其它的都可以而且应该惰性加载。 比如 AdminModule 就只有少数已认证的用户才需要它，所以你应该只有在正确的人请求它时才加载。
Some modules, like AppModule, must be loaded from the start. But others can and should be lazy loaded. The AdminModule, for example, is needed by a few authorized users, so you should only load it when requested by the right people.
惰性加载路由配置
Lazy Loading route configuration
把 admin-routing.module.ts 中的 admin 路径从 'admin' 改为空路径 ''。
Change the admin path in the admin-routing.module.ts from 'admin' to an empty string, '', the empty path.
Router 支持空路径路由，可以使用它们来分组路由，而不用往 URL 中添加额外的路径片段。 用户仍旧访问 /admin，并且 AdminComponent 仍然作为用来包含子路由的路由组件。
The Router supports empty path routes; use them to group routes together without adding any additional path segments to the URL. Users will still visit /admin and the AdminComponent still serves as the Routing Component containing child routes.
打开 AppRoutingModule，并把一个新的 admin 路由添加到它的 appRoutes 数组中。
Open the AppRoutingModule and add a new admin route to its appRoutes array.
给它一个 loadChildren 属性（替换掉 children 属性）。 loadChildren 属性接收一个函数，该函数使用浏览器内置的动态导入语法 import('...') 来惰性加载代码，并返回一个承诺（Promise）。 其路径是 AdminModule 的位置（相对于应用的根目录）。 当代码请求并加载完毕后，这个 Promise 就会解析成一个包含 NgModule 的对象，也就是 AdminModule。
Give it a loadChildren property instead of a children property. The loadChildren property takes a function that returns a promise using the browser's built-in syntax for lazy loading code using dynamic imports import('...'). The path is the location of the AdminModule (relative to the app root). After the code is requested and loaded, the Promise resolves an object that contains the NgModule, in this case the AdminModule.
{
path: 'admin',
loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule),
},
注意： 当使用绝对路径时，NgModule 的文件位置必须以 src/app 开头，以便正确解析。对于自定义的 使用绝对路径的路径映射表，项目的 tsconfig.json 中必须配置好 baseUrl 和 paths 属性。
Note: When using absolute paths, the NgModule file location must begin with src/app in order to resolve correctly. For custom path mapping with absolute paths, the baseUrl and paths properties in the project tsconfig.json must be configured.
当路由器导航到这个路由时，它会用 loadChildren 字符串来动态加载 AdminModule，然后把 AdminModule 添加到当前的路由配置中， 最后，它把所请求的路由加载到目标 admin 组件中。
When the router navigates to this route, it uses the loadChildren string to dynamically load the AdminModule. Then it adds the AdminModule routes to its current route configuration. Finally, it loads the requested route to the destination admin component.
惰性加载和重新配置工作只会发生一次，也就是在该路由首次被请求时。在后续的请求中，该模块和路由都是立即可用的。
The lazy loading and re-configuration happen just once, when the route is first requested; the module and routes are available immediately for subsequent requests.
Angular 提供一个内置模块加载器，支持SystemJS来异步加载模块。如果你使用其它捆绑工具比如 Webpack，则使用 Webpack 的机制来异步加载模块。
Angular provides a built-in module loader that supports SystemJS to load modules asynchronously. If you were using another bundling tool, such as Webpack, you would use the Webpack mechanism for asynchronously loading modules.
最后一步是把管理特性区从主应用中完全分离开。 根模块 AppModule 既不能加载也不能引用 AdminModule 及其文件。
Take the final step and detach the admin feature set from the main application. The root AppModule must neither load nor reference the AdminModule or its files.
在 app.module.ts 中，从顶部移除 AdminModule 的导入语句，并且从 NgModule 的 imports 数组中移除 AdminModule。
In app.module.ts, remove the AdminModule import statement from the top of the file and remove the AdminModule from the NgModule's imports array.
CanLoad 守卫：保护对特性模块的未授权加载
CanLoad Guard: guarding unauthorized loading of feature modules
你已经使用 CanActivate 保护 AdminModule 了，它会阻止未授权用户访问管理特性区。如果用户未登录，它就会跳转到登录页。
You're already protecting the AdminModule with a CanActivate guard that prevents unauthorized users from accessing the admin feature area. It redirects to the login page if the user is not authorized.
但是路由器仍然会加载 AdminModule —— 即使用户无法访问它的任何一个组件。 理想的方式是，只有在用户已登录的情况下你才加载 AdminModule。
But the router is still loading the AdminModule even if the user can't visit any of its components. Ideally, you'd only load the AdminModule if the user is logged in.
添加一个CanLoad守卫，它只在用户已登录并且尝试访问管理特性区的时候，才加载 AdminModule 一次。
Add a CanLoadguard that only loads the AdminModule once the user is logged in and attempts to access the admin feature area.
现有的 AuthGuard 的 checkLogin() 方法中已经有了支持 CanLoad 守卫的基础逻辑。
The existing AuthGuard already has the essential logic in its checkLogin() method to support the CanLoad guard.
打开 auth.guard.ts，从 @angular/router 中导入 CanLoad 接口。 把它添加到 AuthGuard 类的 implements 列表中。 然后实现 canLoad，代码如下：
Open auth.guard.ts. Import the CanLoad interface from @angular/router. Add it to the AuthGuard class's implements list. Then implement canLoad() as follows:
canLoad(route: Route): boolean {
let url = `/${route.path}`;
return this.checkLogin(url);
}
路由器会把 canLoad() 方法的 route 参数设置为准备访问的目标 URL。 如果用户已经登录了，checkLogin() 方法就会重定向到那个 URL。
The router sets the canLoad() method's route parameter to the intended destination URL. The checkLogin() method redirects to that URL once the user has logged in.
现在，把 AuthGuard 导入到 AppRoutingModule 中，并把 AuthGuard 添加到 admin 路由的 canLoad 数组中。 完整的 admin 路由是这样的：
Now import the AuthGuard into the AppRoutingModule and add the AuthGuard to the canLoad array property for the admin route. The completed admin route looks like this:
{
path: 'admin',
loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule),
canLoad: [AuthGuard]
},
预加载：特性区的后台加载
Preloading: background loading of feature areas
你已经学会了如何按需加载模块，接下来再看看如何使用预加载技术异步加载模块。
You've learned how to load modules on-demand. You can also load modules asynchronously with preloading.
看起来好像应用一直都是这么做的，但其实并非如此。 AppModule 在应用启动时就被加载了，它是立即加载的。 而 AdminModule 只有当用户点击某个链接时才会加载，它是惰性加载的。
This may seem like what the app has been doing all along. Not quite. The AppModule is loaded when the application starts; that's eager loading. Now the AdminModule loads only when the user clicks on a link; that's lazy loading.
预加载是介于两者之间的一种方式。 来看看危机中心。 用户第一眼不会看到它。 默认情况下，英雄管理才是第一视图。 为了获得尽可能小的初始加载体积和最快的加载速度，你应该对 AppModule 和 HeroesModule 进行急性加载。
Preloading is something in between. Consider the Crisis Center. It isn't the first view that a user sees. By default, the Heroes are the first view. For the smallest initial payload and fastest launch time, you should eagerly load the AppModule and the HeroesModule.
你可以惰性加载危机中心。 但是，你几乎可以肯定用户会在启动应用之后的几分钟内访问危机中心。 理想情况下，应用启动时应该只加载 AppModule 和 HeroesModule，然后几乎立即开始后台加载 CrisisCenterModule。 在用户浏览到危机中心之前，该模块应该已经加载完毕，可供访问了。
You could lazy load the Crisis Center. But you're almost certain that the user will visit the Crisis Center within minutes of launching the app. Ideally, the app would launch with just the AppModule and the HeroesModule loaded and then, almost immediately, load the CrisisCenterModule in the background. By the time the user navigates to the Crisis Center, its module will have been loaded and ready to go.
这就是预加载。
That's preloading.
预加载的工作原理
How preloading works
在每次成功的导航后，路由器会在自己的配置中查找尚未加载并且可以预加载的模块。 是否加载某个模块，以及要加载哪些模块，取决于预加载策略。
After each successful navigation, the router looks in its configuration for an unloaded module that it can preload. Whether it preloads a module, and which modules it preloads, depends upon the preload strategy.
Router 内置了两种预加载策略：
The Router offers two preloading strategies out of the box:
完全不预加载，这是默认值。惰性加载的特性区仍然会按需加载。
No preloading at all which is the default. Lazy loaded feature areas are still loaded on demand.
预加载所有惰性加载的特性区。
Preloading of all lazy loaded feature areas.
默认情况下，路由器或者完全不预加载或者预加载每个惰性加载模块。 路由器还支持自定义预加载策略，以便完全控制要预加载哪些模块以及何时加载。
Out of the box, the router either never preloads, or preloads every lazy load module. The Router also supports custom preloading strategies for fine control over which modules to preload and when.
在下一节，你将会把 CrisisCenterModule 改为默认惰性加载的，并使用 PreloadAllModules 策略来尽快加载它（以及所有其它惰性加载模块）。
In this next section, you'll update the CrisisCenterModule to load lazily by default and use the PreloadAllModules strategy to load it (and all other lazy loaded modules) as soon as possible.
惰性加载危机中心
Lazy load the crisis center
修改路由配置，来惰性加载 CrisisCenterModule。修改的步骤和配置惰性加载 AdminModule 时一样。
Update the route configuration to lazy load the CrisisCenterModule. Take the same steps you used to configure AdminModule for lazy load.
把
CrisisCenterRoutingModule中的路径从crisis-center改为空字符串。Change the
crisis-centerpath in theCrisisCenterRoutingModuleto an empty string.往
AppRoutingModule中添加一个crisis-center路由。Add a
crisis-centerroute to theAppRoutingModule.设置
loadChildren字符串来加载CrisisCenterModule。Set the
loadChildrenstring to load theCrisisCenterModule.从
app.module.ts中移除所有对CrisisCenterModule的引用。Remove all mention of the
CrisisCenterModulefromapp.module.ts.
下面是打开预加载之前的模块修改版：
Here are the updated modules before enabling preload:
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import { Router } from '@angular/router';
import { AppComponent } from './app.component';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
import { ComposeMessageComponent } from './compose-message/compose-message.component';
import { AppRoutingModule } from './app-routing.module';
import { HeroesModule } from './heroes/heroes.module';
import { AuthModule } from './auth/auth.module';
@NgModule({
imports: [
BrowserModule,
BrowserAnimationsModule,
FormsModule,
HeroesModule,
AuthModule,
AppRoutingModule,
],
declarations: [
AppComponent,
ComposeMessageComponent,
PageNotFoundComponent
],
bootstrap: [ AppComponent ]
})
export class AppModule {
}
你可以现在尝试它，并确认在点击了“Crisis Center”按钮之后加载了 CrisisCenterModule。
You could try this now and confirm that the CrisisCenterModule loads after you click the "Crisis Center" button.
要为所有惰性加载模块启用预加载功能，请从 Angular 的路由模块中导入 PreloadAllModules。
To enable preloading of all lazy loaded modules, import the PreloadAllModules token from the Angular router package.
RouterModule.forRoot() 方法的第二个参数接受一个附加配置选项对象。 preloadingStrategy 就是其中之一。 把 PreloadAllModules 添加到 forRoot() 调用中：
The second argument in the RouterModule.forRoot() method takes an object for additional configuration options. The preloadingStrategy is one of those options. Add the PreloadAllModules token to the forRoot() call:
RouterModule.forRoot(
appRoutes,
{
enableTracing: true, // <-- debugging purposes only
preloadingStrategy: PreloadAllModules
}
)
这会让 Router 预加载器立即加载所有惰性加载路由（带 loadChildren 属性的路由）。
This tells the Router preloader to immediately load all lazy loaded routes (routes with a loadChildren property).
当访问 http://localhost:4200 时，/heroes 路由立即随之启动，并且路由器在加载了 HeroesModule 之后立即开始加载 CrisisCenterModule。
When you visit http://localhost:4200, the /heroes route loads immediately upon launch and the router starts loading the CrisisCenterModule right after the HeroesModule loads.
意外的是，AdminModule没有预加载，有什么东西阻塞了它。
Surprisingly, the AdminModule does not preload. Something is blocking it.
CanLoad 会阻塞预加载
CanLoad blocks preload
PreloadAllModules 策略不会加载被CanLoad守卫所保护的特性区。这是刻意设计的。
The PreloadAllModules strategy does not load feature areas protected by a CanLoad guard. This is by design.
你几步之前刚刚给 AdminModule 中的路由添加了 CanLoad 守卫，以阻塞加载那个模块，直到用户认证结束。 CanLoad 守卫的优先级高于预加载策略。
You added a CanLoad guard to the route in the AdminModule a few steps back to block loading of that module until the user is authorized. That CanLoad guard takes precedence over the preload strategy.
如果你要加载一个模块并且保护它防止未授权访问，请移除 canLoad 守卫，只单独依赖CanActivate守卫。
If you want to preload a module and guard against unauthorized access, drop the canLoad() guard method and rely on the canActivate() guard alone.
自定义预加载策略
Custom Preloading Strategy
在大多数场景下，预加载每个惰性加载模块就很好了，但是有时候它却并不是正确的选择，特别是在移动设备和低带宽连接下。 你可能出于用户的测量和其它商业和技术因素而选择只对某些特性模块进行预加载。
Preloading every lazy loaded modules works well in many situations, but it isn't always the right choice, especially on mobile devices and over low bandwidth connections. You may choose to preload only certain feature modules, based on user metrics and other business and technical factors.
使用自定义预加载策略，你可以控制路由器预加载哪些路由以及如何加载。
You can control what and how the router preloads with a custom preloading strategy.
在这一节，你将添加一个自定义策略，它只预加载那些 data.preload 标志为 true 的路由。 回忆一下，你可以往路由的 data 属性中添加任何东西。
In this section, you'll add a custom strategy that only preloads routes whose data.preload flag is set to true. Recall that you can add anything to the data property of a route.
在 AppRoutingModule 的 crisis-center 路由中设置 data.preload 标志。
Set the data.preload flag in the crisis-center route in the AppRoutingModule.
{
path: 'crisis-center',
loadChildren: () => import('./crisis-center/crisis-center.module').then(m => m.CrisisCenterModule),
data: { preload: true }
},
生成一个新的 SelectivePreloadingStrategy 服务。
Generate a new SelectivePreloadingStrategy service.
ng generate service selective-preloading-strategy
import { Injectable } from '@angular/core';
import { PreloadingStrategy, Route } from '@angular/router';
import { Observable, of } from 'rxjs';
@Injectable({
providedIn: 'root',
})
export class SelectivePreloadingStrategyService implements PreloadingStrategy {
preloadedModules: string[] = [];
preload(route: Route, load: () => Observable<any>): Observable<any> {
if (route.data && route.data['preload']) {
// add the route path to the preloaded module array
this.preloadedModules.push(route.path);
// log the route path to the console
console.log('Preloaded: ' + route.path);
return load();
} else {
return of(null);
}
}
}
SelectivePreloadingStrategyService 实现了 PreloadingStrategy，它只有一个方法 preload。
SelectivePreloadingStrategyService implements the PreloadingStrategy, which has one method, preload.
路由器会用两个参数调用调用 preload 方法：
The router calls the preload method with two arguments:
要加载的路由。
The route to consider.
一个加载器（loader）函数，它能异步加载带路由的模块。
A loader function that can load the routed module asynchronously.
preload 的实现必须返回一个 Observable。 如果该路由应该预加载，它就会返回调用加载器函数所返回的 Observable。 如果该路由不应该预加载，它就返回一个 null 值的 Observable 对象。
An implementation of preload must return an Observable. If the route should preload, it returns the observable returned by calling the loader function. If the route should not preload, it returns an Observable of null.
在这个例子中，preload 方法只有在路由的 data.preload 标识为真时才会加载该路由。
In this sample, the preload method loads the route if the route's data.preload flag is truthy.
它还有一个副作用。 SelectivePreloadingStrategyService 会把所选路由的 path 记录在它的公共数组 preloadedModules 中。
It also has a side-effect. SelectivePreloadingStrategyService logs the path of a selected route in its public preloadedModules array.
很快，你就会扩展 AdminDashboardComponent 来注入该服务，并且显示它的 preloadedModules 数组。
Shortly, you'll extend the AdminDashboardComponent to inject this service and display its preloadedModules array.
但是首先，要对 AppRoutingModule 做少量修改。
But first, make a few changes to the AppRoutingModule.
把
SelectivePreloadingStrategyService导入到AppRoutingModule中。Import
SelectivePreloadingStrategyServiceintoAppRoutingModule.把
PreloadAllModules策略替换成对forRoot()的调用，并且传入这个SelectivePreloadingStrategyService。Replace the
PreloadAllModulesstrategy in the call toforRoot()with thisSelectivePreloadingStrategyService.把
SelectivePreloadingStrategyService策略添加到AppRoutingModule的providers数组中，以便它可以注入到应用中的任何地方。Add the
SelectivePreloadingStrategyServicestrategy to theAppRoutingModuleproviders array so it can be injected elsewhere in the app.
现在，编辑 AdminDashboardComponent 以显示这些预加载路由的日志。
Now edit the AdminDashboardComponent to display the log of preloaded routes.
导入
SelectivePreloadingStrategyService（它是一个服务）。Import the
SelectivePreloadingStrategyService.把它注入到仪表盘的构造函数中。
Inject it into the dashboard's constructor.
修改模板来显示这个策略服务的
preloadedModules数组。Update the template to display the strategy service's
preloadedModulesarray.
当完成时，代码如下：
When you're done it looks like this.
import { Component, OnInit } from '@angular/core';
import { ActivatedRoute } from '@angular/router';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';
import { SelectivePreloadingStrategyService } from '../../selective-preloading-strategy.service';
@Component({
selector: 'app-admin-dashboard',
templateUrl: './admin-dashboard.component.html',
styleUrls: ['./admin-dashboard.component.css']
})
export class AdminDashboardComponent implements OnInit {
sessionId: Observable<string>;
token: Observable<string>;
modules: string[];
constructor(
private route: ActivatedRoute,
preloadStrategy: SelectivePreloadingStrategyService
) {
this.modules = preloadStrategy.preloadedModules;
}
ngOnInit() {
// Capture the session ID if available
this.sessionId = this.route
.queryParamMap
.pipe(map(params => params.get('session_id') || 'None'));
// Capture the fragment if available
this.token = this.route
.fragment
.pipe(map(fragment => fragment || 'None'));
}
}
一旦应用加载完了初始路由，CrisisCenterModule 也被预加载了。 通过 Admin 特性区中的记录就可以验证它，“Preloaded Modules”中列出了 crisis-center。 它也被记录到了浏览器的控制台。
Once the application loads the initial route, the CrisisCenterModule is preloaded. Verify this by logging in to the Admin feature area and noting that the crisis-center is listed in the Preloaded Modules. It's also logged to the browser's console.
使用重定向迁移 URL
Migrating URLs with Redirects
你已经设置好了路由，并且用命令式和声明式的方式导航到了很多不同的路由。但是，任何应用的需求都会随着时间而改变。 你把链接 /heroes 和 hero/:id 指向了 HeroListComponent 和 HeroDetailComponent 组件。 如果有这样一个需求，要把链接 heroes 变成 superheroes，你仍然希望以前的 URL 能正常导航。 但你也不想在应用中找到并修改每一个链接，这时候，重定向就可以省去这些琐碎的重构工作。
You've setup the routes for navigating around your application. You've used navigation imperatively and declaratively to many different routes. But like any application, requirements change over time. You've setup links and navigation to /heroes and /hero/:id from the HeroListComponent and HeroDetailComponent components. If there was a requirement that links to heroes become superheroes, you still want the previous URLs to navigate correctly. You also don't want to go and update every link in your application, so redirects makes refactoring routes trivial.
把 /heroes 修改为 /superheros
Changing /heroes to /superheroes
先取得 Hero 路由，并把它们迁移到新的 URL。Router（路由器）会在开始导航之前先在配置中检查所有重定向语句，以便将来按需触发重定向。要支持这种修改，你就要在 heroes-routing.module 文件中把老的路由重定向到新的路由。
Let's take the Hero routes and migrate them to new URLs. The Router checks for redirects in your configuration before navigating, so each redirect is triggered when needed. To support this change, you'll add redirects from the old routes to the new routes in the heroes-routing.module.
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { HeroListComponent } from './hero-list/hero-list.component';
import { HeroDetailComponent } from './hero-detail/hero-detail.component';
const heroesRoutes: Routes = [
{ path: 'heroes', redirectTo: '/superheroes' },
{ path: 'hero/:id', redirectTo: '/superhero/:id' },
{ path: 'superheroes', component: HeroListComponent, data: { animation: 'heroes' } },
{ path: 'superhero/:id', component: HeroDetailComponent, data: { animation: 'hero' } }
];
@NgModule({
imports: [
RouterModule.forChild(heroesRoutes)
],
exports: [
RouterModule
]
})
export class HeroesRoutingModule { }
注意，这里有两种类型的重定向。第一种是不带参数的从 /heroes 重定向到 /superheroes。这是一种非常直观的重定向。第二种是从 /hero/:id 重定向到 /superhero/:id，它还要包含一个 :id 路由参数。 路由器重定向时使用强大的模式匹配功能，这样，路由器就会检查 URL，并且把 path 中带的路由参数替换成相应的目标形式。以前，你导航到形如 /hero/15 的 URL 时，带了一个路由参数 id，它的值是 15。
You'll notice two different types of redirects. The first change is from /heroes to /superheroes without any parameters. This is a straightforward redirect, unlike the change from /hero/:id to /superhero/:id, which includes the :id route parameter. Router redirects also use powerful pattern matching, so the Router inspects the URL and replaces route parameters in the path with their appropriate destination. Previously, you navigated to a URL such as /hero/15 with a route parameter id of 15.
在重定向的时候，路由器还支持查询参数和片段(fragment)。
The Router also supports query parameters and the fragment when using redirects.
当使用绝对地址重定向时，路由器将会使用路由配置的
redirectTo属性中规定的查询参数和片段。When using absolute redirects, the
Routerwill use the query parameters and the fragment from the redirectTo in the route config.当使用相对地址重定向时，路由器将会使用源地址（跳转前的地址）中的查询参数和片段。
When using relative redirects, the
Routeruse the query params and the fragment from the source URL.
在修改 app-routing.module.ts 之前，你要先考虑一条重要的规则。 目前，你把空路径路由重定向到了 /heroes，它又被重定向到了 /superheroes。这样不行，从设计上就不行。 因为路由器在每一层的路由配置中只会处理一次重定向。这样可以防止出现无限循环的重定向。
Before updating the app-routing.module.ts, you'll need to consider an important rule. Currently, our empty path route redirects to /heroes, which redirects to /superheroes. This won't work and is by design as the Router handles redirects once at each level of routing configuration. This prevents chaining of redirects, which can lead to endless redirect loops.
所以，你要在 app-routing.module.ts 中修改空路径路由，让它重定向到 /superheroes。
So instead, you'll update the empty path route in app-routing.module.ts to redirect to /superheroes.
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { ComposeMessageComponent } from './compose-message/compose-message.component';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
import { AuthGuard } from './auth/auth.guard';
import { SelectivePreloadingStrategyService } from './selective-preloading-strategy.service';
const appRoutes: Routes = [
{
path: 'compose',
component: ComposeMessageComponent,
outlet: 'popup'
},
{
path: 'admin',
loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule),
canLoad: [AuthGuard]
},
{
path: 'crisis-center',
loadChildren: () => import('./crisis-center/crisis-center.module').then(m => m.CrisisCenterModule),
data: { preload: true }
},
{ path: '', redirectTo: '/superheroes', pathMatch: 'full' },
{ path: '**', component: PageNotFoundComponent }
];
@NgModule({
imports: [
RouterModule.forRoot(
appRoutes,
{
enableTracing: false, // <-- debugging purposes only
preloadingStrategy: SelectivePreloadingStrategyService,
}
)
],
exports: [
RouterModule
]
})
export class AppRoutingModule { }
由于 RouterLink 指令没有关联到路由配置，所以你需要修改相关的路由链接，以便在新的路由激活时，它们也能保持激活状态。你要修改 app.component.ts 模板中的 /heroes 路由链接。
RouterLinks aren't tied to route configuration, so you'll need to update the associated router links so they remain active when the new route is active. You'll update the app.component.ts template for the /heroes routerLink.
<h1 class="title">Angular Router</h1>
<nav>
<a routerLink="/crisis-center" routerLinkActive="active">Crisis Center</a>
<a routerLink="/superheroes" routerLinkActive="active">Heroes</a>
<a routerLink="/admin" routerLinkActive="active">Admin</a>
<a routerLink="/login" routerLinkActive="active">Login</a>
<a [routerLink]="[{ outlets: { popup: ['compose'] } }]">Contact</a>
</nav>
<div [@routeAnimation]="getAnimationData(routerOutlet)">
<router-outlet #routerOutlet="outlet"></router-outlet>
</div>
<router-outlet name="popup"></router-outlet>
修改 hero-detail.component.ts 中的 goToHeroes() 方法，使用可选的路由参数导航回 /superheroes。
Update the goToHeroes() method in the hero-detail.component.ts to navigate back to /superheroes with the optional route parameters.
gotoHeroes(hero: Hero) {
let heroId = hero ? hero.id : null;
// Pass along the hero id if available
// so that the HeroList component can select that hero.
// Include a junk 'foo' property for fun.
this.router.navigate(['/superheroes', { id: heroId, foo: 'foo' }]);
}
当这些重定向设置好之后，所有以前的路由都指向了它们的新目标，并且每个 URL 也仍然能正常工作。
With the redirects setup, all previous routes now point to their new destinations and both URLs still function as intended.
审查路由器配置
Inspect the router's configuration
你把大量的精力投入到在一系列路由模块文件里配置路由器上，并且小心的以合适的顺序列出它们。 这些路由是否真的如同你预想的那样执行了？ 路由器的真实配置是怎样的？
You put a lot of effort into configuring the router in several routing module files and were careful to list them in the proper order. Are routes actually evaluated as you planned? How is the router really configured?
通过注入它（Router）并检查它的 config 属性，你可以随时审查路由器的当前配置。 例如，把 AppModule 修改为这样，并在浏览器的控制台窗口中查看最终的路由配置。
You can inspect the router's current configuration any time by injecting it and examining its config property. For example, update the AppModule as follows and look in the browser console window to see the finished route configuration.
export class AppModule {
// Diagnostic only: inspect router configuration
constructor(router: Router) {
// Use a custom replacer to display function names in the route configs
const replacer = (key, value) => (typeof value === 'function') ? value.name : value;
console.log('Routes: ', JSON.stringify(router.config, replacer, 2));
}
}
总结与最终的应用
Wrap up and final app
本章中涉及到了很多背景知识，而且本应用程序也太大了，所以没法在这里显示。请访问
You've covered a lot of ground in this guide and the application is too big to reprint here. Please visit the
附录
Appendices
本章剩下的部分是一组附录，它详尽阐述了那些曾匆匆带过的知识点。
The balance of this guide is a set of appendices that elaborate some of the points you covered quickly above.
该附件中的内容不是必须的，感兴趣的人才需要阅读它。
The appendix material isn't essential. Continued reading is for the curious.
附录：链接参数数组
Appendix: link parameters array
链接参数数组保存路由导航时所需的成分：
A link parameters array holds the following ingredients for router navigation:
指向目标组件的那个路由的路径（path）
The path of the route to the destination component.
必备路由参数和可选路由参数，它们将进入该路由的 URL
Required and optional route parameters that go into the route URL.
你可以把 RouterLink 指令绑定到一个数组，就像这样：
You can bind the RouterLink directive to such an array like this:
<a [routerLink]="['/heroes']">Heroes</a>
在指定路由参数时，你写过一个双元素的数组，就像这样：
You've written a two element array when specifying a route parameter like this:
<a [routerLink]="['/hero', hero.id]">
<span class="badge">{{ hero.id }}</span>{{ hero.name }}
</a>
你可以在对象中提供可选的路由参数，就像这样：
You can provide optional route parameters in an object like this:
<a [routerLink]="['/crisis-center', { foo: 'foo' }]">Crisis Center</a>
这三个例子涵盖了你在单级路由的应用中所需的一切。在你添加一个像危机中心一样的子路由时，你可以创建新链接数组。
These three examples cover the need for an app with one level routing. The moment you add a child router, such as the crisis center, you create new link array possibilities.
回忆一下，你曾为危机中心指定过一个默认的子路由，以便能使用这种简单的 RouterLink。
Recall that you specified a default child route for the crisis center so this simple RouterLink is fine.
<a [routerLink]="['/crisis-center']">Crisis Center</a>
分解一下。
Parse it out.
数组中的第一个条目标记出了父路由(
/crisis-center)。The first item in the array identifies the parent route (
/crisis-center).这个父路由没有参数，因此这步已经完成了。
There are no parameters for this parent route so you're done with it.
没有默认的子路由，因此你得选取一个。
There is no default for the child route so you need to pick one.
你决定跳转到
CrisisListComponent，它的路由路径是'/'，但你不用显式的添加它。You're navigating to the
CrisisListComponent, whose route path is/, but you don't need to explicitly add the slash.哇！
['/crisis-center']。Voilà!
['/crisis-center'].
更进一步。这次要构建一个从根组件往下导航到“巨龙危机”时的链接参数数组：
Take it a step further. Consider the following router link that navigates from the root of the application down to the Dragon Crisis:
<a [routerLink]="['/crisis-center', 1]">Dragon Crisis</a>
数组中的第一个条目标记出了父路由(
/crisis-center)。The first item in the array identifies the parent route (
/crisis-center).这个父路由没有参数，因此这步已经完成了。
There are no parameters for this parent route so you're done with it.
数组中的第二个条目（'/:id'）用来标记出到指定危机的详情页的子路由。
The second item identifies the child route details about a particular crisis (
/:id).详细的子路由需要一个
id路由参数。The details child route requires an
idroute parameter.你把巨龙危机的
id添加为该数组中的第二个条目（1）。You added the
idof the Dragon Crisis as the second item in the array (1).最终生成的路径是
/crisis-center/1。The resulting path is
/crisis-center/1.
只要想，你也可以用危机中心路由单独重定义 AppComponent 的模板：
If you wanted to, you could redefine the AppComponent template with Crisis Center routes exclusively:
template: `
<h1 class="title">Angular Router</h1>
<nav>
<a [routerLink]="['/crisis-center']">Crisis Center</a>
<a [routerLink]="['/crisis-center/1', { foo: 'foo' }]">Dragon Crisis</a>
<a [routerLink]="['/crisis-center/2']">Shark Crisis</a>
</nav>
<router-outlet></router-outlet>
`
总结：你可以用一级、两级或多级路由来写应用程序。 链接参数数组提供了用来表示任意深度路由的链接参数数组以及任意合法的路由参数序列、必须的路由器参数以及可选的路由参数对象。
In sum, you can write applications with one, two or more levels of routing. The link parameters array affords the flexibility to represent any routing depth and any legal sequence of route paths, (required) router parameters, and (optional) route parameter objects.
附录：LocationStrategy 以及浏览器 URL 样式
Appendix: LocationStrategy and browser URL styles
当路由器导航到一个新的组件视图时，它会用该视图的 URL 来更新浏览器的当前地址以及历史。 严格来说，这个 URL 其实是本地的，浏览器不会把该 URL 发给服务器，并且不会重新加载此页面。
When the router navigates to a new component view, it updates the browser's location and history with a URL for that view. This is a strictly local URL. The browser shouldn't send this URL to the server and should not reload the page.
现代 HTML 5 浏览器支持history.pushState API， 这是一项可以改变浏览器的当前地址和历史，却又不会触发服务端页面请求的技术。 路由器可以合成出一个“自然的”URL，它看起来和那些需要进行页面加载的 URL 没什么区别。
Modern HTML5 browsers support history.pushState, a technique that changes a browser's location and history without triggering a server page request. The router can compose a "natural" URL that is indistinguishable from one that would otherwise require a page load.
下面是危机中心的 URL 在“HTML 5 pushState”风格下的样子：
Here's the Crisis Center URL in this "HTML5 pushState" style:
localhost:3002/crisis-center/
老旧的浏览器在当前地址的 URL 变化时总会往服务器发送页面请求……唯一的例外规则是：当这些变化位于“#”（被称为“hash”）后面时不会发送。通过把应用内的路由 URL 拼接在 # 之后，路由器可以获得这条“例外规则”带来的优点。下面是到危机中心路由的“hash URL”：
Older browsers send page requests to the server when the location URL changes unless the change occurs after a "#" (called the "hash"). Routers can take advantage of this exception by composing in-application route URLs with hashes. Here's a "hash URL" that routes to the Crisis Center.
localhost:3002/src/#/crisis-center/
路由器通过两种 LocationStrategy 提供者来支持所有这些风格：
The router supports both styles with two LocationStrategy providers:
PathLocationStrategy- 默认的策略，支持“HTML 5 pushState”风格。PathLocationStrategy—the default "HTML5 pushState" style.HashLocationStrategy- 支持“hash URL”风格。HashLocationStrategy—the "hash URL" style.
RouterModule.forRoot() 函数把 LocationStrategy 设置成了 PathLocationStrategy，使其成为了默认策略。 你可以在启动过程中改写（override）它，来切换到 HashLocationStrategy 风格 —— 如果你更喜欢这种。
The RouterModule.forRoot() function sets the LocationStrategy to the PathLocationStrategy, making it the default strategy. You can switch to the HashLocationStrategy with an override during the bootstrapping process if you prefer it.
要学习关于“提供者”和启动过程的更多知识，参见依赖注入一章。
Learn about providers and the bootstrap process in the Dependency Injection guide.
哪种策略更好？
Which strategy is best?
你必须选择一种策略，并且在项目的早期就这么干。一旦该应用进入了生产阶段，要改起来可就不容易了，因为外面已经有了大量对应用 URL 的引用。
You must choose a strategy and you need to make the right call early in the project. It won't be easy to change later once the application is in production and there are lots of application URL references in the wild.
几乎所有的 Angular 项目都会使用默认的 HTML 5 风格。它生成的 URL 更易于被用户理解，它也为将来做服务端渲染预留了空间。
Almost all Angular projects should use the default HTML5 style. It produces URLs that are easier for users to understand. And it preserves the option to do server-side rendering later.
在服务器端渲染指定的页面，是一项可以在该应用首次加载时大幅提升响应速度的技术。那些原本需要十秒甚至更长时间加载的应用，可以预先在服务端渲染好，并在少于一秒的时间内完整呈现在用户的设备上。
Rendering critical pages on the server is a technique that can greatly improve perceived responsiveness when the app first loads. An app that would otherwise take ten or more seconds to start could be rendered on the server and delivered to the user's device in less than a second.
只有当应用的 URL 看起来像是标准的 Web URL，中间没有 hash（#）时，这个选项才能生效。
This option is only available if application URLs look like normal web URLs without hashes (#) in the middle.
除非你有强烈的理由不得不使用 hash 路由，否则就应该坚决使用默认的 HTML 5 路由风格。
Stick with the default unless you have a compelling reason to resort to hash routes.
<base href> 标签
The <base href>
路由器使用浏览器的 history.pushState API 进行导航。借助 pushState 你可以让应用中的 URL 路径看上去就像你期望的那样，比如 localhost:4200/crisis-center，应用内的 URL 和服务器的 URL 没有区别。
The router uses the browser's history.pushState for navigation. Thanks to pushState, you can make in-app URL paths look the way you want them to look, e.g. localhost:4200/crisis-center. The in-app URLs can be indistinguishable from server URLs.
现代的 HTML5 浏览器都支持 pushState，这也就是为什么很多人把这种 URL 形式称为 "HTML 5" 风格的 URL。
Modern HTML5 browsers were the first to support pushState which is why many people refer to these URLs as "HTML5 style" URLs.
路由器默认使用 HTML5 风格的导航。 在附录中的 LocationStrategy 与浏览器 URL 风格中，你可以了解为何推荐使用 HTML5 风格的 URL，如何调整其行为，以及必要时如何切换到老式的 hash（#）风格。
HTML5 style navigation is the router default. In the LocationStrategy and browser URL styles Appendix, learn why HTML5 style is preferred, how to adjust its behavior, and how to switch to the older hash (#) style, if necessary.
你必须在应用的 index.html 中添加一个 <base href> 元素才能让 pushState 路由正常工作。 浏览器要用 <base href> 的值为引用 CSS、脚本和图片文件时使用的相对 URL 添加前缀。
You must add a <base href> element to the app's index.html for pushState routing to work. The browser uses the <base href> value to prefix relative URLs when referencing CSS files, scripts, and images.
请把 <base> 元素添加在 <head> 标签的紧后面。如果应用的根目录是 app 目录，那么就可以像这个应用程序一样，设置 index.html中的 href 值。代码如下。
Add the <base> element just after the <head> tag. If the app folder is the application root, as it is for this application, set the href value in index.htmlexactly as shown here.
<base href="/">
HTML 5 URL 与<base href>
HTML5 URLs and the <base href>
由于路由器默认使用“HTML 5 pushState”风格，所以你必须用一个base href来配置该策略（Strategy）。
While the router uses the HTML5 pushState style by default, you must configure that strategy with a base href.
配置该策略的首选方式是往 index.html 的 <head> 中添加一个<base href> element标签。
The preferred way to configure the strategy is to add a <base href> element tag in the <head> of the index.html.
<base href="/">
如果没有此标签，当通过“深链接”进入该应用时，浏览器就不能加载资源（图片、CSS、脚本）。如果有人把应用的链接粘贴进浏览器的地址栏或从邮件中点击应用的链接时，这种问题就发生。
Without that tag, the browser may not be able to load resources (images, CSS, scripts) when "deep linking" into the app. Bad things could happen when someone pastes an application link into the browser's address bar or clicks such a link in an email.
有些开发人员可能无法添加 <base> 元素，这可能是因为它们没有访问 <head> 或 index.html 的权限。
Some developers may not be able to add the <base> element, perhaps because they don't have access to <head> or the index.html.
它们仍然可以使用 HTML 5 格式的 URL，但要采取两个步骤进行补救：
Those developers may still use HTML5 URLs by taking two remedial steps:
用适当的[APP_BASE_HREF][]值提供（provide）路由器。
Provide the router with an appropriate [APP_BASE_HREF][] value.
对所有 Web 资源使用绝对地址：CSS、图片、脚本、模板 HTML。
Use root URLs for all web resources: CSS, images, scripts, and template HTML files.
HashLocationStrategy 策略
HashLocationStrategy
你可以在根模块的 RouterModule.forRoot() 的第二个参数中传入一个带有 useHash: true 的对象，以回到基于 HashLocationStrategy 的传统方式。
You can go old-school with the HashLocationStrategy by providing the useHash: true in an object as the second argument of the RouterModule.forRoot() in the AppModule.
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule } from '@angular/forms';
import { Routes, RouterModule } from '@angular/router';
import { AppComponent } from './app.component';
import { PageNotFoundComponent } from './page-not-found/page-not-found.component';
const routes: Routes = [
];
@NgModule({
imports: [
BrowserModule,
FormsModule,
RouterModule.forRoot(routes, { useHash: true }) // .../#/crisis-center/
],
declarations: [
AppComponent,
PageNotFoundComponent
],
providers: [
],
bootstrap: [ AppComponent ]
})
export class AppModule { }
