From d3ed81064b35cdc94603e86ad7c60a54e7fb9307 Mon Sep 17 00:00:00 2001
From: Zhicheng Wang <zcwang@thoughtworks.com>
Date: Tue, 15 May 2018 23:10:30 +0800
Subject: [PATCH] chore: extract dict

---
 aio/tools/translator/dict-latest.json | 3548 +++++++++++++++----------
 1 file changed, 2119 insertions(+), 1429 deletions(-)

diff --git a/aio/tools/translator/dict-latest.json b/aio/tools/translator/dict-latest.json
index 3f506df9bb..104980d623 100644
--- a/aio/tools/translator/dict-latest.json
+++ b/aio/tools/translator/dict-latest.json
@@ -42,9 +42,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/_fragments/glossary-t2.md"
   },
   {
-    "key": "#ANGULARJSTOANGULARQUICKREFERENCE",
-    "original": "# AngularJS to Angular Quick Reference",
-    "translation": "# 从 AngularJS 到 Angular 快速参考",
+    "key": "#ANGULARJSTOANGULARCONCEPTS:QUICKREFERENCE",
+    "original": "# AngularJS to Angular Concepts: Quick Reference",
+    "translation": "# 关于AngularJS 与 Angular 概念的快速参考",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ajs-quick-reference.md"
   },
   {
@@ -990,9 +990,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ajs-quick-reference.md"
   },
   {
-    "key": "WITHTHEANGULARCLIYOUCANCONFIGUREYOURGLOBALSTYLESINTHEANGULARCLIJSONFILEYOUCANRENAMETHEEXTENSIONTOSCSSTOUSESASS",
-    "original": "With the Angular CLI, you can configure your global styles in the `.angular-cli.json` file.\n      You can rename the extension to `.scss` to use sass.",
-    "translation": "使用 Angular CLI，你可以在 `.angular-cli.json` 文件中配置全局样式。\n      也可以把扩展名改为 `.scss` 来使用 sass。",
+    "key": "WITHTHEANGULARCLIYOUCANCONFIGUREYOURGLOBALSTYLESINTHEANGULARJSONFILEYOUCANRENAMETHEEXTENSIONTOSCSSTOUSESASS",
+    "original": "With the Angular CLI, you can configure your global styles in the `angular.json` file.\n      You can rename the extension to `.scss` to use sass.",
+    "translation": "使用 Angular CLI，你可以在 `angular.json` 文件中配置全局样式。\n      也可以把扩展名改为 `.scss` 来使用 sass。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ajs-quick-reference.md"
   },
   {
@@ -1728,8 +1728,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "METADATAJSONFILESCONTAININFOMRATIONNEEDEDBYTHETEMPLATECOMPILERFROMATSFILETHATISNOTINCLUDEDINTHEDTSFILEPRODUCEDBYTHETYPESCRIPTCOMPILERTHISINFORMATIONCONTAINSFOREXAMPLETHECONTENTOFANNOTATIONSSUCHASACOMPONENTSTEMPLATEWHICHTYPESCRIPTEMITSTOTHEJSFILEBUTNOTTOTHEDTSFILE",
-    "original": "`.metadata.json` files contain infomration needed by the template compiler from a `.ts`\nfile that is not included in the `.d.ts` file produced by the TypeScript compiler. This information contains,\nfor example, the content of annotations (such as a component's template) which TypeScript\nemits to the `.js` file but not to the `.d.ts` file.",
+    "key": "METADATAJSONFILESCONTAININFORMATIONNEEDEDBYTHETEMPLATECOMPILERFROMATSFILETHATISNOTINCLUDEDINTHEDTSFILEPRODUCEDBYTHETYPESCRIPTCOMPILERTHISINFORMATIONCONTAINSFOREXAMPLETHECONTENTOFANNOTATIONSSUCHASACOMPONENTSTEMPLATEWHICHTYPESCRIPTEMITSTOTHEJSFILEBUTNOTTOTHEDTSFILE",
+    "original": "`.metadata.json` files contain information needed by the template compiler from a `.ts`\nfile that is not included in the `.d.ts` file produced by the TypeScript compiler. This information contains,\nfor example, the content of annotations (such as a component's template) which TypeScript\nemits to the `.js` file but not to the `.d.ts` file.",
     "translation": "`.metadata.json` 文件中包含模板编译器所需的信息，这些信息来自于 `.ts` 文件中，但是没有包含在由 TypeScript 编译器生成的 `.d.ts` 文件中。\n比如，这个信息包括 TypeScript 发出的注解内容（如组件的模板），TypeScript 把它生成到了 `.js` 文件中，但是没有生成到 `.d.ts` 文件中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
@@ -1747,8 +1747,8 @@
   },
   {
     "key": "THISOPTIONTELLSTHETEMPLATECOMPILERTOREPORTANERRORTOTHEMETADATAJSONFILEIFSKIPMETADATAEMITISFALSETHISOPTIONISFALSEBYDEFAULTTHISSHOULDONLYBEUSEDWHENSKIPMETADATAEMITISFALSEANDSKIPTEMPLATECODEGENISTRUE",
-    "original": "This option tells the template compiler to report an error to the `.metadata.json`\nfile if `\"skipMetadataEmit\"` is `false` . This option is `false` by default. This should only be used when `\"skipMetadataEmit\"` is `false` and `\"skipTemplateCodeGen\"` is `true`.",
-    "translation": "这个选项告诉模板编译器如果 `\"skipMetadataEmit\"` 为 `false`，那就把错误信息汇报到 `.metadata.json` 中。\n只有当 `\"skipMetadataEmit\"` 为 `false` 且 `\"skipTemplateCodeGen\"` 为 `true` 时才应该使用这个选项。",
+    "original": "This option tells the template compiler to report an error to the `.metadata.json`\nfile if `\"skipMetadataEmit\"` is `false` . This option is `false` by default. This should only be used when `\"skipMetadataEmit\"` is `false` and `\"skipTemplateCodegen\"` is `true`.",
+    "translation": "这个选项告诉模板编译器如果 `\"skipMetadataEmit\"` 为 `false`，那就把错误信息汇报到 `.metadata.json` 中。\n只有当 `\"skipMetadataEmit\"` 为 `false` 且 `\"skipTemplateCodegen\"` 为 `true` 时才应该使用这个选项。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
@@ -1812,9 +1812,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "THISOPTIONTELLSTHECOMPILERTOENABLETHEBINDINGEXPRESSIONVALIDATION#BINDINGEXPRESIONVALIDATIONPHASEOFTHETEMPLATECOMPILERWHICHUSESTYPESCRIPTTOVALIDATEBINDINGEXPRESSIONS",
-    "original": "This option tells the compiler to enable the [binding expression validation](#binding-expresion-validation)\nphase of the template compiler which uses TypeScript to validate binding expressions.",
-    "translation": "该选项告诉编译器要为模板编译器启用[绑定表达式验证](#binding-expresion-validation)阶段，它会使用 TypeScript 来验证绑定表达式。",
+    "key": "THISOPTIONTELLSTHECOMPILERTOENABLETHEBINDINGEXPRESSIONVALIDATION#BINDINGEXPRESSIONVALIDATIONPHASEOFTHETEMPLATECOMPILERWHICHUSESTYPESCRIPTTOVALIDATEBINDINGEXPRESSIONS",
+    "original": "This option tells the compiler to enable the [binding expression validation](#binding-expression-validation)\nphase of the template compiler which uses TypeScript to validate binding expressions.",
+    "translation": "该选项告诉编译器要为模板编译器启用[绑定表达式验证](#binding-expression-validation)阶段，它会使用 TypeScript 来验证绑定表达式。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
@@ -2088,8 +2088,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "BEGINNINGINVERSION5THECOMPILERAUTOMATICALLYPERFORMSTHISREWRITTINGWHILEEMITTINGTHEJSFILE",
-    "original": "Beginning in version 5, the compiler automatically performs this rewritting while emitting the `.js` file.",
+    "key": "BEGINNINGINVERSION5THECOMPILERAUTOMATICALLYPERFORMSTHISREWRITINGWHILEEMITTINGTHEJSFILE",
+    "original": "Beginning in version 5, the compiler automatically performs this rewriting while emitting the `.js` file.",
     "translation": "从 Angular v5 开始，编译器会在生成 `.js` 文件时自动执行这种改写。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
@@ -2400,8 +2400,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "THECOMPILERENCOUNTEREDANEXPRESSIONITDIDNTUNDERSTANDWHILEEVALUTATINGANGULARMETADATA",
-    "original": "The compiler encountered an expression it didn't understand while evalutating Angular metadata.",
+    "key": "THECOMPILERENCOUNTEREDANEXPRESSIONITDIDNTUNDERSTANDWHILEEVALUATINGANGULARMETADATA",
+    "original": "The compiler encountered an expression it didn't understand while evaluating Angular metadata.",
     "translation": "编译器在对 Angular 元数据求值时遇到了一个它不能理解的表达式。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
@@ -2628,8 +2628,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "THISCANHAPPENIFYOUREFERTOANAMBIENTTYPEFOREXAMPLETHEWINDOWTYPEISANAMBIANTTYPEDECLAREDINTHEGLOBALDTSFILE",
-    "original": "This can happen if you refer to an ambient type.\nFor example, the `Window` type is an ambiant type declared in the global `.d.ts` file.",
+    "key": "THISCANHAPPENIFYOUREFERTOANAMBIENTTYPEFOREXAMPLETHEWINDOWTYPEISANAMBIENTTYPEDECLAREDINTHEGLOBALDTSFILE",
+    "original": "This can happen if you refer to an ambient type.\nFor example, the `Window` type is an ambient type declared in the global `.d.ts` file.",
     "translation": "这通常会发生在你引用环境类型时。\n比如，`Window` 类型就是在全局 `.d.ts` 文件中声明的环境类型。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
@@ -2640,8 +2640,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "TYPESCRIPTUNDERSTANDSAMBIANTTYPESSOYOUDONTIMPORTTHEMTHEANGULARCOMPILERDOESNOTUNDERSTANDATYPETHATYOUNEGLECTTOEXPORTORIMPORT",
-    "original": "TypeScript understands ambiant types so you don't import them.\nThe Angular compiler does not understand a type that you neglect to export or import.",
+    "key": "TYPESCRIPTUNDERSTANDSAMBIENTTYPESSOYOUDONTIMPORTTHEMTHEANGULARCOMPILERDOESNOTUNDERSTANDATYPETHATYOUNEGLECTTOEXPORTORIMPORT",
+    "original": "TypeScript understands ambient types so you don't import them.\nThe Angular compiler does not understand a type that you neglect to export or import.",
     "translation": "TypeScript 能理解这些环境类型，所以你不用导入它们。\n但 Angular 编译器不理解你没有导入或导出过的类型。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
@@ -2658,14 +2658,14 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "IFYOUMUSTINJECTANINSTANCEOFANAMBIANTTYPEYOUCANFINESSETHEPROBLEMINFOURSTEPS:",
-    "original": "If you must inject an instance of an ambiant type,\nyou can finesse the problem in four steps:",
+    "key": "IFYOUMUSTINJECTANINSTANCEOFANAMBIENTTYPEYOUCANFINESSETHEPROBLEMINFOURSTEPS:",
+    "original": "If you must inject an instance of an ambient type,\nyou can finesse the problem in four steps:",
     "translation": "如果你必须注入某个环境类型的实例，可以用以下四步来巧妙解决这个问题：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "1CREATEANINJECTIONTOKENFORANINSTANCEOFTHEAMBIANTTYPE",
-    "original": "1. Create an injection token for an instance of the ambiant type.",
+    "key": "1CREATEANINJECTIONTOKENFORANINSTANCEOFTHEAMBIENTTYPE",
+    "original": "1. Create an injection token for an instance of the ambient type.",
     "translation": "为环境类型的实例创建一个注入令牌。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
@@ -2796,8 +2796,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "INTHEVALIDATIONPHASETHEANGULARTEMPLATECOMPILERUSESTHETYPESCRIPTCOMPILERTOVALIDATETHEBINDINGEXPRESSIONSINTEMPLATESENABLETHISPHASEEXPLICITYBYADDINGTHECOMPILEROPTIONFULLTEMPLATETYPECHECKINTHEANGULARCOMPILEROPTIONSOFTHEPROJECTSTSCONFIGJSONSEEANGULARCOMPILEROPTIONS#COMPILEROPTIONS",
-    "original": "In the validation phase, the Angular template compiler uses the TypeScript compiler to validate the\n  binding expressions in templates. Enable this phase explicity by adding the compiler\n  option `\"fullTemplateTypeCheck\"` in the `\"angularCompilerOptions\"` of the project's `tsconfig.json` (see\n  [Angular Compiler Options](#compiler-options)).",
+    "key": "INTHEVALIDATIONPHASETHEANGULARTEMPLATECOMPILERUSESTHETYPESCRIPTCOMPILERTOVALIDATETHEBINDINGEXPRESSIONSINTEMPLATESENABLETHISPHASEEXPLICITLYBYADDINGTHECOMPILEROPTIONFULLTEMPLATETYPECHECKINTHEANGULARCOMPILEROPTIONSOFTHEPROJECTSTSCONFIGJSONSEEANGULARCOMPILEROPTIONS#COMPILEROPTIONS",
+    "original": "In the validation phase, the Angular template compiler uses the TypeScript compiler to validate the\n  binding expressions in templates. Enable this phase explicitly by adding the compiler\n  option `\"fullTemplateTypeCheck\"` in the `\"angularCompilerOptions\"` of the project's `tsconfig.json` (see\n  [Angular Compiler Options](#compiler-options)).",
     "translation": "在验证阶段，Angular 的模板编译器会使用 TypeScript 编译器来验证模板中的绑定表达式。\n  通过在项目的 `tsconfig.json`（参见 [Angular Compiler Options](#compiler-options)）的 `\"angularCompilerOptions\"` 中添加编译选项 `\"fullTemplateTypeCheck\"` 可以启用这个阶段。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
@@ -2820,8 +2820,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
   {
-    "key": "THEFILENAMEREPORTEDINTHEERRORMESSAGEMYCOMPONENTTSMYCOMPONENTHTMLISASYNTHETICFILEGENERATEDBYTHETEMPLATECOMPILERTHATHOLDSCONTENTSOFTHEMYCOMPONENTCLASSTEMPLATECOMPILERNEVERWRITESTHISFILETODISKTHELINEANDCOLUMNNUMBERSARERELATIVETOTHETEMPLATESTRINGINTHECOMPONENTANNOTATIONOFTHECLASSMYCOMPONENTINTHISCASEIFACOMPONENTUSESTEMPLATEURLINSTEADOFTEMPLATETHEERRORSAREREPORTEDINTHEHTMLFILEREFERENECEDBYTHETEMPLATEURLINSTEADOFASYNTHETICFILE",
-    "original": "The file name reported in the error message, `my.component.ts.MyComponent.html`, is a synthetic file\n  generated by the template compiler that holds contents of the `MyComponent` class template.\n  Compiler never writes this file to disk. The line and column numbers are relative to the template string\n  in the `@Component` annotation of the class, `MyComponent` in this case. If a component uses\n  `templateUrl` instead of `template`, the errors are reported in the HTML file refereneced by the\n  `templateUrl` instead of a synthetic file.",
+    "key": "THEFILENAMEREPORTEDINTHEERRORMESSAGEMYCOMPONENTTSMYCOMPONENTHTMLISASYNTHETICFILEGENERATEDBYTHETEMPLATECOMPILERTHATHOLDSCONTENTSOFTHEMYCOMPONENTCLASSTEMPLATECOMPILERNEVERWRITESTHISFILETODISKTHELINEANDCOLUMNNUMBERSARERELATIVETOTHETEMPLATESTRINGINTHECOMPONENTANNOTATIONOFTHECLASSMYCOMPONENTINTHISCASEIFACOMPONENTUSESTEMPLATEURLINSTEADOFTEMPLATETHEERRORSAREREPORTEDINTHEHTMLFILEREFERENCEDBYTHETEMPLATEURLINSTEADOFASYNTHETICFILE",
+    "original": "The file name reported in the error message, `my.component.ts.MyComponent.html`, is a synthetic file\n  generated by the template compiler that holds contents of the `MyComponent` class template.\n  Compiler never writes this file to disk. The line and column numbers are relative to the template string\n  in the `@Component` annotation of the class, `MyComponent` in this case. If a component uses\n  `templateUrl` instead of `template`, the errors are reported in the HTML file referenced by the\n  `templateUrl` instead of a synthetic file.",
     "translation": "错误信息中汇报的文件名 `my.component.ts.MyComponent.html` 是一个由模板编译器生成出的虚拟文件，\n  用于保存 `MyComponent` 类的模板内容。\n  编译器永远不会把这个文件写入磁盘。这个例子中，这里的行号和列号都是相对于 `MyComponent` 的 `@Component` 注解中的模板字符串的。\n  如果组件使用 `templateUrl` 来代替 `template`，这些错误就会在 `templateUrl` 引用的 HTML 文件中汇报，而不是这个虚拟文件中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/aot-compiler.md"
   },
@@ -3054,8 +3054,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/architecture-components.md"
   },
   {
-    "key": "THECOMPONENTDECORATORIDENTIFIESTHECLASSIMMEDIATELYBELOWITASACOMPONENTCLASSANDSPECIFIESITSMETADATAINTHEEXAMPLECODEBELOWYOUCANSEETHATHEROLISTCOMPONENTISJUSTACLASSWITHNOSPECIALANGULARNOTATIONORSYNTAXATALLITSNOTACOMPONENTUNTILMARKITASONEWITHTHECOMPONENTDECORATOR",
-    "original": "The `@Component` decorator identifies the class immediately below it as a component class, and specifies its metadata. In the example code below, you can see that `HeroListComponent` is just a class, with no special Angular notation or syntax at all. It's not a component until mark it as one with the `@Component` decorator.",
+    "key": "THECOMPONENTDECORATORIDENTIFIESTHECLASSIMMEDIATELYBELOWITASACOMPONENTCLASSANDSPECIFIESITSMETADATAINTHEEXAMPLECODEBELOWYOUCANSEETHATHEROLISTCOMPONENTISJUSTACLASSWITHNOSPECIALANGULARNOTATIONORSYNTAXATALLITSNOTACOMPONENTUNTILYOUMARKITASONEWITHTHECOMPONENTDECORATOR",
+    "original": "The `@Component` decorator identifies the class immediately below it as a component class, and specifies its metadata. In the example code below, you can see that `HeroListComponent` is just a class, with no special Angular notation or syntax at all. It's not a component until you mark it as one with the `@Component` decorator.",
     "translation": "`@Component` 装饰器会指出紧随其后的那个类是个组件类，并为其指定元数据。\n在下面的范例代码中，你可以看到 `HeroListComponent` 只是一个普通类，完全没有 Angular 特有的标记或语法。\n直到给它加上了 `@Component` 装饰器，它才变成了组件。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/architecture-components.md"
   },
@@ -5052,9 +5052,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/bootstrapping.md"
   },
   {
-    "key": "FORMOREONNGMODULESYOURELIKELYTOSEEFREQUENTLYINAPPSSEEFREQUENTLYUSEDMODULES#",
-    "original": "For more on NgModules you're likely to see frequently in apps,\nsee [Frequently Used Modules](#).",
-    "translation": "要进一步了解常见的 NgModules 知识，参见 [关于模块的常见问题](#)。",
+    "key": "FORMOREONNGMODULESYOURELIKELYTOSEEFREQUENTLYINAPPSSEEFREQUENTLYUSEDMODULESGUIDEFREQUENTNGMODULES",
+    "original": "For more on NgModules you're likely to see frequently in apps,\nsee [Frequently Used Modules](guide/frequent-ngmodules).",
+    "translation": "要进一步了解常见的 NgModules 知识，参见 [关于模块的常见问题](guide/frequent-ngmodules)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/bootstrapping.md"
   },
   {
@@ -6270,15 +6270,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/cheatsheet.md"
   },
   {
-    "key": "PCALLEDAFTERCODENGAFTERCONTENTINITCODEWHENTHECOMPONENTSVIEWHASBEENINITIALIZEDAPPLIESTOCOMPONENTSONLYP",
-    "original": "<p>Called after <code>ngAfterContentInit</code> when the component's view has been initialized. Applies to components only.</p>",
-    "translation": "<p>当<code>ngAfterContentInit</code>完毕，并且组件的视图已经初始化完毕时调用。只适用于组件。</p>",
+    "key": "PCALLEDAFTERCODENGAFTERCONTENTINITCODEWHENTHECOMPONENTSVIEWSANDCHILDVIEWSTHEVIEWTHATADIRECTIVEISINHASBEENINITIALIZEDP",
+    "original": "<p>Called after <code>ngAfterContentInit</code> when the component's views and child views / the view that a directive is in has been initialized.</p>",
+    "translation": "<p>当<code>ngAfterContentInit</code>完毕，并且组件的视图及其子视图或指令所属的视图已经初始化完毕时调用。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/cheatsheet.md"
   },
   {
-    "key": "PCALLEDAFTEREVERYCHECKOFTHECOMPONENTSVIEWAPPLIESTOCOMPONENTSONLYP",
-    "original": "<p>Called after every check of the component's view. Applies to components only.</p>",
-    "translation": "<p>当组件视图每次执行变更检测时调用。只适用于组件。</p>",
+    "key": "PCALLEDAFTEREVERYCHECKOFTHECOMPONENTSVIEWSANDCHILDVIEWSTHEVIEWTHATADIRECTIVEISINP",
+    "original": "<p>Called after every check of the component's views and child views / the view that a directive is in.</p>",
+    "translation": "<p>当组件的视图及其子视图或指令所属的视图每次执行变更检测时调用。</p>",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/cheatsheet.md"
   },
   {
@@ -7530,9 +7530,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/component-styles.md"
   },
   {
-    "key": "WHENBUILDINGWITHTHECLIYOUMUSTCONFIGURETHEANGULARCLIJSONTOINCLUDEALLEXTERNALASSETSINCLUDINGEXTERNALSTYLEFILES",
-    "original": "When building with the CLI, you must configure the `.angular-cli.json` to include _all external assets_, including external style files.",
-    "translation": "当使用 CLI 进行构建时，你必须配置 `.angular-cli.json` 文件，使其包含*所有外部资源*（包括外部的样式表文件）。",
+    "key": "WHENBUILDINGWITHTHECLIYOUMUSTCONFIGURETHEANGULARJSONTOINCLUDEALLEXTERNALASSETSINCLUDINGEXTERNALSTYLEFILES",
+    "original": "When building with the CLI, you must configure the `angular.json` to include _all external assets_, including external style files.",
+    "translation": "当使用 CLI 进行构建时，你必须配置 `angular.json` 文件，使其包含*所有外部资源*（包括外部的样式表文件）。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/component-styles.md"
   },
   {
@@ -7704,21 +7704,21 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
-    "key": "REGISTERPROVIDERSFORDEPENDENCIESUSEDTHROUGHOUTTHEAPPLICATIONINTHEROOTAPPLICATIONCOMPONENTAPPCOMPONENT",
-    "original": "Register providers for dependencies used throughout the application in the root application component, `AppComponent`.",
-    "translation": "在应用程序根组件 `AppComponent` 中注册那些被应用程序全局使用的依赖提供商。",
+    "key": "REGISTERPROVIDERSFORDEPENDENCIESUSEDTHROUGHOUTTHEAPPLICATIONINTHEINJECTABLEDECORATOROFTHESERVICEITSELF",
+    "original": "Register providers for dependencies used throughout the application \nin the `@Injectable()` decorator of the service itself.",
+    "translation": "在服务本身的 `@Injectable()` 装饰器中注册那些将被应用程序全局使用的依赖提供商。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
-    "key": "THEFOLLOWINGEXAMPLESHOWSIMPORTINGANDREGISTERINGTHELOGGERSERVICEUSERCONTEXTANDTHEUSERSERVICEINTHECOMPONENTMETADATAPROVIDERSARRAY",
-    "original": "The following example shows importing and registering\nthe `LoggerService`, `UserContext`, and the `UserService`\nin the `@Component` metadata `providers` array.",
-    "translation": "在下面的例子中，通过 `@Component` 元数据的 `providers` 数组导入和注册了几个服务(`LoggerService`, `UserContext` 和 `UserService`)。",
+    "key": "PROVIDEDINHERETELLSANGULARTHATTHEROOTINJECTORISRESPONSIBLEFORCREATINGANINSTANCEOFTHEHEROSERVICESERVICESTHATAREPROVIDEDTHISWAYAREAUTOMATICALLYMADEAVAILABLETOTHEENTIREAPPLICATIONANDDONTNEEDTOBELISTEDINANYMODULE",
+    "original": "`providedIn` here tells Angular that the root injector is responsible for creating an instance of the `HeroService`.\nServices that are provided this way are automatically made available to the entire \napplication and don't need to be listed in any module.",
+    "translation": "这里的 `providedIn` 告诉 Angular，要由根注入器负责创建 `HeroService` 的实例。\n所有用这种方式提供的服务，都会自动在整个应用中可用，而不必把它们显式列在任何模块中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
-    "key": "ALLOFTHESESERVICESAREIMPLEMENTEDASCLASSESSERVICECLASSESCANACTASTHEIROWNPROVIDERSWHICHISWHYLISTINGTHEMINTHEPROVIDERSARRAYISALLTHEREGISTRATIONYOUNEED",
-    "original": "All of these services are implemented as classes.\nService classes can act as their own providers which is why listing them in the `providers` array\nis all the registration you need.",
-    "translation": "所有这些服务都是用类实现的。服务类能充当自己的提供商，这就是为什么只要把它们列在 `providers` 数组里就算注册成功了。",
+    "key": "SERVICECLASSESCANACTASTHEIROWNPROVIDERSWHICHISWHYDEFININGTHEMINTHEINJECTABLEDECORATORISALLTHEREGISTRATIONYOUNEED",
+    "original": "Service classes can act as their own providers which is why defining them in the `@Injectable` decorator\nis all the registration you need.",
+    "translation": "这些服务类可以充当自己的提供商，因此你只要把它们定义在 `@Injectable` 装饰器中就算注册成功了。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
@@ -7740,21 +7740,21 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
-    "key": "GENERALLYREGISTERPROVIDERSINTHENGMODULERATHERTHANINTHEROOTAPPLICATIONCOMPONENT",
-    "original": "Generally, register providers in the `NgModule` rather than in the root application component.",
-    "translation": "通常会在 `NgModule` 中注册提供商，而不是在应用程序根组件中。",
+    "key": "IFAPROVIDERCANNOTBECONFIGUREDINTHEINJECTABLEDECORATOROFTHESERVICETHENREGISTERAPPLICATIONWIDEPROVIDERSINTHEROOTAPPMODULENOTINTHEAPPCOMPONENTGENERALLYREGISTERPROVIDERSINTHENGMODULERATHERTHANINTHEROOTAPPLICATIONCOMPONENT",
+    "original": "If a provider cannot be configured in the `@Injectable` decorator of the service, then register application-wide providers in the root `AppModule`, not in the `AppComponent`. Generally, register providers in the `NgModule` rather than in the root application component.",
+    "translation": "如果某个提供商不是在服务的 `@Injectable` 装饰器中配置的，那么就要在根模块 `AppModule` 中把它注册为全应用级的提供商，而不是在 `AppComponent` 中。\n一般来说，要在 `NgModule` 中注册提供商，而不是在应用程序根组件中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
-    "key": "DOTHISWHENYOUEXPECTTHESERVICETOBEINJECTABLEEVERYWHEREORYOUARECONFIGURINGANOTHERAPPLICATIONGLOBALSERVICEBEFORETHEAPPLICATIONSTARTS",
-    "original": "Do this when you expect the service to be injectable everywhere,\nor you are configuring another application global service _before the application starts_.",
-    "translation": "如果你希望这个服务在应用中到处都可以被注入，或者必须在应用**启动前**注册一个全局服务，那就这么做。",
+    "key": "DOTHISWHENUSERSSHOULDEXPLICITLYOPTINTOUSEASERVICEORTHESERVICESHOULDBEPROVIDEDINALAZILYLOADEDCONTEXTORWHENYOUARECONFIGURINGANOTHERAPPLICATIONGLOBALSERVICEBEFORETHEAPPLICATIONSTARTS",
+    "original": "Do this when users should explicitly opt-in to use a service, or the service should be \nprovided in a lazily-loaded context, \nor when you are configuring another application global service _before the application starts_.",
+    "translation": "下列情况下会用到这种方法：1. 当用户应该明确选择所用的服务时。2. 当你要在惰性加载的上下文中提供该服务时。3. 当你要在应用启动之前配置应用中的另一个全局服务时。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
-    "key": "HEREISANEXAMPLEOFTHESECONDCASEWHERETHECOMPONENTROUTERCONFIGURATIONINCLUDESANONDEFAULTLOCATIONSTRATEGYGUIDEROUTER#LOCATIONSTRATEGYBYLISTINGITSPROVIDERINTHEPROVIDERSLISTOFTHEAPPMODULE",
-    "original": "Here is an example of the second case, where the component router configuration includes a non-default\n[location strategy](guide/router#location-strategy) by listing its provider\nin the `providers` list of the `AppModule`.",
-    "translation": "下面的例子是第二种情况，它为组件路由器配置了一个非默认的[地址策略（location strategy）](guide/router#location-strategy)，并把它加入到 `AppModule` 的 `providers` 数组中。",
+    "key": "HEREISANEXAMPLEOFTHECASEWHERETHECOMPONENTROUTERCONFIGURATIONINCLUDESANONDEFAULTLOCATIONSTRATEGYGUIDEROUTER#LOCATIONSTRATEGYBYLISTINGITSPROVIDERINTHEPROVIDERSLISTOFTHEAPPMODULE",
+    "original": "Here is an example of the case where the component router configuration includes a non-default\n[location strategy](guide/router#location-strategy) by listing its provider\nin the `providers` list of the `AppModule`.",
+    "translation": "下面的例子就属于这些情况，它为组件路由器配置了一个非默认的[地址策略（location strategy）](guide/router#location-strategy)，并把它加入到 `AppModule` 的 `providers` 数组中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
@@ -7818,33 +7818,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
-    "key": "THATDECORATORMAKESITPOSSIBLEFORANGULARTOIDENTIFYTHETYPESOFITSTWODEPENDENCIESLOGGERSERVICEANDUSERSERVICE",
-    "original": "That decorator makes it possible for Angular to identify the types of its two dependencies, `LoggerService` and `UserService`.",
-    "translation": "该装饰器让 Angular 有能力识别这两个依赖 `LoggerService` 和 `UserService` 的类型。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
-  },
-  {
-    "key": "TECHNICALLYTHEINJECTABLEDECORATORISONLYREQUIREDFORASERVICECLASSTHATHASITSOWNDEPENDENCIESTHELOGGERSERVICEDOESNTDEPENDONANYTHINGTHELOGGERWOULDWORKIFYOUOMITTEDINJECTABLEANDTHEGENERATEDCODEWOULDBESLIGHTLYSMALLER",
-    "original": "Technically, the `@Injectable()`decorator is only required for a service class that has _its own dependencies_.\nThe `LoggerService` doesn't depend on anything. The logger would work if you omitted `@Injectable()`\nand the generated code would be slightly smaller.",
-    "translation": "严格来说，这个 `@Injectable()` 装饰器只在一个服务类有*自己的依赖*的时候，才是*不可缺少*的。\n`LoggerService` 不依赖任何东西，所以该日志服务在没有 `@Injectable()` 的时候应该也能工作，生成的代码也更少一些。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
-  },
-  {
-    "key": "BUTTHESERVICEWOULDBREAKTHEMOMENTYOUGAVEITADEPENDENCYANDYOUDHAVETOGOBACKANDADDINJECTABLETOFIXITADDINJECTABLEFROMTHESTARTFORTHESAKEOFCONSISTENCYANDTOAVOIDFUTUREPAIN",
-    "original": "But the service would break the moment you gave it a dependency and you'd have to go back\nand add `@Injectable()` to fix it. Add `@Injectable()` from the start for the sake\nof consistency and to avoid future pain.",
-    "translation": "但是在给它添加依赖的那一瞬间，该服务就会停止工作，要想修复它，就必须要添加 `@Injectable()`。\n为了保持一致性和防止将来的麻烦，推荐从一开始就加上 `@Injectable()`。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
-  },
-  {
-    "key": "ALTHOUGHTHISSITERECOMMENDSAPPLYINGINJECTABLETOALLSERVICECLASSESDONTFEELBOUNDBYITSOMEDEVELOPERSPREFERTOADDITONLYWHERENEEDEDANDTHATSAREASONABLEPOLICYTOO",
-    "original": "Although this site recommends applying `@Injectable()` to all service classes, don't feel bound by it.\nSome developers prefer to add it only where needed and that's a reasonable policy too.",
-    "translation": "虽然推荐在所有服务中使用 `@Injectable()`，但你也不需要一定要这么做。一些开发者就更喜欢在真正需要的地方才添加，这也是一个合理的策略。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
-  },
-  {
-    "key": "THEAPPCOMPONENTCLASSHADTWODEPENDENCIESASWELLBUTNOINJECTABLEITDIDNTNEEDINJECTABLEBECAUSETHATCOMPONENTCLASSHASTHECOMPONENTDECORATORINANGULARWITHTYPESCRIPTASINGLEDECORATORMDASHANYDECORATORMDASHISSUFFICIENTTOIDENTIFYDEPENDENCYTYPES",
-    "original": "The `AppComponent` class had two dependencies as well but no `@Injectable()`.\nIt didn't need `@Injectable()` because that component class has the `@Component` decorator.\nIn Angular with TypeScript, a *single* decorator&mdash;*any* decorator&mdash;is sufficient to identify dependency types.",
-    "translation": "`AppComponent` 类有两个依赖，但它没有 `@Injectable()`。\n它不需要 `@Injectable()`，这是因为组件类有 `@Component` 装饰器。\n在用 TypeScript 的 Angular 应用里，有一个*单独的*装饰器 &mdash; *任何*装饰器 &mdash; 来标识依赖的类型就够了。",
+    "key": "THEINJECTABLEDECORATORINDICATESTHATTHEANGULARDISYSTEMISUSEDTOCREATEONEORMOREINSTANCESOFUSERCONTEXTSERVICE",
+    "original": "The `@Injectable` decorator indicates that the Angular DI system is used to create one or more instances of `UserContextService`.",
+    "translation": "`@Injectable` 装饰器会向 Angular DI 系统指明应该为 `UserContextService` 创建一个实例还是多个实例。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
@@ -8178,9 +8154,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
-    "key": "ANEWINJECTORHASNOPROVIDERSANGULARINITIALIZESTHEINJECTORSITCREATESWITHSOMEPROVIDERSITCARESABOUTYOUHAVETOREGISTERYOUROWNAPPLICATIONPROVIDERSMANUALLYUSUALLYINTHEPROVIDERSARRAYOFTHECOMPONENTORDIRECTIVEMETADATA:",
-    "original": "A new injector has no providers.\nAngular initializes the injectors it creates with some providers it cares about.\nYou have to register your _own_ application providers manually,\nusually in the `providers` array of the `Component` or `Directive` metadata:",
-    "translation": "新建的注入器中没有提供商。\nAngular 会使用一些自带的提供商来初始化这些注入器。你必须自行注册属于*自己*的提供商，通常用 ` 组件 ` 或者 ` 指令 ` 元数据中的 `providers` 数组进行注册。",
+    "key": "ANEWINJECTORHASNOPROVIDERSANGULARINITIALIZESTHEINJECTORSITCREATESWITHSOMEPROVIDERSITCARESABOUTYOUHAVETOREGISTERYOUROWNAPPLICATIONPROVIDERSMANUALLYUSUALLYINTHEINJECTABLEDECORATOROFTHESERVICEPROVIDERSARRAYOFTHENGMODULEORDIRECTIVEMETADATA:",
+    "original": "A new injector has no providers.\nAngular initializes the injectors it creates with some providers it cares about.\nYou have to register your _own_ application providers manually,\nusually in the `@Injectable` decorator of the service, `providers` array of the `NgModule` or `Directive` metadata:",
+    "translation": "新建的注入器中没有提供商。\nAngular 会使用一些自带的提供商来初始化这些注入器。你必须自行注册属于*自己*的提供商，通常会在该服务的 `@Injectable` 装饰器中，或在 `NgModule` 或 `Directive` 元数据的 `providers` 数组中进行注册。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
@@ -8190,9 +8166,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
-    "key": "THESIMPLECLASSPROVIDERISTHEMOSTTYPICALBYFARYOUMENTIONTHECLASSINTHEPROVIDERSARRAYANDYOUREDONE",
-    "original": "The simple class provider is the most typical by far.\nYou mention the class in the `providers` array and you're done.",
-    "translation": "简单的类提供商是最典型的例子。只要在 `providers` 数值里面提到该类就可以了。",
+    "key": "THESIMPLEWAYOFDEFININGPROVIDERSINTHEINJECTABLEDECORATOROFTHECLASSISRECOMMENDED",
+    "original": "The simple way of defining providers in the `@Injectable` decorator of the class is recommended.",
+    "translation": "建议直接在服务类的 `@Injectable` 装饰器中定义服务提供商。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
+  },
+  {
+    "key": "ANOTHERALTERNATIVEISTOMENTIONTHECLASSINTHEPROVIDERSARRAYOFTHENGMODULEANDYOUREDONE",
+    "original": "Another alternative is to mention the class in the providers array of the `@NgModule` and you're done.",
+    "translation": "备选方案是在 `@NgModule` 的 `providers` 数组中引用下这个类就可以了。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection-in-action.md"
   },
   {
@@ -9282,15 +9264,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "THATCOMMANDCREATESTHEFOLLOWINGHEROSERVICESKELETON",
-    "original": "That command creates the following `HeroService` skeleton.",
-    "translation": "这条命令会创建如下的 `HeroService` 骨架代码：",
+    "key": "THECOMMANDABOVECREATESTHEFOLLOWINGHEROSERVICESKELETON",
+    "original": "The command above creates the following `HeroService` skeleton.",
+    "translation": "上述命令会创建如下的 `HeroService` 骨架代码：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "ASSUMEFORNOWTHATTHEINJECTABLEDECORATOR#INJECTABLEISANESSENTIALINGREDIENTINEVERYANGULARSERVICEDEFINITIONTHERESTOFTHECLASSHASBEENREWRITTENTOEXPOSEAGETHEROESMETHODTHATRETURNSTHESAMEMOCKDATAASBEFORE",
-    "original": "Assume for now that the [`@Injectable` decorator](#injectable) is an essential ingredient in every Angular service definition.\nThe rest of the class has been rewritten to expose a `getHeroes` method \nthat returns the same mock data as before.",
-    "translation": "目前先把 [`@Injectable` 装饰器](#injectable)当做定义每个 Angular 服务时的必备部分。\n把该类的其它部分改写为暴露一个返回和以前一样的 mock 数据的 `getHeroes` 方法。",
+    "key": "THEINJECTABLEDECORATORISANESSENTIALINGREDIENTINEVERYANGULARSERVICEDEFINITIONTHERESTOFTHECLASSHASBEENREWRITTENTOEXPOSEAGETHEROESMETHODTHATRETURNSTHESAMEMOCKDATAASBEFORE",
+    "original": "The `@Injectable` decorator is an essential ingredient in every Angular service definition.\nThe rest of the class has been rewritten to expose a `getHeroes` method \nthat returns the same mock data as before.",
+    "translation": "[`@Injectable` 装饰器](#injectable)是定义每个 Angular 服务时的必备部分。\n把该类的其它部分改写为暴露一个返回和以前一样的 mock 数据的 `getHeroes` 方法。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -9306,15 +9288,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "##REGISTERASERVICEPROVIDER",
-    "original": "## Register a service provider",
-    "translation": "## 注册服务提供商",
+    "key": "##INJECTORS",
+    "original": "## Injectors",
+    "translation": "## 注入器",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "ASERVICEISJUSTACLASSINANGULARUNTILYOUREGISTERITWITHANANGULARDEPENDENCYINJECTOR",
-    "original": "A _service_ is just a class in Angular until you register it with an Angular dependency injector.",
-    "translation": "在你把 Angular 中的*服务*注册进依赖注入器（injector）之前，它只是一个普通的类。",
+    "key": "ASERVICELIKEHEROSERVICEISJUSTACLASSINANGULARUNTILYOUREGISTERITWITHANANGULARDEPENDENCYINJECTOR",
+    "original": "A _service_ like `HeroService` is just a class in Angular until you register it with an Angular dependency injector.",
+    "translation": "在你把 Angular 中的*服务类*（比如 `HeroService` ）注册进依赖注入器（injector）之前，它只是个普通类而已。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -9330,9 +9312,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "YOUDOHAVETOREGISTERPROVIDERSWITHANINJECTORBEFORETHEINJECTORCANCREATETHATSERVICE",
-    "original": "You do have to register _providers_ with an injector \nbefore the injector can create that service.",
-    "translation": "但在注入器能创建服务之前，你得先往注入器中注入这个服务的*提供商*。",
+    "key": "ANGULARDOESNTAUTOMATICALLYKNOWHOWYOUWANTTOCREATEINSTANCESOFYOURSERVICESORTHEINJECTORTOCREATEYOURSERVICEYOUMUSTCONFIGUREITBYSPECIFYINGPROVIDERSFOREVERYSERVICE",
+    "original": "Angular doesn't automatically know how you want to create instances of your services or the injector to create your service. You must configure it by specifying providers for every service.",
+    "translation": "Angular 本身没法自动判断你是打算自行创建服务类的实例，还是等注入器来创建它。你必须通过为每个服务指定服务提供商来配置它。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -9342,33 +9324,51 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "YOULLLEARNMUCHMOREABOUTPROVIDERSBELOW#PROVIDERSFORNOWITISSUFFICIENTTOKNOWTHATTHEYCREATESERVICESANDMUSTBEREGISTEREDWITHANINJECTOR",
-    "original": "You'll learn much more about _providers_ [below](#providers).\nFor now it is sufficient to know that they create services\nand must be registered with an injector.",
-    "translation": "你可以在[稍后的部分](#providers)学到更多关于*提供商*的知识。\n不过目前，只要知道它们用于创建服务，以及它们必须用注入器进行注册就行了。",
+    "key": "YOULLLEARNMUCHMOREABOUTPROVIDERSBELOW#PROVIDERSFORNOWITISSUFFICIENTTOKNOWTHATTHEYCONFIGUREWHEREANDHOWSERVICESARECREATED",
+    "original": "You'll learn much more about _providers_ [below](#providers).\nFor now, it is sufficient to know that they configure where and how services are created.",
+    "translation": "你可以在[稍后的部分](#providers)学到更多关于*提供商*的知识。\n不过目前，你只要知道它们是用来配置服务应该在哪里创建以及如何创建的就够了。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "YOUCANREGISTERAPROVIDERWITHANYANGULARDECORATORTHATSUPPORTSTHEPROVIDERSARRAYPROPERTY",
-    "original": "You can register a provider with any Angular decorator that supports the  **`providers` array property**.",
-    "translation": "你可以使用 Angular 中那些支持 `providers` 数组属性的装饰器来注册提供商。",
+    "key": "THEREAREMANYWAYSTOREGISTERASERVICEPROVIDERWITHANINJECTORTHISSECTIONSHOWSTHEMOSTCOMMONWAYSOFCONFIGURINGAPROVIDERFORYOURSERVICES",
+    "original": "There are many ways to register a service provider with an injector. This section shows the most common ways \nof configuring a provider for your services.",
+    "translation": "有很多方式可以为注入器注册服务提供商。本节会展示为你的服务配置提供商最常见的途径。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "MANYANGULARDECORATORSACCEPTMETADATAWITHAPROVIDERSPROPERTYTHETWOMOSTIMPORTANTEXAMPLESARECOMPONENTANDNGMODULE",
-    "original": "Many Angular decorators accept metadata with a `providers` property.\nThe two most important examples are `@Component` and `@NgModule`.",
-    "translation": "很多 Angular 的装饰器都支持带有 `providers` 属性的元数据。\n最重要的两个例子是 `@Component` 和 `@NgModule`。",
+    "key": "##INJECTABLEPROVIDERS",
+    "original": "## @Injectable providers",
+    "translation": "## @Injectable 的 providers 数组",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "###COMPONENTPROVIDERS",
-    "original": "### _@Component_ providers",
-    "translation": "### 在组件中注册提供商",
+    "key": "THEINJECTABLEDECORATORIDENTIFIESSERVICESANDOTHERCLASSESTHATAREINTENDEDTOBEINJECTEDITCANALSOBEUSEDTOCONFIGUREAPROVIDERFORTHOSESERVICES",
+    "original": "The `@Injectable` decorator identifies services and other classes that are intended to be injected. It can also be used to configure a provider for those services.",
+    "translation": "`@Injectable` 装饰器会指出这些服务或其它类是用来注入的。它还能用于为这些服务提供配置项。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "HERESAREVISEDHEROESCOMPONENTTHATREGISTERSTHEHEROSERVICEINITSPROVIDERSARRAY",
-    "original": "Here's a revised `HeroesComponent` that registers the `HeroService` in its `providers` array.",
-    "translation": "下面是修改过的 `HerosComponent`，把 `HeroService` 注册到了它的 `providers` 数组中。",
+    "key": "HEREWECONFIGUREAPROVIDERFORHEROSERVICEUSINGTHEINJECTABLEDECORATORONTHECLASS",
+    "original": "Here we configure a provider for `HeroService` using the `@Injectable` decorator on the class.",
+    "translation": "这里我们使用类上的 `@Injectable` 装饰器来为 `HeroService` 配置了一个提供商。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "PROVIDEDINTELLSANGULARTHATTHEROOTINJECTORISRESPONSIBLEFORCREATINGANINSTANCEOFTHEHEROSERVICEBYINVOKINGITSCONSTRUCTORANDMAKINGITAVAILABLEACROSSTHEAPPLICATIONTHECLISETSUPTHISKINDOFAPROVIDERAUTOMATICALLYFORYOUWHENGENERATINGANEWSERVICE",
+    "original": "`providedIn` tells Angular that the root injector is responsible for creating an instance of the `HeroService` (by invoking its constructor) and making it available across the application. The CLI sets up this kind of a provider automatically for you when generating a new service.",
+    "translation": "`providedIn` 告诉 Angular，它的根注入器要负责调用 `HeroService` 类的构造函数来创建一个实例，并让它在整个应用中都是可用的。在使用 CLI 生成新服务时，会默认帮你设置为这种提供商。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "SOMETIMESITSNOTDESIRABLETOHAVEASERVICEALWAYSBEPROVIDEDINTHEAPPLICATIONROOTINJECTORPERHAPSUSERSSHOULDEXPLICITLYOPTINTOUSINGTHESERVICEORTHESERVICESHOULDBEPROVIDEDINALAZILYLOADEDCONTEXTINTHISCASETHEPROVIDERSHOULDBEASSOCIATEDWITHASPECIFICNGMODULECLASSANDWILLBEUSEDBYWHICHEVERINJECTORINCLUDESTHATMODULE",
+    "original": "Sometimes it's not desirable to have a service always be provided in the application root injector. Perhaps users should explicitly opt-in to using the service, or the service should be provided in a lazily-loaded context. In this case, the provider should be associated with a specific `@NgModule` class, and will be used by whichever injector includes that module.",
+    "translation": "有时，你不希望只在应用的根注入器中提供服务。有可能用户希望显式选择要使用的服务，或者应该在一个惰性加载的环境下提供该服务。这种情况下，服务提供商应该关联到一个特定的 `@NgModule` 类，而且应该用于该模块包含的任何一个注入器中。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "INTHEFOLLOWINGEXCERPTTHEINJECTABLEDECORATORISUSEDTOCONFIGUREAPROVIDERTHATWILLBEAVAILABLEINANYINJECTORTHATINCLUDESTHEHEROMODULE",
+    "original": "In the following excerpt, the `@Injectable` decorator is used to configure a provider that will be available in any injector that includes the HeroModule.",
+    "translation": "下面这段代码中，`@Injectable` 装饰器用来配置一个服务提供商，它可以用在任何包含了 HeroModule 的注入器中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -9390,9 +9390,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "THANKSTOTHESEREGISTRATIONSANGULARCANINJECTTHEUSERSERVICEORTHEHERODICONFIGVALUEINTOANYCLASSTHATITCREATES",
-    "original": "Thanks to these registrations, Angular can inject the `UserService` or the `HERO_DI_CONFIG` value\ninto any class that it creates.",
-    "translation": "得益于这些注册语句，Angular 现在可以向它创建的任何类中注册 `UserService` 或 `HERO_DI_CONFIG` 值了。",
+    "key": "WITHTHEABOVEREGISTRATIONSANGULARCANINJECTTHEUSERSERVICEORTHEHERODICONFIGVALUEINTOANYCLASSTHATITCREATES",
+    "original": "With the above registrations, Angular can inject the `UserService` or the `HERO_DI_CONFIG` value\ninto any class that it creates.",
+    "translation": "借助这些注册语句，Angular 现在可以向它创建的任何类中注册 `UserService` 或 `HERO_DI_CONFIG` 值了。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -9402,15 +9402,39 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "###NGMODULEORCOMPONENT",
-    "original": "### _@NgModule_ or _@Component_?",
-    "translation": "### _@NgModule_ 还是 _@Component_?",
+    "key": "###COMPONENTPROVIDERS",
+    "original": "### _@Component_ providers",
+    "translation": "### 在组件中注册提供商",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "SHOULDYOUREGISTERASERVICEWITHANANGULARMODULEORWITHACOMPONENTTHETWOCHOICESLEADTODIFFERENCESINSERVICESCOPEANDSERVICELIFETIME",
-    "original": "Should you register a service with an Angular module or with a component?\nThe two choices lead to differences in service _scope_ and service _lifetime_.",
-    "translation": "你该使用 Angular 的模块还是组件来注册服务呢？\n这两个选择的差别在于服务的*范围*和*生命周期*。",
+    "key": "INADDITIONTOPROVIDINGTHESERVICEAPPLICATIONWIDEORWITHINAPARTICULARNGMODULESERVICESCANALSOBEPROVIDEDINSPECIFICCOMPONENTSSERVICESPROVIDEDINCOMPONENTLEVELISONLYAVAILABLEWITHINTHATCOMPONENTINJECTORORINANYOFITSCHILDCOMPONENTS",
+    "original": "In addition to providing the service application-wide or within a particular `@NgModule`, services can also be provided in specific components. Services provided in component-level is only available within that component injector or in any of its child components.",
+    "translation": "除了提供给全应用级或特定的 `@NgModule` 中之外，服务还可以提供给指定的组件。在组件级提供的服务职能在该组件及其子组件的注入器中使用。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THEEXAMPLEBELOWSHOWSAREVISEDHEROESCOMPONENTTHATREGISTERSTHEHEROSERVICEINITSPROVIDERSARRAY",
+    "original": "The example below shows a revised `HeroesComponent` that registers the `HeroService` in its `providers` array.",
+    "translation": "下面的例子展示了一个修改过的 `HeroesComponent`，它在自己的 `providers` 数组中注册了 `HeroService`。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "###INJECTABLENGMODULEORCOMPONENT",
+    "original": "### @Injectable, _@NgModule_ or _@Component_?",
+    "translation": "### @Injectable、_@NgModule_ 还是 _@Component_ ？",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "SHOULDYOUPROVIDEASERVICEWITHANINJECTABLEDECORATORINANNGMODULEORWITHINANCOMPONENTTHECHOICESLEADTODIFFERENCESINTHEFINALBUNDLESIZESERVICESCOPEANDSERVICELIFETIME",
+    "original": "Should you provide a service with an `@Injectable` decorator, in an `@NgModule`, or within an `@Component`?\nThe choices lead to differences in the final bundle size, service _scope_, and service _lifetime_.",
+    "translation": "你该使用 `@Injectable` 装饰器、`@NgModule`还是 `@Component` 来提供服务呢？\n这几个选择的差别在于最终的打包体积、服务的*范围*和服务的*生命周期*。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "WHENYOUREGISTERPROVIDERSINTHEINJECTABLEDECORATOROFTHESERVICEITSELFOPTIMIZATIONTOOLSSUCHASTHOSEUSEDBYTHECLISPRODUCTIONBUILDSCANPERFORMTREESHAKINGWHICHREMOVESSERVICESTHATARENTUSEDBYYOURAPPTREESHAKINGRESULTSINSMALLERBUNDLESIZES",
+    "original": "When you register providers in the **@Injectable** decorator of the service itself, optimization tools such as those used by the CLI's production builds can perform tree shaking, which removes services that aren't used by your app. Tree shaking results in smaller bundle sizes.",
+    "translation": "当你在服务本身的 **@Injectable** 装饰器中注册提供商时，优化工具（比如 CLI 产品模式构建时所用的）可以执行摇树优化，这会移除所有没在应用中使用过的服务。摇树优化会导致更小的打包体积。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -9420,9 +9444,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "YOURELIKELYTOINJECTTHEUSERSERVICEINMANYPLACESTHROUGHOUTTHEAPPANDWILLWANTTOINJECTTHESAMESERVICEINSTANCEEVERYTIMEPROVIDINGTHEUSERSERVICEWITHANANGULARMODULEISAGOODCHOICE",
-    "original": "You're likely to inject the `UserService` in many places throughout the app\nand will want to inject the same service instance every time.\nProviding the `UserService` with an Angular module is a good choice.",
-    "translation": "如果你想要把这个 `UserService` 注入到应用中的很多地方，并且期望每次注入的都是同一个服务实例，那么在 Angular 的模块中提供 `UserService` 就是不错的选择。",
+    "key": "YOURELIKELYTOINJECTTHEUSERSERVICEINMANYPLACESTHROUGHOUTTHEAPPANDWILLWANTTOINJECTTHESAMESERVICEINSTANCEEVERYTIMEPROVIDINGTHEUSERSERVICEWITHANANGULARMODULEISAGOODCHOICEIFANINJECTABLEPROVIDERISNOTANOPTION",
+    "original": "You're likely to inject the `UserService` in many places throughout the app\nand will want to inject the same service instance every time.\nProviding the `UserService` with an Angular module is a good choice if an `@Injectable` provider is not an option.",
+    "translation": "你可能想要把这个 `UserService` 注入到应用中的很多地方，并期望每次注入的都是同一个服务实例。\n这时候如果不能用 `@Injectable`，那么就可以在 Angular 的模块中提供 `UserService`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -9467,246 +9491,6 @@
     "translation": "由组件提供的服务，其范围和生命周期是 [Angular 如何创建组件实例](#component-child-injectors) 的必然结果。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
-  {
-    "key": "##INJECTASERVICE",
-    "original": "## Inject a service",
-    "translation": "## 注入某个服务",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THEHEROLISTCOMPONENTSHOULDGETHEROESFROMTHEHEROSERVICE",
-    "original": "The `HeroListComponent` should get heroes from the `HeroService`.",
-    "translation": "`HeroListComponent` 应该从 `HeroService` 中获取这些英雄数据。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THECOMPONENTSHOULDNTCREATETHEHEROSERVICEWITHNEWITSHOULDASKFORTHEHEROSERVICETOBEINJECTED",
-    "original": "The component shouldn't create the `HeroService` with `new`.\nIt should ask for the `HeroService` to be injected.",
-    "translation": "该组件不应该使用 `new` 来创建 `HeroService`。\n它应该要求注入 `HeroService`。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "YOUCANTELLANGULARTOINJECTADEPENDENCYINTHECOMPONENTSCONSTRUCTORBYSPECIFYINGACONSTRUCTORPARAMETERWITHTHEDEPENDENCYTYPEHERESTHEHEROLISTCOMPONENTCONSTRUCTORASKINGFORTHEHEROSERVICETOBEINJECTED",
-    "original": "You can tell Angular to inject a dependency in the component's constructor by specifying a **constructor parameter with the dependency type**.\nHere's the `HeroListComponent` constructor, asking for the `HeroService` to be injected.",
-    "translation": "你可以通过**在构造函数中添加一个带有该依赖类型的参数**来要求 Angular 把这个依赖注入到组件的构造函数中。\n下面是 `HeroListComponent` 的构造函数，它要求注入 `HeroService`。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "OFCOURSETHEHEROLISTCOMPONENTSHOULDDOSOMETHINGWITHTHEINJECTEDHEROSERVICEHERESTHEREVISEDCOMPONENTMAKINGUSEOFTHEINJECTEDSERVICESIDEBYSIDEWITHTHEPREVIOUSVERSIONFORCOMPARISON",
-    "original": "Of course, the `HeroListComponent` should do something with the injected `HeroService`.\nHere's the revised component, making use of the injected service, side-by-side with the previous version for comparison.",
-    "translation": "当然，`HeroListComponent` 还应该使用注入的这个 `HeroService` 做点什么。\n下面输出修改过的组件，改用注入的服务，与前一个版本对比一下。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "NOTICETHATTHEHEROLISTCOMPONENTDOESNTKNOWWHERETHEHEROSERVICECOMESFROMYOUKNOWTHATITCOMESFROMTHEPARENTHEROESCOMPONENTBUTIFYOUDECIDEDINSTEADTOPROVIDETHEHEROSERVICEINTHEAPPMODULETHEHEROLISTCOMPONENTWOULDNTCHANGEATALLTHEONLYTHINGTHATMATTERSISTHATTHEHEROSERVICEISPROVIDEDINSOMEPARENTINJECTOR",
-    "original": "Notice that the `HeroListComponent` doesn't know where the `HeroService` comes from.\n_You_ know that it comes from the parent `HeroesComponent`.\nBut if you decided instead to provide the `HeroService` in the `AppModule`,\nthe `HeroListComponent` wouldn't change at all.\nThe _only thing that matters_ is that the `HeroService` is provided in some parent injector.",
-    "translation": "注意，`HeroListComponent` 并不知道 `HeroService` 来自哪里。\n当然*你自己*知道它来自父组件 `HeroesComponent`。\n但是如果你决定改在 `AppModule` 中提供 `HeroService`，`HeroListComponent` 不用做任何修改。\n它*唯一需要关心的事情*是 `HeroService` 是由某个父注入器提供的。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "##SINGLETONSERVICES",
-    "original": "## Singleton services",
-    "translation": "## 单例服务",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "SERVICESARESINGLETONSWITHINTHESCOPEOFANINJECTORTHEREISATMOSTONEINSTANCEOFASERVICEINAGIVENINJECTOR",
-    "original": "Services are singletons _within the scope of an injector_.\nThere is at most one instance of a service in a given injector.",
-    "translation": "服务*在每个注入器的范围内*是单例的。\n在任何一个注入器中，最多只会有同一个服务的一个实例。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THEREISONLYONEROOTINJECTORANDTHEUSERSERVICEISREGISTEREDWITHTHATINJECTORTHEREFORETHERECANBEJUSTONEUSERSERVICEINSTANCEINTHEENTIREAPPANDEVERYCLASSTHATINJECTSUSERSERVICEGETTHISSERVICEINSTANCE",
-    "original": "There is only one root injector and the `UserService` is registered with that injector.\nTherefore, there can be just one `UserService` instance in the entire app\nand every class that injects `UserService` get this service instance.",
-    "translation": "这里只有一个根注入器，而 `UserService` 就是在该注入器中注册的。\n所以，在整个应用中只能有一个 `UserService` 实例，每个要求注入 `UserService` 的类都会得到这个服务实例。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "HOWEVERANGULARDIISAHIERARCHICALINJECTIONSYSTEMGUIDEHIERARCHICALDEPENDENCYINJECTIONWHICHMEANSTHATNESTEDINJECTORSCANCREATETHEIROWNSERVICEINSTANCESANGULARCREATESNESTEDINJECTORSALLTHETIME",
-    "original": "However, Angular DI is a \n[hierarchical injection system](guide/hierarchical-dependency-injection), \nwhich means that nested injectors can create their own service instances.\nAngular creates nested injectors all the time.",
-    "translation": "不过，Angular DI 是一个 [多级注入系统](guide/hierarchical-dependency-injection)，这意味着各级注入器都可以创建它们自己的服务实例。\nAngular 总会创建多级注入器。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "##COMPONENTCHILDINJECTORS",
-    "original": "## Component child injectors",
-    "translation": "## 组件的子注入器",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "FOREXAMPLEWHENANGULARCREATESANEWINSTANCEOFACOMPONENTTHATHASCOMPONENTPROVIDERSITALSOCREATESANEWCHILDINJECTORFORTHATINSTANCE",
-    "original": "For example, when Angular creates a new instance of a component that has `@Component.providers`,\nit also creates a new _child injector_ for that instance.",
-    "translation": "例如，当 Angular 创建一个带有 `@Component.providers` 的组件实例时，也会同时为这个实例创建一个新的*子注入器*。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "COMPONENTINJECTORSAREINDEPENDENTOFEACHOTHERANDEACHOFTHEMCREATESITSOWNINSTANCESOFTHECOMPONENTPROVIDEDSERVICES",
-    "original": "Component injectors are independent of each other and\neach of them creates its own instances of the component-provided services.",
-    "translation": "组件注入器是彼此独立的，每一个都会为这些组件提供的服务创建单独的实例。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "WHENANGULARDESTROYSONEOFTHESECOMPONENTINSTANCEITALSODESTROYSTHECOMPONENTSINJECTORANDTHATINJECTORSSERVICEINSTANCES",
-    "original": "When Angular destroys one of these component instance, it also destroys the\ncomponent's injector and that injector's service instances.",
-    "translation": "当 Angular 销毁任何一个组件实例时，也会同时销毁组件的注入器以及该注入器中的那些服务实例。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THANKSTOINJECTORINHERITANCEGUIDEHIERARCHICALDEPENDENCYINJECTIONYOUCANSTILLINJECTAPPLICATIONWIDESERVICESINTOTHESECOMPONENTSACOMPONENTSINJECTORISACHILDOFITSPARENTCOMPONENTSINJECTORANDADESCENDENTOFITSPARENTSPARENTSINJECTORANDSOONALLTHEWAYBACKTOTHEAPPLICATIONSROOTINJECTORANGULARCANINJECTASERVICEPROVIDEDBYANYINJECTORINTHATLINEAGE",
-    "original": "Thanks to [injector inheritance](guide/hierarchical-dependency-injection),\nyou can still inject application-wide services into these components.\nA component's injector is a child of its parent component's injector,\nand a descendent of its parent's parent's injector, and so on all the way back to the application's _root_ injector.\nAngular can inject a service provided by any injector in that lineage.",
-    "translation": "在[注入器继承机制](guide/hierarchical-dependency-injection)的帮助下，你仍然可以把全应用级的服务注入到这些组件中。\n组件的注入器也是其父组件的注入器的子注入器，这同样适用于其父组件的父组件的注入器，以此类推，最终会回到应用的*根*注入器。\nAngular 可以注入由这个注入器谱系提供的任何一个注入器。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "FOREXAMPLEANGULARCOULDINJECTAHEROLISTCOMPONENTWITHBOTHTHEHEROSERVICEPROVIDEDINHEROCOMPONENTANDTHEUSERSERVICEPROVIDEDINAPPMODULE",
-    "original": "For example, Angular could inject a `HeroListComponent`\nwith both the `HeroService` provided in `HeroComponent`\nand the `UserService` provided in `AppModule`.",
-    "translation": "比如，Angular 可以把由 `HeroComponent` 提供的 `HeroService` 和由 `AppModule` 提供的 `UserService` 注入到 `HeroService` 中。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "##TESTINGTHECOMPONENT",
-    "original": "## Testing the component",
-    "translation": "## 测试组件",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "EARLIERYOUSAWTHATDESIGNINGACLASSFORDEPENDENCYINJECTIONMAKESTHECLASSEASIERTOTESTLISTINGDEPENDENCIESASCONSTRUCTORPARAMETERSMAYBEALLYOUNEEDTOTESTAPPLICATIONPARTSEFFECTIVELY",
-    "original": "Earlier you saw that designing a class for dependency injection makes the class easier to test.\nListing dependencies as constructor parameters may be all you need to test application parts effectively.",
-    "translation": "前面强调过，设计一个适合依赖注入的类，可以让这个类更容易测试。\n要有效的测试应用中的一部分，只需要在构造函数的参数中列出依赖。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "FOREXAMPLEYOUCANCREATEANEWHEROLISTCOMPONENTWITHAMOCKSERVICETHATYOUCANMANIPULATEUNDERTEST:",
-    "original": "For example, you can create a new `HeroListComponent` with a mock service that you can manipulate\nunder test:",
-    "translation": "例如，新建的 `HeroListComponent` 实例使用一个模拟 (mock) 服务，以便可以在测试中操纵它：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "LEARNMOREINTHETESTINGGUIDETESTINGGUIDE",
-    "original": "Learn more in the [Testing](guide/testing) guide.",
-    "translation": "要学习更多知识，参见[测试](guide/testing)一章。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "##WHENTHESERVICENEEDSASERVICE",
-    "original": "## When the service needs a service",
-    "translation": "## 当服务需要别的服务时",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THEHEROSERVICEISVERYSIMPLEITDOESNTHAVEANYDEPENDENCIESOFITSOWN",
-    "original": "The `HeroService` is very simple. It doesn't have any dependencies of its own.",
-    "translation": "这个 `HeroService` 非常简单。它本身不需要任何依赖。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "WHATIFITHADADEPENDENCYWHATIFITREPORTEDITSACTIVITIESTHROUGHALOGGINGSERVICEYOUDAPPLYTHESAMECONSTRUCTORINJECTIONPATTERNADDINGACONSTRUCTORTHATTAKESALOGGERPARAMETER",
-    "original": "What if it had a dependency? What if it reported its activities through a logging service?\nYou'd apply the same *constructor injection* pattern,\nadding a constructor that takes a `Logger` parameter.",
-    "translation": "如果它也有依赖，该怎么办呢？例如，它需要通过日志服务来汇报自己的活动。\n你同样用*构造函数注入*模式，来添加一个带有 `Logger` 参数的构造函数。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "HEREISTHEREVISEDHEROSERVICETHATINJECTSTHELOGGERSIDEBYSIDEWITHTHEPREVIOUSSERVICEFORCOMPARISON",
-    "original": "Here is the revised `HeroService` that injects the `Logger`, side-by-side with the previous service for comparison.",
-    "translation": "下面是修改后的 `HeroService`，它注入了 `Logger`，对比前后这两个版本：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THECONSTRUCTORASKSFORANINJECTEDINSTANCEOFALOGGERANDSTORESITINAPRIVATEFIELDCALLEDLOGGERTHEGETHEROESMETHODLOGSAMESSAGEWHENASKEDTOFETCHHEROES",
-    "original": "The constructor asks for an injected instance of a `Logger` and stores it in a private field called `logger`.\nThe `getHeroes()` method logs a message when asked to fetch heroes.",
-    "translation": "这个构造函数要求注入一个 `Logger` 类的实例，并把它存到名为 `logger` 的私有字段中。\n  当请求英雄数据时，`getHeroes()` 中就会记录一个消息。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "####THEDEPENDENTLOGGERSERVICE",
-    "original": "#### The dependent _Logger_ service",
-    "translation": "#### 被依赖的 `Logger` 服务",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THESAMPLEAPPSLOGGERSERVICEISQUITESIMPLE:",
-    "original": "The sample app's `Logger` service is quite simple:",
-    "translation": "这个范例应用的 `Logger` 服务非常简单：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "IFTHEAPPDIDNTPROVIDETHISLOGGERANGULARWOULDTHROWANEXCEPTIONWHENITLOOKEDFORALOGGERTOINJECTINTOTHEHEROSERVICE",
-    "original": "If the app didn't provide this `Logger`,\nAngular would throw an exception when it looked for a `Logger` to inject\ninto the `HeroService`.",
-    "translation": "如果该应用没有提供这个 `Logger` 服务，当 Angular 试图把 `Logger` 注入到 `HeroService` 中时，就会抛出一个异常。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "BECAUSEASINGLETONLOGGERSERVICEISUSEFULEVERYWHEREITSPROVIDEDINTHEROOTAPPMODULE",
-    "original": "Because a singleton logger service is useful everywhere,\nit's provided in the root `AppModule`.",
-    "translation": "因为 `Logger` 服务的单例应该随处可用，所以要在根模块 `AppModule` 中提供它。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THEINJECTABLEAPICOREINJECTABLEDECORATORIDENTIFIESASERVICECLASSTHATMIGHTREQUIREINJECTEDDEPENDENCIES",
-    "original": "The **[@Injectable()](api/core/Injectable)** decorator identifies a service class \nthat _might_ require injected dependencies.",
-    "translation": "**[@Injectable()](api/core/Injectable)** 装饰器表示*可能*需要往这个服务类中注入其它依赖。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THEHEROSERVICEMUSTBEANNOTATEDWITHINJECTABLEBECAUSEITREQUIRESANINJECTEDLOGGER",
-    "original": "The `HeroService` must be annotated with `@Injectable()` because it requires an injected `Logger`.",
-    "translation": "`HeroService` 必须带有 `@Injectable()` 装饰器，因为它需要把 `Logger` 注入进来。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "ALWAYSWRITEINJECTABLEWITHPARENTHESESNOTJUSTINJECTABLE",
-    "original": "Always write `@Injectable()` with parentheses, not just `@Injectable`.",
-    "translation": "写 `@Injectable()` 时必须带括号，不能只写 `@Injectable`。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "WHENANGULARCREATESACLASSWHOSECONSTRUCTORHASPARAMETERSITLOOKSFORTYPEANDINJECTIONMETADATAABOUTTHOSEPARAMETERSSOTHATITCANINJECTTHERIGHTSERVICE",
-    "original": "When Angular creates a class whose constructor has parameters,\nit looks for type and injection metadata about those parameters\nso that it can inject the right service.",
-    "translation": "当 Angular 要创建一个构造函数中带参数的类时，会先查找这些参数的类型，以便根据这些参数的元数据注入正确的服务。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "IFANGULARCANTFINDTHATPARAMETERINFORMATIONITTHROWSANERROR",
-    "original": "If Angular can't find that parameter information, it throws an error.",
-    "translation": "如果不能找到该参数的信息，Angular 就会报错。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "ANGULARCANONLYFINDTHEPARAMETERINFORMATIONIFTHECLASSHASADECORATOROFSOMEKINDWHILEANYDECORATORWILLDOTHEINJECTABLEDECORATORISTHESTANDARDDECORATORFORSERVICECLASSES",
-    "original": "Angular can only find the parameter information _if the class has a decorator of some kind_.\nWhile _any_ decorator will do,\nthe `@Injectable()` decorator is the standard decorator for service classes.",
-    "translation": "Angular 只能在*带有某种装饰器的类*上查找参数信息。*任何*装饰器都可以，而 `@Injectable()` 装饰器是各种服务类的标准装饰器。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THEDECORATORREQUIREMENTISIMPOSEDBYTYPESCRIPT",
-    "original": "The decorator requirement is imposed by TypeScript.",
-    "translation": "之所以必须有装饰器，是因为 TypeScript 强制要求的。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "TYPESCRIPTNORMALLYDISCARDSPARAMETERTYPEINFORMATIONWHENITTRANSPILESTHECODETOJAVASCRIPTITPRESERVESTHISINFORMATIONIFTHECLASSHASADECORATORANDTHEEMITDECORATORMETADATACOMPILEROPTIONISSETTRUEINTYPESCRIPTSTSCONFIGJSONCONFIGURATIONFILE",
-    "original": "TypeScript normally discards parameter type information when it _transpiles_ the code to JavaScript.\nIt preserves this information if the class has a decorator\nand the `emitDecoratorMetadata` compiler option is set `true` \nin TypeScript's `tsconfig.json` configuration file, .",
-    "translation": "当把 TypeScript 转译成 JavaScript 时，通常会丢弃参数的类型信息。\n但当该类带有装饰器并且当 `tsconfig.json` 配置文件中的 `emitDecoratorMetadata` 编译选项为 `true` 时，它就会保留这些信息。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THECLICONFIGURESTSCONFIGJSONWITHEMITDECORATORMETADATA:TRUEITSYOURJOBTOPUTINJECTABLEONYOURSERVICECLASSES",
-    "original": "The CLI configures `tsconfig.json` with `emitDecoratorMetadata: true`\nIt's your job to put `@Injectable()` on your service classes.",
-    "translation": "CLI 生成的 `tsconfig.json` 中已经有 `emitDecoratorMetadata: true` 选项了，你只要把 `@Injectable()` 加到你的服务类上就可以了。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "THELOGGERSERVICEISANNOTATEDWITHINJECTABLEDECORATORTOOALTHOUGHITHASNOCONSTRUCTORANDNODEPENDENCIES",
-    "original": "The `Logger` service is annotated with `@Injectable()` decorator too, \nalthough it has no constructor and no dependencies.",
-    "translation": "`Logger` 服务也带有 `@Injectable()` 装饰器，不过它没有构造器，也没有依赖。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "INFACTEVERYANGULARSERVICECLASSINTHISAPPISANNOTATEDWITHTHEINJECTABLEDECORATORWHETHERORNOTITHASACONSTRUCTORANDDEPENDENCIESINJECTABLEISAREQUIREDCODINGSTYLEFORSERVICES",
-    "original": "In fact, _every_ Angular service class in this app is annotated with the `@Injectable()` decorator, whether or not it has a constructor and dependencies.\n`@Injectable()` is a required coding style for services.",
-    "translation": "该应用中的*每个* Angular 服务类不管有没有构造器和依赖，都带有 `@Injectable()` 装饰器。\n事实上，`@Injectable()` 是风格指南中对服务类的要求。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
   {
     "key": "##PROVIDERS",
     "original": "## Providers",
@@ -9731,12 +9515,6 @@
     "translation": "在下面的几节中会解释指定提供商的多种方式。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
-  {
-    "key": "ALMOSTALLOFTHEACCOMPANYINGCODESNIPPETSAREEXTRACTSFROMTHESAMPLEAPPSPROVIDERSCOMPONENTTSFILE",
-    "original": "Almost all of the accompanying code snippets are extracts from the sample app's `providers.component.ts` file.",
-    "translation": "几乎所有的代码片段都是从范例应用的 `providers.component.ts` 文件中提取出来的。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
   {
     "key": "###THECLASSASITSOWNPROVIDER",
     "original": "### The class as its own provider",
@@ -9983,6 +9761,264 @@
     "translation": "在这个例子中，只在 `HeroesComponent` 中需要它，\n  这里，它代替了元数据 `providers` 数组中原来的 `HeroService` 注册。\n  对比一下新的和旧的实现：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
+  {
+    "key": "###TREESHAKABLEPROVIDERS",
+    "original": "### Tree-shakable providers",
+    "translation": "### 可以被摇树优化的提供商",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "TREESHAKINGISTHEABILITYTOREMOVECODETHATISNOTREFERENCEDINANAPPLICATIONFROMTHEFINALBUNDLETREESHAKABLEPROVIDERSGIVEANGULARTHEABILITYTOREMOVESERVICESTHATARENOTUSEDINYOURAPPLICATIONFROMTHEFINALOUTPUTTHISSIGNIFICANTLYREDUCESTHESIZEOFYOURBUNDLES",
+    "original": "Tree shaking is the ability to remove code that is not referenced in an application from the final bundle. Tree-shakable providers give Angular the ability to remove services that are not used in your application from the final output. This significantly reduces the size of your bundles.",
+    "translation": "摇树优化可以在最终打包时移除应用中从未引用过的代码。可摇树优化的提供商可以让 Angular 从结果中移除应用中那些从未使用过的服务。这可以显著减小打包体积。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "IDEALLYIFANAPPLICATIONISNOTINJECTINGASERVICEITSHOULDNOTBEINCLUDEDINTHEFINALOUTPUTHOWEVERITTURNSOUTTHATTHEANGULARCOMPILERCANNOTIDENTIFYATBUILDTIMEIFTHESERVICEWILLBEREQUIREDORNOTBECAUSEITSALWAYSPOSSIBLETOINJECTASERVICEDIRECTLYUSINGINJECTORGETSERVICEANGULARCANNOTIDENTIFYALLOFTHEPLACESINYOURCODEWHERETHISINJECTIONCOULDHAPPENSOITHASNOCHOICEBUTTOINCLUDETHESERVICEINTHEINJECTORREGARDLESSTHUSSERVICESPROVIDEDINMODULESARENOTTREESHAKEABLE",
+    "original": "Ideally, if an application is not injecting a service, it should not be included in the final output. However, it turns out that the Angular compiler cannot identify at build time if the service will be required or not. Because it's always possible to inject a service directly using `injector.get(Service)`, Angular cannot identify all of the places in your code where this injection could happen, so it has no choice but to include the service in the injector regardless. Thus, services provided in modules are not tree-shakeable.",
+    "translation": "理想情况下，如果应用没有注入过某个服务，它就不应该被包含在最终结果中。不过，问题在于 Angular 的编译器无法在构建期间识别出该服务是不是必要的。\n因为总是可以使用 `injector.get(Service)` 的形式直接注入某个服务，而 Angular 不能从你的代码中识别出所有能够进行这种注入的地方。所以，Angular 别无选择，只能把这个服务包含到注入器中。因此，在模块中提供的服务也就无法进行摇树优化了。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "LETUSCONSIDERANEXAMPLEOFNONTREESHAKABLEPROVIDERSINANGULAR",
+    "original": "Let us consider an example of non-tree-shakable providers in Angular.",
+    "translation": "来看一个 Angular 无法对提供商进行摇树优化的例子。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "INTHISEXAMPLETOPROVIDESERVICESINANGULARYOUINCLUDETHEMINANNGMODULE:",
+    "original": "In this example, to provide services in Angular, you include them in an `@NgModule`:",
+    "translation": "在这个例子中，为了在 Angular 中提供服务，你把它们都包含进了 `@NgModule` 中：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THISMODULECANTHENBEIMPORTEDINTOYOURAPPLICATIONMODULETOMAKETHESERVICEAVAILABLEFORINJECTIONINYOURAPP:",
+    "original": "This module can then be imported into your application module, to make the service available for injection in your app:",
+    "translation": "接着，该模块可以导入到你的应用模块中，以便让该服务在整个应用中可用：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "WHENNGCRUNSITCOMPILESAPPMODULEINTOAMODULEFACTORYWHICHCONTAINSDEFINITIONSFORALLTHEPROVIDERSDECLAREDINALLTHEMODULESITINCLUDESATRUNTIMETHISFACTORYBECOMESANINJECTORTHATINSTANTIATESTHESESERVICES",
+    "original": "When `ngc` runs, it compiles AppModule into a module factory, which contains definitions for all the providers declared in all the modules it includes. At runtime, this factory becomes an injector that instantiates these services.",
+    "translation": "当运行 `ngc` 时，它会把 AppModule 编译进一个模块工厂里，该工厂中含有它包含的所有子模块中声明过的所有提供商。在运行期间，该工厂会编程一个用于实例化这些服务的注入器。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "TREESHAKINGDOESNTWORKINTHEMETHODABOVEBECAUSEANGULARCANNOTDECIDETOEXCLUDEONECHUNKOFCODETHEPROVIDERDEFINITIONFORTHESERVICEWITHINTHEMODULEFACTORYBASEDONWHETHERANOTHERCHUNKOFCODETHESERVICECLASSISUSEDTOMAKESERVICESTREESHAKEABLETHEINFORMATIONABOUTHOWTOCONSTRUCTANINSTANCEOFTHESERVICETHEPROVIDERDEFINITIONNEEDSTOBEAPARTOFTHESERVICECLASSITSELF",
+    "original": "Tree-shaking doesn't work in the method above because Angular cannot decide to exclude one chunk of code (the provider definition for the service within the module factory) based on whether another chunk of code (the service class) is used. To make services tree-shakeable, the information about how to construct an instance of the service (the provider definition) needs to be a part of the service class itself.",
+    "translation": "在这种方式下，摇树优化无法工作，因为 Angular 无法根据该代码（服务类）是否被其它代码块使用过（比如该服务的提供商就定义在了模块工厂里）来排除它。\n要让这些服务可以被摇树优化，所有关于如何构建该服务的实例的信息（提供商定义）就应该是该服务类本身的一部分。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "####CREATINGTREESHAKABLEPROVIDERS",
+    "original": "#### Creating tree-shakable providers",
+    "translation": "#### 创建可摇树优化的服务提供商",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "TOCREATEPROVIDERSTHATARETREESHAKABLETHEINFORMATIONTHATUSEDTOBESPECIFIEDINTHEMODULESHOULDBESPECIFIEDINTHEINJECTABLEDECORATORONTHESERVICEITSELF",
+    "original": "To create providers that are tree-shakable, the information that used to be specified in the module should be specified in the `@Injectable` decorator on the service itself.",
+    "translation": "要想创建可摇树优化的服务提供商，那些原本要通过模块来指定的信息就要改为在服务自身的 `@Injectable` 装饰器中提供。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THEFOLLOWINGEXAMPLESHOWSTHETREESHAKEABLEEQUIVALENTTOTHESERVICEMODULEEXAMPLEABOVE:",
+    "original": "The following example shows the tree-shakeable equivalent to the `ServiceModule` example above:",
+    "translation": "下面的例子展示了一个与上面的 `ServiceModule` 范例等价的可摇树的优化版本：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "INTHEEXAMPLEABOVEPROVIDEDINALLOWSYOUTODECLARETHEINJECTORWHICHINJECTSTHISSERVICEUNLESSTHEREISASPECIALCASETHEVALUESHOULDALWAYSBEROOTSETTINGTHEVALUETOROOTENSURESTHATTHESERVICEISSCOPEDTOTHEROOTINJECTORWITHOUTNAMINGAPARTICULARMODULETHATISPRESENTINTHATINJECTOR",
+    "original": "In the example above, `providedIn` allows you to declare the injector which injects this service. Unless there is a special case, the value should always be root. Setting the value to root ensures that the service is scoped to the root injector, without naming a particular module that is present in that injector.",
+    "translation": "上面这个例子中，`providedIn` 允许你声明要由哪个注入器来注入该服务。除了一些特殊情况外，这个值应该始终是 root（根注入器）。把该值设置为 root 可以确保该服务的范围是根注入器，而不是该注入器所在的那个特定模块。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THESERVICECANBEINSTANTIATEDBYCONFIGURINGAFACTORYFUNCTIONASSHOWNBELOW:",
+    "original": "The service can be instantiated by configuring a factory function as shown below:",
+    "translation": "该服务也可以通过配置一个工厂函数来实例化，例子如下：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "TOOVERRIDETREESHAKABLEPROVIDERSREGISTERTHEPROVIDERUSINGTHEPROVIDERS:ARRAYSYNTAXOFANYANGULARDECORATORTHATSUPPORTSIT",
+    "original": "To override tree-shakable providers, register the provider using the `providers: []` array syntax of any Angular decorator that supports it.",
+    "translation": "要想改写（override）一个可摇树优化的提供商，可以在任何支持 `providers: []` 数组的 Angular 装饰器中注册该提供商。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "##INJECTASERVICE",
+    "original": "## Inject a service",
+    "translation": "## 注入某个服务",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THEHEROLISTCOMPONENTSHOULDGETHEROESFROMTHEHEROSERVICE",
+    "original": "The `HeroListComponent` should get heroes from the `HeroService`.",
+    "translation": "`HeroListComponent` 应该从 `HeroService` 中获取这些英雄数据。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THECOMPONENTSHOULDNTCREATETHEHEROSERVICEWITHNEWITSHOULDASKFORTHEHEROSERVICETOBEINJECTED",
+    "original": "The component shouldn't create the `HeroService` with `new`.\nIt should ask for the `HeroService` to be injected.",
+    "translation": "该组件不应该使用 `new` 来创建 `HeroService`。\n它应该要求注入 `HeroService`。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "YOUCANTELLANGULARTOINJECTADEPENDENCYINTHECOMPONENTSCONSTRUCTORBYSPECIFYINGACONSTRUCTORPARAMETERWITHTHEDEPENDENCYTYPEHERESTHEHEROLISTCOMPONENTCONSTRUCTORASKINGFORTHEHEROSERVICETOBEINJECTED",
+    "original": "You can tell Angular to inject a dependency in the component's constructor by specifying a **constructor parameter with the dependency type**.\nHere's the `HeroListComponent` constructor, asking for the `HeroService` to be injected.",
+    "translation": "你可以通过**在构造函数中添加一个带有该依赖类型的参数**来要求 Angular 把这个依赖注入到组件的构造函数中。\n下面是 `HeroListComponent` 的构造函数，它要求注入 `HeroService`。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "OFCOURSETHEHEROLISTCOMPONENTSHOULDDOSOMETHINGWITHTHEINJECTEDHEROSERVICEHERESTHEREVISEDCOMPONENTMAKINGUSEOFTHEINJECTEDSERVICESIDEBYSIDEWITHTHEPREVIOUSVERSIONFORCOMPARISON",
+    "original": "Of course, the `HeroListComponent` should do something with the injected `HeroService`.\nHere's the revised component, making use of the injected service, side-by-side with the previous version for comparison.",
+    "translation": "当然，`HeroListComponent` 还应该使用注入的这个 `HeroService` 做点什么。\n下面输出修改过的组件，改用注入的服务，与前一个版本对比一下。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "NOTICETHATTHEHEROLISTCOMPONENTDOESNTKNOWWHERETHEHEROSERVICECOMESFROMYOUKNOWTHATITCOMESFROMTHEPARENTHEROESCOMPONENTIFYOUDECIDEDINSTEADTOPROVIDETHEHEROSERVICEINTHEAPPMODULETHEHEROLISTCOMPONENTWOULDNTCHANGEATALLTHEONLYTHINGTHATMATTERSISTHATTHEHEROSERVICEISPROVIDEDINSOMEPARENTINJECTOR",
+    "original": "Notice that the `HeroListComponent` doesn't know where the `HeroService` comes from.\n_You_ know that it comes from the parent `HeroesComponent`.\nIf you decided instead to provide the `HeroService` in the `AppModule`,\nthe `HeroListComponent` wouldn't change at all.\nThe _only thing that matters_ is that the `HeroService` is provided in some parent injector.",
+    "translation": "注意，`HeroListComponent` 并不知道 `HeroService` 来自哪里。\n不过，**你**知道它来自其父组件 `HeroesComponent`。\n如果你决定改为在 `AppModule` 中提供这个 `HeroService`，`HeroListComponent` 不需要做任何改动。\n**唯一需要关心的问题**是，`HeroService` 是由某个父注入器提供的。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "##SINGLETONSERVICES",
+    "original": "## Singleton services",
+    "translation": "## 单例服务",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "SERVICESARESINGLETONSWITHINTHESCOPEOFANINJECTORTHEREISATMOSTONEINSTANCEOFASERVICEINAGIVENINJECTOR",
+    "original": "Services are singletons _within the scope of an injector_.\nThere is at most one instance of a service in a given injector.",
+    "translation": "服务*在每个注入器的范围内*是单例的。\n在任何一个注入器中，最多只会有同一个服务的一个实例。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THEREISONLYONEROOTINJECTORANDTHEUSERSERVICEISREGISTEREDWITHTHATINJECTORTHEREFORETHERECANBEJUSTONEUSERSERVICEINSTANCEINTHEENTIREAPPANDEVERYCLASSTHATINJECTSUSERSERVICEGETTHISSERVICEINSTANCE",
+    "original": "There is only one root injector, and the `UserService` is registered with that injector.\nTherefore, there can be just one `UserService` instance in the entire app,\nand every class that injects `UserService` get this service instance.",
+    "translation": "这里只有一个根注入器，而 `UserService` 就是在该注入器中注册的。\n所以，在整个应用中只能有一个 `UserService` 实例，每个要求注入 `UserService` 的类都会得到这个服务实例。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "HOWEVERANGULARDIISAHIERARCHICALINJECTIONSYSTEMGUIDEHIERARCHICALDEPENDENCYINJECTIONWHICHMEANSTHATNESTEDINJECTORSCANCREATETHEIROWNSERVICEINSTANCESANGULARCREATESNESTEDINJECTORSALLTHETIME",
+    "original": "However, Angular DI is a \n[hierarchical injection system](guide/hierarchical-dependency-injection), \nwhich means that nested injectors can create their own service instances.\nAngular creates nested injectors all the time.",
+    "translation": "不过，Angular DI 是一个 [多级注入系统](guide/hierarchical-dependency-injection)，这意味着各级注入器都可以创建它们自己的服务实例。\nAngular 总会创建多级注入器。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "##COMPONENTCHILDINJECTORS",
+    "original": "## Component child injectors",
+    "translation": "## 组件的子注入器",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "COMPONENTINJECTORSAREINDEPENDENTOFEACHOTHERANDEACHOFTHEMCREATESITSOWNINSTANCESOFTHECOMPONENTPROVIDEDSERVICES",
+    "original": "Component injectors are independent of each other and\neach of them creates its own instances of the component-provided services.",
+    "translation": "组件注入器是彼此独立的，每一个都会为这些组件提供的服务创建单独的实例。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "FOREXAMPLEWHENANGULARCREATESANEWINSTANCEOFACOMPONENTTHATHASCOMPONENTPROVIDERSITALSOCREATESANEWCHILDINJECTORFORTHATINSTANCE",
+    "original": "For example, when Angular creates a new instance of a component that has `@Component.providers`,\nit also creates a new _child injector_ for that instance.",
+    "translation": "例如，当 Angular 创建一个带有 `@Component.providers` 的组件实例时，也会同时为这个实例创建一个新的*子注入器*。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "WHENANGULARDESTROYSONEOFTHESECOMPONENTINSTANCESITALSODESTROYSTHECOMPONENTSINJECTORANDTHATINJECTORSSERVICEINSTANCES",
+    "original": "When Angular destroys one of these component instances, it also destroys the\ncomponent's injector and that injector's service instances.",
+    "translation": "当 Angular 销毁某个组件实例时，也会同时销毁该组件的注入器，以及该注入器中的服务实例。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "BECAUSEOFINJECTORINHERITANCEGUIDEHIERARCHICALDEPENDENCYINJECTIONYOUCANSTILLINJECTAPPLICATIONWIDESERVICESINTOTHESECOMPONENTSACOMPONENTSINJECTORISACHILDOFITSPARENTCOMPONENTSINJECTORANDADESCENDENTOFITSPARENTSPARENTSINJECTORANDSOONALLTHEWAYBACKTOTHEAPPLICATIONSROOTINJECTORANGULARCANINJECTASERVICEPROVIDEDBYANYINJECTORINTHATLINEAGE",
+    "original": "Because of [injector inheritance](guide/hierarchical-dependency-injection),\nyou can still inject application-wide services into these components.\nA component's injector is a child of its parent component's injector,\nand a descendent of its parent's parent's injector, and so on all the way back to the application's _root_ injector.\nAngular can inject a service provided by any injector in that lineage.",
+    "translation": "由于是[多层注入器](guide/hierarchical-dependency-injection)，因此你仍然可以把全应用级的服务注入到这些组件中。\n组件的注入器是其父组件注入器的孩子，也是其爷爷注入器的孙子，以此类推，直到该应用的**根**注入器。\nAngular 可以注入这条线上的任何注入器所提供的服务。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "FOREXAMPLEANGULARCOULDINJECTAHEROLISTCOMPONENTWITHBOTHTHEHEROSERVICEPROVIDEDINHEROCOMPONENTANDTHEUSERSERVICEPROVIDEDINAPPMODULE",
+    "original": "For example, Angular could inject a `HeroListComponent`\nwith both the `HeroService` provided in `HeroComponent`\nand the `UserService` provided in `AppModule`.",
+    "translation": "比如，Angular 可以把由 `HeroComponent` 提供的 `HeroService` 和由 `AppModule` 提供的 `UserService` 注入到 `HeroService` 中。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "##TESTINGTHECOMPONENT",
+    "original": "## Testing the component",
+    "translation": "## 测试组件",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "EARLIERYOUSAWTHATDESIGNINGACLASSFORDEPENDENCYINJECTIONMAKESTHECLASSEASIERTOTESTLISTINGDEPENDENCIESASCONSTRUCTORPARAMETERSMAYBEALLYOUNEEDTOTESTAPPLICATIONPARTSEFFECTIVELY",
+    "original": "Earlier you saw that designing a class for dependency injection makes the class easier to test.\nListing dependencies as constructor parameters may be all you need to test application parts effectively.",
+    "translation": "前面强调过，设计一个适合依赖注入的类，可以让这个类更容易测试。\n要有效的测试应用中的一部分，只需要在构造函数的参数中列出依赖。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "FOREXAMPLEYOUCANCREATEANEWHEROLISTCOMPONENTWITHAMOCKSERVICETHATYOUCANMANIPULATEUNDERTEST:",
+    "original": "For example, you can create a new `HeroListComponent` with a mock service that you can manipulate\nunder test:",
+    "translation": "例如，新建的 `HeroListComponent` 实例使用一个模拟 (mock) 服务，以便可以在测试中操纵它：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "LEARNMOREINTHETESTINGGUIDETESTINGGUIDE",
+    "original": "Learn more in the [Testing](guide/testing) guide.",
+    "translation": "要学习更多知识，参见[测试](guide/testing)一章。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "##WHENTHESERVICENEEDSASERVICE",
+    "original": "## When the service needs a service",
+    "translation": "## 当服务需要别的服务时",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THEHEROSERVICEISVERYSIMPLEITDOESNTHAVEANYDEPENDENCIESOFITSOWN",
+    "original": "The `HeroService` is very simple. It doesn't have any dependencies of its own.",
+    "translation": "这个 `HeroService` 非常简单。它本身不需要任何依赖。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "WHATIFITHADADEPENDENCYWHATIFITREPORTEDITSACTIVITIESTHROUGHALOGGINGSERVICEYOUDAPPLYTHESAMECONSTRUCTORINJECTIONPATTERNADDINGACONSTRUCTORTHATTAKESALOGGERPARAMETER",
+    "original": "What if it had a dependency? What if it reported its activities through a logging service?\nYou'd apply the same *constructor injection* pattern,\nadding a constructor that takes a `Logger` parameter.",
+    "translation": "如果它也有依赖，该怎么办呢？例如，它需要通过日志服务来汇报自己的活动。\n你同样用*构造函数注入*模式，来添加一个带有 `Logger` 参数的构造函数。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "HEREISTHEREVISEDHEROSERVICETHATINJECTSTHELOGGERSIDEBYSIDEWITHTHEPREVIOUSSERVICEFORCOMPARISON",
+    "original": "Here is the revised `HeroService` that injects the `Logger`, side-by-side with the previous service for comparison.",
+    "translation": "下面是修改后的 `HeroService`，它注入了 `Logger`，对比前后这两个版本：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THECONSTRUCTORASKSFORANINJECTEDINSTANCEOFALOGGERANDSTORESITINAPRIVATEFIELDCALLEDLOGGERTHEGETHEROESMETHODLOGSAMESSAGEWHENASKEDTOFETCHHEROES",
+    "original": "The constructor asks for an injected instance of a `Logger` and stores it in a private field called `logger`.\nThe `getHeroes()` method logs a message when asked to fetch heroes.",
+    "translation": "这个构造函数要求注入一个 `Logger` 类的实例，并把它存到名为 `logger` 的私有字段中。\n  当请求英雄数据时，`getHeroes()` 中就会记录一个消息。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "####THEDEPENDENTLOGGERSERVICE",
+    "original": "#### The dependent _Logger_ service",
+    "translation": "#### 被依赖的 `Logger` 服务",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "THESAMPLEAPPSLOGGERSERVICEISQUITESIMPLE:",
+    "original": "The sample app's `Logger` service is quite simple:",
+    "translation": "这个范例应用的 `Logger` 服务非常简单：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "IFTHEAPPDIDNTPROVIDETHISLOGGERANGULARWOULDTHROWANEXCEPTIONWHENITLOOKEDFORALOGGERTOINJECTINTOTHEHEROSERVICE",
+    "original": "If the app didn't provide this `Logger`,\nAngular would throw an exception when it looked for a `Logger` to inject\ninto the `HeroService`.",
+    "translation": "如果该应用没有提供这个 `Logger` 服务，当 Angular 试图把 `Logger` 注入到 `HeroService` 中时，就会抛出一个异常。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
+  {
+    "key": "BECAUSEASINGLETONLOGGERSERVICEISUSEFULEVERYWHEREITSPROVIDEDINTHEROOTAPPMODULE",
+    "original": "Because a singleton logger service is useful everywhere,\nit's provided in the root `AppModule`.",
+    "translation": "因为 `Logger` 服务的单例应该随处可用，所以要在根模块 `AppModule` 中提供它。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
+  },
   {
     "key": "##DEPENDENCYINJECTIONTOKENS",
     "original": "## Dependency injection tokens",
@@ -10080,15 +10116,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "THETYPEPARAMETERWHILEOPTIONALCONVEYSTHEDEPENDENCYSTYPETODEVELOPERSANDTOOLINGTHETOKENDESCRIPTIONISANOTHERDEVELOPERAID",
-    "original": "The type parameter, while optional, conveys the dependency's type to developers and tooling.\nThe token description is another developer aid.",
-    "translation": "类型参数，虽然是可选的，但可以向开发者和开发工具传达类型信息。\n而且这个令牌的描述信息也可以为开发者提供帮助。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "REGISTERTHEDEPENDENCYPROVIDERUSINGTHEINJECTIONTOKENOBJECT:",
-    "original": "Register the dependency provider using the `InjectionToken` object:",
-    "translation": "使用这个 `InjectionToken` 对象注册依赖的提供商：",
+    "key": "YOUCANDIRECTLYCONFIGUREAPROVIDERWHENCREATINGANINJECTIONTOKENTHEPROVIDERCONFIGURATIONDETERMINESWHICHINJECTORPROVIDESTHETOKENANDHOWTHEVALUEWILLBECREATEDTHISISSIMILARTOUSINGINJECTABLEEXCEPTTHATYOUCANNOTDEFINESTANDARDPROVIDERSSUCHASUSECLASSORUSEFACTORYWITHINJECTIONTOKENINSTEADYOUSPECIFYAFACTORYFUNCTIONWHICHRETURNSTHEVALUETOBEPROVIDEDDIRECTLY",
+    "original": "You can directly configure a provider when creating an `InjectionToken`. The provider configuration determines which injector provides the token and how the value will be created.  This is similar to using `@Injectable`, except that you cannot define standard providers (such as `useClass` or `useFactory`) with `InjectionToken`. Instead, you specify a factory function which returns the value to be provided directly.",
+    "translation": "你可以在创建 `InjectionToken` 时直接配置一个提供商。该提供商的配置会决定由哪个注入器来提供这个令牌，以及如何创建它的值。\n这和 `@Injectable` 的用法很像，不过你没法用 `InjectionToken` 来定义标准提供商（比如 `useClass` 或 `useFactory`），而要指定一个工厂函数，该函数直接返回想要提供的值。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -10098,15 +10128,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "ALTHOUGHTHEAPPCONFIGINTERFACEPLAYSNOROLEINDEPENDENCYINJECTIONITSUPPORTSTYPINGOFTHECONFIGURATIONOBJECTWITHINTHECLASS",
-    "original": "Although the `AppConfig` interface plays no role in dependency injection,\nit supports typing of the configuration object within the class.",
-    "translation": "虽然 `AppConfig` 接口在依赖注入过程中没有任何作用，但它为该类中的配置对象提供了强类型信息。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
-  },
-  {
-    "key": "ALTERNATIVELYYOUCANPROVIDEANDINJECTTHECONFIGURATIONOBJECTINANNGMODULELIKEAPPMODULE",
-    "original": "Alternatively, you can provide and inject the configuration object in an ngModule like `AppModule`.",
-    "translation": "或者在 ngModule 中提供并注入这个配置对象，如 `AppModule`。",
+    "key": "IFTHEFACTORYFUNCTIONNEEDSACCESSTOOTHERDITOKENSITCANUSETHEINJECTFUNCTIONFROMANGULARCORETOREQUESTDEPENDENCIES",
+    "original": "If the factory function needs access to other DI tokens, it can use the inject function from `@angular/core` to request dependencies.",
+    "translation": "如果工厂函数需要访问其它的 DI 令牌，它可以使用来自 `@angular/core` 中的 `inject` 函数来申请它的依赖。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -10116,15 +10140,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "THEHEROSERVICEREQUIRESALOGGERBUTWHATIFITCOULDGETBYWITHOUTALOGGERYOUCANTELLANGULARTHATTHEDEPENDENCYISOPTIONALBYANNOTATINGTHECONSTRUCTORARGUMENTWITHOPTIONAL:",
-    "original": "The `HeroService` *requires* a `Logger`, but what if it could get by without\na `logger`?\nYou can tell Angular that the dependency is optional by annotating the\nconstructor argument with `@Optional()`:",
-    "translation": "`HeroService`*需要*一个 `Logger`，但是如果想不提供 Logger 也能得到它，该怎么办呢？\n可以把构造函数的参数标记为 `@Optional()`，告诉 Angular 该依赖是可选的：",
+    "key": "YOUCANTELLANGULARTHATTHEDEPENDENCYISOPTIONALBYANNOTATINGTHECONSTRUCTORARGUMENTWITHNULL:",
+    "original": "You can tell Angular that the dependency is optional by annotating the constructor argument with null:",
+    "translation": "可以把构造函数的参数标记为 `null` 来告诉 Angular 该依赖是可选的：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
-    "key": "WHENUSINGOPTIONALYOURCODEMUSTBEPREPAREDFORANULLVALUEIFYOUDONTREGISTERALOGGERSOMEWHEREUPTHELINETHEINJECTORWILLSETTHEVALUEOFLOGGERTONULL",
-    "original": "When using `@Optional()`, your code must be prepared for a null value. If you\ndon't register a `logger` somewhere up the line, the injector will set the\nvalue of `logger` to null.",
-    "translation": "当使用 `@Optional()` 时，代码必须准备好如何处理空值。\n如果其它的代码没有注册一个 `logger`，注入器会设置该 `logger` 的值为空 null。",
+    "key": "WHENUSINGOPTIONALDEPENDENCIESYOURCODEMUSTBEPREPAREDFORANULLVALUE",
+    "original": "When using optional dependencies, your code must be prepared for a null value.",
+    "translation": "如果要使用可选依赖，你的代码就必须准备好处理空值。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dependency-injection.md"
   },
   {
@@ -10572,9 +10596,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/deployment.md"
   },
   {
-    "key": "THEOUTPUTFOLDERISDISTBYDEFAULTTOOUTPUTTOADIFFERENTFOLDERCHANGETHEOUTDIRINANGULARCLIJSON",
-    "original": "The output folder is  `dist/` by default.\nTo output to a different folder, change the `outDir` in `.angular-cli.json`.",
-    "translation": "默认的输出文件夹是 `dist/`。\n要输出到其它文件夹中，请修改 `.angular-cli.json` 中的 `outDir`。",
+    "key": "THEOUTPUTFOLDERISDISTBYDEFAULTTOOUTPUTTOADIFFERENTFOLDERCHANGETHEOUTPUTPATHINANGULARJSON",
+    "original": "The output folder is  `dist/` by default.\nTo output to a different folder, change the `outputPath` in `angular.json`.",
+    "translation": "默认的输出文件夹是 `dist/`。\n要输出到其它文件夹中，请修改 `angular.json` 中的 `outputPath`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/deployment.md"
   },
   {
@@ -11657,6 +11681,18 @@
     "translation": "[回到顶部](guide/dynamic-form#top)",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/dynamic-form.md"
   },
+  {
+    "key": "###HOWITWORKS",
+    "original": "### How it works",
+    "translation": "### 工作原理",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/elements.md"
+  },
+  {
+    "key": "BROWSER",
+    "original": "Browser",
+    "translation": "浏览器",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/elements.md"
+  },
   {
     "key": "#ENTRYCOMPONENTS",
     "original": "# Entry Components",
@@ -13638,9 +13674,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANGULARHASITSOWNVOCABULARYMOSTANGULARTERMSARECOMMONENGLISHWORDSWITHASPECIFICMEANINGWITHINTHEANGULARSYSTEM",
-    "original": "Angular has its own vocabulary.\nMost Angular terms are common English words\nwith a specific meaning within the Angular system.",
-    "translation": "Angular 有自己的词汇表。\n虽然大多数 Angular 短语都是日常用语，但是在 Angular 体系中，它们有特别的含义。",
+    "key": "ANGULARHASITSOWNVOCABULARYMOSTANGULARTERMSARECOMMONENGLISHWORDSORCOMPUTINGTERMSTHATHAVEASPECIFICMEANINGWITHINTHEANGULARSYSTEM",
+    "original": "Angular has its own vocabulary.\nMost Angular terms are common English words or computing terms\nthat have a specific meaning within the Angular system.",
+    "translation": "Angular 有自己的词汇表。\n虽然大多数 Angular 短语都是日常用语或计算机术语，但是在 Angular 体系中，它们有特别的含义。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -13656,9 +13692,21 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "YOUCANCOMPILEANGULARAPPLICATIONSATBUILDTIMEBYCOMPILINGYOURAPPLICATIONUSINGTHECOMPILERCLINGCYOUCANBOOTSTRAPDIRECTLYTOAMODULEFACTORYMEANINGYOUDONTNEEDTOINCLUDETHEANGULARCOMPILERINYOURJAVASCRIPTBUNDLEAHEADOFTIMECOMPILEDAPPLICATIONSALSOBENEFITFROMDECREASEDLOADTIMEANDINCREASEDPERFORMANCE",
-    "original": "You can compile Angular applications at build time.\nBy compiling your application using the compiler-cli, `ngc`, you can bootstrap directly to a module factory, meaning you don't need to include the Angular compiler in your JavaScript bundle.\nAhead-of-time compiled applications also benefit from decreased load time and increased performance.",
-    "translation": "开发者可以在构造时 (build-time) 编译 Angular 应用程序。\n  通过 `compiler-cli` - `ngc` 编译应用程序，应用可以从一个模块工厂直接启动，\n  意味着不再需要把 Angular 编译器添加到 JavaScript 包中。\n  预编译的应用程序加载迅速，具有更高的性能。",
+    "key": "THEANGULARAHEADOFTIMEAOTCOMPILERCONVERTSYOURANGULARHTMLANDTYPESCRIPTCODEINTOEFFICIENTJAVASCRIPTCODEDURINGTHEBUILDPHASEBEFORETHEBROWSERDOWNLOADSANDRUNSTHATCODETHISISTHEBESTCOMPILATIONMODEFORPRODUCTIONENVIRONMENTSWITHDECREASEDLOADTIMEANDINCREASEDPERFORMANCE",
+    "original": "The Angular ahead-of-time (AOT) compiler converts your Angular HTML and TypeScript code \ninto efficient JavaScript code during the build phase before the browser downloads \nand runs that code. \nThis is the best compilation mode for production environments, with decreased load time and increased performance.",
+    "translation": "Angular 的预先（AOT）编译器可以在编译期间把你的 HTML 代码和 TypeScript 代码转换成高效的 JavaScript 代码，这样浏览器就可以直接下载和运行它们。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "BYCOMPILINGYOURAPPLICATIONUSINGTHENGCCOMMANDLINETOOLYOUCANBOOTSTRAPDIRECTLYTOAMODULEFACTORYMEANINGYOUDONTNEEDTOINCLUDETHEANGULARCOMPILERINYOURJAVASCRIPTBUNDLE",
+    "original": "By compiling your application using the `ngc` command-line tool, you can bootstrap directly to a module factory, meaning you don't need to include the Angular compiler in your JavaScript bundle.",
+    "translation": "使用命令行工具 `ngc` 来编译你的应用之后，就可以直接启动一个模块工厂，这意味着你不必再在 JavaScript 打包文件中包含 Angular 编译器。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "COMPAREJUSTINTIMEJITCOMPILATIONGUIDEGLOSSARY#JIT",
+    "original": "Compare [just-in-time (JIT) compilation](guide/glossary#jit).",
+    "translation": "可以与[即时(JIT)编译](guide/glossary#jit)对比一下。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -13668,9 +13716,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "INPRACTICEASYNONYMFORDECORATIONGUIDEGLOSSARY#DECORATOR",
-    "original": "In practice, a synonym for [Decoration](guide/glossary#decorator).",
-    "translation": "实际上，是[装饰 (decoration)](guide/glossary#decorator) 的同义词。",
+    "key": "ASTRUCTURETHATPROVIDESMETADATAFORACLASSSEEDECORATORGUIDEGLOSSARY#DECORATOR",
+    "original": "A structure that provides metadata for a class. See [Decorator](guide/glossary#decorator).",
+    "translation": "一种为类提供元数据的结构。参见 [装饰器](guide/glossary#decorator)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -13686,63 +13734,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "FOREXAMPLEYOUCANUSETHENGCLASSDIRECTIVETOADDANDREMOVECSSCLASSNAMES",
-    "original": "For example, you can use the `ngClass` directive to add and remove CSS class names.",
-    "translation": "例如，`ngClass` 指令就是典型的属性型指令。它可以添加或移除 CSS 类名。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "LEARNABOUTTHEMINTHEATTRIBUTEDIRECTIVESGUIDEATTRIBUTEDIRECTIVESGUIDE",
-    "original": "Learn about them in the [_Attribute Directives_](guide/attribute-directives) guide.",
-    "translation": "要了解更多信息，请参见[*属性型指令*](guide/attribute-directives)页。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "##BARREL",
-    "original": "## Barrel",
-    "translation": "## 封装桶",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "AWAYTOROLLUPEXPORTSFROMSEVERALES2015MODULESINTOASINGLECONVENIENTES2015MODULETHEBARRELITSELFISANES2015MODULEFILETHATREEXPORTSSELECTEDEXPORTSOFOTHERES2015MODULES",
-    "original": "A way to *roll up exports* from several ES2015 modules into a single convenient ES2015 module.\nThe barrel itself is an ES2015 module file that re-exports *selected* exports of other ES2015 modules.",
-    "translation": "封装桶是把多个模块的*导出结果*汇总到单一的 ES2015 模块的一种方式。\n      封装桶本身是一个 ES2015 模块文件，它重新导出*选中的*导出，这些导入来自其它 ES2015 模块。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "FOREXAMPLEIMAGINETHREEES2015MODULESINAHEROESFOLDER:",
-    "original": "For example, imagine three ES2015 modules in a `heroes` folder:",
-    "translation": "例如，设想在 `heroes` 目录下有三个 ES2015 模块：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "WITHOUTABARRELACONSUMERNEEDSTHREEIMPORTSTATEMENTS:",
-    "original": "Without a barrel, a consumer needs three import statements:",
-    "translation": "如果没有封装桶，消费者需要三条导入语句：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "YOUCANADDABARRELTOTHEHEROESFOLDERCALLEDINDEXBYCONVENTIONTHATEXPORTSALLOFTHESEITEMS:",
-    "original": "You can add a barrel to the `heroes` folder (called `index`, by convention) that exports all of these items:",
-    "translation": "在 `heroes` 目录下添加一个封装桶（按约定叫做 `index`），它导出所有这三项：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "NOWACONSUMERCANIMPORTWHATITNEEDSFROMTHEBARREL",
-    "original": "Now a consumer can import what it needs from the barrel.",
-    "translation": "现在，消费者就就可以从这个封装桶中导入它需要的东西了。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "THEANGULARSCOPEDPACKAGESGUIDEGLOSSARY#SCOPEDPACKAGEEACHHAVEABARRELNAMEDINDEX",
-    "original": "The Angular [scoped packages](guide/glossary#scoped-package) each have a barrel named `index`.",
-    "translation": "Angular 的每个[范围化包 (scoped package)](guide/glossary#scoped-package) 都有一个名为 `index` 的封装桶。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "YOUCANOFTENACHIEVETHESAMERESULTUSINGNGMODULESGUIDEGLOSSARY#NGMODULEINSTEAD",
-    "original": "You can often achieve the same result using [NgModules](guide/glossary#ngmodule) instead.",
-    "translation": "注意，你可以利用 [Angular 模块](guide/glossary#ngmodule)达到同样的目的。",
+    "key": "LEARNMOREINTHEATTRIBUTEDIRECTIVESGUIDEATTRIBUTEDIRECTIVESGUIDE",
+    "original": "Learn more in the [_Attribute Directives_](guide/attribute-directives) guide.",
+    "translation": "要了解更多，参见[*属性型指令*](guide/attribute-directives)",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -13752,15 +13746,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "USUALLYREFERSTODATABINDINGGUIDEGLOSSARY#DATABINDINGANDTHEACTOFBINDINGANHTMLOBJECTPROPERTYTOADATAOBJECTPROPERTY",
-    "original": "Usually refers to [data binding](guide/glossary#data-binding) and the act of\nbinding an HTML object property to a data object property.",
-    "translation": "几乎都是指的[数据绑定 (data binding)](guide/glossary#data-binding) 和将 HTML 对象属性绑定到数据对象属性的行为。",
+    "key": "GENERALLYTHEPRACTICEOFSETTINGAVARIABLEORPROPERTYTOADATAVALUEWITHINANGULARTYPICALLYREFERSTODATABINDINGGUIDEGLOSSARY#DATABINDINGWHICHCOORDINATESDOMOBJECTPROPERTIESWITHDATAOBJECTPROPERTIES",
+    "original": "Generally, the practice of setting a variable or property to a data value. \nWithin Angular, typically refers to [data binding](guide/glossary#data-binding), \nwhich coordinates DOM object properties with data object properties.",
+    "translation": "广义上是指把变量或属性设置为某个数据值的一种实践。\n在 Angular 中，一般是指[数据绑定](guide/glossary#data-binding)，它会根据数据对象属性的值来设置 DOM 对象的属性。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "SOMETIMESREFERSTOADEPENDENCYINJECTIONGUIDEGLOSSARY#DEPENDENCYINJECTIONBINDINGBETWEENATOKENMDASHALSOREFERREDTOASAKEYMDASHANDADEPENDENCYPROVIDERGUIDEGLOSSARY#PROVIDER",
-    "original": "Sometimes refers to a [dependency-injection](guide/glossary#dependency-injection) binding\nbetween a \"token\"&mdash;also referred to as a \"key\"&mdash;and a dependency [provider](guide/glossary#provider).",
-    "translation": "有时也会指在“令牌”（也称为键）和依赖[提供商 (provider)](guide/glossary#provider)\n之间的[依赖注入 (dependency injection)](guide/glossary#dependency-injection) 绑定。\n这种用法很少，而且一般都会在上下文中写清楚。",
+    "key": "SOMETIMESREFERSTOADEPENDENCYINJECTIONGUIDEGLOSSARY#DEPENDENCYINJECTIONBINDINGBETWEENATOKENGUIDEGLOSSARY#TOKENANDADEPENDENCYPROVIDERGUIDEGLOSSARY#PROVIDER",
+    "original": "Sometimes refers to a [dependency-injection](guide/glossary#dependency-injection) binding\nbetween a [token](guide/glossary#token) and a dependency [provider](guide/glossary#provider).",
+    "translation": "有时也会指在“[令牌（Token）](guide/glossary#token)”和依赖[提供商（Provider）](guide/glossary#provider)\n之间的[依赖注入](guide/glossary#dependency-injection) 绑定。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -13770,51 +13764,99 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "YOULAUNCHANANGULARAPPLICATIONBYBOOTSTRAPPINGITUSINGTHEAPPLICATIONROOTNGMODULEAPPMODULE",
-    "original": "You launch an Angular application by \"bootstrapping\" it using the application root NgModule (`AppModule`).",
-    "translation": "通过应用程序根 Angular 模块(`AppModule`)来启动 Angular 应用程序。",
+    "key": "AWAYTOINITIALIZEANDLAUNCHANAPPORSYSTEM",
+    "original": "A way to initialize and launch an app or system.",
+    "translation": "一种用来初始化和启动应用或系统的途径。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "BOOTSTRAPPINGIDENTIFIESANAPPLICATIONSTOPLEVELROOTCOMPONENTGUIDEGLOSSARY#COMPONENTWHICHISTHEFIRSTCOMPONENTTHATISLOADEDFORTHEAPPLICATION",
-    "original": "Bootstrapping identifies an application's top level \"root\" [component](guide/glossary#component),\nwhich is the first component that is loaded for the application.",
-    "translation": "启动过程标识应用的顶级“根”[组件 (component)](guide/glossary#component)，也就是应用加载的第一个组件。",
+    "key": "INANGULARANAPPSROOTNGMODULEAPPMODULEHASABOOTSTRAPPROPERTYTHATIDENTIFIESTHEAPPSTOPLEVELCOMPONENTSGUIDEGLOSSARY#COMPONENTDURINGTHEBOOTSTRAPPROCESSANGULARCREATESANDINSERTSTHESECOMPONENTSINTOTHEINDEXHTMLHOSTWEBPAGEYOUCANBOOTSTRAPMULTIPLEAPPSINTHESAMEINDEXHTMLEACHAPPWITHITSOWNCOMPONENTS",
+    "original": "In Angular, an app's root NgModule (`AppModule`) has a `bootstrap` property that identifies the app's top-level [components](guide/glossary#component). \nDuring the bootstrap process, Angular creates and inserts these components into the `index.html` host web page. \nYou can bootstrap multiple apps in the same `index.html`, each app with its own components.",
+    "translation": "在 Angular 中，应用的根模块（`AppModule`）有一个 `bootstrap` 属性，用于指出该应用的的顶级[组件](guide/glossary#component)。\n在引导期间，Angular 会创建这些组件，并插入到宿主页面 `index.html` 中。\n你可以在同一个 `index.html` 中引导多个应用，每个应用都有一些自己的组件。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "YOUCANBOOTSTRAPMULTIPLEAPPSINTHESAMEINDEXHTMLEACHAPPWITHITSOWNTOPLEVELROOT",
-    "original": "You can bootstrap multiple apps in the same `index.html`, each app with its own top-level root.",
-    "translation": "你可以在同一个 `index.html` 中引导多个应用，每个应用都有它自己的顶级根组件。",
+    "key": "LEARNMOREINTHEBOOTSTRAPPINGGUIDEBOOTSTRAPPINGGUIDE",
+    "original": "Learn more in the [_Bootstrapping_](guide/bootstrapping) guide.",
+    "translation": "要了解更多，参见[*引导*](guide/bootstrapping)一章。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "##CAMELCASE",
-    "original": "## camelCase",
-    "translation": "## 驼峰式命名法 (camelCase)",
+    "key": "##CASECONVENTIONS",
+    "original": "## Case conventions",
+    "translation": "## 大小写约定",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THEPRACTICEOFWRITINGCOMPOUNDWORDSORPHRASESSUCHTHATEACHWORDORABBREVIATIONBEGINSWITHACAPITALLETTEREXCEPTTHEFIRSTLETTERWHICHISLOWERCASE",
-    "original": "The practice of writing compound words or phrases such that each word or abbreviation begins with a capital letter\n_except the first letter, which is lowercase_.",
-    "translation": "驼峰式命名法是书写复合词或短语的一种形式，除首字母要小写外，每个单词或缩写都以大写字母开头。",
+    "key": "ANGULARUSESCAPITALIZATIONCONVENTIONSTODISTINGUISHTHENAMESOFVARIOUSTYPESASDESCRIBEDINTHESTYLEGUIDENAMINGSECTIONGUIDESTYLEGUIDE#0201",
+    "original": "Angular uses capitalization conventions to distinguish the names of various types, as described in the [Style Guide \"Naming\" section](guide/styleguide#02-01).",
+    "translation": "Angular 使用大小写约定来区分多种名字，详见[风格指南中的 \"命名\" 一节](guide/styleguide#02-01)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "FUNCTIONPROPERTYANDMETHODNAMESARETYPICALLYSPELLEDINCAMELCASEFOREXAMPLESQUAREFIRSTNAMEANDGETHEROESNOTICETHATSQUAREISANEXAMPLEOFHOWYOUWRITEASINGLEWORDINCAMELCASE",
-    "original": "Function, property, and method names are typically spelled in camelCase. For example, `square`, `firstName`, and `getHeroes`. Notice that `square` is an example of how you write a single word in camelCase.",
-    "translation": "通常，函数、属性和方法命名使用驼峰式拼写法。例如，`square`, `firstName` 和 `getHeroes`。注意这里的 `square` 是如何用驼峰式命名法表示单一词的例子。",
+    "key": "CAMELCASE:SYMBOLSPROPERTIESMETHODSPIPENAMESNONCOMPONENTDIRECTIVESELECTORSCONSTANTS",
+    "original": "- camelCase : symbols, properties, methods, pipe names, non-component directive selectors, constants",
+    "translation": "小驼峰形式（camelCase）：符号、属性、方法、管道名、非组件指令的选择器、常量。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "CAMELCASEISALSOKNOWNASLOWERCAMELCASETODISTINGUISHITFROMUPPERCAMELCASEORPASCALCASEGUIDEGLOSSARY#PASCALCASEINANGULARDOCUMENTATIONCAMELCASEALWAYSMEANSLOWERCAMELCASE",
-    "original": "camelCase is also known as *lower camel case* to distinguish it from *upper camel case*, or [PascalCase](guide/glossary#pascalcase).\nIn Angular documentation, \"camelCase\" always means *lower camel case*.",
-    "translation": "这种形式也叫做**小写驼峰式命名法 (lower camel case)**，以区分于**大写驼峰式命名法**，也称 [Pascal 命名法 (PascalCase)](guide/glossary#pascalcase)。\nAngular 文档中提到“驼峰式命名法 (camelCase) ”的时候，所指的都是小驼峰命名法。",
+    "key": "UPPERCAMELCASEORPASCALCASE:CLASSNAMESINCLUDINGCLASSESTHATDEFINECOMPONENTSINTERFACESNGMODULESDIRECTIVESPIPESANDSOON",
+    "original": "- UpperCamelCase (or PascalCase): Class names, including classes that define components, interfaces, NgModules, directives, pipes, and so on.",
+    "translation": "大驼峰形式（UpperCamelCase）或叫帕斯卡形式（PascalCase）：类名（也包括用来定义组件、接口、NgModule、指令、管道等的类）。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THEANGULARCLIISACOMMANDLINEINTERFACETOOLTHATCANCREATEAPROJECTADDFILESANDPERFORMAVARIETYOFONGOINGDEVELOPMENTTASKSSUCHASTESTINGBUNDLINGANDDEPLOYMENT",
-    "original": "The Angular CLI is a `command line interface` tool that can create a project, add files, and perform a variety of ongoing development tasks such as testing, bundling, and deployment.",
-    "translation": "Angular CLI 是个命令行接口（Command Line Interface）工具，它可以创建项目、添加文件以及执行各种正在进行的开发任务，比如测试、打包和部署。",
+    "key": "DASHCASEORKEBABCASE:DESCRIPTIVEPARTOFFILENAMESCOMPONENTSELECTORS",
+    "original": "- dash-case (or \"kebab-case\"): descriptive part of file names, component selectors",
+    "translation": "中线形式（dash-case）或叫烤串形式（kebab-case）：文件名中的描述部分，组件的选择器",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "UNDERSCORECASEORSNAKECASE:NOTTYPICALLYUSEDINANGULAR",
+    "original": "- underscore_case (or \"snake_case\"): not typically used in Angular",
+    "translation": "下划线形式（underscore_case）或叫蛇形形式（snake_case）：在 Angular 中没有典型用法。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "UPPERUNDERSCORECASEORUPPERSNAKECASE:TRADITIONALFORCONSTANTSACCEPTABLEBUTPREFERCAMELCASE",
+    "original": "- UPPER_UNDERSCORE_CASE (or UPPER_SNAKE_CASE): traditional for constants (acceptable, but prefer camelCase)",
+    "translation": "大写下划线形式（UPPER_UNDERSCORE_CASE）或叫大写蛇形形式（UPPER_SNAKE_CASE）：传统的常量写法（可以接受，但更推荐用小驼峰形式（camelCase））",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##CLASSDECORATOR",
+    "original": "## Class decorator",
+    "translation": "## 类装饰器",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ADECORATORGUIDEGLOSSARY#DECORATORSTATEMENTIMMEDIATELYBEFOREACLASSDEFINITIONTHATDECLARESTHECLASSTOBEOFTHEGIVENTYPEANDPROVIDESMETADATASUITABLETOTHETYPE",
+    "original": "A [decorator](guide/glossary#decorator) statement immediately before a class definition that declares the class to be of the given type, and provides metadata suitable to the type.",
+    "translation": "出现在类定义紧前方的[装饰器](guide/glossary#decorator)语句用来声明该类具有指定的类型，并且提供适合该类型的元数据。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "THEFOLLOWINGCLASSTYPESCANBEDECLARED:",
+    "original": "The following class types can be declared:",
+    "translation": "可以声明为下列类型之一：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##CLASSFIELDDECORATOR",
+    "original": "## Class field decorator",
+    "translation": "## 类字段装饰器",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ADECORATORGUIDEGLOSSARY#DECORATORSTATEMENTIMMEDIATELYBEFOREAFIELDINACLASSDEFINITIONTHATDECLARESTHETYPEOFTHATFIELDSOMEEXAMPLESAREINPUTANDOUTPUT",
+    "original": "A [decorator](guide/glossary#decorator) statement immediately before a field in a class definition that declares the type of that field. Some examples are `@Input` and `@Output`.",
+    "translation": "出现在类定义中属性紧前方的[装饰器](guide/glossary#decorator)语句用来声明该字段的类型。比如 `@Input` 和 `@Output`。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "THEANGULARCLIHTTPS:CLIANGULARIOISACOMMANDLINETOOLTHATCANCREATEAPROJECTADDFILESANDPERFORMAVARIETYOFONGOINGDEVELOPMENTTASKSSUCHASTESTINGBUNDLINGANDDEPLOYMENT",
+    "original": "The [Angular CLI](https://cli.angular.io/) is a command-line tool that can create a project, add files, and perform a variety of ongoing development tasks such as testing, bundling, and deployment.",
+    "translation": "[Angular CLI](https://cli.angular.io/) 是个命令行（Command Line Interface）工具，它可以创建项目、添加文件以及执行各种正在进行的开发任务，比如测试、打包和部署。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -13830,45 +13872,57 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANANGULARCLASSRESPONSIBLEFOREXPOSINGDATATOAVIEWGUIDEGLOSSARY#VIEWANDHANDLINGMOSTOFTHEVIEWSDISPLAYANDUSERINTERACTIONLOGIC",
-    "original": "An Angular class responsible for exposing data to a [view](guide/glossary#view) and handling most of the view’s display and user-interaction logic.",
-    "translation": "组件是一个 Angular 类，用于把数据展示到[视图 (view)](guide/glossary#view)，并处理几乎所有的视图显示和交互逻辑。",
+    "key": "ACLASSWITHTHECOMPONENTDECORATORGUIDEGLOSSARY#DECORATORTHATASSOCIATESITWITHACOMPANIONTEMPLATEGUIDEGLOSSARY#TEMPLATE",
+    "original": "A class with the `@Component` [decorator](guide/glossary#decorator) that associates it with a companion [template](guide/glossary#template).",
+    "translation": "一个带有 `@Component` [装饰器](guide/glossary#decorator)的类，用来为它关联一个与之相伴的[模板](guide/glossary#template)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THECOMPONENTISONEOFTHEMOSTIMPORTANTBUILDINGBLOCKSINTHEANGULARSYSTEMITISINFACTANANGULARDIRECTIVEGUIDEGLOSSARY#DIRECTIVEWITHACOMPANIONTEMPLATEGUIDEGLOSSARY#TEMPLATE",
-    "original": "The *component* is one of the most important building blocks in the Angular system.\nIt is, in fact, an Angular [directive](guide/glossary#directive) with a companion [template](guide/glossary#template).",
-    "translation": "*组件*是 Angular 系统中最重要的基本构造块之一。\n它其实是一个拥有[模板 (template)](guide/glossary#template)的[指令 (directive)](guide/glossary#directive)。",
+    "key": "ACOMPONENTISASPECIALTYPEOFDIRECTIVEGUIDEGLOSSARY#DIRECTIVETHATREPRESENTSAVIEWGUIDEGLOSSARY#VIEWTHECOMPONENTDECORATOREXTENDSTHEDIRECTIVEDECORATORWITHTEMPLATEORIENTEDFEATURES",
+    "original": "A component is a special type of [directive](guide/glossary#directive) that represents a [view](guide/glossary#view).The `@Component` decorator extends the `@Directive` decorator with template-oriented features.",
+    "translation": "组件是[指令](guide/glossary#directive)的一种特例，它表示一个[视图](guide/glossary#view)。`@Component` 装饰器扩展了 `@Directive` 装饰器，增加了一些与模板有关的特性。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "APPLYTHECOMPONENTDECORATORGUIDEGLOSSARY#DECORATORTOTHECOMPONENTCLASSTHEREBYATTACHINGTOTHECLASSTHEESSENTIALCOMPONENTMETADATATHATANGULARNEEDSTOCREATEACOMPONENTINSTANCEANDRENDERTHECOMPONENTWITHITSTEMPLATEASAVIEW",
-    "original": "Apply the `@Component` [decorator](guide/glossary#decorator) to\nthe component class, thereby attaching to the class the essential component metadata\nthat Angular needs to create a component instance and render the component with its template\nas a view.",
-    "translation": "需要将 `#@Component`[装饰器](guide/glossary#decorator)应用到一个组件类，从而把必要的组件元数据附加到类上。\nAngular 会需要元数据来创建一个组件实例，并把组件的模板作为视图渲染出来。",
+    "key": "ANANGULARCOMPONENTCLASSISRESPONSIBLEFOREXPOSINGDATAANDHANDLINGMOSTOFTHEVIEWSDISPLAYANDUSERINTERACTIONLOGICTHROUGHDATABINDINGGUIDEGLOSSARY#DATABINDING",
+    "original": "An Angular component class is responsible for exposing data and handling most of the view's display and user-interaction logic through [data binding](guide/glossary#data-binding).",
+    "translation": "Angular 的组件类负责暴露数据，并通过[数据绑定机制](guide/glossary#data-binding)来处理绝大多数视图的显示和用户交互逻辑。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THOSEFAMILIARWITHMVCANDMVVMPATTERNSWILLRECOGNIZETHECOMPONENTINTHEROLEOFCONTROLLERORVIEWMODEL",
-    "original": "Those familiar with \"MVC\" and \"MVVM\" patterns will recognize\nthe component in the role of \"controller\" or \"view model\".",
-    "translation": "如果你熟悉 \"MVC\" 和 \"MVVM\" 模式，就会意识到组件充当了“控制器 (controller) ”和“视图模型 (view model) ”的角色。",
+    "key": "READMOREABOUTCOMPONENTSTEMPLATESANDVIEWSINTHEARCHITECTUREGUIDEARCHITECTUREGUIDE",
+    "original": "Read more about components, templates, and views in the [Architecture](guide/architecture) guide.",
+    "translation": "要了解更多关于组件、模板和视图的知识，参见 [架构](guide/architecture) 一章。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "##DASHCASE",
-    "original": "## dash-case",
-    "translation": "## 中线命名法 (dash-case)",
+    "key": "##CUSTOMELEMENT",
+    "original": "## Custom element",
+    "translation": "## 自定义元素",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THEPRACTICEOFWRITINGCOMPOUNDWORDSORPHRASESSUCHTHATEACHWORDISSEPARATEDBYADASHORHYPHENTHISFORMISALSOKNOWNASKEBABCASE",
-    "original": "The practice of writing compound words or phrases such that each word is separated by a dash or hyphen (`-`).\nThis form is also known as kebab-case.",
-    "translation": "中线命名法是书写复合词或短语的一种形式，使用中线 (`-`) 分隔每个单词。\n这种形式也称为烤串命名法 kebab-case。",
+    "key": "AWEBPLATFORMFEATURECURRENTLYSUPPORTEDBYMOSTBROWSERSANDAVAILABLEINOTHERBROWSERSTHROUGHPOLYFILLSSEEBROWSERSUPPORTGUIDEBROWSERSUPPORT",
+    "original": "A Web Platform feature, currently supported by most browsers, and available in other browsers through polyfills (see [Browser Support](guide/browser-support)).",
+    "translation": "一种 Web 平台的特性，目前已经被绝大多数浏览器支持，在其它浏览器中也可以通过腻子脚本获得支持（参见[浏览器支持](guide/browser-support)）。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "DIRECTIVEGUIDEGLOSSARY#DIRECTIVESELECTORSLIKEMYAPPANDTHEROOTOFFILENAMESSUCHASHEROLISTCOMPONENTTSAREOFTENSPELLEDINDASHCASE",
-    "original": "[Directive](guide/glossary#directive) selectors (like `my-app`) and\nthe root of filenames (such as `hero-list.component.ts`) are often\nspelled in dash-case.",
-    "translation": "[指令](guide/glossary#directive)的选择器（例如 `my-app`）和文件名（例如 `hero-list.component.ts`）通常是用中线命名法来命名。",
+    "key": "THECUSTOMELEMENTFEATUREEXTENDSHTMLBYALLOWINGYOUTODEFINEATAGWHOSECONTENTISCREATEDANDCONTROLLEDBYJAVASCRIPTCODEACUSTOMELEMENTALSOCALLEDAWEBCOMPONENTISRECOGNIZEDBYABROWSERWHENITISADDEDTOTHECUSTOMELEMENTREGISTRYHTTPS:DEVELOPERMOZILLAORGENUSDOCSWEBAPICUSTOMELEMENTREGISTRY",
+    "original": "The custom element feature extends HTML by allowing you to define a tag whose content is created and controlled by JavaScript code. A custom element (also called a *web component*) is recognized by a browser when it is added to the [CustomElementRegistry](https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry).",
+    "translation": "这种自定义元素特性通过允许你定义标签（其内容是由 JavaScript 代码来创建和控制的）来扩展 HTML。当自定义元素（也叫 *Web Component*）被添加到 [CustomElementRegistry](https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry) 之后就会被浏览器识别。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "YOUCANUSETHEAPITOTRANSFORMANANGULARCOMPONENTSOTHATITCANBEREGISTEREDWITHTHEBROWSERANDUSEDINANYHTMLTHATYOUADDDIRECTLYTOTHEDOMWITHINANANGULARAPPTHECUSTOMELEMENTTAGINSERTSTHECOMPONENTSVIEWWITHCHANGEDETECTIONANDDATABINDINGFUNCTIONALITYINTOCONTENTTHATWOULDOTHERWISEBEDISPLAYEDWITHOUTANGULARPROCESSING",
+    "original": "You can use the API to transform an Angular component so that it can be registered with the browser and used in any HTML that you add directly to the DOM within an Angular app. The custom element tag inserts the component's view, with change-detection and data-binding functionality, into content that would otherwise be displayed without Angular processing.",
+    "translation": "你可以使用 API 来转换 Angular 组件，以便它能够注册进浏览器中，并且可以用在你往 DOM 中添加的任意 HTML 中。\n自定义元素标签可以把组件的视图（包括变更检测和数据绑定功能）插入到不受 Angular 控制的内容中。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "SEEALSODYNAMICCOMPONENTSGUIDEGLOSSARY#DYNAMICCOMPONENTS",
+    "original": "See also [Dynamic components](guide/glossary#dynamic-components).",
+    "translation": "参见[动态组件](guide/glossary#dynamic-components)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -13878,9 +13932,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "APPLICATIONSDISPLAYDATAVALUESTOAUSERANDRESPONDTOUSERACTIONSSUCHASCLICKSTOUCHESANDKEYSTROKES",
-    "original": "Applications display data values to a user and respond to user\nactions (such as clicks, touches, and keystrokes).",
-    "translation": "应用程序会将数据展示给用户，并对用户的操作（点击、触屏、按键）做出回应。",
+    "key": "DATABINDINGALLOWAPPSTODISPLAYDATAVALUESTOAUSERANDRESPONDTOUSERACTIONSSUCHASCLICKSTOUCHESANDKEYSTROKES",
+    "original": "Data binding allow apps to display data values to a user and respond to user\nactions (such as clicks, touches, and keystrokes).",
+    "translation": "数据绑定允许应用程序将数据展示给用户，并对用户的操作（点击、触屏、按键）做出回应。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -13889,12 +13943,6 @@
     "translation": "在数据绑定机制下，你只要声明一下 HTML 部件和数据源之间的关系，把细节交给框架去处理。\n而以前的手动操作过程是：将数据推送到 HTML 页面中、添加事件监听器、从屏幕获取变化后的数据，并更新应用中的值。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
-  {
-    "key": "ANGULARHASARICHDATABINDINGFRAMEWORKWITHAVARIETYOFDATABINDINGOPERATIONSANDSUPPORTINGDECLARATIONSYNTAX",
-    "original": "Angular has a rich data-binding framework with a variety of data-binding\noperations and supporting declaration syntax.",
-    "translation": "Angular 有一个非常强大的数据绑定框架，具有各种数据绑定操作，并支持声明式语法。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
   {
     "key": "READABOUTTHEFOLLOWINGFORMSOFBINDINGINTHETEMPLATESYNTAXGUIDETEMPLATESYNTAXPAGE:",
     "original": "Read about the following forms of binding in the [Template Syntax](guide/template-syntax) page:",
@@ -13943,6 +13991,60 @@
     "translation": "[基于 ngModel 的双向数据绑定 (Two-way data binding with ngModel)](guide/template-syntax#ngModel)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
+  {
+    "key": "##DECLARABLE",
+    "original": "## Declarable",
+    "translation": "## 可声明对象",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ACLASSTYPETHATYOUCANADDTOTHEDECLARATIONSLISTOFANNGMODULEGUIDEGLOSSARY#NGMODULE",
+    "original": "A class type that you can add to the `declarations` list of an [NgModule](guide/glossary#ngmodule).",
+    "translation": "类的一种类型，你可以把它们添加到 [NgModule](guide/glossary#ngmodule) 的 `declarations` 列表中。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "YOUCANDECLARECOMPONENTSGUIDEGLOSSARY#COMPONENTDIRECTIVESGUIDEGLOSSARY#DIRECTIVEANDPIPESGUIDEGLOSSARY#PIPE",
+    "original": "You can declare [components](guide/glossary#component), [directives](guide/glossary#directive), and [pipes](guide/glossary#pipe).",
+    "translation": "你可以声明[组件](guide/glossary#component)、[指令](guide/glossary#directive)和[管道](guide/glossary#pipe)。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "DONOTDECLARETHEFOLLOWING:",
+    "original": "Do not declare the following:",
+    "translation": "*不要*声明：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ACLASSTHATSALREADYDECLAREDINANOTHERNGMODULE",
+    "original": "- A class that's already declared in another NgModule.",
+    "translation": "已经在其它 NgModule 中声明过的类。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ANARRAYOFDIRECTIVESIMPORTEDFROMANOTHERPACKAGEFOREXAMPLEDONTDECLAREFORMSDIRECTIVESFROMANGULARFORMS",
+    "original": "- An array of directives imported from another package. For example, don't declare `FORMS_DIRECTIVES` from `@angular/forms`.",
+    "translation": "从其它包中导入的指令数组。比如，不要再次声明来自 `@angular/forms` 中的 `FORMS_DIRECTIVES`。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "NGMODULECLASSES",
+    "original": "- NgModule classes.",
+    "translation": "NgModule 类。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "SERVICECLASSES",
+    "original": "- Service classes.",
+    "translation": "服务类",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "NONANGULARCLASSESANDOBJECTSSUCHASSTRINGSNUMBERSFUNCTIONSENTITYMODELSCONFIGURATIONSBUSINESSLOGICANDHELPERCLASSES",
+    "original": "- Non-Angular classes and objects, such as strings, numbers, functions, entity models, configurations, business logic, and helper classes",
+    "translation": "非 Angular 的类和对象，比如：字符串、数字、函数、实体模型、配置、业务逻辑和辅助类。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
   {
     "key": "##DECORATORDECORATION",
     "original": "## Decorator | decoration",
@@ -13950,39 +14052,21 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "AFUNCTIONTHATADDSMETADATATOACLASSITSMEMBERSPROPERTIESMETHODSANDFUNCTIONARGUMENTS",
-    "original": "A *function* that adds metadata to a class, its members (properties, methods) and function arguments.",
-    "translation": "装饰器是一个**函数**，它将元数据添加到类、类成员（属性、方法）和函数参数。",
+    "key": "AFUNCTIONTHATMODIFIESTHEIMMEDIATELYFOLLOWINGCLASSORPROPERTYDEFINITIONDECORATORSALSOCALLEDANNOTATIONSAREANEXPERIMENTALSTAGE2JAVASCRIPTLANGUAGEFEATUREHTTPS:GITHUBCOMWYCATSJAVASCRIPTDECORATORSTYPESCRIPTADDSSUPPORTFORDECORATORS",
+    "original": "A function that modifies the immediately following class or property definition.  \nDecorators (also called annotations) are an experimental (stage 2), JavaScript language [feature](https://github.com/wycats/javascript-decorators). \nTypeScript adds support for decorators.",
+    "translation": "一个函数，用来修饰紧随其后的类或属性定义。\n装饰器（也叫注解）是 JavaScript 的一种语言[特性](https://github.com/wycats/javascript-decorators)，是一项位于阶段2（stage 2）的试验特性。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "DECORATORSAREANEXPERIMENTALSTAGE2JAVASCRIPTLANGUAGEFEATUREHTTPS:GITHUBCOMWYCATSJAVASCRIPTDECORATORSTYPESCRIPTADDSSUPPORTFORDECORATORS",
-    "original": "Decorators are an experimental (stage 2), JavaScript language [feature](https://github.com/wycats/javascript-decorators). TypeScript adds support for decorators.",
-    "translation": "装饰器是一个 JavaScript 的语言[特性](https://github.com/wycats/javascript-decorators)，装饰器在 TypeScript 里已经实现，并被推荐到了 ES2016（也就是 ES7）。",
+    "key": "ANGULARDEFINESDECORATORSTHATATTACHMETADATATOCLASSESORPROPERTIESSOTHATITKNOWSWHATTHOSECLASSESORPROPERTIESMEANANDHOWTHEYSHOULDWORK",
+    "original": "Angular defines decorators that attach metadata to classes or properties so that it knows what those classes or properties mean and how they should work.",
+    "translation": "Angular 定义了一些装饰器，用来为类或属性附加元数据，以便 Angular 了解那些类或属性的含义，以及要如何处理它们。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "TOAPPLYADECORATORPOSITIONITIMMEDIATELYABOVEORTOTHELEFTOFTHEITEMITDECORATES",
-    "original": "To apply a decorator, position it immediately above or to the left of the item it decorates.",
-    "translation": "要想应用装饰器，把它放到被装饰对象的上面或左边。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "ANGULARHASITSOWNSETOFDECORATORSTOHELPITINTEROPERATEWITHYOURAPPLICATIONPARTSTHEFOLLOWINGEXAMPLEISACOMPONENTDECORATORTHATIDENTIFIESACLASSASANANGULARCOMPONENTGUIDEGLOSSARY#COMPONENTANDANINPUTDECORATORAPPLIEDTOTHENAMEPROPERTYOFTHATCOMPONENTTHEELIDEDOBJECTARGUMENTTOTHECOMPONENTDECORATORWOULDCONTAINTHEPERTINENTCOMPONENTMETADATA",
-    "original": "Angular has its own set of decorators to help it interoperate with your application parts.\nThe following example is a `@Component` decorator that identifies a\nclass as an Angular [component](guide/glossary#component) and an `@Input` decorator applied to the `name` property\nof that component. The elided object argument to the `@Component` decorator would contain the pertinent component metadata.",
-    "translation": "Angular 使用自己的一套装饰器来实现应用程序各部件之间的相互操作。\n下面的例子中使用了 `@Component` 装饰器来将一个类标记为 Angular [组件 (component)](guide/glossary#component)，\n并将 `@Input` 装饰器来应用到组件的 `name` 属性。\n`@Component` 装饰器中省略的参数对象会包含与组件有关的元数据。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "THESCOPEOFADECORATORISLIMITEDTOTHELANGUAGEFEATURETHATITDECORATESNONEOFTHEDECORATIONSSHOWNHEREWILLLEAKTOOTHERCLASSESTHATFOLLOWITINTHEFILE",
-    "original": "The scope of a decorator is limited to the language feature\nthat it decorates. None of the decorations shown here will \"leak\" to other\nclasses that follow it in the file.",
-    "translation": "装饰器的作用域会被限制在它所装饰的语言特性。\n在同一文件中，装饰器不会“泄露”到它后面的其它类。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "ALWAYSINCLUDEPARENTHESESWHENAPPLYINGADECORATOR",
-    "original": "Always include parentheses `()` when applying a decorator.",
-    "translation": "永远别忘了在装饰器后面加括号 `()`。",
+    "key": "SEECLASSDECORATORGUIDEGLOSSARY#CLASSDECORATORCLASSFIELDDECORATORGUIDEGLOSSARY#CLASSFIELDDECORATOR",
+    "original": "See [Class decorator](guide/glossary#class-decorator), [Class field decorator](guide/glossary#class-field-decorator).",
+    "translation": "参见 [类装饰器](guide/glossary#class-decorator)、[类属性装饰器](guide/glossary#class-field-decorator)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -13992,81 +14076,33 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ADESIGNPATTERNANDMECHANISMFORCREATINGANDDELIVERINGPARTSOFANAPPLICATIONTOOTHERPARTSOFANAPPLICATIONTHATREQUESTTHEM",
-    "original": "A design pattern and mechanism\nfor creating and delivering parts of an application to other\nparts of an application that request them.",
-    "translation": "依赖注入既是设计模式，同时又是一种机制：当应用程序的一些部件需要另一些部件时，\n利用依赖注入来创建被请求的部件，并将它们注入到发出请求的部件中。",
+    "key": "ADESIGNPATTERNANDMECHANISMFORCREATINGANDDELIVERINGPARTSOFANAPPLICATIONDEPENDENCIESTOOTHERPARTSOFANAPPLICATIONTHATREQUIRETHEM",
+    "original": "A design pattern and mechanism for creating and delivering parts of an application (dependencies) to other parts of an application that require them.",
+    "translation": "依赖注入既是设计模式，同时又是一种机制：当应用程序的一些部件（即一些依赖）需要另一些部件时，\n利用依赖注入来创建被请求的部件，并将它们注入到需要它们的部件中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANGULARDEVELOPERSPREFERTOBUILDAPPLICATIONSBYDEFININGMANYSIMPLEPARTSTHATEACHDOONETHINGWELLANDTHENWIRINGTHEMTOGETHERATRUNTIME",
-    "original": "Angular developers prefer to build applications by defining many simple parts\nthat each do one thing well and then wiring them together at runtime.",
-    "translation": "Angular 开发者构建应用程序时的首选方法是：定义许多简单部件，\n每个部件只做一件事并做好它，然后在运行时把它们装配在一起组成应用程序。",
+    "key": "INANGULARDEPENDENCIESARETYPICALLYSERVICESBUTCANALSOBEVALUESSUCHASSTRINGSORFUNCTIONSANINJECTORGUIDEGLOSSARY#INJECTORFORANAPPCREATEDAUTOMATICALLYDURINGBOOTSTRAPCREATESDEPENDENCIESWHENNEEDEDUSINGAREGISTEREDPROVIDERGUIDEGLOSSARY#PROVIDEROFTHESERVICEORVALUEDIFFERENTPROVIDERSCANPROVIDEDIFFERENTIMPLEMENTATIONSOFTHESAMESERVICE",
+    "original": "In Angular, dependencies are typically services, but can also be values, such as strings or functions. An [injector](guide/glossary#injector) for an app (created automatically during bootstrap) creates dependencies when needed, using a registered [provider](guide/glossary#provider) of the service or value. Different providers can provide different implementations of the same service.",
+    "translation": "在 Angular 中，依赖通常是服务，但是也可以是值，比如字符串或函数。应用的[注入器](guide/glossary#injector)（它是在启动期间自动创建的）会使用该服务或值的已注册[提供商](guide/glossary#provider)来按需创建这些依赖。各个不同的提供商可以为同一个服务提供不同的实现。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THESEPARTSOFTENRELYONOTHERPARTSANANGULARCOMPONENTGUIDEGLOSSARY#COMPONENTPARTMIGHTRELYONASERVICEPARTTOGETDATAORPERFORMACALCULATIONWHENPARTARELIESONANOTHERPARTBYOUSAYTHATADEPENDSONBANDTHATBISADEPENDENCYOFA",
-    "original": "These parts often rely on other parts. An Angular [component](guide/glossary#component)\npart might rely on a service part to get data or perform a calculation. When\npart \"A\" relies on another part \"B,\" you say that \"A\" depends on \"B\" and\nthat \"B\" is a dependency of \"A.\"",
-    "translation": "这些部件通常会依赖其它部件。一个 Angular [组件 (component)](guide/glossary#component)\n可能依赖一个服务部件来获取数据或执行运算。\n如果部件 “A” 要靠另一个部件 “B” 才能工作，你就会说 “A” 依赖 “B” ，“B” 是 “A” 的依赖。",
+    "key": "LEARNMOREINTHEDEPENDENCYINJECTIONGUIDEDEPENDENCYINJECTIONGUIDE",
+    "original": "Learn more in the [Dependency Injection](guide/dependency-injection) guide.",
+    "translation": "要了解更多，参见[依赖注入](guide/dependency-injection)一章。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "YOUCANASKADEPENDENCYINJECTIONSYSTEMTOCREATEAFORUSANDHANDLEALLTHEDEPENDENCIESIFANEEDSBANDBNEEDSCTHESYSTEMRESOLVESTHATCHAINOFDEPENDENCIESANDRETURNSAFULLYPREPAREDINSTANCEOFA",
-    "original": "You can ask a \"dependency injection system\" to create \"A\"\nfor us and handle all the dependencies.\nIf \"A\" needs \"B\" and \"B\" needs \"C,\" the system resolves that chain of dependencies\nand returns a fully prepared instance of \"A.\"",
-    "translation": "你可以要求“依赖注入系统”创建 “A” 并处理所有依赖。如果 “A” 需要 “B” ，“B” 需要 “C ”，\n系统将解析这个依赖链，返回一个完全准备好的 “A” 实例。",
+    "key": "##DITOKEN",
+    "original": "## DI token",
+    "translation": "## DI 令牌",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANGULARPROVIDESANDRELIESUPONITSOWNSOPHISTICATEDDEPENDENCYINJECTIONSYSTEMTOASSEMBLEANDRUNAPPLICATIONSBYINJECTINGAPPLICATIONPARTSINTOOTHERAPPLICATIONPARTSWHEREANDWHENNEEDED",
-    "original": "Angular provides and relies upon its own sophisticated\ndependency-injection system\nto assemble and run applications by \"injecting\" application parts\ninto other application parts where and when needed.",
-    "translation": "Angular 提供并使用自己精心设计的[依赖注入 (dependency injection)](guide/dependency-injection)系统来组装和运行应用程序，在需要的地方和时刻，将一些部件“注入”到另一些部件里面。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "ATTHECOREANINJECTORGUIDEGLOSSARY#INJECTORRETURNSDEPENDENCYVALUESONREQUESTTHEEXPRESSIONINJECTORGETTOKENRETURNSTHEVALUEASSOCIATEDWITHTHEGIVENTOKEN",
-    "original": "At the core, an [`injector`](guide/glossary#injector) returns dependency values on request.\nThe expression `injector.get(token)` returns the value associated with the given token.",
-    "translation": "在 Angular 内核中有一个[注入器 (injector)](guide/glossary#injector)，当请求时返回依赖值。\n表达式 `injector.get(token)` 返回与该 token（令牌）参数相关的值。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "ATOKENISANANGULARTYPEINJECTIONTOKENYOURARELYNEEDTOWORKWITHTOKENSDIRECTLYMOSTMETHODSACCEPTACLASSNAMEFOOORASTRINGFOOANDANGULARCONVERTSITTOATOKENWHENYOUWRITEINJECTORGETFOOTHEINJECTORRETURNSTHEVALUEASSOCIATEDWITHTHETOKENFORTHEFOOCLASSTYPICALLYANINSTANCEOFFOOITSELF",
-    "original": "A token is an Angular type (`InjectionToken`). You rarely need to work with tokens directly; most\nmethods accept a class name (`Foo`) or a string (\"foo\") and Angular converts it\nto a token. When you write `injector.get(Foo)`, the injector returns\nthe value associated with the token for the `Foo` class, typically an instance of `Foo` itself.",
-    "translation": "令牌是一个 Angular 中的类型 (`InjectionToken`)。你很少直接处理令牌。\n绝大多数方法都接受类名 (`Foo`) 或字符串 (\"foo\")， Angular 会把这些类名称和字符串转换成令牌。\n当调用 `injector.get(Foo)` 时，注入器返回用 `Foo` 类生成的令牌所对应的依赖值，该依赖值通常是 `Foo` 类的实例。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "DURINGMANYOFITSOPERATIONSANGULARMAKESSIMILARREQUESTSINTERNALLYSUCHASWHENITCREATESACOMPONENTGUIDEGLOSSARY#COMPONENTFORDISPLAY",
-    "original": "During many of its operations, Angular makes similar requests internally, such as when it creates a [`component`](guide/glossary#component) for display.",
-    "translation": "Angular 在内部执行很多类似的依赖注入请求，例如，在创建用于显示的[组件 (component)](guide/glossary#component)。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "THEINJECTORMAINTAINSANINTERNALMAPOFTOKENSTODEPENDENCYVALUESIFTHEINJECTORCANTFINDAVALUEFORAGIVENTOKENITCREATESANEWVALUEUSINGAPROVIDERFORTHATTOKEN",
-    "original": "The `Injector` maintains an internal map of tokens to dependency values.\nIf the `Injector` can't find a value for a given token, it creates\na new value using a `Provider` for that token.",
-    "translation": "注入器 (`Injector`) 维护一个令牌到依赖值的映射表。\n如果注入器找不到给定令牌对应的依赖值，它会使用提供商 (`Provider`) 创建一个依赖值。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "APROVIDERGUIDEGLOSSARY#PROVIDERISARECIPEFORCREATINGNEWINSTANCESOFADEPENDENCYVALUEASSOCIATEDWITHAPARTICULARTOKEN",
-    "original": "A [provider](guide/glossary#provider) is a recipe for\ncreating new instances of a dependency value associated with a particular token.",
-    "translation": "[提供商 (provider)](guide/glossary#provider)是一个“菜谱”，用于创建特定令牌对应的依赖实例。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "ANINJECTORCANONLYCREATEAVALUEFORAGIVENTOKENIFITHASAPROVIDERFORTHATTOKENINITSINTERNALPROVIDERREGISTRYREGISTERINGPROVIDERSISACRITICALPREPARATORYSTEP",
-    "original": "An injector can only create a value for a given token if it has\na `provider` for that token in its internal provider registry.\nRegistering providers is a critical preparatory step.",
-    "translation": "只有当注入器内部提供商注册表中存在与令牌对应的提供商时，\n注入器才能为这个令牌创建一个依赖值。所以注册提供商是一个非常关键的准备步骤。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "ANGULARREGISTERSSOMEOFITSOWNPROVIDERSWITHEVERYINJECTORYOUCANREGISTERYOUROWNPROVIDERS",
-    "original": "Angular registers some of its own providers with every injector.\nYou can register your own providers.",
-    "translation": "Angular 会为每个注册器注册很多内置提供商。\n你也可以注册自己的提供商。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "READMOREINTHEDEPENDENCYINJECTIONGUIDEDEPENDENCYINJECTIONPAGE",
-    "original": "Read more in the [Dependency Injection](guide/dependency-injection) page.",
-    "translation": "更多信息，参见[依赖注入 (dependency injection)](guide/dependency-injection)。",
+    "key": "ALOOKUPTOKENASSOCIATEDWITHADEPENDENCYPROVIDERGUIDEGLOSSARY#PROVIDERFORUSEWITHTHEDEPENDENCYINJECTIONGUIDEGLOSSARY#DISYSTEM",
+    "original": "A lookup token associated with a dependency [provider](guide/glossary#provider), for use with the [dependency injection](guide/glossary#di) system.",
+    "translation": "一种用来查阅的令牌，它关联到一个依赖[提供商](guide/glossary#provider)，用于[依赖注入](guide/glossary#di)系统中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14076,51 +14112,81 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANANGULARCLASSRESPONSIBLEFORCREATINGRESHAPINGANDINTERACTINGWITHHTMLELEMENTSINTHEBROWSERDOMTHEDIRECTIVEISANGULARSMOSTFUNDAMENTALFEATURE",
-    "original": "An Angular class responsible for creating, reshaping, and interacting with HTML elements\nin the browser DOM. The directive is Angular's most fundamental feature.",
-    "translation": "指令是一个 Angular 类，负责创建和重塑浏览器 DOM 中的 HTML 元素，并与之互动。\n指令是 Angular 中最基本的特性之一。",
+    "key": "ACLASSWITHTHEDIRECTIVEDECORATORGUIDEGLOSSARY#DECORATORTHATCANMODIFYTHESTRUCTUREOFTHEDOMORMODIFYATTRIBUTESINTHEDOMANDCOMPONENTDATAMODEL",
+    "original": "A class with the `@Directive` [decorator](guide/glossary#decorator) that can modify the structure of the DOM, or modify attributes in the DOM and component data model.",
+    "translation": "一个带有 `@Directive` [装饰器](guide/glossary#decorator)的类，它可以修改 DOM 结构或者修改 DOM 的属性和组件数据模型的属性。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ADIRECTIVEISUSUALLYASSOCIATEDWITHANHTMLELEMENTORATTRIBUTETHISELEMENTORATTRIBUTEISOFTENREFERREDTOASTHEDIRECTIVEITSELF",
-    "original": "A directive is usually associated with an HTML element or attribute.\nThis element or attribute is often referred to as the directive itself.",
-    "translation": "指令几乎总与 HTML 元素或属性 (attribute) 相关。\n通常把这些关联到的 HTML 元素或者属性 (attribute) 当做指令本身。",
+    "key": "ADIRECTIVECLASSISUSUALLYASSOCIATEDWITHANHTMLELEMENTORATTRIBUTEANDTHATELEMENTORATTRIBUTEISOFTENREFERREDTOASTHEDIRECTIVEITSELFWHENANGULARFINDSADIRECTIVEINANHTMLTEMPLATEGUIDEGLOSSARY#TEMPLATEITCREATESTHEMATCHINGDIRECTIVECLASSINSTANCEANDGIVESTHEINSTANCECONTROLOVERTHATPORTIONOFTHEBROWSERDOM",
+    "original": "A directive class is usually associated with an HTML element or attribute, and that element or attribute is often referred to as the directive itself.  \nWhen Angular finds a directive in an HTML [template](guide/glossary#template), it creates the matching directive class instance and gives the instance control over that portion of the browser DOM.",
+    "translation": "指令类几乎总与 HTML 元素或属性 (attribute) 相关。\n通常会把这些 HTML 元素或者属性 (attribute) 当做指令本身。\n当 Angular 在 HTML [模板中](guide/glossary#template)发现某个指令时，会创建与之相匹配的指令类的实例，并且把这部分 DOM 的控制权交给它。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "WHENANGULARFINDSADIRECTIVEINANHTMLTEMPLATEITCREATESTHEMATCHINGDIRECTIVECLASSINSTANCEANDGIVESTHEINSTANCECONTROLOVERTHATPORTIONOFTHEBROWSERDOM",
-    "original": "When Angular finds a directive in an HTML template,\nit creates the matching directive class instance\nand gives the instance control over that portion of the browser DOM.",
-    "translation": "当 Angular 在 HTML 模板中遇到一个指令的时候，\n它会创建匹配的指令类的实例，并把浏览器中这部分 DOM 的控制权交给它。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "YOUCANINVENTCUSTOMHTMLMARKUPFOREXAMPLEMYDIRECTIVETOASSOCIATEWITHYOURCUSTOMDIRECTIVESYOUADDTHISCUSTOMMARKUPTOHTMLTEMPLATESASIFYOUWEREWRITINGNATIVEHTMLINTHISWAYDIRECTIVESBECOMEEXTENSIONSOFHTMLITSELF",
-    "original": "You can invent custom HTML markup (for example, `<my-directive>`) to\nassociate with your custom directives. You add this custom markup to HTML templates\nas if you were writing native HTML. In this way, directives become extensions of\nHTML itself.",
-    "translation": "你可以自定义 HTML 标签（例如 `<my-directive>`）来关联自定义指令。\n然后，可以像写原生 HTML 一样把这些自定义标签放到 HTML 模板里。\n这样，指令就变成了 HTML 本身的拓展。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "DIRECTIVESFALLINTOONEOFTHEFOLLOWINGCATEGORIES:",
-    "original": "Directives fall into one of the following categories:",
+    "key": "THEREARETHREECATEGORIESOFDIRECTIVE:",
+    "original": "There are three categories of directive:",
     "translation": "指令分为三类：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "COMPONENTSGUIDEGLOSSARY#COMPONENTCOMBINEAPPLICATIONLOGICWITHANHTMLTEMPLATETORENDERAPPLICATIONVIEWSGUIDEGLOSSARY#VIEWCOMPONENTSAREUSUALLYREPRESENTEDASHTMLELEMENTSTHEYARETHEBUILDINGBLOCKSOFANANGULARAPPLICATION",
-    "original": "* [Components](guide/glossary#component) combine application logic with an HTML template to\nrender application [views](guide/glossary#view). Components are usually represented as HTML elements.\nThey are the building blocks of an Angular application.",
-    "translation": "[组件 (component)](guide/glossary#component): 用于组合程序逻辑和 HTML 模板，渲染出应用程序的[视图](guide/glossary#view)。\n  组件一般表示成 HTML 元素的形式，它们是构建 Angular 应用程序的基本单元。",
+    "key": "COMPONENTSGUIDEGLOSSARY#COMPONENTUSECOMPONENTANEXTENSIONOFDIRECTIVETOASSOCIATEATEMPLATEWITHACLASS",
+    "original": "- [Components](guide/glossary#component) use `@Component` (an extension of `@Directive`) to associate a template with a class.",
+    "translation": "[组件](guide/glossary#component)使用 `@Component`（继承自 `@Directive`）为某个类关联一个模板。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ATTRIBUTEDIRECTIVESGUIDEGLOSSARY#ATTRIBUTEDIRECTIVECANLISTENTOANDMODIFYTHEBEHAVIOROFOTHERHTMLELEMENTSATTRIBUTESPROPERTIESANDCOMPONENTSTHEYAREUSUALLYREPRESENTEDASHTMLATTRIBUTESHENCETHENAME",
-    "original": "* [Attribute directives](guide/glossary#attribute-directive) can listen to and modify the behavior of\nother HTML elements, attributes, properties, and components. They are usually represented\nas HTML attributes, hence the name.",
-    "translation": "[属性型指令 (attribute directive)](guide/glossary#attribute-directive)：可以监控和修改其它 HTML 元素、 \n  HTML 属性 (attribute)、 DOM 属性 (property)、组件等行为等等。它们通常表示为 HTML 属性 (attibute)，故名。",
+    "key": "ATTRIBUTEDIRECTIVESGUIDEGLOSSARY#ATTRIBUTEDIRECTIVEMODIFYBEHAVIORANDAPPEARANCEOFPAGEELEMENTS",
+    "original": "- [Attribute directives](guide/glossary#attribute-directive) modify behavior and appearance of page elements.",
+    "translation": "[属性型指令](guide/glossary#attribute-directive)修改页面元素的行为和外观。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "STRUCTURALDIRECTIVESGUIDEGLOSSARY#STRUCTURALDIRECTIVEARERESPONSIBLEFORSHAPINGORRESHAPINGHTMLLAYOUTTYPICALLYBYADDINGREMOVINGORMANIPULATINGELEMENTSANDTHEIRCHILDREN",
-    "original": "* [Structural directives](guide/glossary#structural-directive) are responsible for\nshaping or reshaping HTML layout, typically by adding, removing, or manipulating\nelements and their children.",
-    "translation": "[结构型指令 (structural directive)](guide/glossary#structural-directive)：负责塑造或重塑 HTML\n布局。这一般是通过添加、删除或者操作 HTML 元素及其子元素来实现的。",
+    "key": "STRUCTURALDIRECTIVESGUIDEGLOSSARY#STRUCTURALDIRECTIVEMODIFYTHESTRUCTUREOFTHEDOM",
+    "original": "- [Structural directives](guide/glossary#structural-directive) modify the structure of the DOM.",
+    "translation": "[结构型指令](guide/glossary#structural-directive)修改 DOM 的结构。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ANGULARSUPPLIESANUMBEROFBUILTINDIRECTIVESTHATBEGINWITHTHENGPREFIXYOUCANALSOCREATENEWDIRECTIVESTOIMPLEMENTYOUROWNFUNCTIONALITYYOUASSOCIATEASELECTORANHTMLTAGSUCHASMYDIRECTIVEWITHACUSTOMDIRECTIVETHEREBYEXTENDINGTHETEMPLATESYNTAXGUIDETEMPLATESYNTAXTHATYOUCANUSEINYOURAPPS",
+    "original": "Angular supplies a number of built-in directives that begin with the `ng` prefix. You can also create new directives to implement your own functionality. \nYou associate a _selector_ (an HTML tag such as `<my-directive>`) with a custom directive, thereby extending the [template syntax](guide/template-syntax) that you can use in your apps.",
+    "translation": "Angular 提供了一些以 `ng` 为前缀的内置指令。你也可以创建新的指令来实现自己的功能。\n你可以为自定义指令关联一个*选择器*（一种形如 `<my-directive>` 的 HTML 标记），以扩展[模板语法](guide/template-syntax)，从而让你能在应用中使用它。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##DOMAINSPECIFICLANGUAGEDSL",
+    "original": "## Domain-specific language (DSL)",
+    "translation": "## 领域特定语言（DSL)",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ASPECIALPURPOSELIBRARYORAPISEEDOMAINSPECIFICLANGUAGEHTTPS:ENWIKIPEDIAORGWIKIDOMAINSPECIFICLANGUAGE",
+    "original": "A special-purpose library or API; see [Domain-specific language](https://en.wikipedia.org/wiki/Domain-specific_language).",
+    "translation": "一种特殊用途的库或 API，参见[领域特定语言](https://en.wikipedia.org/wiki/Domain-specific_language)词条。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ANGULAREXTENDSTYPESCRIPTWITHDOMAINSPECIFICLANGUAGESFORANUMBEROFDOMAINSRELEVANTTOANGULARAPPSDEFINEDINNGMODULESSUCHASANIMATIONSGUIDEANIMATIONSFORMSGUIDEFORMSANDROUTINGANDNAVIGATIONGUIDEROUTER",
+    "original": "Angular extends TypeScript with domain-specific languages for a number of domains relevant to Angular apps, defined in ngModules such as [animations](guide/animations), [forms](guide/forms), and [routing and navigation](guide/router).",
+    "translation": "Angular 在一些相关的应用领域中用领域特定语言扩展了 TypeScript，这些 DSL 都定义在 NgModule 中，比如 [动画](guide/animations)、[表单](guide/forms)和[路由与导航](guide/router)。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##DYNAMICCOMPONENTLOADING",
+    "original": "## Dynamic component loading",
+    "translation": "## 动态组件加载",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ATECHNIQUEFORADDINGACOMPONENTTOTHEDOMATRUNTIMEWHICHREQUIRESTHATYOUEXCLUDETHECOMPONENTFROMCOMPILATIONTHENCONNECTITTOANGULARSCHANGEDETECTIONANDEVENTHANDLINGFRAMEWORKWHENYOUADDITTOTHEDOM",
+    "original": "A technique for adding a component to the DOM at run time, which requires that you exclude the component from compilation, then connect it to Angular's change-detection and event handling framework when you add it to the DOM.",
+    "translation": "一种在运行期间把组件添加到 DOM 中的技术，它需要你从编译期间排除该组件，然后，当你把它添加到 DOM 中时，再把它接入 Angular 的变更检测与事件处理框架。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "SEEALSOCUSTOMELEMENTGUIDEGLOSSARY#CUSTOMELEMENTWHICHPROVIDESANEASIERPATHWITHTHESAMERESULT",
+    "original": "See also [Custom element](guide/glossary#custom-element), which provides an easier path with the same result.",
+    "translation": "参见[自定义组件](guide/glossary#custom-element)，它提供了一种更简单的方式来达到相同的效果。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14136,57 +14202,69 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THELATESTAPPROVEDVERSIONOFJAVASCRIPTISECMASCRIPT2017HTTP:WWWECMAINTERNATIONALORGECMA26280ALSOKNOWNASES2017ORES8MANYANGULARDEVELOPERSWRITETHEIRAPPLICATIONSINES8ORADIALECTTHATSTRIVESTOBECOMPATIBLEWITHITSUCHASTYPESCRIPTGUIDEGLOSSARY#TYPESCRIPT",
-    "original": "The latest approved version of JavaScript is\n[ECMAScript 2017](http://www.ecma-international.org/ecma-262/8.0/)\n(also known as \"ES2017\" or \"ES8\"). Many Angular developers write their applications\nin ES8 or a dialect that strives to be\ncompatible with it, such as [TypeScript](guide/glossary#typescript).",
-    "translation": "最新批准的 JavaScript 版本是[ECMAScript 2016](http://www.ecma-international.org/ecma-262/7.0/)（也称“ES2016”或“ES7”）。\nAngular 的开发人员要么使用这个版本的语言，要么使用与之兼容的方言，例如 [TypeScript](guide/glossary#typescript)。",
+    "key": "NOTALLBROWSERSSUPPORTTHELATESTECMASCRIPTSTANDARDBUTYOUCANUSEATRANSPILERGUIDEGLOSSARY#TRANSPILELIKETYPESCRIPTGUIDEGLOSSARY#TYPESCRIPTTOWRITECODEUSINGTHELATESTFEATURESWHICHWILLTHENBETRANSPILEDTOCODETHATRUNSONVERSIONSTHATARESUPPORTEDBYBROWSERS",
+    "original": "Not all browsers support the latest ECMAScript standard, but you can use a [transpiler](guide/glossary#transpile) (like [TypeScript](guide/glossary#typescript)) to write code using the latest features, which will then be transpiled to code that runs on versions that are supported by browsers.",
+    "translation": "并不是所有浏览器都支持最新的 ECMAScript 标准，不过你可以使用[转译器](guide/glossary#transpile)（比如[TypeScript](guide/glossary#typescript)）来用最新特性写代码，然后它会被转译成可以在浏览器的其它版本上运行的代码。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "MOSTMODERNBROWSERSONLYSUPPORTTHEMUCHOLDERECMASCRIPT5ALSOKNOWNASES5STANDARDAPPLICATIONSWRITTENINES2017ES2016ES2015ORONEOFTHEIRDIALECTSMUSTBETRANSPILEDGUIDEGLOSSARY#TRANSPILETOES5JAVASCRIPT",
-    "original": "Most modern browsers only support the much older \"ECMAScript 5\" (also known as \"ES5\") standard.\nApplications written in ES2017, ES2016, ES2015, or one of their dialects must be [transpiled](guide/glossary#transpile)\nto ES5 JavaScript.",
-    "translation": "目前，几乎所有现代游览器只支持很老的“ECMAScript 5” （也称 ES5）标准。\n使用 ES2016、ES2015 或者其它方言开发的应用程序，必须“[转译 (transpile)](guide/glossary#transpile)”成 ES5 JavaScript。",
+    "key": "TOLEARNMORESEETHEBROWSERSUPPORTGUIDEBROWSERSUPPORTPAGE",
+    "original": "To learn more, see the [Browser Support](guide/browser-support) page.",
+    "translation": "要了解更多，参见[浏览器支持](guide/browser-support)页。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANGULARDEVELOPERSCANWRITEINES5DIRECTLY",
-    "original": "Angular developers can write in ES5 directly.",
-    "translation": "Angular 的开发人员也可以选择直接使用 ES5 编程。",
+    "key": "##ELEMENT",
+    "original": "## Element",
+    "translation": "## 元素",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "##ES2015",
-    "original": "## ES2015",
-    "translation": "## ES2015 语言",
+    "key": "ANGULARDEFINESANELEMENTREFCLASSTOWRAPRENDERSPECIFICNATIVEUIELEMENTSTHISALLOWSYOUUSEANGULARTEMPLATESANDDATABINDINGTOACCESSDOMELEMENTSWITHOUTREFERENCETOTHENATIVEELEMENTINMOSTCASES",
+    "original": "Angular defines an `ElementRef` class to wrap render-specific native UI elements. This allows you use Angular templates and  data-binding to access DOM elements without reference to the native element in most cases.",
+    "translation": "Angular 定义了 `ElementRef` 类来包装与渲染有关的原生 UI 元素。这让你可以在大多数情况下使用 Angular 的模板和数据绑定机制来访问 DOM 元素，而不必再引用原生元素。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "SHORTHANDFORECMASCRIPTGUIDEGLOSSARY#ECMASCRIPT2015",
-    "original": "Short hand for [ECMAScript](guide/glossary#ecmascript) 2015.",
-    "translation": "[ECMAScript](guide/glossary#ecmascript) 2015 的简写。",
+    "key": "THEDOCUMENTATIONGENERALLYREFERSTOEITHERELEMENTSELEMENTREFINSTANCESORDOMELEMENTSWHICHCOULDBEACCESSEDDIRECTLYIFNECESSARY",
+    "original": "The documentation generally refers to either elements (`ElementRef` instances) or  DOM elements (which could be accessed directly if necessary).",
+    "translation": "本文档中一般会使用**元素（Element）**来指代 `ElementRef` 的实例，而用 **DOM 元素**来指代直接访问的 DOM。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "##ES5",
-    "original": "## ES5",
-    "translation": "## ES5 语言",
+    "key": "COMPARECUSTOMELEMENTGUIDEGLOSSARY#CUSTOMELEMENT",
+    "original": "Compare [Custom element](guide/glossary#custom-element).",
+    "translation": "可以对比下[自定义元素](guide/glossary#custom-element)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "SHORTHANDFORECMASCRIPTGUIDEGLOSSARY#ECMASCRIPT5THEVERSIONOFJAVASCRIPTRUNBYMOSTMODERNBROWSERS",
-    "original": "Short hand for [ECMAScript](guide/glossary#ecmascript) 5, the version of JavaScript run by most modern browsers.",
-    "translation": "“[ECMAScript](guide/glossary#ecmascript) 5”的简写，大部分现代浏览器使用的 JavaScript 版本。",
+    "key": "##ENTRYPOINT",
+    "original": "## Entry point",
+    "translation": "## 入口点",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "##ES6",
-    "original": "## ES6",
-    "translation": "## ES6 语言",
+    "key": "AJAVASCRIPTIDTHATMAKESPARTSOFANNPMPACKAGEAVAILABLEFORIMPORTBYOTHERCODETHEANGULARSCOPEDPACKAGESGUIDEGLOSSARY#SCOPEDPACKAGEEACHHAVEANENTRYPOINTNAMEDINDEX",
+    "original": "A JavaScript ID that makes parts of an NPM package available for import by other code. \nThe Angular [scoped packages](guide/glossary#scoped-package) each have an entry point named `index`.",
+    "translation": "JavaScript 的 ID 用来让这段代码成为 NPM 包的一部分，从而让其它代码能导入它。\nAngular 的每个[范围化的包](guide/glossary#scoped-package)都有一个名叫 `index` 的入口点。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "SHORTHANDFORECMASCRIPTGUIDEGLOSSARY#ECMASCRIPT2015",
-    "original": "Short hand for [ECMAScript](guide/glossary#ecmascript) 2015.",
-    "translation": "[ECMAScript](guide/glossary#ecmascript) 2015 的简写。",
+    "key": "WITHINANGULARUSENGMODULESGUIDEGLOSSARY#NGMODULETOACHIEVETHESAMERESULT",
+    "original": "Within Angular, use [NgModules](guide/glossary#ngmodule) to achieve the same result.",
+    "translation": "在 Angular 领域中，[NgModules](guide/glossary#ngmodule) 起到同样的作用。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ANANGULARCLASSOROTHERDEFINITIONTHATPROVIDESADEPENDENCYUSINGTHEDEPENDENCYINJECTIONGUIDEGLOSSARY#DIMECHANISMANINJECTABLECLASSISMARKEDBYTHEINJECTABLEDECORATORGUIDEGLOSSARY#DECORATOR",
+    "original": "An Angular class or other definition that provides a dependency using the [dependency injection](guide/glossary#di) mechanism. An injectable class is marked by the `@Injectable` [decorator](guide/glossary#decorator).",
+    "translation": "Angular 中的类或其它概念使用[依赖注入](guide/glossary#di)机制来提供依赖。要用 `@Injectable` [装饰器](guide/glossary#decorator)标出可注入的类。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "BOTHASERVICEGUIDEGLOSSARY#SERVICEANDACOMPONENTGUIDEGLOSSARY#COMPONENTTHATDEPENDSONTHATSERVICEMUSTBEMARKEDASINJECTABLEOTHERITEMSSUCHASCONSTANTVALUESCANBEINJECTABLE",
+    "original": "Both a [service](guide/glossary#service) and a [component](guide/glossary#component) that depends on that service must be marked as injectable. Other items, such as constant values, can be injectable.",
+    "translation": "无论[服务](guide/glossary#service)还是[组件](guide/glossary#component)，只要它们依赖服务，就必须标记为可注入的（可作为注入目标的）。其它内容（比如常量）也可以作为注入源。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14196,9 +14274,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANOBJECTINTHEANGULARDEPENDENCYINJECTIONSYSTEMGUIDEGLOSSARY#DEPENDENCYINJECTIONTHATCANFINDANAMEDDEPENDENCYINITSCACHEORCREATEADEPENDENCYWITHAREGISTEREDPROVIDERGUIDEGLOSSARY#PROVIDER",
-    "original": "An object in the Angular [dependency-injection system](guide/glossary#dependency-injection)\nthat can find a named dependency in its cache or create a dependency\nwith a registered [provider](guide/glossary#provider).",
-    "translation": "Angular [依赖注入系统 (Dependency Injection System)](guide/glossary#dependency-injection)中的一个对象，\n它可以在自己的缓存中找到一个命名的“依赖”或者利用已注册的[提供商 (provider)](guide/glossary#provider) 创建这样一个依赖。",
+    "key": "ANOBJECTINTHEANGULARDEPENDENCYINJECTIONSYSTEMGUIDEGLOSSARY#DEPENDENCYINJECTIONTHATCANFINDANAMEDDEPENDENCYINITSCACHEORCREATEADEPENDENCYWITHAREGISTEREDPROVIDERGUIDEGLOSSARY#PROVIDERINJECTORSARECREATEDFORNGMODULESAUTOMATICALLYASPARTOFTHEBOOTSTRAPPROCESSANDINHERITEDTHROUGHTHECOMPONENTHIERARCHY",
+    "original": "An object in the Angular [dependency-injection system](guide/glossary#dependency-injection)\nthat can find a named dependency in its cache or create a dependency\nwith a registered [provider](guide/glossary#provider). Injectors are created for NgModules automatically as part of the bootstrap process, and inherited through the component hierarchy.",
+    "translation": "Angular [依赖注入系统](guide/glossary#dependency-injection)中可以在缓存中根据名字查找依赖，也可以通过已注册的[提供商](guide/glossary#provider)来创建依赖。\n启动过程中会自动为每个模块创建一个注入器，并被组件树继承。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14208,15 +14286,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ADIRECTIVEPROPERTYTHATCANBETHETARGETOFAPROPERTYBINDINGGUIDETEMPLATESYNTAX#PROPERTYBINDINGEXPLAINEDINDETAILINTHETEMPLATESYNTAXGUIDETEMPLATESYNTAXPAGEDATAVALUESFLOWINTOTHISPROPERTYFROMTHEDATASOURCEIDENTIFIEDINTHETEMPLATEEXPRESSIONTOTHERIGHTOFTHEEQUALSIGN",
-    "original": "A directive property that can be the *target* of a\n[property binding](guide/template-syntax#property-binding) (explained in detail in the [Template Syntax](guide/template-syntax) page).\nData values flow *into* this property from the data source identified\nin the template expression to the right of the equal sign.",
-    "translation": "输入属性是一个指令属性，可以作为[属性绑定 (property binding)](guide/template-syntax#property-binding)（详情参见[模板语法](guide/template-syntax)页）的目标。\n数据值会从模板表达式等号右侧的数据源流入这个属性。",
+    "key": "WHENDEFININGADIRECTIVEGUIDEGLOSSARY#DIRECTIVETHEINPUTDECORATORONADIRECTIVEPROPERTYMAKESTHATPROPERTYAVAILABLEASATARGETOFAPROPERTYBINDINGGUIDETEMPLATESYNTAX#PROPERTYBINDINGDATAVALUESFLOWINTOANINPUTPROPERTYFROMTHEDATASOURCEIDENTIFIEDINTHETEMPLATEEXPRESSIONGUIDEGLOSSARY#TEMPLATEEXPRESSIONTOTHERIGHTOFTHEEQUALSIGN",
+    "original": "When defining a [directive](guide/glossary#directive), the `@Input` decorator on a directive property makes that property available as a *target* of a\n[property binding](guide/template-syntax#property-binding).\nData values flow into an input property from the data source identified\nin the [template expression](guide/glossary#template-expression) to the right of the equal sign.",
+    "translation": "当定义[指令](guide/glossary#directive)时，指令属性上的 `@Input` 装饰器让该属性可以作为[属性绑定](guide/template-syntax#property-binding)的*目标*使用。\n数据值会从等号右侧的[模板表达式](guide/glossary#template-expression)所指定的数据源流入组件的输入属性。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "SEETHEINPUTANDOUTPUTPROPERTIESGUIDETEMPLATESYNTAX#INPUTSOUTPUTSSECTIONOFTHETEMPLATESYNTAXGUIDETEMPLATESYNTAXPAGE",
-    "original": "See the [Input and output properties](guide/template-syntax#inputs-outputs) section of the [Template Syntax](guide/template-syntax) page.",
-    "translation": "参见[模板语法](guide/template-syntax)中的[输入与输出属性](guide/template-syntax#inputs-outputs)部分。",
+    "key": "TOLEARNMORESEEINPUTANDOUTPUTPROPERTIESGUIDETEMPLATESYNTAX#INPUTSOUTPUTS",
+    "original": "To learn more, see [input and output properties](guide/template-syntax#inputs-outputs).",
+    "translation": "要了解更多，参见[输入与输出属性](guide/template-syntax#inputs-outputs)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14226,8 +14304,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "AFORMOFPROPERTYDATABINDINGGUIDEGLOSSARY#DATABINDINGINWHICHATEMPLATEEXPRESSIONGUIDEGLOSSARY#TEMPLATEEXPRESSIONBETWEENDOUBLECURLYBRACESRENDERSASTEXTTHATTEXTMAYBECONCATENATEDWITHNEIGHBORINGTEXTBEFOREITISASSIGNEDTOANELEMENTPROPERTYORDISPLAYEDBETWEENELEMENTTAGSASINTHISEXAMPLE",
-    "original": "A form of [property data binding](guide/glossary#data-binding) in which a\n[template expression](guide/glossary#template-expression) between double-curly braces\nrenders as text.  That text may be concatenated with neighboring text\nbefore it is assigned to an element property\nor displayed between element tags, as in this example.",
+    "key": "AFORMOFPROPERTYDATABINDINGGUIDEGLOSSARY#DATABINDINGINWHICHATEMPLATEEXPRESSIONGUIDEGLOSSARY#TEMPLATEEXPRESSIONBETWEENDOUBLECURLYBRACESRENDERSASTEXTTHATTEXTCANBECONCATENATEDWITHNEIGHBORINGTEXTBEFOREITISASSIGNEDTOANELEMENTPROPERTYORDISPLAYEDBETWEENELEMENTTAGSASINTHISEXAMPLE",
+    "original": "A form of [property data binding](guide/glossary#data-binding) in which a\n[template expression](guide/glossary#template-expression) between double-curly braces\nrenders as text.  That text can be concatenated with neighboring text\nbefore it is assigned to an element property\nor displayed between element tags, as in this example.",
     "translation": "[属性数据绑定 (property data binding)](guide/glossary#data-binding) 的一种形式，位于双大括号中的[模板表达式 (template expression)](guide/glossary#template-expression)会被渲染成文本。\n在被赋值给元素属性或者显示在元素标签中之前，这些文本可能会先与周边的文本合并，参见下面的例子。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
@@ -14237,6 +14315,12 @@
     "translation": "更多信息，见[模板语法](guide/template-syntax)中的[插值表达式](guide/template-syntax#interpolation)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
+  {
+    "key": "SEEECMASCRIPTGUIDEGLOSSARY#ECMATYPESCRIPTGUIDEGLOSSARY#TYPESCRIPT",
+    "original": "See [ECMAScript](guide/glossary#ecma), [TypeScript](guide/glossary#typescript).",
+    "translation": "参见 [ECMAScript](guide/glossary#ecma) 和 [TypeScript](guide/glossary#typescript)。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
   {
     "key": "##JUSTINTIMEJITCOMPILATION",
     "original": "## Just-in-time (JIT) compilation",
@@ -14244,39 +14328,39 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ABOOTSTRAPPINGMETHODOFCOMPILINGCOMPONENTSANDMODULESINTHEBROWSERANDLAUNCHINGTHEAPPLICATIONDYNAMICALLYJUSTINTIMEMODEISAGOODCHOICEDURINGDEVELOPMENTCONSIDERUSINGTHEAHEADOFTIMEGUIDEGLOSSARY#AOTMODEFORPRODUCTIONAPPS",
-    "original": "A bootstrapping method of compiling components and modules in the browser\nand launching the application dynamically. Just-in-time mode is a good choice during development.\nConsider using the [ahead-of-time](guide/glossary#aot) mode for production apps.",
-    "translation": "Angular 的即时编译在浏览器中启动并编译所有的组件和模块，动态运行应用程序。\n  它很适合在开发过程中使用。但是在产品发布时，推荐采用[预编译 (ahead-of-time)](guide/glossary#aot) 模式。",
+    "key": "THEANGULARJUSTINTIMEJITCOMPILERCONVERTSYOURANGULARHTMLANDTYPESCRIPTCODEINTOEFFICIENTJAVASCRIPTCODEATRUNTIMEASPARTOFBOOTSTRAPPINGJITCOMPILATIONISTHEDEFAULTWHENYOURUNANGULARSNGBUILDANDNGSERVECLICOMMANDSANDISAGOODCHOICEDURINGDEVELOPMENTJITMODEISSTRONGLYDISCOURAGEDFORPRODUCTIONUSEBECAUSEITRESULTSINLARGEAPPLICATIONPAYLOADSTHATHINDERTHEBOOTSTRAPPERFORMANCE",
+    "original": "The Angular Just-in-Time (JIT) compiler converts your Angular HTML and TypeScript code into efficient JavaScript code at run time, as part of bootstrapping. \nJIT compilation is the default when you run Angular's `ng build` and `ng serve` CLI commands, and is a good choice during development. JIT mode is strongly discouraged for production use because it results in large application payloads that hinder the bootstrap performance.",
+    "translation": "在启动期间，Angular 的即时编译器（JIT)会在运行期间把你的 HTML 和 TypeScript 代码转换成高效的 JavaScript 代码。\n当你运行 Angular 的 CLI 命令 `ng build` 和 `ng serve` 时，JIT 编译是默认选项，而且是开发期间的最佳实践。但是强烈建议你不要在生产环境下使用 JIT 模式，因为它会导致巨大的应用负担，从而拖累启动时的性能。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "##KEBABCASE",
-    "original": "## kebab-case",
-    "translation": "## 烤串命名法 (kebab-case)",
+    "key": "COMPAREAHEADOFTIMEAOTCOMPILATIONGUIDEGLOSSARY#AOT",
+    "original": "Compare [ahead-of-time (AOT) compilation](guide/glossary#aot).",
+    "translation": "参见 [预先 (AOT) 编译](guide/glossary#aot)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "SEEDASHCASEGUIDEGLOSSARY#DASHCASE",
-    "original": "See [dash-case](guide/glossary#dash-case).",
-    "translation": "见[中线命名法 (dash-case)](guide/glossary#dash-case)。",
+    "key": "##LAZYLOADING",
+    "original": "## Lazy loading",
+    "translation": "## 惰性加载",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "##LIFECYCLEHOOKS",
-    "original": "## Lifecycle hooks",
+    "key": "LAZYLOADINGSPEEDSUPAPPLICATIONLOADTIMEBYSPLITTINGTHEAPPLICATIONINTOMULTIPLEBUNDLESANDLOADINGTHEMONDEMANDFOREXAMPLEDEPENDENCIESCANBELAZYLOADEDASNEEDEDEMDASHASOPPOSEDTOEAGERLOADEDMODULESTHATAREREQUIREDBYTHEROOTMODULEANDARETHUSLOADEDONLAUNCHSIMILARLYTHEROUTERGUIDEGLOSSARY#ROUTERCANLOADCHILDVIEWSONLYWHENTHEPARENTVIEWISACTIVATEDANDYOUCANBUILDCUSTOMELEMENTSTHATCANBELOADEDINTOANANGULARAPPWHENNEEDED",
+    "original": "Lazy loading speeds up application load time by splitting the application into multiple bundles and loading them on demand. \nFor example, dependencies can be lazy-loaded as needed&emdash;as opposed to \"eager-loaded\" modules that are required by the root module, and are thus loaded on launch. \nSimilarly, the [router](guide/glossary#router) can load child views only when the parent view is activated, and you can build custom elements that can be loaded into an Angular app when needed.",
+    "translation": "惰性加载会把应用拆分成多个包并且按需加载它们，从而提高应用加载速度。\n比如，一些依赖可以根据需要进行惰性加载，与之相对的是那些 \"急性加载\" 的模块，它们是根模块所要用的，因此会在启动期间加载。\n同样，[路由器](guide/glossary#router)只有当父视图激活时才需要加载子视图，你还可以构建一些自定义元素，它们也可以在需要时才加载进 Angular 应用。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##LIFECYCLEHOOK",
+    "original": "## Lifecycle hook",
     "translation": "## 生命周期钩子",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "DIRECTIVESGUIDEGLOSSARY#DIRECTIVEANDCOMPONENTSGUIDEGLOSSARY#COMPONENTHAVEALIFECYCLEMANAGEDBYANGULARASITCREATESUPDATESANDDESTROYSTHEM",
-    "original": "[Directives](guide/glossary#directive) and [components](guide/glossary#component) have a lifecycle\nmanaged by Angular as it creates, updates, and destroys them.",
-    "translation": "[指令 (directive)](guide/glossary#directive) 和[组件 (component)](guide/glossary#component) 具有生命周期，由 Angular 在创建、更新和销毁它们的过程中进行管理。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "YOUCANTAPINTOKEYMOMENTSINTHATLIFECYCLEBYIMPLEMENTINGONEORMOREOFTHELIFECYCLEHOOKINTERFACES",
-    "original": "You can tap into key moments in that lifecycle by implementing\none or more of the lifecycle hook interfaces.",
-    "translation": "你可以通过实现一个或多个生命周期钩子接口，切入到生命周期中的关键时间点。",
+    "key": "ANINTERFACETHATALLOWSYOUTOTAPINTOTHELIFECYCLEOFDIRECTIVESGUIDEGLOSSARY#DIRECTIVEANDCOMPONENTSGUIDEGLOSSARY#COMPONENTASTHEYARECREATEDUPDATEDANDDESTROYED",
+    "original": "An interface that allows you to tap into the lifecycle of [directives](guide/glossary#directive) and [components](guide/glossary#component) as they are created, updated, and destroyed.",
+    "translation": "一种接口，它允许你监听[指令](guide/glossary#directive)和[组件](guide/glossary#component)的生命周期，比如创建、更新和销毁等。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14340,9 +14424,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "READMOREINTHELIFECYCLEHOOKSGUIDELIFECYCLEHOOKSPAGE",
-    "original": "Read more in the [Lifecycle Hooks](guide/lifecycle-hooks) page.",
-    "translation": "更多信息，见[生命周期钩子 (lifecycle hook)](guide/lifecycle-hooks)。",
+    "key": "TOLEARNMORESEETHELIFECYCLEHOOKSGUIDELIFECYCLEHOOKSPAGE",
+    "original": "To learn more, see the [Lifecycle Hooks](guide/lifecycle-hooks) page.",
+    "translation": "要了解更多，参见[生命周期钩子](guide/lifecycle-hooks)页。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14352,111 +14436,105 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANGULARHASTHEFOLLOWINGTYPESOFMODULES:",
-    "original": "Angular has the following types of modules:",
-    "translation": "Angular 有下列模块类型：",
+    "key": "INGENERALAMODULECOLLECTSABLOCKOFCODEDEDICATEDTOASINGLEPURPOSEANGULARUSESSTANDARDJAVASCRIPTMODULESANDALSODEFINESANANGULARMODULENGMODULE",
+    "original": "In general, a module collects a block of code dedicated to a single purpose. Angular uses standard JavaScript modules, and also defines an Angular module, `NgModule`.",
+    "translation": "通常，模块会收集一组专注于单一目的的代码块。Angular 既使用 JavaScript 的标准模块，也定义了 Angular 自己的模块，也就是 `NgModule`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "NGMODULESGUIDEGLOSSARY#NGMODULEFORDETAILSANDEXAMPLESSEETHENGMODULESGUIDENGMODULESPAGE",
-    "original": "* [NgModules](guide/glossary#ngmodule).\nFor details and examples, see the [NgModules](guide/ngmodules) page.",
-    "translation": "[Angular 模块](guide/glossary#ngmodule)，见[Angular 模块](guide/ngmodules)。",
+    "key": "INJAVASCRIPTECMASCRIPTEACHFILEISAMODULEANDALLOBJECTSDEFINEDINTHEFILEBELONGTOTHATMODULEOBJECTSCANEXPORTEDMAKINGTHEMPUBLICANDPUBLICOBJECTSCANBEIMPORTEDFORUSEBYOTHERMODULES",
+    "original": "In JavaScript (ECMAScript), each file is a module and all objects defined in the file belong to that module. Objects can exported, making them public, and public objects can be imported for use by other modules.",
+    "translation": "在 JavaScript (ECMAScript) 中，每个文件都是一个模块，该文件中定义的所有对象都属于这个模块。这些对象可以导出为公共对象，而这些公共对象可以被其它模块导入后使用。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ES2015MODULESASDESCRIBEDINTHISSECTION",
-    "original": "* ES2015 modules, as described in this section.",
-    "translation": "ES2015 模块，如本节所述。",
+    "key": "ANGULARSHIPSASACOLLECTIONOFJAVASCRIPTMODULESORLIBRARIESEACHANGULARLIBRARYNAMEBEGINSWITHTHEANGULARPREFIXINSTALLTHEMWITHTHENPMPACKAGEMANAGERANDIMPORTPARTSOFTHEMWITHJAVASCRIPTIMPORTDECLARATIONS",
+    "original": "Angular ships as a collection of JavaScript modules, or libraries. Each Angular library name begins with the `@angular` prefix. Install them with the NPM package manager and import parts of them with JavaScript `import` declarations.",
+    "translation": "Angular 就是用一组 JavaScript 模块（或叫库）的形式发布的。每个 Angular 库都带有 `@angular` 前缀。\n使用 NPM 包管理器安装它们，并且使用 JavaScript 的 `import` 声明语句从中导入各个部件。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "FORACOMPARISONSEEJAVASCRIPTMODULESVSNGMODULESGUIDENGMODULEVSJSMODULE",
-    "original": "For a comparison, see [JavaScript Modules vs. NgModules](guide/ngmodule-vs-jsmodule).",
-    "translation": "要对比这两个概念，请参见[JavaScript 模块 vs. NgModules](guide/ngmodule-vs-jsmodule)。",
+    "key": "COMPARETHEANGULARNGMODULEGUIDEGLOSSARY#NGMODULE",
+    "original": "Compare the Angular [NgModule](guide/glossary#ngmodule).",
+    "translation": "参见 Angular [NgModule](guide/glossary#ngmodule)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ACOHESIVEBLOCKOFCODEDEDICATEDTOASINGLEPURPOSE",
-    "original": "A cohesive block of code dedicated to a single purpose.",
-    "translation": "模块是一个内聚的代码块，具有单一用途。",
+    "key": "ACLASSDEFINITIONWITHANNGMODULEDECORATORGUIDEGLOSSARY#DECORATORTHATDECLARESANDSERVESASAMANIFESTFORABLOCKOFCODEDEDICATEDTOANAPPLICATIONDOMAINAWORKFLOWORACLOSELYRELATEDSETOFCAPABILITIES",
+    "original": "A class definition with an `@NgModule` [decorator](guide/glossary#decorator), that declares and serves as a manifest for a block of code dedicated to an application domain, a workflow, or a closely related set of capabilities.",
+    "translation": "一种带有 `@NgModule` [装饰器](guide/glossary#decorator)的类定义，它会声明并提供一组专注于特定功能的代码块，比如业务领域、工作流或一组紧密相关的能力集等。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANGULARAPPSAREMODULAR",
-    "original": "Angular apps are modular.",
-    "translation": "Angular 应用程序是模块化的。",
+    "key": "LIKEAJAVASCRIPTMODULEGUIDEGLOSSARY#MODULEANNGMODULECANEXPORTFUNCTIONALITYFORUSEBYOTHERNGMODULESANDIMPORTPUBLICFUNCTIONALITYFROMOTHERNGMODULES",
+    "original": "Like a [JavaScript module](guide/glossary#module), an NgModule can export functionality for use by other NgModules, and import public functionality from other NgModules.",
+    "translation": "像 [JavaScript 模块](guide/glossary#module)一样，NgModule 能导出那些可供其它 NgModule 使用的功能，也可以从其它 NgModule 中导入其公开的功能。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "INGENERALYOUASSEMBLEANAPPLICATIONFROMMANYMODULESBOTHTHEONESYOUWRITEANDTHEONESYOUACQUIREFROMOTHERS",
-    "original": "In general, you assemble an application from many modules, both the ones you write and the ones you acquire from others.",
-    "translation": "一般来说，你用模块来组装应用程序，这些模块包含自己编写的模块和从其它地方获取的模块。",
+    "key": "THEMETADATAFORANNGMODULECLASSCOLLECTSCOMPONENTSDIRECTIVESANDPIPESTHATTHEAPPLICATIONUSESALONGWITHTHELISTOFIMPORTSANDEXPORTSSEEALSODECLARABLEGUIDEGLOSSARY#DECLARABLE",
+    "original": "The metadata for an NgModule class collects components, directives, and pipes that the application uses along with the list of imports and exports. See also [Declarable](guide/glossary#declarable).",
+    "translation": "NgModule 类的元数据中包括一些供应用使用的组件、指令和管道，以及导入、导出列表。参见[可声明对象](guide/glossary#declarable)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "AMODULEEXPORTSSOMETHINGOFVALUEINTHATCODETYPICALLYONETHINGSUCHASACLASSAMODULETHATNEEDSTHATCLASSIMPORTSIT",
-    "original": "A module *exports* something of value in that code, typically one thing such as a class;\na module that needs that class *imports* it.",
-    "translation": "模块会**导出 (export) **代码中的某些值，最典型的就是类。\n模块如果需要什么东西，那就**导入 (import) **它。",
+    "key": "NGMODULESARETYPICALLYNAMEDAFTERTHEFILEINWHICHTHEEXPORTEDTHINGISDEFINEDFOREXAMPLETHEANGULARDATEPIPEAPICOMMONDATEPIPECLASSBELONGSTOAFEATUREMODULENAMEDDATEPIPEINTHEFILEDATEPIPETSYOUIMPORTTHEMFROMANANGULARSCOPEDPACKAGEGUIDEGLOSSARY#SCOPEDPACKAGESUCHASANGULARCORE",
+    "original": "NgModules are typically named after the file in which the exported thing is defined; for example, the Angular [DatePipe](api/common/DatePipe) class belongs to a feature module named `date_pipe` in the file `date_pipe.ts`. You import them from an Angular [scoped package](guide/glossary#scoped-package) such as `@angular/core`.",
+    "translation": "NgModule 通常会根据它导出的内容决定其文件名，比如，Angular 的 [DatePipe](api/common/DatePipe) 类就属于 `date_pipe.ts` 文件中一个名叫 `date_pipe` 的特性模块。\n你可以从 Angular 的[范围化包](guide/glossary#scoped-package)中导入它们，比如 `@angular/core` 。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THESTRUCTUREOFNGMODULESANDTHEIMPORTEXPORTSYNTAXISBASEDONTHEES2015MODULESTANDARDHTTP:WWW2ALITYCOM201409ES6MODULESFINALHTML",
-    "original": "The structure of NgModules and the import/export syntax\nis based on the [ES2015 module standard](http://www.2ality.com/2014/09/es6-modules-final.html).",
-    "translation": "Angular 的模块结构和导入/导出语法是基于 [ES2015 模块标准](http://www.2ality.com/2014/09/es6-modules-final.html)的。",
+    "key": "EVERYANGULARAPPLICATIONHASAROOTMODULEBYCONVENTIONTHECLASSISCALLEDAPPMODULEANDRESIDESINAFILENAMEDAPPMODULETS",
+    "original": "Every Angular application has a root module. By convention, the class is called `AppModule` and resides in a file named `app.module.ts`.",
+    "translation": "每个 Angular 应用都有一个根模块。通常，这个类会命名为 `AppModule`，并且位于一个名叫 `app.module.ts` 的文件中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANAPPLICATIONTHATADHERESTOTHISSTANDARDREQUIRESAMODULELOADERTOLOADMODULESONREQUESTANDRESOLVEINTERMODULEDEPENDENCIESANGULARDOESNTINCLUDEAMODULELOADERANDDOESNTHAVEAPREFERENCEFORANYPARTICULARTHIRDPARTYLIBRARYYOUCANUSEANYMODULELIBRARYTHATCONFORMSTOTHESTANDARD",
-    "original": "An application that adheres to this standard requires a module loader to\nload modules on request and resolve inter-module dependencies.\nAngular doesn't include a module loader and doesn't have a preference\nfor any particular third-party library.\nYou can use any module library that conforms to the standard.",
-    "translation": "采用这个标准的应用程序需要一个模块加载器来按需加载模块，并解析模块间的依赖关系。\nAngular 不附带模块加载器，也不偏爱任何第三方库（虽然大多数例子使用 SystemJS）。\n你可以选择任何与这个标准兼容的模块化库。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "MODULESARETYPICALLYNAMEDAFTERTHEFILEINWHICHTHEEXPORTEDTHINGISDEFINEDTHEANGULARDATEPIPEHTTPS:GITHUBCOMANGULARANGULARBLOBMASTERPACKAGESCOMMONSRCPIPESDATEPIPETSCLASSBELONGSTOAFEATUREMODULENAMEDDATEPIPEINTHEFILEDATEPIPETS",
-    "original": "Modules are typically named after the file in which the exported thing is defined.\nThe Angular [DatePipe](https://github.com/angular/angular/blob/master/packages/common/src/pipes/date_pipe.ts)\nclass belongs to a feature module named `date_pipe` in the file `date_pipe.ts`.",
-    "translation": "模块一般与它定义导出物的文件同名。例如，Angular 的 [DatePipe](https://github.com/angular/angular/blob/master/modules/angular2/src/common/pipes/date_pipe.ts) 类属于名叫 `date_pipe` 的特性模块，位于 `date_pipe.ts` 文件中。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "YOURARELYACCESSANGULARFEATUREMODULESDIRECTLYYOUUSUALLYIMPORTTHEMFROMANANGULARSCOPEDPACKAGEGUIDEGLOSSARY#SCOPEDPACKAGESUCHASANGULARCORE",
-    "original": "You rarely access Angular feature modules directly. You usually import them from an Angular [scoped package](guide/glossary#scoped-package) such as `@angular/core`.",
-    "translation": "你很少需要直接访问 Angular 的特性模块。\n而通常会从一个 Angular [范围化包 (scoped package)](guide/glossary#scoped-package)中导入它们，例如 `@angular/core`。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "HELPSYOUORGANIZEANAPPLICATIONINTOCOHESIVEBLOCKSOFFUNCTIONALITYANNGMODULEIDENTIFIESTHECOMPONENTSDIRECTIVESANDPIPESTHATTHEAPPLICATIONUSESALONGWITHTHELISTOFEXTERNALNGMODULESTHATTHEAPPLICATIONNEEDSSUCHASFORMSMODULE",
-    "original": "Helps you organize an application into cohesive blocks of functionality.\nAn NgModule identifies the components, directives, and pipes that the application uses along with the list of external NgModules that the application needs, such as `FormsModule`.",
-    "translation": "帮助你把应用组织成多个内聚的功能块。\nNgModule 表示应用的组件、指令和管道以及所用到的外部模块的列表，比如 `FormsModule`。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "EVERYANGULARAPPLICATIONHASANAPPLICATIONROOTMODULECLASSBYCONVENTIONTHECLASSISCALLEDAPPMODULEANDRESIDESINAFILENAMEDAPPMODULETS",
-    "original": "Every Angular application has an application root-module class. By convention, the class is\ncalled `AppModule` and resides in a file named `app.module.ts`.",
-    "translation": "每个 Angular 应用都有一个应用级根模块类。这类通常叫做 `AppModule`，并且位于一个名叫 `app.module.ts` 的文件中。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "FORDETAILSANDEXAMPLESSEENGMODULESGUIDENGMODULESANDTHERELATEDFILESINTHATSECTION",
-    "original": "For details and examples, see [NgModules](guide/ngmodules) and the \nrelated files in that section.",
-    "translation": "要获得详情和范例，参见 [NgModule](guide/ngmodules) 及其相关文件。",
+    "key": "TOLEARNMORESEETHENGMODULESGUIDENGMODULESGUIDE",
+    "original": "To learn more, see the [NgModules](guide/ngmodules) guide.",
+    "translation": "要了解更多，参见 [NgModules](guide/ngmodules)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
     "key": "##OBSERVABLE",
     "original": "## Observable",
-    "translation": "## Observable 对象",
+    "translation": "## Observable（可观察对象）",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANARRAYWHOSEITEMSARRIVEASYNCHRONOUSLYOVERTIMEOBSERVABLESHELPYOUMANAGEASYNCHRONOUSDATASUCHASDATACOMINGFROMABACKENDSERVICEOBSERVABLESAREUSEDWITHINANGULARITSELFINCLUDINGANGULARSEVENTSYSTEMANDITSHTTPCLIENTSERVICE",
-    "original": "An array whose items arrive asynchronously over time.\nObservables help you manage asynchronous data, such as data coming from a backend service.\nObservables are used within Angular itself, including Angular's event system and its HTTP client service.",
-    "translation": "一个 `Observable` 是一个数组，其中的元素随着时间的流逝异步地到达。\n`Observable` 帮助你管理异步数据，例如来自后台服务的数据。\nAngular 自身使用了 `Observable`，包括 Angular 的事件系统和它的 http 客户端服务。",
+    "key": "APRODUCEROFMULTIPLEVALUESWHICHITPUSHESTOSUBSCRIBERSGUIDEGLOSSARY#SUBSCRIBERUSEDFORASYNCHRONOUSEVENTHANDLINGTHROUGHOUTANGULARYOUEXECUTEANOBSERVABLEBYSUBSCRIBINGTOITWITHITSSUBSCRIBEMETHODPASSINGCALLBACKSFORNOTIFICATIONSOFNEWVALUESERRORSORCOMPLETION",
+    "original": "A producer of multiple values, which it pushes to [subscribers](guide/glossary#subscriber). Used for asynchronous event handling throughout Angular. You execute an observable by subscribing to it with its `subscribe()` method, passing callbacks for notifications of new values, errors, or completion.",
+    "translation": "一个多值生成器，这些值会被推送给[订阅者](guide/glossary#subscriber)。\nAngular 中到处都会用到异步事件处理。你要通过调用可观察对象的 `subscribe()` 方法来订阅它，从而让这个可观察对象得以执行，你还要给该方法传入一些回调函数来接收 \"有新值\"、\"错误\" 或 \"完成\" 等通知。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "TOUSEOBSERVABLESANGULARUSESATHIRDPARTYLIBRARYCALLEDREACTIVEEXTENSIONSRXJSOBSERVABLESAREAPROPOSEDFEATUREFORES2016THENEXTVERSIONOFJAVASCRIPT",
-    "original": "To use observables, Angular uses a third-party library called Reactive Extensions (RxJS).\nObservables are a proposed feature for ES2016, the next version of JavaScript.",
-    "translation": "为了使用 `Observable`， Angular 采用了名为 Reactive Extensions (RxJS) 的第三方包。\n在下个版本的 JavaScript - ES 2016 中，`Observable` 是建议的特性之一。",
+    "key": "OBSERVABLESCANDELIVERSINGLEORMULTIPLEVALUESOFANYTYPETOSUBSCRIBERSEITHERSYNCHRONOUSLYASAFUNCTIONDELIVERSAVALUETOITSCALLERORONASCHEDULEASUBSCRIBERRECEIVESNOTIFICATIONOFNEWVALUESASTHEYAREPRODUCEDANDOFEITHERERRORORNORMALCOMPLETION",
+    "original": "Observables can deliver single or multiple values of any type to subscribers, either synchronously (as a function delivers a value to its caller), or on a schedule. A subscriber receives notification of new values as they are produced, and of either error or normal completion.",
+    "translation": "可观察对象可以把任意类型的一个或多个值传给订阅者，无论是同步（就像函数把值返回给它的调用者一样）还是异步。\n一旦生成了新值，订阅者就会收到通知，并且还会收到错误或正常完成的通知。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ANGULARUSESATHIRDPARTYLIBRARYCALLEDREACTIVEEXTENSIONSRXJSHTTP:REACTIVEXIORXJS",
+    "original": "Angular uses a third-party library called [Reactive Extensions (RxJS)](http://reactivex.io/rxjs/).",
+    "translation": "Angular 使用一个名叫[响应式扩展 (RxJS)](http://reactivex.io/rxjs/)的第三方包来实现这些功能。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "TOLEARNMORESEETHEOBSERVABLESGUIDEGLOSSARY#OBSERVABLEGUIDE",
+    "original": "To learn more, see the [Observables](guide/glossary#observable) guide.",
+    "translation": "要了解更多，参见[可观察对象](guide/glossary#observable)。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##OBSERVER",
+    "original": "## Observer",
+    "translation": "## 观察者",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ANOBJECTPASSEDTOTHESUBSCRIBEMETHODFORANOBSERVABLEGUIDEGLOSSARY#OBSERVABLETHATDEFINESTHECALLBACKSFORTHESUBSCRIBERGUIDEGLOSSARY#SUBSCRIBER",
+    "original": "An object passed to the `subscribe()` method for an [observable](guide/glossary#observable) that defines the callbacks for the [subscriber](guide/glossary#subscriber).",
+    "translation": "传给[可观察对象](guide/glossary#observable) 的 `subscribe()` 方法的一个对象，其中定义了[订阅者](guide/glossary#subscriber)的一组回调函数。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14466,33 +14544,21 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ADIRECTIVEPROPERTYTHATCANBETHETARGETOFEVENTBINDINGREADMOREINTHEEVENTBINDINGGUIDETEMPLATESYNTAX#EVENTBINDINGSECTIONOFTHETEMPLATESYNTAXGUIDETEMPLATESYNTAXPAGEEVENTSSTREAMOUTOFTHISPROPERTYTOTHERECEIVERIDENTIFIEDINTHETEMPLATEEXPRESSIONTOTHERIGHTOFTHEEQUALSIGN",
-    "original": "A directive property that can be the *target* of event binding\n(read more in the [event binding](guide/template-syntax#event-binding)\nsection of the [Template Syntax](guide/template-syntax) page).\nEvents stream *out* of this property to the receiver identified\nin the template expression to the right of the equal sign.",
-    "translation": "输出属性是一个指令属性，可作为[事件绑定](guide/template-syntax.html#event-binding)的 **目标** 。\n事件流从这个属性流*出*到模板表达式等号的右边的接收者。",
+    "key": "WHENDEFININGADIRECTIVEGUIDEGLOSSARY#DIRECTIVETHEOUTPUTDECORATORONADIRECTIVEPROPERTYMAKESTHATPROPERTYAVAILABLEASATARGETOFEVENTBINDINGGUIDETEMPLATESYNTAX#EVENTBINDING",
+    "original": "When defining a [directive](guide/glossary#directive), the `@Output` decorator on a directive property makes that property available as a *target* of [event binding](guide/template-syntax#event-binding).",
+    "translation": "当定义[指令](guide/glossary#directive)时，指令属性上的 `@Output` 装饰器会让该属性可用作[事件绑定](guide/template-syntax#event-binding)的*目标*。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "SEETHEINPUTANDOUTPUTPROPERTIESGUIDETEMPLATESYNTAX#INPUTSOUTPUTSSECTIONOFTHETEMPLATESYNTAXGUIDETEMPLATESYNTAXPAGE",
-    "original": "See the [Input and output properties](guide/template-syntax#inputs-outputs) section of the [Template Syntax](guide/template-syntax) page.",
-    "translation": "参见[模板语法](guide/template-syntax)中的[输入与输出属性](guide/template-syntax#inputs-outputs)部分。",
+    "key": "EVENTSSTREAMOUTOFTHISPROPERTYTOTHERECEIVERIDENTIFIEDINTHETEMPLATEEXPRESSIONGUIDEGLOSSARY#TEMPLATEEXPRESSIONTOTHERIGHTOFTHEEQUALSIGN",
+    "original": "Events stream *out* of this property to the receiver identified\nin the [template expression](guide/glossary#template-expression) to the right of the equal sign.",
+    "translation": "事件从该属性流*出*到等号右侧指定的[模板表达式](guide/glossary#template-expression)中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "##PASCALCASE",
-    "original": "## PascalCase",
-    "translation": "## Pascal 命名法 (PascalCase)",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "THEPRACTICEOFWRITINGINDIVIDUALWORDSCOMPOUNDWORDSORPHRASESSUCHTHATEACHWORDORABBREVIATIONBEGINSWITHACAPITALLETTERCLASSNAMESARETYPICALLYSPELLEDINPASCALCASEFOREXAMPLEPERSONANDHERODETAILCOMPONENT",
-    "original": "The practice of writing individual words, compound words, or phrases such that each word or abbreviation begins with a capital letter.\nClass names are typically spelled in PascalCase. For example, `Person` and `HeroDetailComponent`.",
-    "translation": "Pascal 命名法是书写单词、复合词或短语的一种形式，每个单词或缩写都以大写开头。\n类名一般都采用 Pascal 命名法。例如 `Person` 和 `HeroDetailComponent`。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "THISFORMISALSOKNOWNASUPPERCAMELCASETODISTINGUISHITFROMLOWERCAMELCASEORSIMPLYCAMELCASEGUIDEGLOSSARY#CAMELCASEINTHISDOCUMENTATIONPASCALCASEMEANSUPPERCAMELCASEANDCAMELCASEMEANSLOWERCAMELCASE",
-    "original": "This form is also known as *upper camel case* to distinguish it from *lower camel case* or simply [camelCase](guide/glossary#camelcase).\nIn this documentation, \"PascalCase\" means *upper camel case* and  \"camelCase\" means *lower camel case*.",
-    "translation": "这种形式也称**大写驼峰式命名法**，以区别于**小写驼峰式命名法”或[驼峰式命名法 (camelCase)](guide/glossary#camelcase)** 。\n在本文档中，“Pascal 命名法”都是指的*大写驼峰式命名法*，“驼峰式命名法”指的都是*小写驼峰式命名法*。",
+    "key": "TOLEARNMORESEEINPUTANDOUTPUTPROPERTIESGUIDETEMPLATESYNTAX#INPUTSOUTPUTS",
+    "original": "To learn more, see [input and output properties](guide/template-syntax#inputs-outputs).",
+    "translation": "要了解更多，参见[输入与输出属性](guide/template-syntax#inputs-outputs)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14502,15 +14568,33 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANANGULARPIPEISAFUNCTIONTHATTRANSFORMSINPUTVALUESTOOUTPUTVALUESFORDISPLAYINAVIEWGUIDEGLOSSARY#VIEWHERESANEXAMPLETHATUSESTHEBUILTINCURRENCYPIPETODISPLAYANUMERICVALUEINTHELOCALCURRENCY",
-    "original": "An Angular pipe is a function that transforms input values to output values for\ndisplay in a [view](guide/glossary#view).\nHere's an example that uses the built-in `currency` pipe to display\na numeric value in the local currency.",
-    "translation": "Angular 管道是一个函数，用于把输入值转换成输出值以供[视图 (view)](guide/glossary#view)显示。\n下面这个例子中，用内置的 `currency` 管道把数字值显示为本地货币格式。",
+    "key": "ACLASSWITHTHEPIPEDECORATORWHICHDEFINESAFUNCTIONTHATTRANSFORMSINPUTVALUESTOOUTPUTVALUESFORDISPLAYINAVIEWGUIDEGLOSSARY#VIEW",
+    "original": "A class with the `@Pipe` decorator which defines a function that transforms input values to output values for display in a [view](guide/glossary#view).",
+    "translation": "一个带有 `@Pipe` 装饰器的类，它定义了一个函数，用来把输入值转换成输出值，以显示在[视图](guide/glossary#view)中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "YOUCANALSOWRITEYOUROWNCUSTOMPIPESREADMOREINTHEPAGEONPIPESGUIDEPIPES",
-    "original": "You can also write your own custom pipes.\nRead more in the page on [pipes](guide/pipes).",
-    "translation": "你还可以写自己的自定义管道。\n更多信息，见[管道](guide/pipes)。",
+    "key": "ANGULARDEFINESVARIOUSPIPESANDYOUCANDEFINENEWPIPES",
+    "original": "Angular defines various pipes, and you can define new pipes.",
+    "translation": "Angular 定义了很多管道，并且你还可可以自定义新的管道。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "TOLEARNMORESEETHEPIPESGUIDEPIPESPAGE",
+    "original": "To learn more, see the [pipes](guide/pipes) page.",
+    "translation": "要了解更多，参见[管道](guide/pipes)页。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##POLYFILL",
+    "original": "## Polyfill",
+    "translation": "## 腻子脚本（polyfill）",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ANNPMPACKAGEGUIDENPMPACKAGESTHATPLUGSGAPSINABROWSERSJAVASCRIPTIMPLEMENTATIONSEETHEBROWSERSUPPORTGUIDEBROWSERSUPPORTGUIDEFORPOLYFILLSTHATSUPPORTPARTICULARFUNCTIONALITYFORPARTICULARPLATFORMS",
+    "original": "An [NPM package](guide/npm-packages) that plugs gaps in a browser's JavaScript implementation. See the [Browser Support](guide/browser-support) guide for polyfills that support particular functionality for particular platforms.",
+    "translation": "一个 [NPM 包](guide/npm-packages)，它负责弥补浏览器 JavaScript 实现与最新标准之间的 \"缝隙\"。参见[浏览器支持](guide/browser-support)页，以了解要在特定平台支持特定功能时所需的腻子脚本。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14520,9 +14604,21 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "APROVIDERCREATESANEWINSTANCEOFADEPENDENCYFORTHEDEPENDENCYINJECTIONGUIDEGLOSSARY#DEPENDENCYINJECTIONSYSTEMITRELATESALOOKUPTOKENTOCODEMDASHSOMETIMESCALLEDARECIPEMDASHTHATCANCREATEADEPENDENCYVALUE",
-    "original": "A _provider_ creates a new instance of a dependency for the\n[dependency injection](guide/glossary#dependency-injection) system.\nIt relates a lookup token to code&mdash;sometimes called a \"recipe\"&mdash;that can create a dependency value.",
-    "translation": "依赖注入系统依靠提供商来创建依赖的实例。\n它把一个查找令牌和代码（有时也叫“配方”）关联到一起，以便创建依赖值。",
+    "key": "APROVIDEROFANINJECTABLESERVICEMDASHSPECIFICALLYACODERECIPEASSOCIATEDWITHADITOKENGUIDEGLOSSARY#TOKENWHICHANINJECTORGUIDEGLOSSARY#INJECTORUSESTOCREATEANEWINSTANCEOFADEPENDENCYFORACLASSTHATREQUIRESIT",
+    "original": "A provider of an injectable service&mdash;specifically, a code recipe associated with a [DI token](guide/glossary#token), which an [injector](guide/glossary#injector) uses to create a new instance of a dependency for a class that requires it.",
+    "translation": "一种可注入服务的提供商。更准确的说是一个与 [DI 令牌](guide/glossary#token)相关的代码 \"菜谱\"，[注入器](guide/glossary#injector)会使用这个菜谱来创建它所依赖的那些类的实例。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ANGULARREGISTERSITSOWNPROVIDERSWITHEVERYINJECTORFORSERVICESTHATANGULARDEFINESYOUCANREGISTERYOUROWNPROVIDERSFORSERVICESTHATYOURAPPNEEDS",
+    "original": "Angular registers its own providers with every injector, for services that Angular defines. You can register your own providers for services that your app needs.",
+    "translation": "Angular 会为其自带的服务在每个注入器中注册它自己的提供商。你也可以自己注册应用所需的自己的服务提供商。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "SEEALSOSERVICEGUIDEGLOSSARY#SERVICEDEPENDENCYINJECTIONGUIDEGLOSSARY#DI",
+    "original": "See also [Service](guide/glossary#service), [Dependency Injection](guide/glossary#di).",
+    "translation": "参见[服务](guide/glossary#service)和[依赖注入](guide/glossary#di)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14580,39 +14676,27 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "MOSTAPPLICATIONSCONSISTOFMANYSCREENSORVIEWSGUIDEGLOSSARY#VIEWTHEUSERNAVIGATESAMONGTHEMBYCLICKINGLINKSANDBUTTONSANDPERFORMINGOTHERSIMILARACTIONSTHATCAUSETHEAPPLICATIONTOREPLACEONEVIEWWITHANOTHER",
-    "original": "Most applications consist of many screens or [views](guide/glossary#view).\nThe user navigates among them by clicking links and buttons,\nand performing other similar actions that cause the application to\nreplace one view with another.",
-    "translation": "大多数应用程序包含多个屏幕或[视图 (view)](guide/glossary#view)。\n用户通过点击链接、按钮和其它类似动作，在它们之间导航，使应用程序从一个视图切换到另一个视图。",
+    "key": "ATOOLTHATCONFIGURESANDIMPLEMENTSNAVIGATIONAMONGSTATESANDVIEWSGUIDEGLOSSARY#VIEWWITHINANANGULARAPP",
+    "original": "A tool that configures and implements navigation among states and [views](guide/glossary#view) within an Angular app.",
+    "translation": "一种工具，用来配置和实现 Angular 应用中各个状态和[视图](guide/glossary#view)之间的导航。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THEANGULARCOMPONENTROUTERISARICHLYFEATUREDMECHANISMFORCONFIGURINGANDMANAGINGTHEENTIREVIEWNAVIGATIONPROCESSINCLUDINGTHECREATIONANDDESTRUCTIONOFVIEWS",
-    "original": "The Angular component router is a richly featured mechanism for configuring and managing the entire view navigation process, including the creation and destruction\nof views.",
-    "translation": "Angular 的组件路由器是一个特性丰富的机制，可以配置和管理整个导航过程，包括建立和销毁视图。",
+    "key": "THEROUTERMODULEISANNGMODULEGUIDEGLOSSARY#NGMODULETHATPROVIDESTHENECESSARYSERVICEPROVIDERSANDDIRECTIVESFORNAVIGATINGTHROUGHAPPLICATIONVIEWSAROUTINGCOMPONENTGUIDEGLOSSARY#ROUTINGCOMPONENTISONETHATIMPORTSTHEROUTERMODULEANDWHOSETEMPLATECONTAINSAROUTEROUTLETELEMENTWHEREITCANDISPLAYVIEWSPRODUCEDBYTHEROUTER",
+    "original": "The Router module is an [NgModule](guide/glossary#ngmodule) that provides the necessary service providers and directives for navigating through application views. A [routing component](guide/glossary#routing-component) is one that imports the Router module and whose template contains a `RouterOutlet` element where it can display views produced by the router.",
+    "translation": "路由器模块是一个 [NgModule](guide/glossary#ngmodule)，它提供在应用视图间导航时需要的服务提供商和指令。[路由组件](guide/glossary#routing-component)是一种组件，它导入了路由模块，并且其模板中包含 `RouterOutlet` 元素，路由器生成的视图就会被显示在那里。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "INMOSTCASESCOMPONENTSBECOMEATTACHEDTOAROUTERBYMEANSOFAROUTERCONFIGTHATDEFINESROUTESTOVIEWS",
-    "original": "In most cases, components become attached to a router by means\nof a `RouterConfig` that defines routes to views.",
-    "translation": "多数情况下，组件会通过 `RouterConfig` 中定义的路由到视图的对照表来附加到[路由器](guide/glossary#router)上。",
+    "key": "THEROUTERDEFINESNAVIGATIONAMONGVIEWSONASINGLEPAGEASOPPOSEDTONAVIGATIONAMONGPAGESITINTERPRETSURLLIKELINKSTODETERMINEWHICHVIEWSTOCREATEORDESTROYANDWHICHCOMPONENTSTOLOADORUNLOADITALLOWSYOUTOTAKEADVANTAGEOFLAZYLOADINGGUIDEGLOSSARY#LAZYLOADINYOURANGULARAPPS",
+    "original": "The Router defines navigation among views on a single page, as opposed to navigation among pages. It interprets URL-like links to determine which views to create or destroy, and which components to load or unload. It allows you to take advantage of [lazy-loading](guide/glossary#lazy-load) in your Angular apps.",
+    "translation": "路由器定义了在单页面中的各个视图之间导航的方式，而不是在页面之间。它会解释类似 URL 的链接，以决定该创建或销毁哪些视图，以及要加载或卸载哪些组件。它让你可以在 Angular 应用中获得[惰性加载](guide/glossary#lazy-load)的好处。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "AROUTINGCOMPONENTSGUIDEGLOSSARY#ROUTINGCOMPONENTTEMPLATEHASAROUTEROUTLETELEMENTWHEREITCANDISPLAYVIEWSPRODUCEDBYTHEROUTER",
-    "original": "A [routing component's](guide/glossary#routing-component) template has a `RouterOutlet` element\nwhere it can display views produced by the router.",
-    "translation": "[路由组件](guide/glossary#routing-component)的模板中带有一个 `RouterOutlet` 元素，那是显示路由器生成的视图的地方。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "OTHERVIEWSINTHEAPPLICATIONLIKELYHAVEANCHORTAGSORBUTTONSWITHROUTERLINKDIRECTIVESTHATUSERSCANCLICKTONAVIGATE",
-    "original": "Other views in the application likely have anchor tags or buttons with `RouterLink`\ndirectives that users can click to navigate.",
-    "translation": "应用中的其它视图中某些锚标签或按钮上带有 `RouterLink` 指令，用户可以点击它们进行导航。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "FORMOREINFORMATIONSEETHEROUTINGNAVIGATIONGUIDEROUTERPAGE",
-    "original": "For more information, see the [Routing & Navigation](guide/router) page.",
-    "translation": "更多信息，见[路由与导航](guide/router)。",
+    "key": "TOLEARNMORESEETHEROUTINGNAVIGATIONGUIDEROUTERGUIDE",
+    "original": "To learn more, see the [Routing & Navigation](guide/router) guide.",
+    "translation": "要了解更多，参见[路由与导航](guide/router)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14633,6 +14717,18 @@
     "translation": "更多信息，见[路由与导航](guide/router)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
+  {
+    "key": "##ROUTEROUTLET",
+    "original": "## Router outlet",
+    "translation": "## 路由出口",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ADIRECTIVETHATACTSASAPLACEHOLDERINAROUTINGCOMPONENTSTEMPLATEWHICHANGULARDYNAMICALLYFILLSBASEDONTHECURRENTROUTERSTATE",
+    "original": "A directive that acts as a placeholder in a routing component's template, which Angular dynamically fills based on the current router state.",
+    "translation": "一种指令，它在路由组件的模板中充当占位符的角色，Angular 会根据当前的路由状态动态填充它。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
   {
     "key": "##ROUTINGCOMPONENT",
     "original": "## Routing component",
@@ -14658,21 +14754,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "AWAYTOGROUPRELATEDNPMPACKAGESREADMOREATTHENPMSCOPEHTTPS:DOCSNPMJSCOMMISCSCOPEPAGE",
-    "original": "A way to group related *npm* packages.\nRead more at the [npm-scope](https://docs.npmjs.com/misc/scope) page.",
-    "translation": "对相关的 *npm* 包进行分组的一种方式，参阅[npm-scope](https://docs.npmjs.com/misc/scope)。",
+    "key": "AWAYTOGROUPRELATEDNPMPACKAGESNGMODULESAREDELIVEREDWITHINSCOPEDPACKAGESWHOSENAMESBEGINWITHTHEANGULARSCOPENAMEANGULARFOREXAMPLEANGULARCOREANGULARCOMMONANGULARHTTPANDANGULARROUTER",
+    "original": "A way to group related NPM packages. \nNgModules are delivered within *scoped packages* whose names begin with the Angular *scope name* `@angular`. For example, `@angular/core`, `@angular/common`, `@angular/http`, and `@angular/router`.",
+    "translation": "一种把相关的 NPM 包分组到一起的方式。\nAngular 的 NgModule 都是在一些以 `@angular` 为范围名的*范围化包*中发布的。比如 `@angular/core`、`@angular/common`、`@angular/http` 和 `@angular/router`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "NGMODULESAREDELIVEREDWITHINSCOPEDPACKAGESSUCHASANGULARCOREANGULARCOMMONANGULARPLATFORMBROWSERDYNAMICANGULARHTTPANDANGULARROUTER",
-    "original": "NgModules are delivered within *scoped packages* such as `@angular/core`,\n`@angular/common`, `@angular/platform-browser-dynamic`, `@angular/http`, and `@angular/router`.",
-    "translation": "Angular 模块是用一系列*范围化包*的形式发布的，例如 `@angular/core`、`@angular/common`、`@angular/platform-browser-dynamic`、`@angular/http` 和 `@angular/router`。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "IMPORTASCOPEDPACKAGETHESAMEWAYTHATYOUIMPORTANORMALPACKAGETHEONLYDIFFERENCEFROMACONSUMERPERSPECTIVEISTHATTHESCOPEDPACKAGENAMEBEGINSWITHTHEANGULARSCOPENAMEANGULAR",
-    "original": "Import a scoped package the same way that you import a normal package.\nThe only difference, from a consumer perspective,\nis that the scoped package name begins with the Angular *scope name*, `@angular`.",
-    "translation": "导入范围化包与导入*普通*包方式相同。\n  从消费者的视角看，唯一的不同是那些包的名字是用 Angular 的*范围化包名*`@angular` 开头的。",
+    "key": "IMPORTASCOPEDPACKAGEINTHESAMEWAYTHATYOUIMPORTANORMALPACKAGE",
+    "original": "Import a scoped package in the same way that you import a normal package.",
+    "translation": "和导入普通包相同的方式导入范围化包。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14682,45 +14772,21 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "FORDATAORLOGICTHATISNOTASSOCIATEDWITHASPECIFICVIEWORTHATYOUWANTTOSHAREACROSSCOMPONENTSBUILDSERVICES",
-    "original": "For data or logic that is not associated\nwith a specific view or that you want to share across components, build services.",
-    "translation": "服务用于封装不与任何特定视图相关的数据和逻辑，或者用于在组件之间共享数据和逻辑。",
+    "key": "INANGULARASERVICEISACLASSWITHTHEINJECTABLEGUIDEGLOSSARY#INJECTABLEDECORATORTHATENCAPSULATESNONUILOGICANDCODETHATCANBEREUSEDACROSSANAPPLICATIONANGULARDISTINGUISHESCOMPONENTSFROMSERVICESINORDERTOINCREASEMODULARITYANDREUSABILITY",
+    "original": "In Angular, a service is a class with the [@Injectable](guide/glossary#injectable) decorator that encapsulates non-UI logic and code that can be re-used across an application. \nAngular distinguishes components from services in order to increase modularity and reusability.",
+    "translation": "在 Angular 中，服务就是一个带有 [@Injectable](guide/glossary#injectable) 装饰器的类，它封装了可以在应用程序中复用的非 UI 逻辑和代码。\nAngular 把组件和服务分开，是为了增进模块化程度和可复用性。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "APPLICATIONSOFTENREQUIRESERVICESSUCHASAHERODATASERVICEORALOGGINGSERVICE",
-    "original": "Applications often require services such as a hero data service or a logging service.",
-    "translation": "应用程序经常需要服务，例如英雄数据服务或者日志服务。",
+    "key": "THEINJECTABLEMETADATAALLOWSTHESERVICECLASSTOBEUSEDWITHTHEDEPENDENCYINJECTIONGUIDEGLOSSARY#DIMECHANISMTHEINJECTABLECLASSISINSTANTIATEDBYAPROVIDERGUIDEGLOSSARY#PROVIDERANDAMODULEMAINTAINSALISTOFPROVIDERSTHATCANPROVIDEAPARTICULARTYPEOFSERVICEASNEEDEDBYCOMPONENTSOROTHERSERVICESTHATREQUIREIT",
+    "original": "The `@Injectable` metadata allows the service class to be used with the [dependency injection](guide/glossary#di) mechanism. The injectable class is instantiated by a [provider](guide/glossary#provider), and a module maintains a list of providers that can provide a particular type of service as needed by components or other services that require it.",
+    "translation": "`@Injectable` 元数据让服务类能用于[依赖注入](guide/glossary#di)机制中。可注入的类是用[提供商](guide/glossary#provider)进行实例化的，模块中包含一个提供商列表，它可以为依赖它的组件或其它服务提供该服务的具体类。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ASERVICEISACLASSWITHAFOCUSEDPURPOSEYOUOFTENCREATEASERVICETOIMPLEMENTFEATURESTHATAREINDEPENDENTFROMANYSPECIFICVIEWPROVIDESHAREDDATAORLOGICACROSSCOMPONENTSORENCAPSULATEEXTERNALINTERACTIONS",
-    "original": "A service is a class with a focused purpose.\nYou often create a service to implement features that are\nindependent from any specific view,\nprovide shared data or logic across components, or encapsulate external interactions.",
-    "translation": "服务是一个具有特定功能的类。\n你经常创建服务来实现不依赖任何特定视图的特征，\n在组件之间提供共享数据或逻辑，或者封装外部的交互。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "APPLICATIONSOFTENREQUIRESERVICESSUCHASADATASERVICEORALOGGINGSERVICE",
-    "original": "Applications often require services such as a data service or a logging service.",
-    "translation": "应用通常都需要服务，比如数据服务或者日志服务。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "FORMOREINFORMATIONSEETHESERVICESTUTORIALTOHPT4PAGEOFTHETOUROFHEROESTUTORIALTUTORIAL",
-    "original": "For more information, see the [Services](tutorial/toh-pt4) page of the [Tour of Heroes](tutorial) tutorial.",
-    "translation": "更多信息，见[英雄指南](tutorial)中的[服务](tutorial/toh-pt4)。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "##SNAKECASE",
-    "original": "## snake_case",
-    "translation": "## 蛇形命名法",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "THEPRACTICEOFWRITINGCOMPOUNDWORDSORPHRASESSUCHTHATANUNDERSCORESEPARATESONEWORDFROMTHENEXTTHISFORMISALSOKNOWNASUNDERSCORECASE",
-    "original": "The practice of writing compound words or phrases such that an\nunderscore (`_`) separates one word from the next. This form is also known as *underscore case*.",
-    "translation": "写复合词或短语的一种方式，在多个词之间用下划线(`_`)分隔。也叫*下划线命名法*",
+    "key": "TOLEARNMORESEEINTRODUCTIONTOSERVICESGUIDEARCHITECTURESERVICES",
+    "original": "To learn more, see [Introduction to Services](guide/architecture-services).",
+    "translation": "要了解更多，参见[服务简介](guide/architecture-services)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14730,15 +14796,57 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ACATEGORYOFDIRECTIVEGUIDEGLOSSARY#DIRECTIVETHATCANSHAPEORRESHAPEHTMLLAYOUTTYPICALLYBYADDINGANDREMOVINGELEMENTSINTHEDOMTHENGIFCONDITIONALELEMENTDIRECTIVEANDTHENGFORREPEATERDIRECTIVEAREWELLKNOWNEXAMPLES",
-    "original": "A category of [directive](guide/glossary#directive) that can\nshape or reshape HTML layout, typically by adding and removing elements in the DOM.\nThe `ngIf` \"conditional element\" directive and the `ngFor` \"repeater\" directive are well-known examples.",
-    "translation": "结构型指令是[指令 (directive)](guide/glossary#directive)一种，\n可以通过在 DOM 中添加、删除或操作元素和其各级子元素来塑造或重塑 HTML 布局。\n例如，`ngIf` 这个“条件化元素”指令，`ngFor` 这个“重复器”指令都是众所周知的例子。",
+    "key": "ACATEGORYOFDIRECTIVEGUIDEGLOSSARY#DIRECTIVETHATISRESPONSIBLEFORSHAPINGORRESHAPINGHTMLLAYOUTBYMODIFYINGTHEDOMADDINGREMOVINGORMANIPULATINGELEMENTSANDTHEIRCHILDREN",
+    "original": "A category of [directive](guide/glossary#directive) that is responsible for shaping or reshaping HTML layout by modifying the DOM (adding, removing, or manipulating elements and their children).",
+    "translation": "一种[指令](guide/glossary#directive)类型，它能通过修改 DOM （添加、删除或操纵元素及其子元素）来修整或重塑 HTML 的布局。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "READMOREINTHESTRUCTURALDIRECTIVESGUIDESTRUCTURALDIRECTIVESPAGE",
-    "original": "Read more in the [Structural Directives](guide/structural-directives) page.",
-    "translation": "更多信息，见[结构型指令](guide/structural-directives)。",
+    "key": "TOLEARNMORESEETHESTRUCTURALDIRECTIVESGUIDESTRUCTURALDIRECTIVESPAGE",
+    "original": "To learn more, see the [Structural Directives](guide/structural-directives) page.",
+    "translation": "要了解更多，参见[结构型指令](guide/structural-directives)页。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##SUBSCRIBER",
+    "original": "## Subscriber",
+    "translation": "## 订阅者",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "AFUNCTIONTHATDEFINESHOWTOOBTAINORGENERATEVALUESORMESSAGESTOBEPUBLISHEDTHISFUNCTIONISEXECUTEDWHENACONSUMERCALLSTHESUBSCRIBEMETHODOFANOBSERVABLEGUIDEGLOSSARY#OBSERVABLE",
+    "original": "A function that defines how to obtain or generate values or messages to be published. This function is executed when a consumer calls the `subscribe()` method of an [observable](guide/glossary#observable).",
+    "translation": "一个函数，用于定义如何获取或生成要发布的值或消息。\n当有消费者调用[可观察对象](guide/glossary#observable)的 `subscribe()` 方法时，该函数就会执行。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "THEACTOFSUBSCRIBINGTOANOBSERVABLETRIGGERSITSEXECUTIONASSOCIATESCALLBACKSWITHITANDCREATESASUBSCRIPTIONOBJECTTHATLETSYOUUNSUBSCRIBE",
+    "original": "The act of subscribing to an observable triggers its execution, associates callbacks with it, and creates a `Subscription` object that lets you unsubscribe.",
+    "translation": "订阅一个可观察对象就会触发该对象的执行、为该对象关联一些回调函数，并创建一个 `Subscription`（订阅记录）对象来让你能取消订阅。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "THESUBSCRIBEMETHODTAKESAJAVASCRIPTOBJECTCALLEDANOBSERVERWITHUPTOTHREECALLBACKSONEFOREACHTYPEOFNOTIFICATIONTHATANOBSERVABLECANDELIVER:",
+    "original": "The `subscribe()` method takes a JavaScript object (called an \"observer\") with up to three callbacks, one for each type of notification that an observable can deliver:",
+    "translation": "`subscribe()` 方法接收一个 JavaScript 对象（叫做 \"观察者\"），其中最多可以包含三个回调，分别对应可观察对象可以发出的几种通知类型：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "THENEXTNOTIFICATION:SENDSAVALUESUCHASANUMBERASTRINGANOBJECTETC",
+    "original": "- The `next` notification: sends a value such as a Number, a String, an Object, etc.",
+    "translation": "`next`（下一个）通知会发送一个值，比如数字、字符串、对象等。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "THEERRORNOTIFICATIONSENDSAJAVASCRIPTERROROREXCEPTION",
+    "original": "- The `error` notification sends a JavaScript Error or exception.",
+    "translation": "`error`（错误）通知会发送 JavaScript 错误或异常。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "THECOMPLETENOTIFICATIONDOESNOTSENDAVALUEBUTTHEHANDLERISCALLEDWHENTHECALLCOMPLETESSCHEDULEDVALUESCANCONTINUETOBERETURNEDAFTERTHECALLCOMPLETES",
+    "original": "- The `complete` notification does not send a value, but the handler is called when the call completes. Scheduled values can continue to be returned after the call completes.",
+    "translation": "`complete`（完成）通知不会发送值，但是当调用结束时会调用这个处理器。异步的值可能会在调用了完成之后继续发送过来。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14748,9 +14856,27 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ACHUNKOFHTMLTHATANGULARUSESTORENDERAVIEWGUIDEGLOSSARY#VIEWWITHTHESUPPORTANDGUIDANCEOFANANGULARDIRECTIVEGUIDEGLOSSARY#DIRECTIVEMOSTNOTABLYACOMPONENTGUIDEGLOSSARY#COMPONENT",
-    "original": "A chunk of HTML that Angular uses to render a [view](guide/glossary#view) with\nthe support and guidance of an Angular [directive](guide/glossary#directive),\nmost notably a [component](guide/glossary#component).",
-    "translation": "模板是一大块 HTML。Angular 会在[指令 (directive)](guide/glossary#directive) 特别是[组件 (component)](guide/glossary#component)\n    的支持和持续指导下，用它来渲染[视图 (view)](guide/glossary#view)。",
+    "key": "ATEMPLATEDEFINESHOWTORENDERACOMPONENTSVIEWGUIDEGLOSSARY#VIEWINHTML",
+    "original": "A template defines how to render a component's [view](guide/glossary#view) in HTML",
+    "translation": "模板用来定义如何在 HTML 中渲染组件的[视图](guide/glossary#view)。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ATEMPLATECOMBINESSTRAIGHTHTMLWITHANGULARDATABINDINGGUIDEGLOSSARY#DATABINDINGSYNTAXDIRECTIVESGUIDEGLOSSARY#DIRECTIVEANDTEMPLATEEXPRESSIONSGUIDEGLOSSARY#TEMPLATEEXPRESSIONLOGICALCONSTRUCTSTHEANGULARELEMENTSINSERTORCALCULATEVALUESTHATMODIFYTHEHTMLELEMENTSBEFORETHEPAGEISDISPLAYED",
+    "original": "A template combines straight HTML with Angular [data-binding](guide/glossary#data-binding) syntax, [directives](guide/glossary#directive),  and [template expressions](guide/glossary#template-expression) (logical constructs). The Angular elements insert or calculate values that modify the HTML elements before the page is displayed.",
+    "translation": "模板会把纯 HTML 和 Angular 的[数据绑定](guide/glossary#data-binding)语法、[指令](guide/glossary#directive)和[模板表达式](guide/glossary#template-expression)组合起来。Angular 的元素会插入或计算那些值，以便在页面显示出来之前修改 HTML 元素。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ATEMPLATEISASSOCIATEDWITHACOMPONENTGUIDEGLOSSARY#COMPONENTCLASSTHROUGHCOMPONENTDECORATORGUIDEGLOSSARY#DECORATORTHEHTMLCANBEPROVIDEDINLINEASTHEVALUEOFTHETEMPLATEPROPERTYORINASEPARATEHTMLFILELINKEDTHROUGHTHETEMPLATEURLPROPERTY",
+    "original": "A template is associated with a [component](guide/glossary#component) class through `@Component` [decorator](guide/glossary#decorator). The HTML can be provided inline, as the value of the `template` property, or in a separate HTML file linked through the `templateUrl` property.",
+    "translation": "模板通过 `@Component` [装饰器](guide/glossary#decorator)与[组件](guide/glossary#component)类关联起来。其 HTML 可以作为 `template` 属性的值用内联的方式提供，也可以通过 `templateUrl` 属性链接到一个独立的 HTML 文件。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ADDITIONALTEMPLATESREPRESENTEDBYATEMPLATEREFOBJECTCANDEFINEALTERNATIVEOREMBEDDEDVIEWSWHICHCANBEREFERENCEDFROMMULTIPLECOMPONENTS",
+    "original": "Additional templates, represented by a `TemplateRef` object, can define alternative or _embedded_ views, which can be referenced from multiple components.",
+    "translation": "用 `TemplateRef` 对象表示的其它模板用来定义一些备用视图或*内嵌*视图，它们可以来自多个不同的组件。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14825,6 +14951,18 @@
     "translation": "到[模板语法](guide/template-syntax)一章的[模板表达式](guide/template-syntax#template-expressions)部分了解更多模板表达式的知识。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
+  {
+    "key": "##TOKEN",
+    "original": "## Token",
+    "translation": "## 令牌",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ANOPAQUEIDENTIFIERUSEDFOREFFICIENTTABLELOOKUPINANGULARADITOKENGUIDEGLOSSARY#DITOKENISUSEDTOFINDPROVIDERSGUIDEGLOSSARY#PROVIDEROFDEPENDENCIESINTHEDEPENDENCYINJECTIONGUIDEGLOSSARY#DISYSTEM",
+    "original": "An opaque identifier used for efficient table lookup. In Angular, a [DI token](guide/glossary#di-token) is used to find [providers](guide/glossary#provider) of dependencies in the [dependency injection](guide/glossary#di) system.",
+    "translation": "用于高效查表的不透明标识符（译注：不透明是指你不必了解其细节）。在 Angular 中，[DI 令牌](guide/glossary#di-token)用于在[依赖注入](guide/glossary#di)系统中查找[服务提供商](guide/glossary#provider)。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
   {
     "key": "##TRANSPILE",
     "original": "## Transpile",
@@ -14832,9 +14970,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THEPROCESSOFTRANSFORMINGCODEWRITTENINONEFORMOFJAVASCRIPTSUCHASTYPESCRIPTINTOANOTHERFORMOFJAVASCRIPTSUCHASES5GUIDEGLOSSARY#ES5",
-    "original": "The process of transforming code written in one form of JavaScript\n(such as TypeScript) into another form of JavaScript  (such as [ES5](guide/glossary#es5)).",
-    "translation": "把一种形式的 JavaScript（例如 TypeScript）转换成另一种形式的 JavaScript（例如 [ES5](guide/glossary#es5)）的过程。",
+    "key": "THETRANSLATIONPROCESSTHATTRANFORMSONEVERSIONOFJAVASCRIPTTOANOTHERVERSIONFOREXAMPLEDOWNLEVELINGES2015TOTHEOLDERES5VERSION",
+    "original": "The translation process that tranforms one version of JavaScript to another version; for example, down-leveling ES2015 to the older ES5 version.",
+    "translation": "一种翻译过程，它会把一个版本的 JavaScript 转换成另一个版本，比如把下一版的 ES2015 转换成老版本的 ES5。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14844,27 +14982,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "AVERSIONOFJAVASCRIPTTHATSUPPORTSMOSTECMASCRIPT2015GUIDEGLOSSARY#ES2015LANGUAGEFEATURESSUCHASDECORATORSGUIDEGLOSSARY#DECORATOR",
-    "original": "A version of JavaScript that supports most [ECMAScript 2015](guide/glossary#es2015)\nlanguage features such as [decorators](guide/glossary#decorator).",
-    "translation": "JavaScript 的一个版本，支持了几乎所有 [ECMAScript 2015](guide/glossary#es2015) 语言特性，例如[装饰器 (decorator)](guide/glossary#decorator))。",
+    "key": "TYPESCRIPTISAPROGRAMMINGLANGUAGENOTABLEFORITSOPTIONALTYPINGSYSTEMWHICHPROVIDESCOMPILETIMETYPECHECKINGANDSTRONGTOOLINGSUPPORTSUCHASCODECOMPLETIONREFACTORINGINLINEDOCUMENTATIONANDINTELLIGENTSEARCHMANYCODEEDITORSANDIDESSUPPORTTYPESCRIPTEITHERNATIVELYORWITHPLUGINS",
+    "original": "TypeScript is a programming language notable for its optional typing system, which provides\ncompile-time type checking and strong tooling support (such as\ncode completion, refactoring, inline documentation, and intelligent search). Many code editors\nand IDEs support TypeScript either natively or with plug-ins.",
+    "translation": "TypeScript 是一种程序设计语言，以其可选类型系统著称。\n该类型系统提供了编译时类型检查和强大的工具支持（比如代码补齐、重构、内联文档和智能搜索等）。\n许多代码编辑器和 IDE 都原生支持 TypeScript 或通过插件提供支持。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "TYPESCRIPTISALSONOTABLEFORITSOPTIONALTYPINGSYSTEMWHICHPROVIDESCOMPILETIMETYPECHECKINGANDSTRONGTOOLINGSUPPORTSUCHASINTELLISENSECODECOMPLETIONREFACTORINGANDINTELLIGENTSEARCHMANYCODEEDITORSANDIDESSUPPORTTYPESCRIPTEITHERNATIVELYORWITHPLUGINS",
-    "original": "TypeScript is also notable for its optional typing system, which provides\ncompile-time type checking and strong tooling support (such as \"intellisense,\"\ncode completion, refactoring, and intelligent search). Many code editors\nand IDEs support TypeScript either natively or with plugins.",
-    "translation": "TypeScript 还以它的可选类型系统而著称。\n该类型系统提供了编译时类型检查和强大的工具支持（例如 “Intellisense”，代码补齐，重构和智能搜索等）。\n许多代码编辑器和 IDE 都原生支持 TypeScript 或通过插件提供支持。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "TYPESCRIPTISTHEPREFERREDLANGUAGEFORANGULARDEVELOPMENTALTHOUGHYOUCANUSEOTHERJAVASCRIPTDIALECTSSUCHASES5GUIDEGLOSSARY#ES5",
-    "original": "TypeScript is the preferred language for Angular development, although\nyou can use other JavaScript dialects such as [ES5](guide/glossary#es5).",
-    "translation": "TypeScript 是 Angular 的首选语言，当然，你可以使用其它 JavaScript 方言，例如[ES5](guide/glossary#es5)。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "READMOREABOUTTYPESCRIPTATTYPESCRIPTLANGORGHTTP:WWWTYPESCRIPTLANGORG",
-    "original": "Read more about TypeScript at [typescriptlang.org](http://www.typescriptlang.org/).",
-    "translation": "更多信息，见[typescript.org](http://www.typescriptlang.org/)。",
+    "key": "TYPESCRIPTISTHEPREFERREDLANGUAGEFORANGULARDEVELOPMENTREADMOREABOUTTYPESCRIPTATTYPESCRIPTLANGORGHTTP:WWWTYPESCRIPTLANGORG",
+    "original": "TypeScript is the preferred language for Angular development. Read more about TypeScript at [typescriptlang.org](http://www.typescriptlang.org/).",
+    "translation": "TypeScript 是 Angular 的首选语言。要了解更多，参见 [typescriptlang.org](http://www.typescriptlang.org/)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14874,21 +15000,63 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "APORTIONOFTHESCREENTHATDISPLAYSINFORMATIONANDRESPONDSTOUSERACTIONSSUCHASCLICKSMOUSEMOVESANDKEYSTROKES",
-    "original": "A portion of the screen that displays information and responds\nto user actions such as clicks, mouse moves, and keystrokes.",
-    "translation": "视图是屏幕中一小块，用来显示信息并响应用户动作，例如点击、移动鼠标和按键。",
+    "key": "AVIEWISTHESMALLESTGROUPINGOFDISPLAYELEMENTSTHATCANBECREATEDANDDESTROYEDTOGETHER",
+    "original": "A view is the smallest grouping of display elements that can be created and destroyed together.",
+    "translation": "视图是指显示元素的最小分组单位，它们会被同时创建和销毁。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ANGULARRENDERSAVIEWUNDERTHECONTROLOFONEORMOREDIRECTIVESGUIDEGLOSSARY#DIRECTIVEESPECIALLYCOMPONENTGUIDEGLOSSARY#COMPONENTDIRECTIVESANDTHEIRCOMPANIONTEMPLATESGUIDEGLOSSARY#TEMPLATETHECOMPONENTPLAYSSUCHAPROMINENTROLETHATITSOFTENCONVENIENTTOREFERTOACOMPONENTASAVIEW",
-    "original": "Angular renders a view under the control of one or more [directives](guide/glossary#directive),\nespecially  [component](guide/glossary#component) directives and their companion [templates](guide/glossary#template).\nThe component plays such a prominent role that it's often\nconvenient to refer to a component as a view.",
-    "translation": "Angular 在一个或多个[指令 (directive)](guide/glossary#directive) 的控制下渲染视图，\n尤其是[组件 (component)](guide/glossary#component) 指令及其[模板 (template)](guide/glossary#template)。\n组件扮演着非常重要的角色，以至于习惯上会把组件视为一种视图。",
+    "key": "ANGULARRENDERSAVIEWUNDERTHECONTROLOFONEORMOREDIRECTIVESGUIDEGLOSSARY#DIRECTIVEESPECIALLYCOMPONENTGUIDEGLOSSARY#COMPONENTDIRECTIVESANDTHEIRCOMPANIONTEMPLATESGUIDEGLOSSARY#TEMPLATE",
+    "original": "Angular renders a view under the control of one or more [directives](guide/glossary#directive),\nespecially  [component](guide/glossary#component) directives and their companion [templates](guide/glossary#template).",
+    "translation": "Angular 在一个或多个[指令 (directive)](guide/glossary#directive) 的控制下渲染视图，\n尤其是[组件 (component)](guide/glossary#component) 指令及其[模板 (template)](guide/glossary#template)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "VIEWSOFTENCONTAINOTHERVIEWSANYVIEWMIGHTBELOADEDANDUNLOADEDDYNAMICALLYASTHEUSERNAVIGATESTHROUGHTHEAPPLICATIONTYPICALLYUNDERTHECONTROLOFAROUTERGUIDEGLOSSARY#ROUTER",
-    "original": "Views often contain other views. Any view might be loaded and unloaded\ndynamically as the user navigates through the application, typically\nunder the control of a [router](guide/glossary#router).",
-    "translation": "视图一般包含其它视图，在用户在应用程序中导航时，\n任何视图都可能被动态加载或卸载，这一般会在[路由器 (router)](guide/glossary#router) 的控制下进行。",
+    "key": "AVIEWISSPECIFICALLYREPRESENTEDBYAVIEWREFINSTANCEASSOCIATEDWITHTHECOMPONENTAVIEWTHATBELONGSTOACOMPONENTISCALLEDAHOSTVIEWVIEWSARETYPICALLYCOLLECTEDINTOVIEWHIERARCHIESGUIDEGLOSSARY#VIEWTREE",
+    "original": "A view is specifically represented by a `ViewRef` instance associated with the component. \nA view that belongs to a component is called a  _host view_. \nViews are typically collected into [view hierarchies](guide/glossary#view-tree).",
+    "translation": "具体实现上，视图由一个与该组件相关的 `ViewRef` 实例表示。\n属于某个组件的视图叫做*宿主视图*。\n通常会把视图组织成一些[视图树（view hierarchies）](guide/glossary#view-tree)。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "PROPERTIESOFELEMENTSINAVIEWCANCHANGEDYNAMICALLYINRESPONSETOUSERACTIONSTHESTRUCTURENUMBERANDORDEROFELEMENTSINAVIEWCANNOTYOUCANCHANGETHESTRUCTUREOFELEMENTSBYINSERTINGMOVINGORREMOVINGNESTEDVIEWSWITHINTHEIRVIEWCONTAINERS",
+    "original": "Properties of elements in a view can change dynamically, in response to user actions; the structure (number and order) of elements in a view cannot. You can change the structure of elements by inserting, moving, or removing nested views within their view containers.",
+    "translation": "视图中各个元素的属性可以动态修改以响应用户的操作，而这些元素的结构（数量或顺序）则不能。你可以通过在它们的视图容器中插入、移动或移除内嵌视图来修改这些元素的结构。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "VIEWHIERARCHIESCANBELOADEDANDUNLOADEDDYNAMICALLYASTHEUSERNAVIGATESTHROUGHTHEAPPLICATIONTYPICALLYUNDERTHECONTROLOFAROUTERGUIDEGLOSSARY#ROUTER",
+    "original": "View hierarchies can be loaded and unloaded dynamically as the user navigates through the application, typically under the control of a [router](guide/glossary#router).",
+    "translation": "当用户在应用中导航时（比如使用[路由器](guide/glossary#router)），视图树可以动态加载或卸载。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##VIEWHIERARCHY",
+    "original": "## View hierarchy",
+    "translation": "## 视图树",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "ATREEOFRELATEDVIEWSTHATCANBEACTEDONASAUNITTHEROOTVIEWISACOMPONENTSHOSTVIEWAHOSTVIEWCANBETHEROOTOFATREEOFEMBEDDEDVIEWSCOLLECTEDINAVIEWCONTAINERVIEWCONTAINERREFATTACHEDTOANANCHORELEMENTINTHEHOSTINGCOMPONENTTHEVIEWHIERARCHYISAKEYPARTOFANGULARCHANGEDETECTION",
+    "original": "A tree of related views that can be acted on as a unit. The root view is a component's _host view_.  A host view can be the root of a tree of _embedded views_, collected in a _view container_ (`ViewContainerRef`) attached to an anchor element in the hosting component. The view hierarchy is a key part of Angular change detection.",
+    "translation": "一棵相关视图的树，它们可以作为一个整体行动。其根视图就是组件的*宿主视图*。宿主视图可以是*内嵌视图*树的根，它被收集到了宿主组件上的一个*视图容器（`ViewContainerRef`）*中<!-- 再校对 -->。视图树是 Angular 变更检测的关键部件之一。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "THEVIEWHIERARCHYDOESNOTIMPLYACOMPONENTHIERARCHYVIEWSTHATAREEMBEDDEDINTHECONTEXTOFAPARTICULARHIERARCHYCANBEHOSTVIEWSOFOTHERCOMPONENTSTHOSECOMPONENTSCANBEINTHESAMENGMODULEASTHEHOSTINGCOMPONENTORBELONGTOOTHERNGMODULES",
+    "original": "The view hierarchy does not imply a component hierarchy. Views that are embedded in the context of a particular hierarchy can be host views of other components. Those components can be in the same NgModule as the hosting component, or belong to other NgModules.",
+    "translation": "视图树和组件树并不是一一对应的。那些嵌入到指定视图树上下文中的视图也可能是其它组件的宿主视图。那些组件可能和宿主组件位于同一个 NgModule 中，也可能属于其它 NgModule。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "##WEBCOMPONENT",
+    "original": "## Web component",
+    "translation": "## Web 组件",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
+  },
+  {
+    "key": "SEECUSTOMELEMENTGUIDEGLOSSARY#CUSTOMELEMENT",
+    "original": "See [Custom element](guide/glossary#custom-element)",
+    "translation": "参见[自定义元素](guide/glossary#custom-element)",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -14898,33 +15066,27 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "AMECHANISMFORENCAPSULATINGANDINTERCEPTINGAJAVASCRIPTAPPLICATIONSASYNCHRONOUSACTIVITY",
-    "original": "A mechanism for encapsulating and intercepting\na JavaScript application's asynchronous activity.",
-    "translation": "区域是一种用来封装和截听 JavaScript 应用程序异步活动的机制。",
+    "key": "ANEXECUTIONCONTEXTFORASETOFASYNCHRONOUSTASKSUSEFULFORDEBUGGINGPROFILINGANDTESTINGAPPSTHATINCLUDEASYNCHRONOUSOPERATIONSSUCHASEVENTPROCESSINGPROMISESANDCALLSTOREMOTESERVERS",
+    "original": "An execution context for a set of asynchronous tasks. Useful for debugging, profiling, and testing apps that include asynchronous operations such as event processing, promises, and calls to remote servers.",
+    "translation": "一组异步任务的执行上下文。它对于调试、性能分析和测试那些包含了异步操作（如事件处理、承诺、远程服务器调用等）的应用是非常有用的。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "THEBROWSERDOMANDJAVASCRIPTHAVEALIMITEDNUMBEROFASYNCHRONOUSACTIVITIESSUCHASDOMEVENTSFOREXAMPLECLICKSPROMISESHTTPS:DEVELOPERMOZILLAORGENUSDOCSWEBJAVASCRIPTREFERENCEGLOBALOBJECTSPROMISEANDXHRHTTPS:DEVELOPERMOZILLAORGENUSDOCSWEBAPIXMLHTTPREQUESTCALLSTOREMOTESERVERS",
-    "original": "The browser DOM and JavaScript have a limited number\nof asynchronous activities, such as DOM events (for example, clicks),\n[promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), and\n[XHR](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest)\ncalls to remote servers.",
-    "translation": "浏览器中的 DOM 和 JavaScript 之间常会有一些数量有限的异步活动，\n  例如 DOM 事件（例如点击）、[承诺 (promise)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)\n  和通过 [XHR](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) 调用远程服务。",
+    "key": "ANANGULARAPPRUNSINAZONEWHEREITCANRESPONDTOASYNCHRONOUSEVENTSBYCHECKINGFORDATACHANGESANDUPDATINGTHEINFORMATIONITDISPLAYSBYRESOLVINGDATABINDINGSGUIDEGLOSSARY#DATABINDING",
+    "original": "An Angular app runs in a zone where it can respond to asynchronous events by checking for data changes and updating the information it displays by resolving [data bindings](guide/glossary#data-binding).",
+    "translation": "Angular 应用会运行在一个 Zone 区域中，在这里，它可以对异步事件做出反应，可以通过检查数据变更、利用[数据绑定 (data bindings)](guide/glossary#data-binding) 来更新信息显示。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
-    "key": "ZONESINTERCEPTALLOFTHESEACTIVITIESANDGIVEAZONECLIENTTHEOPPORTUNITYTOTAKEACTIONBEFOREANDAFTERTHEASYNCACTIVITYFINISHES",
-    "original": "Zones intercept all of these activities and give a \"zone client\" the opportunity\nto take action before and after the async activity finishes.",
-    "translation": "区域能截听所有这些活动，并让“区域的客户”有机会在异步活动完成之前和之后采取行动。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
-  },
-  {
-    "key": "ANGULARRUNSYOURAPPLICATIONINAZONEWHEREITCANRESPONDTOASYNCHRONOUSEVENTSBYCHECKINGFORDATACHANGESANDUPDATINGTHEINFORMATIONITDISPLAYSVIADATABINDINGSGUIDEGLOSSARY#DATABINDING",
-    "original": "Angular runs your application in a zone where it can respond to\nasynchronous events by checking for data changes and updating\nthe information it displays via [data bindings](guide/glossary#data-binding).",
-    "translation": "Angular 会在一个 Zone 区域中运行应用程序，在这个区域中，它可以对异步事件做出反应，可以通过检查数据变更、利用[数据绑定 (data bindings)](guide/glossary#data-binding) 来更新信息显示。",
+    "key": "AZONECLIENTCANTAKEACTIONBEFOREANDAFTERANASYNCOPERATIONCOMPLETES",
+    "original": "A zone client can take action before and after an async operation completes.",
+    "translation": "Zone 的使用方可以在异步操作完成之前或之后采取行动。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
     "key": "LEARNMOREABOUTZONESINTHISBRIANFORDVIDEOHTTPS:WWWYOUTUBECOMWATCHV3IQTMUSCEU",
     "original": "Learn more about zones in this\n[Brian Ford video](https://www.youtube.com/watch?v=3IqtmUscE_U).",
-    "translation": "更多信息，见 [Brian Ford 的视频](https://www.youtube.com/watch?v=3IqtmUscE_U)。",
+    "translation": "要了解更多，参见 [Brian Ford 的视频](https://www.youtube.com/watch?v=3IqtmUscE_U)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/glossary.md"
   },
   {
@@ -15210,8 +15372,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/hierarchical-dependency-injection.md"
   },
   {
-    "key": "THENYOUCREATEACHILDCOMPONENTBTHATDEFINESITSOWNSPECIALIZEDPROVIDERSFORCARSERVICEANDENGINESERVICETHATHAVESPECIALCAPABILITESSUITABLEFORWHATEVERISGOINGONINCOMPONENTB",
-    "original": "Then you create a child component (B) that defines its own, _specialized_ providers for `CarService` and `EngineService`\nthat have special capabilites suitable for whatever is going on in component (B).",
+    "key": "THENYOUCREATEACHILDCOMPONENTBTHATDEFINESITSOWNSPECIALIZEDPROVIDERSFORCARSERVICEANDENGINESERVICETHATHAVESPECIALCAPABILITIESSUITABLEFORWHATEVERISGOINGONINCOMPONENTB",
+    "original": "Then you create a child component (B) that defines its own, _specialized_ providers for `CarService` and `EngineService`\nthat have special capabilities suitable for whatever is going on in component (B).",
     "translation": "然后，你创建一个子组件（B），它为 `CarService` 和 `EngineService` 定义了自己的*特殊的*提供商，它们具有更特殊的能力，适用于组件 B 的。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/hierarchical-dependency-injection.md"
   },
@@ -15636,9 +15798,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "APPSOFTENPOSTDATATOASERVERTHEYPOSTWHENSUBMITTINGAFORMINTHEFOLLOWINGEXAMPLETHEHEROSERVICEPOSTSWHENADDINGAHEROTOTHEDATABASE",
-    "original": "Apps often POST data to a server. They POST when submitting a form. \nIn the following example, the `HeroService` posts when adding a hero to the database.",
-    "translation": "应用经常把数据 `POST` 到服务器。它们会在提交表单时进行 `POST`。\n下面这个例子中，`HeroService` 在把英雄添加到数据库中时，就会使用 `POST`。",
+    "key": "APPSOFTENPOSTDATATOASERVERTHEYPOSTWHENSUBMITTINGAFORMINTHEFOLLOWINGEXAMPLETHEHEROESSERVICEPOSTSWHENADDINGAHEROTOTHEDATABASE",
+    "original": "Apps often POST data to a server. They POST when submitting a form. \nIn the following example, the `HeroesService` posts when adding a hero to the database.",
+    "translation": "应用经常把数据 `POST` 到服务器。它们会在提交表单时进行 `POST`。\n下面这个例子中，`HeroesService` 在把英雄添加到数据库中时，就会使用 `POST`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
@@ -15666,9 +15828,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "OFCOURSEITCATCHESERRORSINMUCHTHESAMEMANNERDESCRIBEDABOVE#ERRORDETAILSITALSOTAPSTHERETURNEDOBSERVABLEINORDERTOLOGTHESUCCESSFULPOST",
-    "original": "Of course it catches errors in much the same manner [described above](#error-details).\nIt also _taps_ the returned observable in order to log the successful POST.",
-    "translation": "当然，它捕获错误的方式很像[前面描述的](#error-details)操作方式。\n它还*窃听*了可观察对象的返回值，以记录成功的 `POST`。",
+    "key": "OFCOURSEITCATCHESERRORSINMUCHTHESAMEMANNERDESCRIBEDABOVE#ERRORDETAILS",
+    "original": "Of course it catches errors in much the same manner [described above](#error-details).",
+    "translation": "当然，它捕获错误的方式很像[前面描述的](#error-details)操作方式。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
@@ -15702,27 +15864,21 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "YOUMUSTCALLSUBSCRIBEORNOTHINGHAPPENS",
-    "original": "You must call _subscribe()_ or nothing happens!",
-    "translation": "你必须调用 `subscribe()`，否则什么都不会发生。",
+    "key": "THECOMPONENTISNTEXPECTINGARESULTFROMTHEDELETEOPERATIONSOITSUBSCRIBESWITHOUTACALLBACKEVENTHOUGHYOUARENOTUSINGTHERESULTYOUSTILLHAVETOSUBSCRIBECALLINGTHESUBSCRIBEMETHODEXECUTESTHEOBSERVABLEWHICHISWHATINITIATESTHEDELETEREQUEST",
+    "original": "The component isn't expecting a result from the delete operation, so it subscribes without a callback. Even though you are not using the result, you still have to subscribe. Calling the `subscribe()` method _executes_ the observable, which is what initiates the DELETE request.",
+    "translation": "该组件不会等待删除操作的结果，所以它的 subscribe （订阅）中没有回调函数。不过就算你不关心结果，也仍然要订阅它。调用 `subscribe()` 方法会**执行**这个可观察对象，这时才会真的发起 DELETE 请求。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "THECOMPONENTISNTEXPECTINGARESULTFROMTHEDELETEOPERATIONANDSUBSCRIBESWITHOUTACALLBACKTHEBARESUBSCRIBESEEMSPOINTLESS",
-    "original": "The component isn't expecting a result from the delete operation and\nsubscribes without a callback.\nThe bare `.subscribe()` _seems_ pointless.",
-    "translation": "该组件不关心删除操作返回的结果，订阅时也没有回调函数。\n单纯的 `.subscribe()` 方法看似毫无意义。",
+    "key": "YOUMUSTCALLSUBSCRIBEORNOTHINGHAPPENSJUSTCALLINGHEROESSERVICEDELETEHERODOESNOTINITIATETHEDELETEREQUEST",
+    "original": "You must call _subscribe()_ or nothing happens. Just calling `HeroesService.deleteHero()` **does not initiate the DELETE request.**",
+    "translation": "你必须调用 `subscribe()`，否则什么都不会发生。仅仅调用 `HeroesService.deleteHero()` 是**不会发起 DELETE 请求的。**",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "INFACTITISESSENTIALMERELYCALLINGHEROSERVICEDELETEHERODOESNOTINITIATETHEDELETEREQUEST",
-    "original": "In fact, it is essential.\nMerely calling `HeroService.deleteHero()` **does not initiate the DELETE request.**",
-    "translation": "但实际上，它是必备的。\n否则调用 `HeroService.deleteHero()` 时**不会发起 DELETE 请求**。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
-  },
-  {
-    "key": "###ALWAYSSUBSCRIBE",
-    "original": "### Always _subscribe_!",
-    "translation": "### 别忘了*订阅*！",
+    "key": "ALWAYSSUBSCRIBE",
+    "original": "**Always _subscribe_!**",
+    "translation": "**别忘了*订阅*！**",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
@@ -15739,7 +15895,7 @@
   },
   {
     "key": "ALLOBSERVABLESRETURNEDFROMHTTPCLIENTMETHODSARECOLDBYDESIGNEXECUTIONOFTHEHTTPREQUESTISDEFERREDALLOWINGYOUTOEXTENDTHEOBSERVABLEWITHADDITIONALOPERATIONSSUCHASTAPANDCATCHERRORBEFOREANYTHINGACTUALLYHAPPENS",
-    "original": "All observables returned from `HttpClient` methods are _cold_ by design.\nExecution of the HTTP request is _deferred_, allowing you to extend the\nobservable with additional operations such as  `tap` and `catchError`\n before anything actually happens.",
+    "original": "All observables returned from `HttpClient` methods are _cold_ by design.\nExecution of the HTTP request is _deferred_, allowing you to extend the\nobservable with additional operations such as  `tap` and `catchError` before anything actually happens.",
     "translation": "`HttpClient` 的所有方法返回的可观察对象都设计为*冷的*。\nHTTP 请求的执行都是*延期执行的*，让你可以用 `tap` 和 `catchError` 这样的操作符来在实际执行什么之前，先对这个可观察对象进行扩展。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
@@ -15768,9 +15924,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "ANAPPWILLSENDAPUTREQUESTTOCOMPLETELYREPLACEARESOURCEWITHUPDATEDDATATHEFOLLOWINGHEROSERVICEEXAMPLEISJUSTLIKETHEPOSTEXAMPLE",
-    "original": "An app will send a PUT request to completely replace a resource with updated data.\nThe following `HeroService` example is just like the POST example.",
-    "translation": "应用可以发送 PUT 请求，来使用修改后的数据完全替换掉一个资源。\n下面的 `HeroService` 例子和 POST 的例子很像。",
+    "key": "ANAPPWILLSENDAPUTREQUESTTOCOMPLETELYREPLACEARESOURCEWITHUPDATEDDATATHEFOLLOWINGHEROESSERVICEEXAMPLEISJUSTLIKETHEPOSTEXAMPLE",
+    "original": "An app will send a PUT request to completely replace a resource with updated data.\nThe following `HeroesService` example is just like the POST example.",
+    "translation": "应用可以发送 PUT 请求，来使用修改后的数据完全替换掉一个资源。\n下面的 `HeroesService` 例子和 POST 的例子很像。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
@@ -15786,9 +15942,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "THEABOVESECTIONSDETAILHOWTOUSETHEBASICHTTPFUNCTIONALITYINANGULARCOMMONHTTPBUTSOMETIMESYOUNEEDTODOMORETHANMAKESIMPLEREQUESTSANDGETDATABACK",
-    "original": "The above sections detail how to use the basic HTTP functionality in `@angular/common/http`, but sometimes you need to do more than make simple requests and get data back.",
-    "translation": "上面这个小节中详细讲解了如何使用 `@angular/common/http` 中提供的基本 HTTP 功能，但有时候除了单纯发起请求和取回数据之外，你还要再做点别的。",
+    "key": "WEHAVEDISCUSSEDTHEBASICHTTPFUNCTIONALITYINANGULARCOMMONHTTPBUTSOMETIMESYOUNEEDTODOMORETHANMAKESIMPLEREQUESTSANDGETDATABACK",
+    "original": "We have discussed the basic HTTP functionality in `@angular/common/http`, but sometimes you need to do more than make simple requests and get data back.",
+    "translation": "我们已经讨论了 `@angular/common/http` 的基本 HTTP 功能，但有时候除了单纯发起请求和取回数据之外，你还要再做点别的。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
@@ -15804,9 +15960,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "YOUSAWEARLIER#ADDINGHEADERSTHATTHEHEROSERVICESETSTHEDEFAULTHEADERSBYPASSINGANOPTIONSOBJECTHTTPOPTIONSTOITSSAVEMETHODSYOUCANDOMORE",
-    "original": "You [saw earlier](#adding-headers) that the `HeroService` sets the default headers by\npassing an options object (`httpOptions`) to its save methods.\nYou can do more.",
-    "translation": "[以前你曾在](#adding-headers) `HeroService` 中通过在其保存方法中传入配置对象 `httpOptions` 设置过默认头。\n你还可以做更多。",
+    "key": "YOUSAWEARLIER#ADDINGHEADERSTHATTHEHEROESSERVICESETSTHEDEFAULTHEADERSBYPASSINGANOPTIONSOBJECTHTTPOPTIONSTOITSSAVEMETHODSYOUCANDOMORE",
+    "original": "You [saw earlier](#adding-headers) that the `HeroesService` sets the default headers by\npassing an options object (`httpOptions`) to its save methods.\nYou can do more.",
+    "translation": "[以前你曾在](#adding-headers) `HeroesService` 中通过在其保存方法中传入配置对象 `httpOptions` 设置过默认头。\n你还可以做更多。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
@@ -15847,7 +16003,7 @@
   },
   {
     "key": "IFTHEREISASEARCHTERMTHECODECONSTRUCTSANOPTIONSOBJECTWITHANHTMLURLENCODEDSEARCHPARAMETERIFTHETERMWEREFOOTHEGETREQUESTURLWOULDBEAPIHEROESNAMEFOO",
-    "original": "If there is a search term, the code constructs an options object with an HTML URL encoded search parameter. If the term were \"foo\", the GET request URL would be `api/heroes/?name=foo`.",
+    "original": "If there is a search term, the code constructs an options object with an HTML URL-encoded search parameter. If the term were \"foo\", the GET request URL would be `api/heroes/?name=foo`.",
     "translation": "如果有搜索词，这段代码就会构造一个包含进行过 URL 编码的搜索词的选项对象。如果这个搜索词是“foo”，这个 GET 请求的 URL 就会是 `api/heroes/?name=foo`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
@@ -15871,7 +16027,7 @@
   },
   {
     "key": "WHENTHEUSERENTERSANAMEINASEARCHBOXTHEPACKAGESEARCHCOMPONENTSENDSASEARCHREQUESTFORAPACKAGEWITHTHATNAMETOTHENPMWEBAPI",
-    "original": "When the user enters a name in a search-box, the `PackageSearchComponent` sends\na search request for a package with that name to the NPM web api.",
+    "original": "When the user enters a name in a search-box, the `PackageSearchComponent` sends\na search request for a package with that name to the NPM web API.",
     "translation": "当用户在搜索框中输入名字时，`PackageSearchComponent` 就会把一个根据名字搜索包的请求发送给 NPM 的 web api。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
@@ -15894,9 +16050,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "THESEARCHTEXTISTHESEQUENCEOFSEARCHBOXVALUESCOMINGFROMTHEUSERITSDEFINEDASANRXJSSUBJECTWHICHMEANSITISANOBSERVABLETHATCANALSOPRODUCEVALUESFORITSELFBYCALLINGNEXTVALUEASHAPPENSINTHESEARCHMETHOD",
-    "original": "The `searchText$` is the sequence of search-box values coming from the user.\nIt's defined as an RxJS `Subject`, which means it is an `Observable`\nthat can also produce values for itself by calling `next(value)`,\nas happens in the `search()` method.",
-    "translation": "`searchText$` 是一个序列，包含用户输入到搜索框中的所有值。\n它定义成了 RxJS 的 `Subject` 对象，这表示它是一个 `Observable`，同时还可以自行调用 `next(value)` 来产生值。\n`search()` 方法中就是这么做的。",
+    "key": "THESEARCHTEXTISTHESEQUENCEOFSEARCHBOXVALUESCOMINGFROMTHEUSERITSDEFINEDASANRXJSSUBJECTWHICHMEANSITISAMULTICASTINGOBSERVABLETHATCANALSOPRODUCEVALUESFORITSELFBYCALLINGNEXTVALUEASHAPPENSINTHESEARCHMETHOD",
+    "original": "The `searchText$` is the sequence of search-box values coming from the user.\nIt's defined as an RxJS `Subject`, which means it is a multicasting `Observable`\nthat can also produce values for itself by calling `next(value)`,\nas happens in the `search()` method.",
+    "translation": "`searchText$` 是一个序列，包含用户输入到搜索框中的所有值。\n它定义成了 RxJS 的 `Subject` 对象，这表示它是一个多播 `Observable`，同时还可以自行调用 `next(value)` 来产生值。\n`search()` 方法中就是这么做的。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
@@ -16417,8 +16573,8 @@
   },
   {
     "key": "AREVISEDVERSIONOFTHECACHINGINTERCEPTOROPTIONALLYRETURNSANOBSERVABLETHATIMMEDIATELYEMITSTHECACHEDRESPONSESENDSTHEREQUESTTOTHENPMWEBAPIANYWAYANDEMITSAGAINLATERWITHTHEUPDATEDSEARCHRESULTS",
-    "original": "A revised version of the `CachingInterceptor` optionally returns an _observable_ that\nimmediately emits the cached response, sends the request to the npm web api anyway,\nand emits again later with the updated search results.",
-    "translation": "修改后的 `CachingInterceptor` 版本可以返回一个立即发出缓存的响应，然后仍然把请求发送到 npm 的 Web API，然后再把修改过的搜索结果重新发出一次。",
+    "original": "A revised version of the `CachingInterceptor` optionally returns an _observable_ that\nimmediately emits the cached response, sends the request to the NPM web API anyway,\nand emits again later with the updated search results.",
+    "translation": "修改后的 `CachingInterceptor` 版本可以返回一个立即发出缓存的响应，然后仍然把请求发送到 NPM 的 Web API，然后再把修改过的搜索结果重新发出一次。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
@@ -16680,9 +16836,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
-    "key": "CALLREQUESTERRORWITHANERROREVENTINSTEADOFREQUESTFLUSHASINTHISEXAMPLE",
-    "original": "Call `request.error()` with an `ErrorEvent` instead of `request.flush()`, as in this example.",
-    "translation": "那就调用 `request.error()`，并给它传入一个 `ErrorEvent`，而不是 `request.flush()`。例子如下：",
+    "key": "CALLREQUESTFLUSHWITHANERRORMESSAGEASSEENINTHEFOLLOWINGEXAMPLE",
+    "original": "Call `request.flush()` with an error message, as seen in the following example.",
+    "translation": "调用 `request.flush()` 并传入一个错误信息，如下所示：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
+  },
+  {
+    "key": "ALTERNATIVELYYOUCANCALLREQUESTERRORWITHANERROREVENT",
+    "original": "Alternatively, you can call `request.error()` with an `ErrorEvent`.",
+    "translation": "另外，你还可以使用 `ErrorEvent` 来调用 `request.error()`.",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/http.md"
   },
   {
@@ -19152,9 +19314,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/lifecycle-hooks.md"
   },
   {
-    "key": "NOTICETHATTHEMYCHILDTAGISTUCKEDBETWEENTHEAFTERCONTENTTAGSNEVERPUTCONTENTBETWEENACOMPONENTSELEMENTTAGSUNLESSYOUINTENDTOPROJECTTHATCONTENTINTOTHECOMPONENT",
-    "original": "Notice that the `<my-child>` tag is tucked between the `<after-content>` tags.\nNever put content between a component's element tags *unless you intend to project that content\ninto the component*.",
-    "translation": "注意，`<my-child>` 标签被包含在 `<after-content>` 标签中。\n永远不要在组件标签的内部放任何内容 —— *除非你想把这些内容投影进这个组件中*。",
+    "key": "NOTICETHATTHEAPPCHILDTAGISTUCKEDBETWEENTHEAFTERCONTENTTAGSNEVERPUTCONTENTBETWEENACOMPONENTSELEMENTTAGSUNLESSYOUINTENDTOPROJECTTHATCONTENTINTOTHECOMPONENT",
+    "original": "Notice that the `<app-child>` tag is tucked between the `<after-content>` tags.\nNever put content between a component's element tags *unless you intend to project that content\ninto the component*.",
+    "translation": "注意，`<app-child>` 标签被包含在 `<after-content>` 标签中。\n永远不要在组件标签的内部放任何内容 —— *除非你想把这些内容投影进这个组件中*。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/lifecycle-hooks.md"
   },
   {
@@ -19164,9 +19326,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/lifecycle-hooks.md"
   },
   {
-    "key": "THENGCONTENTTAGISAPLACEHOLDERFORTHEEXTERNALCONTENTITTELLSANGULARWHERETOINSERTTHATCONTENTINTHISCASETHEPROJECTEDCONTENTISTHEMYCHILDFROMTHEPARENT",
-    "original": "The `<ng-content>` tag is a *placeholder* for the external content.\nIt tells Angular where to insert that content.\nIn this case, the projected content is the `<my-child>` from the parent.",
-    "translation": "`<ng-content>` 标签是外来内容的*占位符*。\n它告诉 Angular 在哪里插入这些外来内容。\n在这里，被投影进去的内容就是来自父组件的 `<my-child>` 标签。",
+    "key": "THENGCONTENTTAGISAPLACEHOLDERFORTHEEXTERNALCONTENTITTELLSANGULARWHERETOINSERTTHATCONTENTINTHISCASETHEPROJECTEDCONTENTISTHEAPPCHILDFROMTHEPARENT",
+    "original": "The `<ng-content>` tag is a *placeholder* for the external content.\nIt tells Angular where to insert that content.\nIn this case, the projected content is the `<app-child>` from the parent.",
+    "translation": "`<ng-content>` 标签是外来内容的*占位符*。\n它告诉 Angular 在哪里插入这些外来内容。\n在这里，被投影进去的内容就是来自父组件的 `<app-child>` 标签。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/lifecycle-hooks.md"
   },
   {
@@ -20412,15 +20574,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
   },
   {
-    "key": "THEFORROOTSTATICMETHODISACONVENTIONTHATMAKESITEASYFORDEVELOPERSTOCONFIGURETHEMODULESPROVIDERS",
-    "original": "The `forRoot()` static method is a convention that makes it easy for developers to configure the module's providers.",
-    "translation": "静态方法 `forRoot()` 是一个约定，它可以让开发人员更轻松的配置模块的提供商。",
+    "key": "THEFORROOTSTATICMETHODISACONVENTIONTHATMAKESITEASYFORDEVELOPERSTOCONFIGURESERVICESANDPROVIDERSTHATAREINTENDEDTOBESINGLETONSAGOODEXAMPLEOFFORROOTISTHEROUTERMODULEFORROOTMETHOD",
+    "original": "The `forRoot()` static method is a convention that makes it easy for developers to configure services and providers that are intended to be singletons. A good example of `forRoot()` is the `RouterModule.forRoot()` method.",
+    "translation": "静态方法 `forRoot()` 是一个约定，它可以让开发人员更轻松的配置模块的想要单例使用的服务及其提供商。`RouterModule.forRoot()` 就是一个很好的例子。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
   },
   {
-    "key": "THEROUTERMODULEFORROOTMETHODISAGOODEXAMPLEAPPSPASSAROUTESOBJECTTOROUTERMODULEFORROOTINORDERTOCONFIGURETHEAPPWIDEROUTERSERVICEWITHROUTESROUTERMODULEFORROOTRETURNSAMODULEWITHPROVIDERSAPICOREMODULEWITHPROVIDERSYOUADDTHATRESULTTOTHEIMPORTSLISTOFTHEROOTAPPMODULE",
-    "original": "The `RouterModule.forRoot()` method is a good example.\nApps pass a `Routes` object to `RouterModule.forRoot()` in order to configure the app-wide `Router` service with routes.\n`RouterModule.forRoot()` returns a [ModuleWithProviders](api/core/ModuleWithProviders).\nYou add that result to the `imports` list of the root `AppModule`.",
-    "translation": "`RouterModule.forRoot()` 就是一个很好的例子。\n应用把一个 `Routes` 对象传给 `RouterModule.forRoot()`，为的就是使用路由配置全应用级的 `Router` 服务。\n`RouterModule.forRoot()` 返回一个[ModuleWithProviders](api/core/ModuleWithProviders)对象。\n你把这个结果添加到根模块 `AppModule` 的 `imports` 列表中。",
+    "key": "APPSPASSAROUTESOBJECTTOROUTERMODULEFORROOTINORDERTOCONFIGURETHEAPPWIDEROUTERSERVICEWITHROUTESROUTERMODULEFORROOTRETURNSAMODULEWITHPROVIDERSAPICOREMODULEWITHPROVIDERSYOUADDTHATRESULTTOTHEIMPORTSLISTOFTHEROOTAPPMODULE",
+    "original": "Apps pass a `Routes` object to `RouterModule.forRoot()` in order to configure the app-wide `Router` service with routes.\n`RouterModule.forRoot()` returns a [ModuleWithProviders](api/core/ModuleWithProviders).\nYou add that result to the `imports` list of the root `AppModule`.",
+    "translation": "应用把一个 `Routes` 对象传给 `RouterModule.forRoot()`，为的就是使用路由配置全应用级的 `Router` 服务。\n`RouterModule.forRoot()` 返回一个[ModuleWithProviders](api/core/ModuleWithProviders)对象。\n你把这个结果添加到根模块 `AppModule` 的 `imports` 列表中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
   },
   {
@@ -20429,6 +20591,12 @@
     "translation": "只能在应用的根模块 `AppModule` 中调用并导入 `.forRoot()` 的结果。\n在其它模块中导入它，特别是惰性加载模块中，是违反设计目标的并会导致一个运行时错误。\n要了解更多，参见[单例服务](guide/singleton-services)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
   },
+  {
+    "key": "FORASERVICEINSTEADOFUSINGFORROOTSPECIFYPROVIDEDIN:ROOTONTHESERVICESINJECTABLEDECORATORWHICHMAKESTHESERVICEAUTOMATICALLYAVAILABLETOTHEWHOLEAPPLICATIONANDTHUSSINGLETONBYDEFAULT",
+    "original": "For a service, instead of using `forRoot()`,  specify `providedIn: 'root'` on the service's `@Injectable()` decorator, which \nmakes the service automatically available to the whole application and thus singleton by default.",
+    "translation": "对于服务来说，除了可以使用 `forRoot()`外，更好的方式是在该服务的 `@Injectable()` 装饰器中指定 `providedIn: 'root'`，它让该服务自动在全应用级可用，这样它也就默认是单例的。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
+  },
   {
     "key": "ROUTERMODULEALSOOFFERSAFORCHILDSTATICMETHODFORCONFIGURINGTHEROUTESOFLAZYLOADEDMODULES",
     "original": "`RouterModule` also offers a `forChild` static method for configuring the routes of lazy-loaded modules.",
@@ -20640,9 +20808,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
   },
   {
-    "key": "REGISTERAPPLICATIONWIDEPROVIDERSINTHEROOTAPPMODULENOTINTHEAPPCOMPONENT",
-    "original": "Register application-wide providers in the root `AppModule`, not in the `AppComponent`.",
-    "translation": "在根模块 `AppModule` 中注册全应用级提供商，而不是 `AppComponent` 中。",
+    "key": "DEFINEAPPLICATIONWIDEPROVIDERSBYSPECIFYINGPROVIDEDIN:ROOTONITSINJECTABLEDECORATORINTHECASEOFSERVICESORATINJECTIONTOKENCONSTRUCTIONINTHECASEWHERETOKENSAREPROVIDEDPROVIDERSTHATARECREATEDTHISWAYAUTOMATICALLYAREMADEAVAILABLETOTHEENTIREAPPLICATIONANDDONTNEEDTOBELISTEDINANYMODULE",
+    "original": "Define application-wide providers by specifying `providedIn: 'root'` on its `@Injectable()` decorator (in the case of services) or at `InjectionToken` construction (in the case where tokens are provided). Providers that are created this way automatically are made available to the entire application and don't need to be listed in any module.",
+    "translation": "通过在服务的 `@Injectable()` 装饰器中（例如服务）指定 `providedIn: 'root'` 来定义全应用级提供商，或者 `InjectionToken` 的构造器（例如提供令牌的地方），都可以定义全应用级提供商。\n通过这种方式创建的服务提供商会自动在整个应用中可用，而不用把它列在任何模块中。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
+  },
+  {
+    "key": "IFAPROVIDERCANNOTBECONFIGUREDINTHISWAYPERHAPSBECAUSEITHASNOSENSIBLEDEFAULTVALUETHENREGISTERAPPLICATIONWIDEPROVIDERSINTHEROOTAPPMODULENOTINTHEAPPCOMPONENT",
+    "original": "If a provider cannot be configured in this way (perhaps because it has no sensible default value), then register application-wide providers in the root `AppModule`, not in the `AppComponent`.",
+    "translation": "如果某个提供商不能用这种方式配置（可能因为它没有有意义的默认值），那就在根模块 `AppModule` 中注册这些全应用级服务，而不是在 `AppComponent` 中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
   },
   {
@@ -20700,9 +20874,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
   },
   {
-    "key": "INGENERALPREFERREGISTERINGFEATURESPECIFICPROVIDERSINMODULESNGMODULEPROVIDERSTOREGISTERINGINCOMPONENTSCOMPONENTPROVIDERS",
-    "original": "In general, prefer registering feature-specific providers in modules (`@NgModule.providers`)\nto registering in components (`@Component.providers`).",
-    "translation": "通常，优先把模块中具体特性的提供商注册到模块中（`@NgModule.providers`），而不是组件中（`@Component.providers`）。",
+    "key": "PROVIDERSSHOULDBECONFIGUREDUSINGINJECTABLESYNTAXIFPOSSIBLETHEYSHOULDBEPROVIDEDINTHEAPPLICATIONROOTPROVIDEDIN:ROOTSERVICESTHATARECONFIGUREDTHISWAYARELAZILYLOADEDIFTHEYAREONLYUSEDFROMALAZILYLOADEDCONTEXT",
+    "original": "Providers should be configured using `@Injectable` syntax. If possible, they should be provided in the application root (`providedIn: 'root'`). Services that are configured this way are lazily loaded if they are only used from a lazily loaded context.",
+    "translation": "提供商应该使用 `@Injectable` 语法进行配置。只要可能，就应该把它们在应用的根注入器中提供（`providedIn: 'root'`）。\n如果它们只被惰性加载的上下文中使用，那么这种方式配置的服务就是惰性加载的。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
+  },
+  {
+    "key": "IFITSTHECONSUMERSDECISIONWHETHERAPROVIDERISAVAILABLEAPPLICATIONWIDEORNOTTHENREGISTERPROVIDERSINMODULESNGMODULEPROVIDERSINSTEADOFREGISTERINGINCOMPONENTSCOMPONENTPROVIDERS",
+    "original": "If it's the consumer's decision whether a provider is available application-wide or not, \nthen register providers in modules (`@NgModule.providers`) instead of registering in components (`@Component.providers`).",
+    "translation": "如果要由消费方来决定是否把它作为全应用级提供商，那么就要在模块中（`@NgModule.providers`）注册提供商，而不是组件中（`@Component.providers`）。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/ngmodule-faq.md"
   },
   {
@@ -21493,8 +21673,8 @@
   },
   {
     "key": "YOUCANDOWNLOADANDINSTALLTHESENPMPACKAGESWITHTHENPMCLIENTHTTPS:DOCSNPMJSCOMCLIINSTALLWHICHRUNSASANODEJSAPPLICATION",
-    "original": "You can download and install these npm packages with the [**npm client**](https://docs.npmjs.com/cli/install), which runs as a node.js application.",
-    "translation": "你可以使用 [**npm**](https://docs.npmjs.com/cli/install) 来安装这些 npm 包，npm 命令也是一个 node.js 应用。",
+    "original": "You can download and install these npm packages with the [**npm client**](https://docs.npmjs.com/cli/install), which runs as a Node.js® application.",
+    "translation": "你可以使用 [**npm**](https://docs.npmjs.com/cli/install) 来安装这些 npm 包，npm 命令也是一个 Node.js® 应用。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/npm-packages.md"
   },
   {
@@ -21516,20 +21696,20 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/npm-packages.md"
   },
   {
-    "key": "VERIFYTHATYOUARERUNNINGNODEV4XXORHIGHERANDNPM3XXORHIGHERBYRUNNINGTHECOMMANDSNODEVANDNPMVINATERMINALCONSOLEWINDOWOLDERVERSIONSPRODUCEERRORS",
-    "original": "**Verify that you are running node `v4.x.x` or higher and npm `3.x.x` or higher**\nby running the commands `node -v` and `npm -v` in a terminal/console window.\nOlder versions produce errors.",
-    "translation": "在终端/控制器窗口运行命令 `node -v` 和 `npm -v`，来**确认你运行的 node 是 `v4.x.x` 或更高，npm 为 `3.x.x` 或更高。**\n老版本会产生错误。",
+    "key": "VERIFYTHATYOUARERUNNINGNODEJSV8XORHIGHERANDNPM5XORHIGHERBYRUNNINGTHECOMMANDSNODEVANDNPMVINATERMINALCONSOLEWINDOWOLDERVERSIONSPRODUCEERRORS",
+    "original": "**Verify that you are running Node.js `v8.x` or higher and npm `5.x` or higher**\nby running the commands `node -v` and `npm -v` in a terminal/console window.\nOlder versions produce errors.",
+    "translation": "在终端/控制器窗口运行命令 `node -v` 和 `npm -v`，来**确认你运行的 node 是 `v8.x` 或更高，npm 为 `5.x` 或更高。**\n老版本会产生错误。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/npm-packages.md"
   },
   {
-    "key": "CONSIDERUSINGNVMHTTPS:GITHUBCOMCREATIONIXNVMFORMANAGINGMULTIPLEVERSIONSOFNODEANDNPMYOUMAYNEEDNVMHTTPS:GITHUBCOMCREATIONIXNVMIFYOUALREADYHAVEPROJECTSRUNNINGONYOURMACHINETHATUSEOTHERVERSIONSOFNODEANDNPM",
-    "original": "Consider using [nvm](https://github.com/creationix/nvm) for managing multiple\nversions of node and npm. You may need [nvm](https://github.com/creationix/nvm) if\nyou already have projects running on your machine that use other versions of node and npm.",
-    "translation": "建议使用[nvm](https://github.com/creationix/nvm)来管理 node 和 npm 的多个版本。如果你机器上已经有某些项目运行了 node 和 npm 的其它版本，你就会需要[nvm](https://github.com/creationix/nvm)了。",
+    "key": "CONSIDERUSINGNVMHTTPS:GITHUBCOMCREATIONIXNVMFORMANAGINGMULTIPLEVERSIONSOFNODEJSANDNPMYOUMAYNEEDNVMHTTPS:GITHUBCOMCREATIONIXNVMIFYOUALREADYHAVEPROJECTSRUNNINGONYOURMACHINETHATUSEOTHERVERSIONSOFNODEJSANDNPM",
+    "original": "Consider using [nvm](https://github.com/creationix/nvm) for managing multiple\nversions of Node.js and npm. You may need [nvm](https://github.com/creationix/nvm) if\nyou already have projects running on your machine that use other versions of Node.js and npm.",
+    "translation": "建议使用[nvm](https://github.com/creationix/nvm)来管理 node 和 npm 的多个版本。如果你机器上已经有某些项目运行了 Node.js 和 npm 的其它版本，你就会需要[nvm](https://github.com/creationix/nvm)了。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/npm-packages.md"
   },
   {
-    "key": "BOTHNPMANDYARNINSTALLPACKAGESIDENTIFIEDINAPACKAGEJSONHTTPS:DOCSNPMJSCOMFILESPACKAGEJSONFILE",
-    "original": "Both `npm` and `yarn` install packages identified in a [**package.json**](https://docs.npmjs.com/files/package.json) file.",
+    "key": "BOTHNPMANDYARNINSTALLPACKAGESTHATAREIDENTIFIEDINAPACKAGEJSONHTTPS:DOCSNPMJSCOMFILESPACKAGEJSONFILE",
+    "original": "Both `npm` and `yarn` install packages that are identified in a [**package.json**](https://docs.npmjs.com/files/package.json) file.",
     "translation": "无论是 `npm` 还是 `yarn`，所安装的包都记录在 [**package.json**](https://docs.npmjs.com/files/package.json) 文件中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/npm-packages.md"
   },
@@ -21726,9 +21906,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/npm-packages.md"
   },
   {
-    "key": "TYPES:TYPESCRIPTDEFINITIONFILESFOR3RDPARTYLIBRARIESSUCHASJASMINEANDNODE",
-    "original": "**@types/... **: TypeScript definition files for 3rd party libraries such as Jasmine and node.",
-    "translation": "**@types/... **：第三方库（比如 Jasmine 和 node）的 TypeScript 类型定义文件。",
+    "key": "TYPES:TYPESCRIPTDEFINITIONFILESFOR3RDPARTYLIBRARIESSUCHASJASMINEANDNODEJS",
+    "original": "**@types/... **: TypeScript definition files for 3rd party libraries such as Jasmine and Node.js.",
+    "translation": "**@types/... **：第三方库（比如 Jasmine 和 Node.js）的 TypeScript 类型定义文件。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/npm-packages.md"
   },
   {
@@ -21756,9 +21936,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/npm-packages.md"
   },
   {
-    "key": "TSNODEHTTPS:WWWNPMJSCOMPACKAGETSNODE:TYPESCRIPTEXECUTIONENVIRONMENTANDREPLFORNODE",
-    "original": "**[ts-node](https://www.npmjs.com/package/ts-node)**: TypeScript execution environment and REPL for node.",
-    "translation": "**[ts-node](https://www.npmjs.com/package/ts-node)**：TypeScript 的运行环境以及在 node 环境下用的 REPL。",
+    "key": "TSNODEHTTPS:WWWNPMJSCOMPACKAGETSNODE:TYPESCRIPTEXECUTIONENVIRONMENTANDREPLFORNODEJS",
+    "original": "**[ts-node](https://www.npmjs.com/package/ts-node)**: TypeScript execution environment and REPL for Node.js.",
+    "translation": "**[ts-node](https://www.npmjs.com/package/ts-node)**：TypeScript 的运行环境以及在 Node.js 环境下用的 REPL。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/npm-packages.md"
   },
   {
@@ -22068,8 +22248,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/observables.md"
   },
   {
-    "key": "NOTETHATANEXTFUNCTIONCOULDRECEIVEFORINSTANCEMESSAGESTRINGSOREVENTOBJECTSNUMERICVALUESORSTUCTURESDEPENDINGONCONTEXTASAGENERALTERMWEREFERTODATAPUBLISHEDBYANOBSERVABLEASASTREAMANYTYPEOFVALUECANBEREPRESENTEDWITHANOBSERVABLEANDTHEVALUESAREPUBLISHEDASASTREAM",
-    "original": "Note that a `next()` function could receive, for instance, message strings, or event objects, numeric values, or stuctures, depending on context. As a general term, we refer to data published by an observable as a *stream*. Any type of value can be represented with an observable, and the values are published as a stream.",
+    "key": "NOTETHATANEXTFUNCTIONCOULDRECEIVEFORINSTANCEMESSAGESTRINGSOREVENTOBJECTSNUMERICVALUESORSTRUCTURESDEPENDINGONCONTEXTASAGENERALTERMWEREFERTODATAPUBLISHEDBYANOBSERVABLEASASTREAMANYTYPEOFVALUECANBEREPRESENTEDWITHANOBSERVABLEANDTHEVALUESAREPUBLISHEDASASTREAM",
+    "original": "Note that a `next()` function could receive, for instance, message strings, or event objects, numeric values, or structures, depending on context. As a general term, we refer to data published by an observable as a *stream*. Any type of value can be represented with an observable, and the values are published as a stream.",
     "translation": "注意，`next()` 函数可以接受消息字符串、事件对象、数字值或各种结构，具体类型取决于上下文。\n为了更通用一点，我们把由可观察对象发布出来的数据统称为*流*。任何类型的值都可以表示为可观察对象，而这些值会被发布为一个流。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/observables.md"
   },
@@ -22968,21 +23148,39 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
   },
   {
-    "key": "##CREATEASERVICE",
-    "original": "## Create a service",
-    "translation": "## 创建服务",
+    "key": "APROVIDERISANINSTRUCTIONTOTHEDISYSTEMONHOWTOOBTAINAVALUEFORADEPENDENCYMOSTOFTHETIMETHESEDEPENDENCIESARESERVICESTHATYOUCREATEANDPROVIDE",
+    "original": "A provider is an instruction to the DI system on how to obtain a value for a dependency. Most of the time, these dependencies are services that you create and provide.",
+    "translation": "提供商就相当于说明书，用来指导 DI 系统该如何获取某个依赖的值。\n大多数情况下，这些依赖就是你要创建和提供的那些服务。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
   },
   {
-    "key": "YOUCANPROVIDESERVICESTOYOURAPPBYUSINGTHEPROVIDERSARRAYINANNGMODULECONSIDERTHEDEFAULTAPPGENERATEDBYTHECLIINORDERTOADDAUSERSERVICETOITYOUCANGENERATEONEBYENTERINGTHEFOLLOWINGCOMMANDINTHETERMINALWINDOW:",
-    "original": "You can provide services to your app by using the `providers` array in an NgModule.\nConsider the default app generated by the CLI. In order to add a user service to it,\nyou can generate one by entering the following command in the terminal window:",
-    "translation": "你可以使用 NgModule 中的 `providers` 数组来为你的应用提供服务。\n对于用 CLI 生成的默认应用，要想为它添加一个 `user` 服务，你可以在终端窗口中输入如下命令来生成一个：",
+    "key": "##PROVIDINGASERVICE",
+    "original": "## Providing a service",
+    "translation": "## 提供服务",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
   },
   {
-    "key": "THISCREATESASERVICECALLEDUSERSERVICEYOUNOWNEEDTOMAKETHESERVICEAVAILABLEINYOURAPPSINJECTORUPDATEAPPMODULETSBYIMPORTINGITWITHYOUROTHERIMPORTSTATEMENTSATTHETOPOFTHEFILEANDADDINGITTOTHEPROVIDERSARRAY:",
-    "original": "This creates a service called `UserService`. You now need to make the service available in your\napp's injector. Update `app.module.ts` by importing it with your other import statements at the top\nof the file and adding it to the `providers` array:",
-    "translation": "这将会创建一个名叫 `UserService` 的服务。你现在要让该服务在你的应用注入器中可用，就要修改 `app.module.ts` 文件。先在文件的顶部导入它，然后把它加入 `providers` 数组中：",
+    "key": "IFYOUALREADYHAVEACLIGENERATEDAPPCREATEASERVICEUSINGTHEFOLLOWINGCLICOMMANDINTHEROOTPROJECTDIRECTORYREPLACEUSERWITHTHENAMEOFYOURSERVICE",
+    "original": "If you already have a CLI generated app, create a service using the following CLI command in the root project directory. Replace _User_ with the name of your service.",
+    "translation": "如果你是用 CLI 创建的应用，那么可以使用下列 CLI 命令在项目根目录下创建一个服务。把其中的 `User` 替换成你的服务名。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
+  },
+  {
+    "key": "THISCOMMANDCREATESTHEFOLLOWINGUSERSERVICESKELETON:",
+    "original": "This command creates the following `UserService` skeleton:",
+    "translation": "该命令会创建下列 `UserService` 骨架：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
+  },
+  {
+    "key": "YOUCANNOWINJECTUSERSERVICEANYWHEREINYOURAPPLICATION",
+    "original": "You can now inject `UserService` anywhere in your application.",
+    "translation": "现在，你就可以在应用中到处注入 `UserService` 了。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
+  },
+  {
+    "key": "THESERVICEITSELFISACLASSTHATTHECLIGENERATEDANDTHATSDECORATEDWITHINJECTABLEBYDEFAULTTHISDECORATORISCONFIGUREDWITHAPROVIDEDINPROPERTYWHICHCREATESAPROVIDERFORTHESERVICEINTHISCASEPROVIDEDIN:ROOTSPECIFIESTHATTHESERVICESHOULDBEPROVIDEDINTHEROOTINJECTOR",
+    "original": "The service itself is a class that the CLI generated and that's decorated with `@Injectable`. By default, this decorator is configured with a `providedIn` property, which creates a provider for the service. In this case, `providedIn: 'root'` specifies that the service should be provided in the root injector.",
+    "translation": "该服务本身是 CLI 创建的一个类，并且加上了 `@Injectable` 装饰器。默认情况下，该装饰器是用 `providedIn` 属性进行配置的，它会为该服务创建一个提供商。在这个例子中，`providedIn: 'root'` 指定该服务应该在根注入器中提供。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
   },
   {
@@ -22992,9 +23190,33 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
   },
   {
-    "key": "WHENYOUADDASERVICEPROVIDERTOTHEPROVIDERSARRAYOFTHEROOTMODULEITSAVAILABLETHROUGHOUTTHEAPPADDITIONALLYWHENYOUIMPORTAMODULETHATHASPROVIDERSTHOSEPROVIDERSAREALSOAVAILABLETOALLTHECLASSESINTHEAPPASLONGTHEYHAVETHELOOKUPTOKENFOREXAMPLEIFYOUIMPORTTHEHTTPCLIENTMODULEINTOYOURAPPMODULEITSPROVIDERSARETHENAVAILABLETOTHEENTIREAPPANDYOUCANMAKEHTTPREQUESTSFROMANYWHEREINYOURAPP",
-    "original": "When you add a service provider to the `providers` array of the root module, it’s available throughout the app. Additionally, when you import a module that has providers, those providers are also available to all the classes in the app as long they have the lookup token. For example, if you import the `HttpClientModule` into your `AppModule`, its providers are then available to the entire app and you can make HTTP requests from anywhere in your app.",
-    "translation": "当你把服务提供商添加到根模块的 `providers` 数组中时，它就在整个应用程序中可用了。\n另外，当你导入一个带有服务提供商的模块时，其中的服务提供商也同样对整个应用中的类是可用的 —— 只要它们有供查找用的服务令牌。\n比如，如果你把 `HttpClientModule` 导入了 `AppModule`，它里面的提供商就是对整个应用可用的，你可以在应用的任何地方发起 HTTP 请求。",
+    "key": "WHENYOUADDASERVICEPROVIDERTOTHEROOTAPPLICATIONINJECTORITSAVAILABLETHROUGHOUTTHEAPPADDITIONALLYTHESEPROVIDERSAREALSOAVAILABLETOALLTHECLASSESINTHEAPPASLONGTHEYHAVETHELOOKUPTOKEN",
+    "original": "When you add a service provider to the root application injector, it’s available throughout the app. Additionally, these providers are also available to all the classes in the app as long they have the lookup token.",
+    "translation": "当你把服务提供商添加到应用的根注入器中时，它就在整个应用程序中可用了。\n另外，这些服务提供商也同样对整个应用中的类是可用的 —— 只要它们有供查找用的服务令牌。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
+  },
+  {
+    "key": "YOUSHOULDALWAYSPROVIDEYOURSERVICEINTHEROOTINJECTORUNLESSTHEREISACASEWHEREYOUWANTTHESERVICETOBEAVAILABLEONLYIFTHECONSUMERIMPORTSAPARTICULARNGMODULE",
+    "original": "You should always provide your service in the root injector unless there is a case where you want the service to be available only if the consumer imports a particular `@NgModule)`.",
+    "translation": "你应该始终在根注入器中提供这些服务 —— 除非你希望该服务只有在消费方要导入特定的 `@NgModule` 时才生效。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
+  },
+  {
+    "key": "##PROVIDEDINANDNGMODULES",
+    "original": "## providedIn and NgModules",
+    "translation": "## `providedIn` 与 NgModule",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
+  },
+  {
+    "key": "ITSALSOPOSSIBLETOSPECIFYTHATASERVICESHOULDBEPROVIDEDINAPARTICULARNGMODULEFOREXAMPLEIFYOUDONTWANTUSERSERVICETOBEAVAILABLETOAPPLICATIONSUNLESSTHEYIMPORTAUSERMODULEYOUVECREATEDYOUCANSPECIFYTHATTHESERVICESHOULDBEPROVIDEDINTHEMODULE:",
+    "original": "It's also possible to specify that a service should be provided in a particular `@NgModule`. For example, if you don't want `UserService` to be available to applications unless they import a `UserModule` you've created, you can specify that the service should be provided in the module:",
+    "translation": "也可以规定某个服务只有在特定的 `@NgModule` 中提供。比如，如果你你希望只有当消费方导入了你创建的 `UserModule` 时才让 `UserService` 在应用中生效，那就可以指定该服务要在该模块中提供：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
+  },
+  {
+    "key": "THEEXAMPLEABOVESHOWSTHEPREFERREDWAYTOPROVIDEASERVICEINAMODULETHISMETHODISPREFERREDBECAUSEITENABLESTREESHAKINGOFTHESERVICEIFNOTHINGINJECTSITIFITSNOTPOSSIBLETOSPECIFYINTHESERVICEWHICHMODULESHOULDPROVIDEITYOUCANALSODECLAREAPROVIDERFORTHESERVICEWITHINTHEMODULE:",
+    "original": "The example above shows the preferred way to provide a service in a module. This method is preferred because it enables tree-shaking of the service if nothing injects it. If it's not possible to specify in the service which module should provide it, you can also declare a provider for the service within the module:",
+    "translation": "上面的例子展示的就是在模块中提供服务的首选方式。之所以推荐该方式，是因为当没有人注入它时，该服务就可以被摇树优化掉。如果没办法指定哪个模块该提供这个服务，你也可以在那个模块中为该服务声明一个提供商：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
   },
   {
@@ -23093,6 +23315,12 @@
     "translation": "[惰性加载模块](guide/lazy-loading-ngmodules)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
   },
+  {
+    "key": "TREESHAKABLEPROVIDERSGUIDEDEPENDENCYINJECTION#TREESHAKABLEPROVIDERS",
+    "original": "* [Tree-shakable Providers](guide/dependency-injection#tree-shakable-providers).",
+    "translation": "[可摇树优化的服务提供商](guide/dependency-injection#tree-shakable-providers)。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/providers.md"
+  },
   {
     "key": "NGMODULEFAQGUIDENGMODULEFAQ",
     "original": "* [NgModule FAQ](guide/ngmodule-faq).",
@@ -23154,15 +23382,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
   {
-    "key": "VERIFYTHATYOUARERUNNINGATLEASTNODE69XANDNPM3XXBYRUNNINGNODEVANDNPMVINATERMINALCONSOLEWINDOWOLDERVERSIONSPRODUCEERRORSBUTNEWERVERSIONSAREFINE",
-    "original": "**Verify that you are running at least node `6.9.x` and npm `3.x.x`**\nby running `node -v` and `npm -v` in a terminal/console window.\nOlder versions produce errors, but newer versions are fine.",
-    "translation": "请先在终端/控制台窗口中运行命令 `node -v` 和 `npm -v`，\n**来验证一下你正在运行 node `6.9.x` 和 npm `3.x.x` 以上的版本。**\n更老的版本可能会出现错误，更新的版本则没问题。",
+    "key": "VERIFYTHATYOUARERUNNINGATLEASTNODEJSVERSION8XORGREATERANDNPMVERSION5XORGREATERBYRUNNINGNODEVANDNPMVINATERMINALCONSOLEWINDOWOLDERVERSIONSPRODUCEERRORSBUTNEWERVERSIONSAREFINE",
+    "original": "**Verify that you are running at least Node.js version `8.x` or greater and npm version `5.x` or greater**\nby running `node -v` and `npm -v` in a terminal/console window.\nOlder versions produce errors, but newer versions are fine.",
+    "translation": "请先在终端/控制台窗口中运行命令 `node -v` 和 `npm -v`，\n**来验证一下你正在运行 node `8.x` 和 npm `5.x` 以上的版本。**\n更老的版本可能会出现错误，更新的版本则没问题。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
   {
     "key": "THENINSTALLTHEANGULARCLIHTTPS:GITHUBCOMANGULARANGULARCLIGLOBALLY",
-    "original": "Then **install the [Angular CLI](https://github.com/angular/angular-cli)** globally.",
-    "translation": "然后全局安装 **[Angular CLI](https://github.com/angular/angular-cli)** 。",
+    "original": "Then install the [Angular CLI](https://github.com/angular/angular-cli) globally.",
+    "translation": "然后全局安装 [Angular CLI](https://github.com/angular/angular-cli)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
   {
@@ -23178,15 +23406,27 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
   {
-    "key": "GENERATEANEWPROJECTANDSKELETONAPPLICATIONBYRUNNINGTHEFOLLOWINGCOMMANDS:",
-    "original": "Generate a new project and skeleton application by running the following commands:",
-    "translation": "运行下列命令来生成一个新项目以及应用的骨架代码：",
+    "key": "GENERATEANEWPROJECTANDDEFAULTAPPBYRUNNINGTHEFOLLOWINGCOMMAND:",
+    "original": "Generate a new project and default app by running the following command:",
+    "translation": "运行下列命令来生成一个新项目以及默认的应用代码：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
   {
-    "key": "PATIENCEPLEASEITTAKESTIMETOSETUPANEWPROJECTMOSTOFITISSPENTINSTALLINGNPMPACKAGES",
-    "original": "Patience, please.\nIt takes time to set up a new project; most of it is spent installing npm packages.",
-    "translation": "请耐心等待。\n创建新项目需要花费很多时间，大多数时候都是在安装那些 npm 包。",
+    "key": "THEANGULARCLIINSTALLSTHENECESSARYNPMPACKAGESCREATESTHEPROJECTFILESANDPOPULATESTHEPROJECTWITHASIMPLEDEFAULTAPPTHISCANTAKESOMETIME",
+    "original": "The Angular CLI installs the necessary npm packages, creates the project files, and populates the project with a simple default app. This can take some time.",
+    "translation": "Angular CLI 会安装必要的 NPM 包、创建项目文件，并在该项目中生成一个简单的默认应用。这可能要花一点时间。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
+  },
+  {
+    "key": "YOUCANADDPREPACKAGEDFUNCTIONALITYTOANEWPROJECTBYUSINGTHENGADDCOMMANDTHENGADDCOMMANDTRANSFORMSAPROJECTBYAPPLYINGTHESCHEMATICSINTHESPECIFIEDPACKAGEFORMOREINFORMATIONSEETHEANGULARCLIDOCUMENTATIONHTTPS:GITHUBCOMANGULARANGULARCLIWIKIADDANGULARCLIDOCUMENTATION",
+    "original": "You can add pre-packaged functionality to a new project by using the `ng add` command. The `ng add` command transforms a project by applying the schematics in the specified package. \nFor more information, see the [Angular CLI documentation.](https://github.com/angular/angular-cli/wiki/add \"Angular CLI documentation\")",
+    "translation": "你可以使用 `ng add` 命令往新项目中添加一些预先打包好的功能。\n`ng add` 命令会通过应用来自特定 NPM 包中的图纸（schematic）来转换此项目。\n要了解更多，参见 [Angular CLI 文档](https://github.com/angular/angular-cli/wiki/add \"Angular CLI documentation\")。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
+  },
+  {
+    "key": "ANGULARMATERIALPROVIDESSCHEMATICSFORTYPICALAPPLAYOUTSSEETHEANGULARMATERIALDOCUMENTATIONHTTPS:MATERIALANGULARIOGUIDESANGULARMATERIALDOCUMENTATIONFORDETAILS",
+    "original": "Angular Material provides schematics for typical app layouts. \nSee the [Angular Material documentation](https://material.angular.io/guides \"Angular Material documentation\") for details.",
+    "translation": "比如 Angular Material 就为一些典型布局提供了图纸。参见 [Angular Material 文档](https://material.angular.io/guides \"Angular Material documentation\")。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
   {
@@ -23351,6 +23591,12 @@
     "translation": "这个文件夹中包括为各个目标环境准备的文件，它们导出了一些应用中要用到的配置变量。\n      这些文件会在构建应用时被替换。\n      比如你可能在生产环境中使用不同的 API 端点地址，或使用不同的统计 Token 参数。\n      甚至使用一些模拟服务。\n      所有这些，CLI 都替你考虑到了。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
+  {
+    "key": "ACONFIGURATIONFILETOSHARETARGETBROWSERSHTTPS:GITHUBCOMBROWSERSLISTBROWSERSLISTBETWEENDIFFERENTFRONTENDTOOLS",
+    "original": "A configuration file to share [target browsers](https://github.com/browserslist/browserslist) between different front-end tools.",
+    "translation": "一个配置文件，用来在不同的前端工具之间共享[目标浏览器](https://github.com/browserslist/browserslist)。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
+  },
   {
     "key": "EVERYSITEWANTSTOLOOKGOODONTHEBOOKMARKBARGETSTARTEDWITHYOURVERYOWNANGULARICON",
     "original": "Every site wants to look good on the bookmark bar.\n      Get started with your very own Angular icon.",
@@ -23363,6 +23609,12 @@
     "translation": "这是别人访问你的网站是看到的主页面的 HTML 文件。\n      大多数情况下你都不用编辑它。\n      在构建应用时，CLI 会自动把所有 `js` 和 `css` 文件添加进去，所以你不必在这里手动添加任何 `<script>` 或 `<link>` 标签。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
+  {
+    "key": "UNITTESTCONFIGURATIONFORTHEKARMATESTRUNNERHTTPS:KARMARUNNERGITHUBIOUSEDWHENRUNNINGNGTEST",
+    "original": "Unit test configuration for the [Karma test runner](https://karma-runner.github.io),\n      used when running `ng test`.",
+    "translation": "给[Karma](https://karma-runner.github.io)的单元测试配置，当运行 `ng test` 时会用到它。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
+  },
   {
     "key": "THEMAINENTRYPOINTFORYOURAPPCOMPILESTHEAPPLICATIONWITHTHEJITCOMPILERGUIDEGLOSSARY#JITANDBOOTSTRAPSTHEAPPLICATIONSROOTMODULEAPPMODULETORUNINTHEBROWSERYOUCANALSOUSETHEAOTCOMPILERGUIDEAOTCOMPILERWITHOUTCHANGINGANYCODEBYAPPENDINGTHEAOTFLAGTOTHENGBUILDANDNGSERVECOMMANDS",
     "original": "The main entry point for your app.\n      Compiles the application with the [JIT compiler](guide/glossary#jit)\n      and bootstraps the application's root module (`AppModule`) to run in the browser.\n      You can also use the [AOT compiler](guide/aot-compiler)\n      without changing any code by appending the`--aot` flag to the `ng build` and `ng serve` commands.",
@@ -23393,6 +23645,12 @@
     "translation": "TypeScript 编译器的配置文件。`tsconfig.app.json` 是为 Angular 应用准备的，而 `tsconfig.spec.json` 是为单元测试准备的。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
+  {
+    "key": "ADDITIONALLINTINGCONFIGURATIONFORTSLINTHTTPS:PALANTIRGITHUBIOTSLINTTOGETHERWITHCODELYZERHTTP:CODELYZERCOMUSEDWHENRUNNINGNGLINTLINTINGHELPSKEEPYOURCODESTYLECONSISTENT",
+    "original": "Additional Linting configuration for [TSLint](https://palantir.github.io/tslint/) together with\n      [Codelyzer](http://codelyzer.com/), used when running `ng lint`.\n      Linting helps keep your code style consistent.",
+    "translation": "额外的 Linting 配置。当运行 `ng lint` 时，它会供带有 [Codelyzer](http://codelyzer.com/) 的 [TSLint](https://palantir.github.io/tslint/) 使用。\n      Linting 可以帮你们保持代码风格的一致性。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
+  },
   {
     "key": "###THEROOTFOLDER",
     "original": "### The root folder",
@@ -23429,12 +23687,6 @@
     "translation": "`Node.js` 创建了这个文件夹，并且把 `package.json` 中列举的所有第三方模块都放在其中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
-  {
-    "key": "CONFIGURATIONFORANGULARCLIINTHISFILEYOUCANSETSEVERALDEFAULTSANDALSOCONFIGUREWHATFILESAREINCLUDEDWHENYOURPROJECTISBUILTCHECKOUTTHEOFFICIALDOCUMENTATIONIFYOUWANTTOKNOWMORE",
-    "original": "Configuration for Angular CLI.\n      In this file you can set several defaults and also configure what files are included\n      when your project is built.\n      Check out the official documentation if you want to know more.",
-    "translation": "Angular CLI 的配置文件。\n      在这个文件中，你可以设置一系列默认值，还可以配置项目编译时要包含的那些文件。\n      要了解更多，请参阅它的官方文档。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
-  },
   {
     "key": "SIMPLECONFIGURATIONFORYOUREDITORTOMAKESUREEVERYONETHATUSESYOURPROJECTHASTHESAMEBASICCONFIGURATIONMOSTEDITORSSUPPORTANEDITORCONFIGFILESEEHTTP:EDITORCONFIGORGFORMOREINFORMATION",
     "original": "Simple configuration for your editor to make sure everyone that uses your project\n      has the same basic configuration.\n      Most editors support an `.editorconfig` file.\n      See http://editorconfig.org for more information.",
@@ -23442,15 +23694,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
   {
-    "key": "GITCONFIGURATIONTOMAKESUREAUTOGENERATEDFILESARENOTCOMMITEDTOSOURCECONTROL",
-    "original": "Git configuration to make sure autogenerated files are not commited to source control.",
+    "key": "GITCONFIGURATIONTOMAKESUREAUTOGENERATEDFILESARENOTCOMMITTEDTOSOURCECONTROL",
+    "original": "Git configuration to make sure autogenerated files are not committed to source control.",
     "translation": "一个 Git 的配置文件，用来确保某些自动生成的文件不会被提交到源码控制系统中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
   {
-    "key": "UNITTESTCONFIGURATIONFORTHEKARMATESTRUNNERHTTPS:KARMARUNNERGITHUBIOUSEDWHENRUNNINGNGTEST",
-    "original": "Unit test configuration for the [Karma test runner](https://karma-runner.github.io),\n      used when running `ng test`.",
-    "translation": "给[Karma](https://karma-runner.github.io)的单元测试配置，当运行 `ng test` 时会用到它。",
+    "key": "CONFIGURATIONFORANGULARCLIINTHISFILEYOUCANSETSEVERALDEFAULTSANDALSOCONFIGUREWHATFILESAREINCLUDEDWHENYOURPROJECTISBUILTCHECKOUTTHEOFFICIALDOCUMENTATIONIFYOUWANTTOKNOWMORE",
+    "original": "Configuration for Angular CLI.\n      In this file you can set several defaults and also configure what files are included\n      when your project is built.\n      Check out the official documentation if you want to know more.",
+    "translation": "Angular CLI 的配置文件。\n      在这个文件中，你可以设置一系列默认值，还可以配置项目编译时要包含的那些文件。\n      要了解更多，请参阅它的官方文档。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/quickstart.md"
   },
   {
@@ -24516,9 +24768,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/reactive-forms.md"
   },
   {
-    "key": "NOTICETHATHEROLISTCOMPONENTTSIMPORTSOBSERVABLEANDFINALLYWHILEHEROSERVICETSIMPORTSOBSERVABLEOFANDDELAYFROMRXJS",
-    "original": "Notice that `hero-list.component.ts` imports `Observable` and `finally` while `hero.service.ts` imports `Observable`, `of`,\nand `delay` from `rxjs`.",
-    "translation": "注意，`hero-list.component.ts` 从 `rxjs` 中导入了 `Observable` 和 `finally`，而 `hero.service.ts` 导入了 `Observable`、`of` 和 `delay`。",
+    "key": "NOTICETHATHEROLISTCOMPONENTTSIMPORTSOBSERVABLEANDTHEFINALIZEOPERATORWHILEHEROSERVICETSIMPORTSOBSERVABLEOFANDTHEDELAYOPERATORFROMRXJS",
+    "original": "Notice that `hero-list.component.ts` imports `Observable` and the `finalize` operator, while `hero.service.ts` imports `Observable`, `of`, and the `delay` operator from `rxjs`.",
+    "translation": "注意，`hero-list.component.ts` 从 `rxjs` 中导入了 `Observable` 和 `finalize`，而 `hero.service.ts` 导入了 `Observable`、`of` 和 `delay` 操作符。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/reactive-forms.md"
   },
   {
@@ -24696,9 +24948,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/reactive-forms.md"
   },
   {
-    "key": "INHERODETAILCOMPONENTHTMLCHANGEFORMARRAYNAMEADDRESSTOFORMARRAYNAMESECRETLAIRS",
-    "original": "In `hero-detail.component.html` change `formArrayName=\"address\"` to `formArrayName=\"secretLairs\"`.",
-    "translation": "在 `hero-detail.component.html` 中 把 `formArrayName=\"address\"` 改为 `formArrayName=\"secretLairs\"`。",
+    "key": "INHERODETAILCOMPONENTHTMLCHANGEFORMGROUPNAMEADDRESSTOFORMARRAYNAMESECRETLAIRS",
+    "original": "In `hero-detail.component.html` change `formGroupName=\"address\"` to `formArrayName=\"secretLairs\"`.",
+    "translation": "在 `hero-detail.component.html` 中 把 `formGroupName=\"address\"` 改为 `formArrayName=\"secretLairs\"`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/reactive-forms.md"
   },
   {
@@ -25061,6 +25313,318 @@
     "translation": "你可以到<live-example title=\"Reactive Forms Demo in Stackblitz\">响应式表单在线例子</live-example>中下载本章所有步骤的完整代码。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/reactive-forms.md"
   },
+  {
+    "key": "#ANGULARVERSIONINGANDRELEASES",
+    "original": "# Angular versioning and releases",
+    "translation": "# Angular 的版本与发布",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WERECOGNIZETHATYOUNEEDSTABILITYFROMTHEANGULARFRAMEWORKSTABILITYENSURESTHATREUSABLECOMPONENTSANDLIBRARIESTUTORIALSTOOLSANDLEARNEDPRACTICESDONTBECOMEOBSOLETEUNEXPECTEDLYSTABILITYISESSENTIALFORTHEECOSYSTEMAROUNDANGULARTOTHRIVE",
+    "original": "We recognize that you need stability from the Angular framework. Stability ensures that reusable components and libraries, tutorials, tools, and learned practices don't become obsolete unexpectedly. Stability is essential for the ecosystem around Angular to thrive.",
+    "translation": "我们知道你希望 Angular 框架具有稳定性（stability）。稳定性可以确保组件与库、教程、工具和现有实践不会突然被废弃。稳定性是让基于 Angular 的生态系统变得繁荣的基石。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WEALSOSHAREWITHYOUTHEDESIREFORANGULARTOKEEPEVOLVINGWESTRIVETOENSURETHATTHEFOUNDATIONONTOPOFWHICHYOUAREBUILDINGISCONTINUOUSLYIMPROVINGANDENABLINGYOUTOSTAYUPTODATEWITHTHERESTOFTHEWEBECOSYSTEMANDYOURUSERNEEDS",
+    "original": "We also share with you the desire for Angular to keep evolving. We strive to ensure that the foundation on top of which you are building is continuously improving and enabling you to stay up-to-date with the rest of the web ecosystem and your user needs.",
+    "translation": "我们也和你一样希望 Angular 能持续演进。我们会努力确保这些你用于构建应用的基础能得到持续的改进，并让你能及时同步到 Web 生态系统的其它部分的最新进展，用户需求也是一样。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "THISDOCUMENTCONTAINSTHEPRACTICESTHATWEFOLLOWTOPROVIDEYOUWITHALEADINGEDGEAPPDEVELOPMENTPLATFORMBALANCEDWITHSTABILITYWESTRIVETOENSURETHATFUTURECHANGESAREALWAYSINTRODUCEDINAPREDICTABLEWAYWEWANTEVERYONEWHODEPENDSONANGULARTOKNOWWHENANDHOWNEWFEATURESAREADDEDANDTOBEWELLPREPAREDWHENOBSOLETEONESAREREMOVED",
+    "original": "This document contains the practices that we follow to provide you with a leading-edge app development platform, balanced with stability. We strive to ensure that future changes are always introduced in a predictable way. We want everyone who depends on Angular to know when and how new features are added, and to be well-prepared when obsolete ones are removed.",
+    "translation": "本文档包含一些我们所遵循的实践，它让我们能为你提供一个前沿的应用开发平台，同时兼顾稳定性。我们会努力确保将来的变化总是以一种可预期的方式引入。我们希望每个 Angular 用户都明白我们将在何时添加以及如何添加新特性，并且为那些将要移除的、准备废弃的特性提前做好准备。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "SEEUPDATINGYOURPROJECTSGUIDEUPDATINGUPDATINGYOURPROJECTSFORINFORMATIONABOUTHOWTOUPDATEYOURAPPSANDLIBRARIESTOTHELATESTVERSIONOFANGULAR",
+    "original": "See [Updating your projects](guide/updating \"Updating your projects\") for information about how to update your apps and libraries to the latest version of Angular.",
+    "translation": "参见[更新你的项目](guide/updating \"Updating your projects\")，以了解如何把你的应用和库更新到 Angular 的最新版本。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "THEPRACTICESDESCRIBEDINTHISDOCUMENTAPPLYTOANGULAR20ANDLATERIFYOUARECURRENTLYUSINGANGULARJSSEEUPGRADINGFROMANGULARJSGUIDEUPGRADEUPGRADINGFROMANGULARJSANGULARJSISTHENAMEFORALLV1XVERSIONSOFANGULAR",
+    "original": "The practices described in this document apply to Angular 2.0 and later. If you are currently using AngularJS, see [Upgrading from AngularJS](guide/upgrade \"Upgrading from Angular JS\"). _AngularJS_ is the name for all v1.x versions of Angular.",
+    "translation": "本文档中提及的这些实践适用于 Angular 2.0 及以后的版本。如果你正在使用 AngularJS，请参见[从 AngularJS 升级](guide/upgrade \"Upgrading from Angular JS\")。*AngularJS*专指 Angular 所有的 v1.x 版本。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "##ANGULARVERSIONING",
+    "original": "## Angular versioning",
+    "translation": "## Angular 的版本",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "ANGULARVERSIONNUMBERSINDICATETHELEVELOFCHANGESTHATAREINTRODUCEDBYTHERELEASETHISUSEOFSEMANTICVERSIONINGHTTPS:SEMVERORGSEMANTICVERSIONINGSPECIFICATIONHELPSYOUUNDERSTANDTHEPOTENTIALIMPACTOFUPDATINGTOANEWVERSION",
+    "original": "Angular version numbers indicate the level of changes that are introduced by the release. This use of [semantic versioning](https://semver.org/ \"Semantic Versioning Specification\") helps you understand the potential impact of updating to a new version.",
+    "translation": "Angular 的版本号表明本次发布中所引入的变更级别。它使用[语义化版本号](https://semver.org/ \"Semantic Versioning Specification\")来帮助你理解升级到新版本时的潜在影响。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "ANGULARVERSIONNUMBERSHAVETHREEPARTS:MAJORMINORPATCHFOREXAMPLEVERSION529INDICATESMAJORVERSION5MINORVERSION2ANDPATCHVERSION9",
+    "original": "Angular version numbers have three parts: `major.minor.patch`. For example, version 5.2.9 indicates major version 5, minor version 2, and patch version 9.",
+    "translation": "Angular 的版本号包括三个部分：`major.minor.patch`。比如，版本 5.2.9 表示主版本号是 5，小版本号是 2，补丁版本号是 9。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "THEVERSIONNUMBERISINCREMENTEDBASEDONTHELEVELOFCHANGEINCLUDEDINTHERELEASE",
+    "original": "The version number is incremented based on the level of change included in the release.",
+    "translation": "版本号是根据本次发布中包含的变更的级别进行递增的。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "MAJORRELEASESCONTAINSIGNIFICANTNEWFEATURESSOMEBUTMINIMALDEVELOPERASSISTANCEISEXPECTEDDURINGTHEUPDATEWHENUPDATINGTOANEWMAJORRELEASEYOUMAYNEEDTORUNUPDATESCRIPTSREFACTORCODERUNADDITIONALTESTSANDLEARNNEWAPIS",
+    "original": "* Major releases contain significant new features, some but minimal developer assistance is expected during the update. When updating to a new major release, you may need to run update scripts, refactor code, run additional tests, and learn new APIs.",
+    "translation": "主版本包含重要的新特性，其中的部分特性在升级时会需要由开发人员提供少量的协助才能完成。当升级到新的主版本时，你可能需要运行升级脚本、重构代码、运行其它测试以及学习新的 API。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "MINORRELEASESCONTAINNEWSMALLERFEATURESMINORRELEASESAREFULLYBACKWARDCOMPATIBLENODEVELOPERASSISTANCEISEXPECTEDDURINGUPDATEBUTYOUCANOPTIONALLYMODIFYYOURAPPSANDLIBRARIESTOBEGINUSINGNEWAPISFEATURESANDCAPABILITIESTHATWEREADDEDINTHERELEASEWEUPDATEPEERDEPENDENCIESINMINORVERSIONSBYEXPANDINGTHESUPPORTEDVERSIONSBUTWEDONOTREQUIREPROJECTSTOUPDATETHESEDEPENDENCIES",
+    "original": "* Minor releases contain new smaller features. Minor releases are fully backward-compatible; no developer assistance is expected during update, but you can optionally modify your apps and libraries to begin using new APIs, features, and capabilities that were added in the release. We update peer dependencies in minor versions by expanding the supported versions, but we do not require projects to update these dependencies.",
+    "translation": "小版本包含新的小型特性。小版本是完全向后兼容的，在升级期间，不需要开发人员提供协助，但是你可以（可选的）修改你的应用和库，来使用本次发布中新增的 API、特性和能力。我们会扩展平级依赖（peer dependency）中的小版本号范围来更新平级依赖，但并不需要你的项目也更新那些依赖。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "PATCHRELEASESARELOWRISKBUGFIXRELEASESNODEVELOPERASSISTANCEISEXPECTEDDURINGUPDATE",
+    "original": "* Patch releases are low risk, bug fix releases. No developer assistance is expected during update.",
+    "translation": "补丁版本是风险最低的、修 BUG 的版本。在升级期间完全不需要开发人员的协助。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "IFYOUAREUPDATINGWITHINTHESAMEMAJORVERSIONTHENYOUCANSKIPANYINTERMEDIATEVERSIONSANDUPDATEDIRECTLYTOTHETARGETEDVERSIONFOREXAMPLEIFYOUWANTTOUPDATEFROM500TO529THENYOUCANUPDATEDIRECTLYYOUDONOTNEEDTOUPDATEFROM500TO510BEFOREUPDATINGTO529",
+    "original": "If you are updating within the same major version, then you can skip any intermediate versions and update directly to the targeted version. For example, if you want to update from 5.0.0 to 5.2.9, then you can update directly; you do not need to update from 5.0.0 to 5.1.0 before updating to 5.2.9.",
+    "translation": "如果你正在同一个主版本内进行升级，那么你可以跳过任何中间版本，直接升级到目标版本。比如，如果你想从 5.0.0 升级到 5.2.9，那么你可以直接升级，而不用先升级到 5.1.0 再升级到 5.2.9。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "IFYOUAREUPDATINGFROMONEMAJORVERSIONTOANOTHERTHENWERECOMMENDTHATYOUDONTSKIPMAJORVERSIONSFOLLOWTHEINSTRUCTIONSTOINCREMENTALLYUPDATETOTHENEXTMAJORVERSIONTESTINGANDVALIDATINGATEACHSTEPFOREXAMPLEIFYOUWANTTOUPDATEFROMVERSION4XXTOVERSION6XXWERECOMMENDTHATYOUUPDATETOTHELATEST5XXRELEASEFIRSTAFTERSUCCESSFULLYUPDATINGTO5XXYOUCANTHENUPDATETO6XX",
+    "original": "If you are updating from one major version to another, then we recommend that you don't skip major versions. Follow the instructions to incrementally update to the next major version, testing and validating at each step. For example, if you want to update from version 4.x.x to version 6.x.x, we recommend that you update to the latest 5.x.x release first. After successfully updating to 5.x.x, you can then update to 6.x.x.",
+    "translation": "如果你要从一个主版本升级到另一个，那么我们建议你不要跳过主版本。要遵循升级指南，逐次升级到下一个主版本，在每一个步骤做完后都测试并验证一下。比如，如果你要从 4.x.x 升级到 6.x.x，我们建议你先升级到 5.x.x 中的最新版。在成功升级到 5.x.x 后，你就可以升级到 6.x.x 了。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "PRERELEASEPREVIEWSMDASHSUCHASBETAANDRELEASECANDIDATEVERSIONSMDASHAREINDICATEDBYAPPENDINGADASHANDABETAORRCIDENTIFIERSUCHASVERSION529RC3",
+    "original": "Pre-release previews&mdash;such as Beta and Release Candidate versions&mdash;are indicated by appending a dash and a beta or rc identifier, such as version 5.2.9-rc.3.",
+    "translation": "预发布的预览版（比如 Beta 和 RC 版本）会在版本号后面跟一个横线，再跟一个 beta 或 rc 标识，比如 5.2.9-rc.3。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "##RELEASEFREQUENCY",
+    "original": "## Release frequency",
+    "translation": "## 发布频率",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WEWORKTOWARDAREGULARSCHEDULEOFRELEASESSOTHATYOUCANPLANANDCOORDINATEYOURUPDATESWITHTHECONTINUINGEVOLUTIONOFANGULAR",
+    "original": "We work toward a regular schedule of releases, so that you can plan and coordinate your updates with the continuing evolution of Angular.",
+    "translation": "我们会定期发布新版本，以便随着 Angular 的不断演进，你可以提前计划并协调这些升级工作。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "INGENERALYOUCANEXPECTTHEFOLLOWINGRELEASECYCLE:",
+    "original": "In general, you can expect the following release cycle:",
+    "translation": "通常，你可以期待下列发布周期：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "AMAJORRELEASEEVERY6MONTHS",
+    "original": "* A major release every 6 months",
+    "translation": "每 6 个月一个主版本",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "13MINORRELEASESFOREACHMAJORRELEASE",
+    "original": "* 1-3 minor releases for each major release",
+    "translation": "每个主版本中包含 1~3 个小版本",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "APATCHRELEASEALMOSTEVERYWEEK",
+    "original": "* A patch release almost every week",
+    "translation": "差不多每周一个补丁版本",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WEBAKEQUALITYINTOOURRELEASESMDASHANDLETYOUPREVIEWWHATSCOMINGNEXTMDASHBYPROVIDINGBETARELEASESANDRELEASECANDIDATESRCSFOREACHMAJORANDMINORRELEASE",
+    "original": "We bake quality into our releases&mdash;and let you preview what's coming next&mdash;by providing Beta releases and release candidates (RCs) for each major and minor release.",
+    "translation": "我们会通过为每个主版本和小版本提供 Beta 发布和 RC 发布，来提高这些发布的质量，并且让你可以预览未来的特性。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "THISCADENCEOFRELEASESGIVESYOUACCESSTONEWBETAFEATURESASSOONASTHEYAREREADYWHILEMAINTAININGTHESTABILITYANDRELIABILITYOFTHEPLATFORMFORPRODUCTIONUSERS",
+    "original": "This cadence of releases gives you access to new beta features as soon as they are ready, while maintaining the stability and reliability of the platform for production users.",
+    "translation": "这种发布节奏可以让你可以通过 beta 版提前使用新特性，同时，为生产环境下的用户维护本平台的稳定性和可靠性。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "##RELEASESCHEDULE",
+    "original": "## Release schedule",
+    "translation": "## 发布计划",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "DISCLAIMER:THEDATESAREOFFEREDASGENERALGUIDANCEANDMAYBEADJUSTEDBYUSWHENNECESSARYTOENSUREDELIVERYOFAHIGHQUALITYPLATFORM",
+    "original": "Disclaimer: The dates are offered as general guidance and may be adjusted by us when necessary to ensure delivery of a high-quality platform.",
+    "translation": "免责声明：这些日期只是作为一般性的指导，在必要时我们会进行调整，以确保始终提供高质量的平台。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "THEFOLLOWINGTABLECONTAINSOURCURRENTTARGETRELEASEDATESFORTHENEXTTWOMAJORVERSIONSOFANGULAR:",
+    "original": "The following table contains our current target release dates for the next two major versions of Angular:",
+    "translation": "下表中包含下面两个 Angular 主版本的目标发布日期：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "DATESTABLERELEASECOMPATIBILITYSEPTEMBEROCTOBER2018700600MARCHAPRIL2019800700",
+    "original": "Date | Stable Release | Compatibility\n ---------------------- | -------------- | ----------------\n September/October 2018 | 7.0.0 | ^6.0.0\n March/April 2019 | 8.0.0 | ^7.0.0",
+    "translation": "<t>Date</t><t>日期</t>  | <t>Stable Release</t><t>稳定版</t> | <t>Compatibility</t><t>兼容性</t>\n ---------------------- | -------------- | ----------------\n <t>September/October 2018</t><t>2018-09/10</t> | 7.0.0          | ^6.0.0\n <t>March/April 2019</t><t>2019-03/04</t>       | 8.0.0          | ^7.0.0",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "COMPATIBLITYNOTE:THEPRIMARYGOALOFTHEBACKWARDSCOMPATIBILITYPROMISEISTOENSURETHATCHANGESINTHECOREFRAMEWORKANDTOOLINGDONTBREAKTHEEXISTINGECOSYSTEMOFCOMPONENTSANDAPPLICATIONSANDDONTPUTUNDUEUPGRADEMIGRATIONBURDENONANGULARAPPLICATIONANDCOMPONENTAUTHORS",
+    "original": "Compatiblity note: The primary goal of the backwards compatibility promise is to ensure that changes in the core framework and tooling don't break the existing ecosystem of components and applications and don't put undue upgrade/migration burden on Angular application and component authors.",
+    "translation": "兼容性说明：向后兼容性承诺的主要目标是确保在核心框架和核心工具中的变化不会破坏现有组件和应用的生态系统，并且不要给 Angular 应用和组件的开发者带来额外的升级/迁移负担。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "##LONGTERMSUPPORT",
+    "original": "## Long-term support",
+    "translation": "## 长期支持",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "ALLOFOURRELEASESARESUPPORTEDACTIVELYFORABOUT6MONTHSUNTILTHENEXTMAJORRELEASEANDTHENTHEYARESUPPORTEDTHROUGHLONGTERMSUPPORTLTSFORANOTHER12MONTHS",
+    "original": "All of our releases are supported actively for about 6 months (until the next major release), and then they are supported through long-term support (LTS) for another 12 months.",
+    "translation": "我们所有的主版本都会提供大约 6 个月的活跃支持（直到下一个主版本发布），之后再额外提供 12 个月的长期支持（LTS）。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "DURINGTHELTSPERIODONLYCRITICALFIXESANDSECURITYPATCHESWILLBEMERGEDANDRELEASED",
+    "original": "During the LTS period, only critical fixes and security patches will be merged and released.",
+    "translation": "在 LTS 期间，只会合并及发布那些至关重要的 BUG 修复和安全补丁。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "THELTSSTATEOFONEMAJORVERSIONSTARTSONTHEDAYOFTHENEXTMAJORRELEASELTSSTATUSENDSAPPROXIMATELYONEYEARLATERWHENWERELEASEANOTHERMAJORVERSION",
+    "original": "The LTS state of one major version starts on the day of the next major release. LTS status ends approximately one year later, when we release another major version.",
+    "translation": "每个主版本的 LTS 状态都从下一个主版本发布之日起算。LTS 状态大约会在一年后的另一个主版本发布时结束。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "VERSIONLTSSTARTDATELTSENDDATE400OCTOBER2017OCTOBER2018500APRIL2018APRIL2019600OCTOBER2018OCTOBER2019",
+    "original": "Version | LTS Start Date | LTS End Date\n ----------- | -------------- | ------------\n ^4.0.0 | October 2017 | October 2018\n ^5.0.0 | April 2018 | April 2019\n ^6.0.0 | October 2018 | October 2019",
+    "translation": "<t>Version</t><t>版本</t>     | <t>LTS Start Date</t><t>LTS 起始日期</t> | <t>LTS End Date</t><t>LTS 结束日期</t>\n ----------- | -------------- | ------------\n ^4.0.0      | <t>October 2017</t><t>2017-10</t> | <t>October 2018</t><t>2018-10</t>\n ^5.0.0      | <t>April 2018</t><t>2018-04</t> | <t>April 2019</t><t>2019-04</t>\n ^6.0.0      | <t>October 2018</t><t>2018-10</t> | <t>October 2019</t><t>2019-10</t>",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "##DEPRECATIONPRACTICES",
+    "original": "## Deprecation practices",
+    "translation": "## 弃用策略",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "SOMETIMESQUOTBREAKINGCHANGESQUOTSUCHASTHEREMOVALOFSUPPORTFORSELECTAPISANDFEATURESARENECESSARYTOINNOVATEANDSTAYCURRENTWITHNEWBESTPRACTICESCHANGINGDEPENDENCIESORCHANGESINTHEWEBPLATFORMITSELF",
+    "original": "Sometimes &quot;breaking changes&quot;, such as the removal of support for select APIs and features, are necessary to innovate and stay current with new best practices, changing dependencies, or changes in the (web) platform itself.",
+    "translation": "\"破坏性变更\"（比如移除特定的 API 和特性）有时候是必须的，比如创新、让最佳实践与时俱进、变更依赖关系甚至来自 Web 平台自身的变化。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "TOMAKETHESETRANSITIONSASEASYASPOSSIBLEWEMAKETWOCOMMITMENTSTOYOU:",
+    "original": "To make these transitions as easy as possible, we make two commitments to you:",
+    "translation": "要让这些转变尽可能的简单，我们会给你两项保证：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WEWORKHARDTOMINIMIZETHENUMBEROFBREAKINGCHANGESANDTOPROVIDEMIGRATIONTOOLSWHENPOSSIBLE",
+    "original": "* We work hard to minimize the number of breaking changes and to provide migration tools when possible.",
+    "translation": "我们会尽量减少破坏性变更的数量，并尽可能提供迁移工具。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WEFOLLOWTHEDEPRECATIONPOLICYDESCRIBEDHERESOYOUHAVETIMETOUPDATEYOURAPPSTOTHELATESTAPISANDBESTPRACTICES",
+    "original": "* We follow the deprecation policy described here, so you have time to update your apps to the latest APIs and best practices.",
+    "translation": "我们会遵循这里所讲的弃用策略，让你有时间把应用升级到最新的 API 和最佳实践。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "TOHELPENSURETHATYOUHAVESUFFICIENTTIMEANDACLEARPATHTOUPDATETHISISOURDEPRECATIONPOLICY:",
+    "original": "To help ensure that you have sufficient time and a clear path to update, this is our deprecation policy:",
+    "translation": "为了保证你能有充足的时间和清晰的路径进行升级，我们制定了如下弃用策略：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WHENANNOUNCEDEPRECATEDFEATURESINTHECHANGELOGHTTPS:GITHUBCOMANGULARANGULARBLOBMASTERCHANGELOGMDANGULARCHANGELOG",
+    "original": "* When announce deprecated features in the [change log](https://github.com/angular/angular/blob/master/CHANGELOG.md \"Angular change log\").",
+    "translation": "当在[变更记录](https://github.com/angular/angular/blob/master/CHANGELOG.md \"Angular change log\")中宣布了准备弃用的特性时。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WHENWEANNOUNCEADEPRECATIONWEALSOANNOUNCEARECOMMENDEDUPDATEPATH",
+    "original": "* When we announce a deprecation, we also announce a recommended update path.",
+    "translation": "当我们宣布一项弃用时，我们也会同时宣布建议的升级路径。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WESUPPORTEXISTINGUSEOFASTABLEAPIDURINGTHEDEPRECATIONPERIODSOYOURCODEWILLKEEPWORKINGDURINGTHATPERIOD",
+    "original": "* We support existing use of a stable API during the deprecation period, so  your code will keep working during that period.",
+    "translation": "我们会在弃用期间支持使用现有的稳定 API，所以在此期间你的代码仍然能正常工作。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WESUPPORTEACHDEPRECATEDAPIFORATLEASTTWOSUBSEQUENTMAJORRELEASESWHICHMEANSATLEAST12MONTHSAFTERDEPRECATION",
+    "original": "* We support each deprecated API for at least two subsequent major releases, which means at least 12 months after deprecation.",
+    "translation": "我们会支持每个弃用的 API 至少连续两个主版本，这意味着在弃用之前至少有 12 个月的时间。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "WEONLYMAKEPEERDEPENDENCYUPDATESTHATREQUIRECHANGESTOYOURAPPSINAMAJORRELEASEINMINORRELEASESWEUPDATEPEERDEPENDENCIESBYEXPANDINGTHESUPPORTEDVERSIONSBUTWEDONOTREQUIREPROJECTSTOUPDATETHESEDEPENDENCIESUNTILAFUTUREMAJORVERSION",
+    "original": "* We only make peer dependency updates that require changes to your apps in a major release. In minor releases, we update peer dependencies by expanding the supported versions, but we do not require projects to update these dependencies until a future major version.",
+    "translation": "我们只会在主版本中更新你的应用所需的平级依赖。在小版本中，我们通过扩展支持的版本来升级平级依赖。但是我们不需要项目也更新这些依赖 —— 直到下一个主版本为止。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "##PUBLICAPISURFACE",
+    "original": "## Public API surface",
+    "translation": "## 公共 API",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "ANGULARISACOLLECTIONOFMANYPACKAGESSUBPROJECTSANDTOOLSTOPREVENTACCIDENTALUSEOFPRIVATEAPISMDASHANDSOTHATYOUCANCLEARLYUNDERSTANDWHATISCOVEREDBYTHEPRACTICESDESCRIBEDHEREMDASHWEDOCUMENTWHATISANDISNOTCONSIDEREDOURPUBLICAPISURFACEFORDETAILSSEESUPPORTEDPUBLICAPISURFACEOFANGULARHTTPS:GITHUBCOMANGULARANGULARBLOBMASTERDOCSPUBLICAPIMDSUPPORTEDPUBLICAPISURFACEOFANGULAR",
+    "original": "Angular is a collection of many packages, sub-projects, and tools. To prevent accidental use of private APIs&mdash;and so that you can clearly understand what is covered by the practices described here&mdash;we document what is and is not considered our public API surface. For details, see [Supported Public API Surface of Angular](https://github.com/angular/angular/blob/master/docs/PUBLIC_API.md \"Supported Public API Surface of Angular\").",
+    "translation": "Angular 是很多包、子项目和工具的集合。为了防止你意外使用私有 API（这样你才能更清楚的理解哪些 API 会被这里所说的实践所覆盖），我们对公开 API 包含以及不包含哪些 API 进行了文档化。要了解详情，参见 [Angular 的公共 API](https://github.com/angular/angular/blob/master/docs/PUBLIC_API.md \"Supported Public API Surface of Angular\")。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "ANYCHANGESTOTHEPUBLICAPISURFACEWILLBEDONEUSINGTHEVERSIONINGSUPPORTANDDEPRECIATIONPOLICIESDESCRIBEABOVE",
+    "original": "Any changes to the public API surface will be done using the versioning, support, and depreciation policies describe above.",
+    "translation": "任何对公共 API 的修改都适用于上述这些版本、支持和弃用策略。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "##ANGULARLABS",
+    "original": "## Angular Labs",
+    "translation": "## Angular 实验室（Labs）",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "ANGULARLABSISANINITIATIVETOCULTIVATENEWFEATURESANDITERATEONTHEMQUICKLYANGULARLABSPROVIDESASAFEPLACEFOREXPLORATIONANDEXPERIMENTATIONBYTHEANGULARTEAM",
+    "original": "Angular Labs is an initiative to cultivate new features and iterate on them quickly. Angular Labs provides a safe place for exploration and experimentation by the Angular team.",
+    "translation": "Angular 实验室是一项旨在试验新特性并快速迭代它们的尝试。Angular 实验室为 Angular 团队提供了一个探索和试验的安全场所。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "ANGULARLABSPROJECTSAREARENOTREADYFORPRODUCTIONUSEANDNOCOMMITMENTISMADETOBRINGTHEMTOPRODUCTIONTHEPOLICIESANDPRACTICESTHATAREDESCRIBEDINTHISDOCUMENTDONOTAPPLYTOANGULARLABSPROJECTS",
+    "original": "Angular Labs projects are are not ready for production use, and no commitment is made to bring them to production. The policies and practices that are described in this document do not apply to Angular Labs projects.",
+    "translation": "Angular 实验室项目尚未准备好供产品环境使用，并且没有任何会把它们带入到产品环境的承诺。本文档中描述的这些策略和实践都不适用于 Angular 实验室中的项目。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
+  {
+    "key": "ANGULARLABSPROJECTSTYPICALLYAREINSEPARATEBRANCHESINTHEANGULARREPOCLEARLYSEPARATEDFROMTHEMAINANGULARCODEBASE",
+    "original": "Angular Labs projects typically are in separate branches in the Angular repo, clearly separated from the main Angular codebase.",
+    "translation": "典型的 Angular 实验室项目都位于 Angular 仓库的独立分支中，会从 Angular 主代码库中明确分离出来。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/releases.md"
+  },
   {
     "key": "#ROUTINGNAVIGATION",
     "original": "# Routing & Navigation",
@@ -25393,13 +25957,13 @@
   },
   {
     "key": "PARAMSMDASHANOBSERVABLETHATCONTAINSTHEREQUIREDANDOPTIONALPARAMETERS#OPTIONALROUTEPARAMETERSSPECIFICTOTHEROUTEUSEPARAMMAPINSTEAD",
-    "original": "**`params`** &mdash; An `Observable` that contains the required and [optional parameters](#optional-route-parameters) specific to the route. Use `paramMap` instead.",
+    "original": "**`params`**&mdash;An `Observable` that contains the required and [optional parameters](#optional-route-parameters) specific to the route. Use `paramMap` instead.",
     "translation": "**`params`** —— 一个 `Observable` 对象，其中包含当前路由的必要参数和[可选参数](#optional-route-parameters)。请改用 `paramMap`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/router.md"
   },
   {
     "key": "QUERYPARAMSMDASHANOBSERVABLETHATCONTAINSTHEQUERYPARAMETERS#QUERYPARAMETERSAVAILABLETOALLROUTESUSEQUERYPARAMMAPINSTEAD",
-    "original": "**`queryParams`** &mdash; An `Observable` that contains the [query parameters](#query-parameters) available to all routes.\nUse `queryParamMap` instead.",
+    "original": "**`queryParams`**&mdash;An `Observable` that contains the [query parameters](#query-parameters) available to all routes.\nUse `queryParamMap` instead.",
     "translation": "**`queryParams`** —— 一个 `Observable` 对象，其中包含对所有路由都有效的[查询参数](#query-parameters)。请改用 `queryParamMap`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/router.md"
   },
@@ -26791,7 +27355,7 @@
   },
   {
     "key": "EACHROUTINGMODULEAUGMENTSTHEROUTECONFIGURATIONINTHEORDEROFIMPORTIFYOULISTAPPROUTINGMODULEFIRSTTHEWILDCARDROUTEWILLBEREGISTEREDBEFORETHEHEROROUTESTHEWILDCARDROUTEMDASHWHICHMATCHESEVERYURLMDASHWILLINTERCEPTTHEATTEMPTTONAVIGATETOAHEROROUTE",
-    "original": "Each routing module augments the route configuration _in the order of import_.\nIf you list `AppRoutingModule` first, the wildcard route will be registered\n_before_ the hero routes.\nThe wildcard route &mdash; which matches _every_ URL &mdash;\nwill intercept the attempt to navigate to a hero route.",
+    "original": "Each routing module augments the route configuration _in the order of import_.\nIf you list `AppRoutingModule` first, the wildcard route will be registered\n_before_ the hero routes.\nThe wildcard route&mdash;which matches _every_ URL&mdash;will intercept the attempt to navigate to a hero route.",
     "translation": "每个路由模块都会根据*导入的顺序*把自己的路由配置追加进去。\n如果你先列出了 `AppRoutingModule`，那么通配符路由就会被注册在“英雄管理”路由*之前*。\n通配符路由（它匹配*任意*URL）将会拦截住每一个到“英雄管理”路由的导航，因此事实上屏蔽了所有“英雄管理”路由。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/router.md"
   },
@@ -27211,7 +27775,7 @@
   },
   {
     "key": "THEOPTIONALROUTEPARAMETERSARENOTSEPARATEDBYANDASTHEYWOULDBEINTHEURLQUERYSTRINGTHEYARESEPARATEDBYSEMICOLONSTHISISMATRIXURLNOTATIONMDASHSOMETHINGYOUMAYNOTHAVESEENBEFORE",
-    "original": "The optional route parameters are not separated by \"?\" and \"&\" as they would be in the URL query string.\nThey are **separated by semicolons \";\"**\nThis is *matrix URL* notation &mdash; something you may not have seen before.",
+    "original": "The optional route parameters are not separated by \"?\" and \"&\" as they would be in the URL query string.\nThey are **separated by semicolons \";\"**\nThis is *matrix URL* notation&mdash;something you may not have seen before.",
     "translation": "可选的路由参数没有使用“？”和“&”符号分隔，因为它们将用在 URL 查询字符串中。\n它们是**用“;”分隔的**。\n这是*矩阵 URL*标记法 —— 你以前可能从未见过。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/router.md"
   },
@@ -28429,7 +28993,7 @@
   },
   {
     "key": "ALTHOUGHITDOESNTACTUALLYLOGINITHASWHATYOUNEEDFORTHISDISCUSSIONITHASANISLOGGEDINFLAGTOTELLYOUWHETHERTHEUSERISAUTHENTICATEDITSLOGINMETHODSIMULATESANAPICALLTOANEXTERNALSERVICEBYRETURNINGANOBSERVABLETHATRESOLVESSUCCESSFULLYAFTERASHORTPAUSETHEREDIRECTURLPROPERTYWILLSTORETHEATTEMPTEDURLSOYOUCANNAVIGATETOITAFTERAUTHENTICATING",
-    "original": "Although it doesn't actually log in, it has what you need for this discussion.\nIt has an `isLoggedIn` flag to tell you whether the user is authenticated.\nIts `login` method simulates an API call to an external service by returning an\nObservable that resolves successfully after a short pause.\nThe `redirectUrl` property will store the attempted URL so you can navigate to it after authenticating.",
+    "original": "Although it doesn't actually log in, it has what you need for this discussion.\nIt has an `isLoggedIn` flag to tell you whether the user is authenticated.\nIts `login` method simulates an API call to an external service by returning an\nobservable that resolves successfully after a short pause.\nThe `redirectUrl` property will store the attempted URL so you can navigate to it after authenticating.",
     "translation": "虽然它不会真的进行登录，但足够让你进行这个讨论了。\n它有一个 `isLoggedIn` 标志，用来标识是否用户已经登录过了。\n它的 `login` 方法会仿真一个对外部服务的 API 调用，返回一个可观察对象（observable）。在短暂的停顿之后，这个可观察对象就会解析成功。\n`redirectUrl` 属性将会保存在 URL 中，以便认证完之后导航到它。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/router.md"
   },
@@ -28746,9 +29310,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/router.md"
   },
   {
-    "key": "THECRISISSERVICEGETCRISISMETHODRETURNSANOBSERVABLERETURNTHATOBSERVABLETOPREVENTTHEROUTEFROMLOADINGUNTILTHEDATAISFETCHEDTHEROUTERGUARDSREQUIREANOBSERVABLETOCOMPLETEMEANINGITHASEMITTEDALLOFITSVALUESYOUUSETHETAKEOPERATORWITHANARGUMENTOF1TOENSURETHATTHEOBSERVABLECOMPLETESAFTERRETRIEVINGTHEFIRSTVALUEFROMTHEOBSERVABLERETURNEDBYTHEGETCRISISMETHODIFITDOESNTRETURNAVALIDCRISISNAVIGATETHEUSERBACKTOTHECRISISLISTCOMPONENTCANCELINGTHEPREVIOUSINFLIGHTNAVIGATIONTOTHECRISISDETAILCOMPONENT",
-    "original": "The `CrisisService.getCrisis` method returns an Observable.\nReturn that observable to prevent the route from loading until the data is fetched.\nThe `Router` guards require an Observable to `complete`, meaning it has emitted all\nof its values. You use the `take` operator with an argument of `1` to ensure that the\nObservable completes after retrieving the first value from the Observable returned by the\n`getCrisis` method.\nIf it doesn't return a valid `Crisis`, navigate the user back to the `CrisisListComponent`,\ncanceling the previous in-flight navigation to the `CrisisDetailComponent`.",
-    "translation": "`CrisisService.getCrisis` 方法返回了一个 `Promise`。\n返回 `Promise` 可以阻止路由被加载，直到数据获取完毕。\n如果它没有返回一个有效的 `Crisis`，就把用户导航回 `CrisisListComponent`，并取消以前到 `CrisisDetailComponent` 尚未完成的导航。",
+    "key": "THECRISISSERVICEGETCRISISMETHODRETURNSANOBSERVABLEINORDERTOPREVENTTHEROUTEFROMLOADINGUNTILTHEDATAISFETCHEDTHEROUTERGUARDSREQUIREANOBSERVABLETOCOMPLETEMEANINGITHASEMITTEDALLOFITSVALUESYOUUSETHETAKEOPERATORWITHANARGUMENTOF1TOENSURETHATTHEOBSERVABLECOMPLETESAFTERRETRIEVINGTHEFIRSTVALUEFROMTHEOBSERVABLERETURNEDBYTHEGETCRISISMETHODIFITDOESNTRETURNAVALIDCRISISNAVIGATETHEUSERBACKTOTHECRISISLISTCOMPONENTCANCELINGTHEPREVIOUSINFLIGHTNAVIGATIONTOTHECRISISDETAILCOMPONENT",
+    "original": "The `CrisisService.getCrisis` method returns an observable, in order to prevent the route from loading until the data is fetched.\nThe `Router` guards require an observable to `complete`, meaning it has emitted all\nof its values. You use the `take` operator with an argument of `1` to ensure that the\nobservable completes after retrieving the first value from the observable returned by the\n`getCrisis` method. If it doesn't return a valid `Crisis`, navigate the user back to the `CrisisListComponent`,\ncanceling the previous in-flight navigation to the `CrisisDetailComponent`.",
+    "translation": "`CrisisService.getCrisis` 方法返回了一个可观察对象，这是为了防止在数据获取完毕前加载路由。\n如果它没有返回一个有效的 `Crisis`，就把用户导航回 `CrisisListComponent`，并取消以前到 `CrisisDetailComponent` 尚未完成的导航。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/router.md"
   },
   {
@@ -28789,7 +29353,7 @@
   },
   {
     "key": "1THEOBSERVABLEPROVIDEDTOTHEROUTERMUSTCOMPLETEIFTHEOBSERVABLEDOESNOTCOMPLETETHENAVIGATIONWILLNOTCONTINUE",
-    "original": "1. The Observable provided to the Router _must_ complete.\nIf the Observable does not complete, the navigation will not continue.",
+    "original": "1. The observable provided to the Router _must_ complete.\nIf the observable does not complete, the navigation will not continue.",
     "translation": "由路由器提供的 Observable *必须* 完成（complete），否则导航不会继续。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/router.md"
   },
@@ -29275,7 +29839,7 @@
   },
   {
     "key": "ANIMPLEMENTATIONOFPRELOADMUSTRETURNANOBSERVABLEIFTHEROUTESHOULDPRELOADITRETURNSTHEOBSERVABLERETURNEDBYCALLINGTHELOADERFUNCTIONIFTHEROUTESHOULDNOTPRELOADITRETURNSANOBSERVABLEOFNULL",
-    "original": "An implementation of `preload`must return an `Observable`.\nIf the route should preload, it returns the observable returned by calling the loader function.\nIf the route should _not_ preload, it returns an `Observable` of `null`.",
+    "original": "An implementation of `preload` must return an `Observable`.\nIf the route should preload, it returns the observable returned by calling the loader function.\nIf the route should _not_ preload, it returns an `Observable` of `null`.",
     "translation": "`preload` 的实现必须返回一个 `Observable`。\n如果该路由应该预加载，它就会返回调用加载器函数所返回的 `Observable`。\n如果该路由*不*应该预加载，它就返回一个 `null` 值的 `Observable` 对象。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/router.md"
   },
@@ -30541,7 +31105,7 @@
   },
   {
     "key": "THESRCNGSWCONFIGJSONCONFIGURATIONFILESPECIFIESWHICHFILESANDDATAURLSTHEANGULARSERVICEWORKERSHOULDCACHEANDHOWITSHOULDUPDATETHECACHEDFILESANDDATATHECLIPROCESSESTHECONFIGURATIONFILEDURINGNGBUILDPRODMANUALLYYOUCANPROCESSITWITHTHENGSWCONFIGTOOL:",
-    "original": "The `src/ngsw-config.json` configuration file specifies which files and data URLs the Angular \nservice worker should cache and how it should update the cached files and data. The \nCLI processes the configuration file during `ng build --prod`. Manually, you can process \nit with the `ngsw-config` tool:",
+    "original": "The `src/ngsw-config.json` configuration file specifies which files and data URLs the Angular\nservice worker should cache and how it should update the cached files and data. The\nCLI processes the configuration file during `ng build --prod`. Manually, you can process\nit with the `ngsw-config` tool:",
     "translation": "配置文件 `src/ngsw-config.json` 指定了 Angular Service Worker 应该缓存哪些文件和数据的 URL，以及如何更新缓存的文件和数据。\nCLI 会在 `ng build --prod` 期间处理配置文件。\n如果想手动处理，你可以使用 `ngsw-config` 工具：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
@@ -30552,9 +31116,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
   {
-    "key": "PATTERNSUSEALIMITEDGLOBFORMAT:",
-    "original": "Patterns use a limited glob format:",
-    "translation": "它的模式使用受限的 glob 格式：",
+    "key": "UNLESSOTHERWISENOTEDPATTERNSUSEALIMITEDGLOBFORMAT:",
+    "original": "Unless otherwise noted, patterns use a limited glob format:",
+    "translation": "如无特别说明，这些模式都使用受限的 glob 格式：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
   {
@@ -30564,9 +31128,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
   {
-    "key": "MATCHESEXACTLYONEPATHSEGMENTORFILENAMESEGMENT",
-    "original": "* `*` matches exactly one path segment or filename segment.",
-    "translation": "`*` 只匹配一段路径或文件名。",
+    "key": "MATCHES0ORMORECHARACTERSEXCLUDING",
+    "original": "* `*` matches 0 or more characters excluding `/`.",
+    "translation": "`*` 匹配 0 个或更多个除 `/` 之外的字符。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
   {
@@ -30702,9 +31266,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
   {
-    "key": "URLSINCLUDESBOTHURLSANDURLPATTERNSTHATWILLBEMATCHEDATRUNTIMETHESERESOURCESARENOTFETCHEDDIRECTLYANDDONOTHAVECONTENTHASHESBUTTHEYWILLBECACHEDACCORDINGTOTHEIRHTTPHEADERSTHISISMOSTUSEFULFORCDNSSUCHASTHEGOOGLEFONTSSERVICE",
-    "original": "* `urls` includes both URLs and URL patterns that will be matched at runtime. These resources are not fetched directly and do not have content hashes, but they will be cached according to their HTTP headers. This is most useful for CDNs such as the Google Fonts service.",
-    "translation": "`urls` 包括要在运行时进行匹配的 URL 和 URL 模式。\n  这些资源不是直接获取的，也没有内容散列，但它们会根据 HTTP 标头进行缓存。\n  这对于像 Google Fonts 服务这样的 CDN 非常有用。",
+    "key": "URLSINCLUDESBOTHURLSANDURLPATTERNSTHATWILLBEMATCHEDATRUNTIMETHESERESOURCESARENOTFETCHEDDIRECTLYANDDONOTHAVECONTENTHASHESBUTTHEYWILLBECACHEDACCORDINGTOTHEIRHTTPHEADERSTHISISMOSTUSEFULFORCDNSSUCHASTHEGOOGLEFONTSSERVICEBRNEGATIVEGLOBPATTERNSARENOTSUPPORTED",
+    "original": "* `urls` includes both URLs and URL patterns that will be matched at runtime. These resources are not fetched directly and do not have content hashes, but they will be cached according to their HTTP headers. This is most useful for CDNs such as the Google Fonts service.<br>\n  _(Negative glob patterns are not supported.)_",
+    "translation": "`urls` 包括要在运行时进行匹配的 URL 和 URL 模式。\n  这些资源不是直接获取的，也没有内容散列，但它们会根据 HTTP 标头进行缓存。\n  这对于像 Google Fonts 服务这样的 CDN 非常有用。<br>\n  **（不支持 glob 的逆模式）**",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
   {
@@ -30726,9 +31290,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
   {
-    "key": "ALISTOFURLPATTERNSURLSTHATMATCHTHESEPATTERNSWILLBECACHEDACCORDINGTOTHISDATAGROUPSPOLICY",
-    "original": "A list of URL patterns. URLs that match these patterns will be cached according to this data group's policy.",
-    "translation": "一个 URL 模式的列表。匹配这些模式的 URL 将会根据该数据组的策略进行缓存。",
+    "key": "ALISTOFURLPATTERNSURLSTHATMATCHTHESEPATTERNSWILLBECACHEDACCORDINGTOTHISDATAGROUPSPOLICYBRNEGATIVEGLOBPATTERNSARENOTSUPPORTED",
+    "original": "A list of URL patterns. URLs that match these patterns will be cached according to this data group's policy.<br>\n  _(Negative glob patterns are not supported.)_",
+    "translation": "一个 URL 模式的列表。匹配这些模式的 URL 将会根据该数据组的策略进行缓存。<br>\n  **（不支持 glob 中的逆模式）**",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
   {
@@ -30827,6 +31391,90 @@
     "translation": "`freshness` 为数据的即时性而优化，优先从网络获取请求的数据。只有当网络超时时，请求才会根据 `timeout` 的设置回退到缓存中。这对于那些频繁变化的资源很有用，例如账户余额。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
   },
+  {
+    "key": "THISOPTIONALSECTIONENABLESYOUTOSPECIFYACUSTOMLISTOFURLSTHATWILLBEREDIRECTEDTOTHEINDEXFILE",
+    "original": "This optional section enables you to specify a custom list of URLs that will be redirected to the index file.",
+    "translation": "这个可选节让你可以指定一个自定义的 URL 列表，它们都会被重定向到索引文件。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "###HANDLINGNAVIGATIONREQUESTS",
+    "original": "### Handling navigation requests",
+    "translation": "### 处理导航请求",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "THESERVICEWORKERWILLREDIRECTNAVIGATIONREQUESTSTHATDONTMATCHANYASSETORDATAGROUPTOTHESPECIFIEDINDEXFILE#INDEXFILEAREQUESTISCONSIDEREDTOBEANAVIGATIONREQUESTIF:",
+    "original": "The ServiceWorker will redirect navigation requests that don't match any `asset` or `data` group to the specified [index file](#index-file). A request is considered to be a navigation request if:",
+    "translation": "对于没有匹配上任何 `asset` 或 `data` 组的导航请求，ServiceWorker 会把它们重定向到指定的[索引文件](#index-file)。下列请求将会视为导航请求：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "1ITSMODEHTTPS:DEVELOPERMOZILLAORGENUSDOCSWEBAPIREQUESTMODEISNAVIGATION",
+    "original": "1. Its [mode](https://developer.mozilla.org/en-US/docs/Web/API/Request/mode) is `navigation`.",
+    "translation": "它的[模式](https://developer.mozilla.org/en-US/docs/Web/API/Request/mode)是 `navigation`。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "2ITACCEPTSATEXTHTMLRESPONSEASDETERMINEDBYTHEVALUEOFTHEACCEPTHEADER",
+    "original": "2. It accepts a `text/html` response (as determined by the value of the `Accept` header).",
+    "translation": "它接受 `text/html` 响应（根据 `Accept` 头的值决定）。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "3ITSURLMATCHESCERTAINCRITERIASEEBELOW",
+    "original": "3. Its URL matches certain criteria (see below).",
+    "translation": "它的 URL 符合特定的条件（稍后讲）。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "BYDEFAULTTHESECRITERIAARE:",
+    "original": "By default, these criteria are:",
+    "translation": "默认情况下，这些条件是：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "1THEURLMUSTNOTCONTAINAFILEEXTENSIONIEAINTHELASTPATHSEGMENT",
+    "original": "1. The URL must not contain a file extension (i.e. a `.`) in the last path segment.",
+    "translation": "URL 的最后一段路径中不能包含文件扩展名（比如 `.`）。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "2THEURLMUSTNOTCONTAIN",
+    "original": "2. The URL must not contain `__`.",
+    "translation": "URL 中不能包含 `__`。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "###MATCHINGNAVIGATIONREQUESTURLS",
+    "original": "### Matching navigation request URLs",
+    "translation": "### 匹配导航请求的 URL",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "WHILETHESEDEFAULTCRITERIAAREFINEINMOSTCASESITISSOMETIMESDESIRABLETOCONFIGUREDIFFERENTRULESFOREXAMPLEYOUMAYWANTTOIGNORESPECIFICROUTESTHATARENOTPARTOFTHEANGULARAPPANDPASSTHEMTHROUGHTOTHESERVER",
+    "original": "While these default criteria are fine in most cases, it is sometimes desirable to configure different rules. For example, you may want to ignore specific routes (that are not part of the Angular app) and pass them through to the server.",
+    "translation": "虽然这些默认条件在大多数情况下都挺好用，不过有时还是要配置一些不同的规则。比如，你可能希望忽略一些特定的路由（它们可能不是 Angular 应用的一部分），而是把它们透传给服务器。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "THISFIELDCONTAINSANARRAYOFURLSANDGLOBLIKE#GLOBPATTERNSURLPATTERNSTHATWILLBEMATCHEDATRUNTIMEITCANCONTAINBOTHNEGATIVEPATTERNSIEPATTERNSSTARTINGWITHANDNONNEGATIVEPATTERNSANDURLS",
+    "original": "This field contains an array of URLs and [glob-like](#glob-patterns) URL patterns that will be matched at runtime. It can contain both negative patterns (i.e. patterns starting with `!`) and non-negative patterns and URLs.",
+    "translation": "该字段包含一个将要在运行期间匹配的 URL 和 [类似 glob 的](#glob-patterns) URL模式。\n它既可以包含正向模式也可以包含反向模式（比如用 `!` 开头的模式）。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "ONLYREQUESTSWHOSEURLSMATCHANYOFTHENONNEGATIVEURLSPATTERNSANDNONEOFTHENEGATIVEONESWILLBECONSIDEREDNAVIGATIONREQUESTSTHEURLQUERYWILLBEIGNOREDWHENMATCHING",
+    "original": "Only requests whose URLs match _any_ of the non-negative URLs/patterns and _none_ of the negative ones will be considered navigation requests. The URL query will be ignored when matching.",
+    "translation": "只有那些能匹配**任意**正向 URL 或 URL 模式并且**不匹配任何一个**反向模式的 URL 才会视为导航请求。当匹配时，这些 URL 查询将会被忽略。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
+  {
+    "key": "IFTHEFIELDISOMITTEDITDEFAULTSTO:",
+    "original": "If the field is omitted, it defaults to:",
+    "translation": "如果省略了该字段，它的默认值是：",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-config.md"
+  },
   {
     "key": "#SERVICEWORKERINPRODUCTION",
     "original": "# Service worker in production",
@@ -30889,19 +31537,19 @@
   },
   {
     "key": "THISFILEINTEGRITYISESPECIALLYIMPORTANTWHENLAZYLOADINGMODULESAJSBUNDLEMAYREFERENCEMANYLAZYCHUNKSANDTHEFILENAMESOFTHELAZYCHUNKSAREUNIQUETOTHEPARTICULARBUILDOFTHEAPPIFARUNNINGAPPATVERSIONXATTEMPTSTOLOADALAZYCHUNKBUTTHESERVERHASUPDATEDTOVERSIONX1ALREADYTHELAZYLOADINGOPERATIONWILLFAIL",
-    "original": "This file integrity is especially important when lazy loading modules. \nA JS bundle may reference many lazy chunks, and the filenames of the \nlazy chunks are unique to the particular build of the app. If a running \napp at version `X` attempts to load a lazy chunk, but the server has \nupdated to version `X + 1` already, the lazy loading operation will fail.",
+    "original": "This file integrity is especially important when lazy loading modules.\nA JS bundle may reference many lazy chunks, and the filenames of the\nlazy chunks are unique to the particular build of the app. If a running\napp at version `X` attempts to load a lazy chunk, but the server has\nupdated to version `X + 1` already, the lazy loading operation will fail.",
     "translation": "当使用惰性加载模块时，文件的整体性就显得格外重要。\n某个 JS 包可能引用很多惰性块，而这些惰性块的文件名在应用的每次特定的构建中都是唯一的。\n如果运行应用的 `X` 版本视图加载一个惰性块，但该块的服务器已经升级到了 `X + 1`版本，这次惰性加载操作就会失败。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "THEVERSIONIDENTIFIEROFTHEAPPISDETERMINEDBYTHECONTENTSOFALLRESOURCESANDITCHANGESIFANYOFTHEMCHANGEINPRACTICETHEVERSIONISDETERMINEDBYTHECONTENTSOFTHENGSWJSONFILEWHICHINCLUDESHASHESFORALLKNOWNCONTENTIFANYOFTHECACHEDFILESCHANGETHEFILESHASHWILLCHANGEINNGSWJSONCAUSINGTHEANGULARSERVICEWORKERTOTREATTHEACTIVESETOFFILESASANEWVERSION",
-    "original": "The version identifier of the app is determined by the contents of all \nresources, and it changes if any of them change. In practice, the version \nis determined by the contents of the `ngsw.json` file, which includes \nhashes for all known content. If any of the cached files change, the file's \nhash will change in `ngsw.json`, causing the Angular service worker to \ntreat the active set of files as a new version.",
+    "original": "The version identifier of the app is determined by the contents of all\nresources, and it changes if any of them change. In practice, the version\nis determined by the contents of the `ngsw.json` file, which includes\nhashes for all known content. If any of the cached files change, the file's\nhash will change in `ngsw.json`, causing the Angular service worker to\ntreat the active set of files as a new version.",
     "translation": "本应用的版本标识符由其所有资源的内容决定，如果它们中的任何一个发生了变化，则版本标识符也随之改变。 \n实际上，版本是由 `ngsw.json` 文件的内容决定的，包含了所有已知内容的哈希值。\n如果任何一个被缓存的文件发生了变化，则该文件的哈希也将在`ngsw.json`中随之变化，从而导致 Angular Service Worker 将这个活动文件的集合视为一个新版本。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "WITHTHEVERSIONINGBEHAVIOROFTHEANGULARSERVICEWORKERANAPPLICATIONSERVERCANENSURETHATTHEANGULARAPPALWAYSHASACONSISTENTSETOFFILES",
-    "original": "With the versioning behavior of the Angular service worker, an application \nserver can ensure that the Angular app always has a consistent set of files.",
+    "original": "With the versioning behavior of the Angular service worker, an application\nserver can ensure that the Angular app always has a consistent set of files.",
     "translation": "借助 Angular Service Worker 的这种版本控制行为，应用服务器就可以确保这个 Angular 应用中的这组文件始终保持一致。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -30924,20 +31572,20 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
-    "key": "ONEOFTHEPOTENTIALSIDEEFFECTSOFLONGCACHINGISINADVERTENTLYCACHINGANINVALIDRESOURCEINANORMALHTTPCACHEAHARDREFRESHORCACHEEXPIRATIONLIMITSTHENEGATIVEEFFECTSOFCACHINGANINVALIDFILEASERVICEWORKERIGNORESSUCHCONSTRAINTSANDEFFECTIVELYLONGCACHESTHEENTIREAPPCONSEQUENTLYITISESSENTIALTHATTHESERVICEWORKERGETTHECORRECTCONTENT",
-    "original": "One of the potential side effects of long caching is inadvertently \ncaching an invalid resource. In a normal HTTP cache, a hard refresh \nor cache expiration limits the negative effects of caching an invalid \nfile. A service worker ignores such constraints and effectively long \ncaches the entire app. Consequently, it is essential that the service worker \nget the correct content.",
+    "key": "ONEOFTHEPOTENTIALSIDEEFFECTSOFLONGCACHINGISINADVERTENTLYCACHINGANINVALIDRESOURCEINANORMALHTTPCACHEAHARDREFRESHORCACHEEXPIRATIONLIMITSTHENEGATIVEEFFECTSOFCACHINGANINVALIDFILEASERVICEWORKERIGNORESSUCHCONSTRAINTSANDEFFECTIVELYLONGCACHESTHEENTIREAPPCONSEQUENTLYITISESSENTIALTHATTHESERVICEWORKERGETSTHECORRECTCONTENT",
+    "original": "One of the potential side effects of long caching is inadvertently\ncaching an invalid resource. In a normal HTTP cache, a hard refresh\nor cache expiration limits the negative effects of caching an invalid\nfile. A service worker ignores such constraints and effectively long\ncaches the entire app. Consequently, it is essential that the service worker\ngets the correct content.",
     "translation": "长周期缓存的潜在副作用之一就是可能无意中缓存了无效的资源。\n在普通的HTTP缓存中，硬刷新或缓存过期限制了缓存这种无效文件导致的负面影响。\n而 Service Worker 会忽略这样的约束，事实上会对整个应用程序进行长期缓存。\n因此，让 Service Worker 获得正确的内容就显得至关重要。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "TOENSURERESOURCEINTEGRITYTHEANGULARSERVICEWORKERVALIDATESTHEHASHESOFALLRESOURCESFORWHICHITHASAHASHTYPICALLYFORACLIAPPTHISISEVERYTHINGINTHEDISTDIRECTORYCOVEREDBYTHEUSERSSRCNGSWCONFIGJSONCONFIGURATION",
-    "original": "To ensure resource integrity, the Angular service worker validates \nthe hashes of all resources for which it has a hash. Typically for \na CLI app, this is everything in the `dist` directory covered by \nthe user's `src/ngsw-config.json` configuration.",
+    "original": "To ensure resource integrity, the Angular service worker validates\nthe hashes of all resources for which it has a hash. Typically for\na CLI app, this is everything in the `dist` directory covered by\nthe user's `src/ngsw-config.json` configuration.",
     "translation": "为了确保资源的整体性，Angular Service Worker 会验证所有带哈希的资源的哈希值。\n通常，对于 CLI 应用程序，用户的 `src/ngsw-config.json` 配置文件中会涵盖 `dist` 目录下的所有内容。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "IFAPARTICULARFILEFAILSVALIDATIONTHEANGULARSERVICEWORKERATTEMPTSTOREFETCHTHECONTENTUSINGACACHEBUSTINGURLPARAMETERTOELIMINATETHEEFFECTSOFBROWSERORINTERMEDIATECACHINGIFTHATCONTENTALSOFAILSVALIDATIONTHESERVICEWORKERCONSIDERSTHEENTIREVERSIONOFTHEAPPTOBEINVALIDANDITSTOPSSERVINGTHEAPPIFNECESSARYTHESERVICEWORKERENTERSASAFEMODEWHEREREQUESTSFALLBACKONTHENETWORKOPTINGNOTTOUSEITSCACHEIFTHERISKOFSERVINGINVALIDBROKENOROUTDATEDCONTENTISHIGH",
-    "original": "If a particular file fails validation, the Angular service worker \nattempts to re-fetch the content using a \"cache-busting\" URL \nparameter to eliminate the effects of browser or intermediate \ncaching. If that content also fails validation, the service worker \nconsiders the entire version of the app to be invalid and it stops \nserving the app. If necessary, the service worker enters a safe mode \nwhere requests fall back on the network, opting not to use its cache \nif the risk of serving invalid, broken, or outdated content is high.",
+    "original": "If a particular file fails validation, the Angular service worker\nattempts to re-fetch the content using a \"cache-busting\" URL\nparameter to eliminate the effects of browser or intermediate\ncaching. If that content also fails validation, the service worker\nconsiders the entire version of the app to be invalid and it stops\nserving the app. If necessary, the service worker enters a safe mode\nwhere requests fall back on the network, opting not to use its cache\nif the risk of serving invalid, broken, or outdated content is high.",
     "translation": "如果某个特定的文件未能通过验证，Angular Service Worker 就会尝试用 “cache-busting” URL 为参数重新获取内容，以消除浏览器或中间缓存的影响。\n如果该内容也未能通过验证，则 Service Worker 会认为该应用的整个版本都无效，并停止用它提供服务。\n如有必要，Service Worker 会进入安全模式，这些请求将退化为直接访问网络。\n如果服务无效、损坏或内容过期的风险很高，则会选择不使用缓存。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -30973,13 +31621,13 @@
   },
   {
     "key": "THEONLYRESOURCESTHATHAVEHASHESINTHENGSWJSONMANIFESTARERESOURCESTHATWEREPRESENTINTHEDISTDIRECTORYATTHETIMETHEMANIFESTWASBUILTOTHERRESOURCESESPECIALLYTHOSELOADEDFROMCDNSHAVECONTENTTHATISUNKNOWNATBUILDTIMEORAREUPDATEDMOREFREQUENTLYTHANTHEAPPISDEPLOYED",
-    "original": "The only resources that have hashes in the `ngsw.json` \nmanifest are resources that were present in the `dist` \ndirectory at the time the manifest was built. Other \nresources, especially those loaded from CDNs, have \ncontent that is unknown at build time or are updated \nmore frequently than the app is deployed.",
+    "original": "The only resources that have hashes in the `ngsw.json`\nmanifest are resources that were present in the `dist`\ndirectory at the time the manifest was built. Other\nresources, especially those loaded from CDNs, have\ncontent that is unknown at build time or are updated\nmore frequently than the app is deployed.",
     "translation": "`ngsw.json` 清单中唯一带哈希值的资源就是构建清单时 `dist` 目录中的资源。\n而其他资源，特别是从 CDN 加载的资源，其内容在构建时是未知的，或者会比应用程序部署得更频繁。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "IFTHEANGULARSERVICEWORKERDOESNOTHAVEAHASHTOVALIDATEAGIVENRESOURCEITSTILLCACHESITSCONTENTSBUTITHONORSTHEHTTPCACHINGHEADERSBYUSINGAPOLICYOFSTALEWHILEREVALIDATETHATISWHENHTTPCACHINGHEADERSFORACACHEDRESOURCEINDICATETHATTHERESOURCEHASEXPIREDTHEANGULARSERVICEWORKERCONTINUESTOSERVETHECONTENTANDITATTEMPTSTOREFRESHTHERESOURCEINTHEBACKGROUNDTHISWAYBROKENUNHASHEDRESOURCESDONOTREMAININTHECACHEBEYONDTHEIRCONFIGUREDLIFETIMES",
-    "original": "If the Angular service worker does not have a hash to validate \na given resource, it still caches its contents but it honors \nthe HTTP caching headers by using a policy of \"stale while \nrevalidate.\" That is, when HTTP caching headers for a cached \nresource indicate that the resource has expired, the Angular \nservice worker continues to serve the content and it attempts \nto refresh the resource in the background. This way, broken \nunhashed resources do not remain in the cache beyond their \nconfigured lifetimes.",
+    "original": "If the Angular service worker does not have a hash to validate\na given resource, it still caches its contents but it honors\nthe HTTP caching headers by using a policy of \"stale while\nrevalidate.\" That is, when HTTP caching headers for a cached\nresource indicate that the resource has expired, the Angular\nservice worker continues to serve the content and it attempts\nto refresh the resource in the background. This way, broken\nunhashed resources do not remain in the cache beyond their\nconfigured lifetimes.",
     "translation": "如果 Angular Service Worker 没有哈希可以验证给定的资源，它仍然会缓存它的内容，但会使用 “重新验证时失效” 的策略来承认HTTP缓存头。\n也就是说，当被缓存资源的 HTTP 缓存头指出该资源已过期时，Angular Service Worker 将继续提供内容，并尝试在后台刷新资源。\n这样，那些被破坏的非哈希资源留在缓存中的时间就不会超出为它配置的生命周期。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -30991,25 +31639,25 @@
   },
   {
     "key": "ITCANBEPROBLEMATICFORANAPPIFTHEVERSIONOFRESOURCESITSRECEIVINGCHANGESSUDDENLYORWITHOUTWARNINGSEETHEVERSIONSGUIDESERVICEWORKERDEVOPS#VERSIONSSECTIONABOVEFORADESCRIPTIONOFSUCHISSUES",
-    "original": "It can be problematic for an app if the version of resources \nit's receiving changes suddenly or without warning. See the \n[Versions](guide/service-worker-devops#versions) section above \nfor a description of such issues.",
+    "original": "It can be problematic for an app if the version of resources\nit's receiving changes suddenly or without warning. See the\n[Versions](guide/service-worker-devops#versions) section above\nfor a description of such issues.",
     "translation": "如果应用程序的资源版本突然发生了变化或没有给出警告，就可能会有问题。有关这些问题的描述，请参阅前面的 [版本](guide/service-worker-devops#versions) 部分。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "THEANGULARSERVICEWORKERPROVIDESAGUARANTEE:ARUNNINGAPPWILLCONTINUETORUNTHESAMEVERSIONOFTHEAPPIFANOTHERINSTANCEOFTHEAPPISOPENEDINANEWWEBBROWSERTABTHENTHEMOSTCURRENTVERSIONOFTHEAPPISSERVEDASARESULTTHATNEWTABCANBERUNNINGADIFFERENTVERSIONOFTHEAPPTHANTHEORIGINALTAB",
-    "original": "The Angular service worker provides a guarantee: a running app \nwill continue to run the same version of the app. If another \ninstance of the app is opened in a new web browser tab, then \nthe most current version of the app is served. As a result, \nthat new tab can be running a different version of the app \nthan the original tab.",
+    "original": "The Angular service worker provides a guarantee: a running app\nwill continue to run the same version of the app. If another\ninstance of the app is opened in a new web browser tab, then\nthe most current version of the app is served. As a result,\nthat new tab can be running a different version of the app\nthan the original tab.",
     "translation": "Angular Service Worker 会保证：正在运行的应用程序会继续运行和当前应用相同的版本。\n而如果在新的 Web 浏览器选项卡中打开了该应用的另一个实例，则会提供该应用的最新版本。\n因此，这个新标签可以和原始标签同时运行不同版本的应用。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "ITSIMPORTANTTONOTETHATTHISGUARANTEEISSTRONGERTHANTHATPROVIDEDBYTHENORMALWEBDEPLOYMENTMODELWITHOUTASERVICEWORKERTHEREISNOGUARANTEETHATCODELAZILYLOADEDLATERINARUNNINGAPPISFROMTHESAMEVERSIONASTHEINITIALCODEFORTHEAPP",
-    "original": "It's important to note that this guarantee is **stronger** \nthan that provided by the normal web deployment model. Without \na service worker, there is no guarantee that code lazily loaded \nlater in a running app is from the same version as the initial \ncode for the app.",
+    "original": "It's important to note that this guarantee is **stronger**\nthan that provided by the normal web deployment model. Without\na service worker, there is no guarantee that code lazily loaded\nlater in a running app is from the same version as the initial\ncode for the app.",
     "translation": "值得注意的是，这种担保比普通的 Web 部署模型提供的担保还要**更强一点**。\n如果没有 Service Worker，则不能保证稍后在这个正在运行的应用中惰性加载的代码\n和其初始代码的版本是一样的。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "THEREAREAFEWLIMITEDREASONSWHYTHEANGULARSERVICEWORKERMIGHTCHANGETHEVERSIONOFARUNNINGAPPSOMEOFTHEMAREERRORCONDITIONS:",
-    "original": "There are a few limited reasons why the Angular service worker \nmight change the version of a running app. Some of them are \nerror conditions:",
+    "original": "There are a few limited reasons why the Angular service worker\nmight change the version of a running app. Some of them are\nerror conditions:",
     "translation": "Angular Service Worker 为什么可能会更改运行中的应用的版本有几个有限的原因。\n其中一些是因为出错了：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31027,13 +31675,13 @@
   },
   {
     "key": "THEANGULARSERVICEWORKERISAWAREOFWHICHVERSIONSAREINUSEATANYGIVENMOMENTANDITCLEANSUPVERSIONSWHENNOTABISUSINGTHEM",
-    "original": "The Angular service worker is aware of which versions are in \nuse at any given moment and it cleans up versions when \nno tab is using them.",
+    "original": "The Angular service worker is aware of which versions are in\nuse at any given moment and it cleans up versions when\nno tab is using them.",
     "translation": "Angular Service Worker 能知道在任何指定的时刻正在使用哪些版本，\n并清除那些没有被任何选项卡使用的版本。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "OTHERREASONSTHEANGULARSERVICEWORKERMIGHTCHANGETHEVERSIONOFARUNNINGAPPARENORMALEVENTS:",
-    "original": "Other reasons the Angular service worker might change the version \nof a running app are normal events:",
+    "original": "Other reasons the Angular service worker might change the version\nof a running app are normal events:",
     "translation": "另一些可能导致 Angular Service Worker 在运行期间改变版本的因素是一些正常事件：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31057,19 +31705,19 @@
   },
   {
     "key": "THEANGULARSERVICEWORKERISASMALLSCRIPTTHATRUNSINWEBBROWSERSFROMTIMETOTIMETHESERVICEWORKERWILLBEUPDATEDWITHBUGFIXESANDFEATUREIMPROVEMENTS",
-    "original": "The Angular service worker is a small script that runs in web browsers. \nFrom time to time, the service worker will be updated with bug \nfixes and feature improvements.",
+    "original": "The Angular service worker is a small script that runs in web browsers.\nFrom time to time, the service worker will be updated with bug\nfixes and feature improvements.",
     "translation": "Angular Service Worker 是一个运行在Web浏览器中的小脚本。\n有时，这个 Service Worker 也可能会需要更新，以修复错误和增强特性。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "THEANGULARSERVICEWORKERISDOWNLOADEDWHENTHEAPPISFIRSTOPENEDANDWHENTHEAPPISACCESSEDAFTERAPERIODOFINACTIVITYIFTHESERVICEWORKERHASCHANGEDTHESERVICEWORKERWILLBEUPDATEDINTHEBACKGROUND",
-    "original": "The Angular service worker is downloaded when the app is first opened \nand when the app is accessed after a period of inactivity. If the \nservice worker has changed, the service worker will be updated in the background.",
+    "original": "The Angular service worker is downloaded when the app is first opened\nand when the app is accessed after a period of inactivity. If the\nservice worker has changed, the service worker will be updated in the background.",
     "translation": "首次打开应用时或在一段非活动时间之后再访问应用程序时，就会下载 Angular Service Worker。 如果 Service Worker 发生了变化，Service Worker 就会在后台进行更新。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "MOSTUPDATESTOTHEANGULARSERVICEWORKERARETRANSPARENTTOTHEAPPMDASHTHEOLDCACHESARESTILLVALIDANDCONTENTISSTILLSERVEDNORMALLYHOWEVEROCCASIONALLYABUGFIXORFEATUREINTHEANGULARSERVICEWORKERREQUIRESTHEINVALIDATIONOFOLDCACHESINTHISCASETHEAPPWILLBEREFRESHEDTRANSPARENTLYFROMTHENETWORK",
-    "original": "Most updates to the Angular service worker are transparent to the \napp&mdash;the old caches are still valid and content is still served \nnormally. However, occasionally a bugfix or feature in the Angular \nservice worker requires the invalidation of old caches. In this case, \nthe app will be refreshed transparently from the network.",
+    "original": "Most updates to the Angular service worker are transparent to the\napp&mdash;the old caches are still valid and content is still served\nnormally. However, occasionally a bugfix or feature in the Angular\nservice worker requires the invalidation of old caches. In this case,\nthe app will be refreshed transparently from the network.",
     "translation": "Angular Service Worker 的大部分更新对应用程序来说都是透明的 - 旧缓存仍然有效，其内容仍然能正常使用。\n但是，在 Angular Service Worker 中可能偶尔会有错误修复或新功能，需要让旧的缓存失效。\n这时，应用程序就从会网络上透明地进行刷新。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31081,7 +31729,7 @@
   },
   {
     "key": "OCCASIONALLYITMAYBENECESSARYTOEXAMINETHEANGULARSERVICEWORKERINARUNNINGSTATETOINVESTIGATEISSUESORTOENSURETHATITISOPERATINGASDESIGNEDBROWSERSPROVIDEBUILTINTOOLSFORDEBUGGINGSERVICEWORKERSANDTHEANGULARSERVICEWORKERITSELFINCLUDESUSEFULDEBUGGINGFEATURES",
-    "original": "Occasionally, it may be necessary to examine the Angular service \nworker in a running state to investigate issues or to ensure that \nit is operating as designed. Browsers provide built-in tools for \ndebugging service workers and the Angular service worker itself \nincludes useful debugging features.",
+    "original": "Occasionally, it may be necessary to examine the Angular service\nworker in a running state to investigate issues or to ensure that\nit is operating as designed. Browsers provide built-in tools for\ndebugging service workers and the Angular service worker itself\nincludes useful debugging features.",
     "translation": "偶尔，可能会需要检查运行中的 Angular Service Worker，以调查问题或确保它在按设计运行。\n浏览器提供了用于调试 Service Worker 的内置工具，而且 Angular Service Worker 本身也包含了一些有用的调试功能。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31093,7 +31741,7 @@
   },
   {
     "key": "THEANGULARSERVICEWORKEREXPOSESDEBUGGINGINFORMATIONUNDERTHENGSWVIRTUALDIRECTORYCURRENTLYTHESINGLEEXPOSEDURLISNGSWSTATEHEREISANEXAMPLEOFTHISDEBUGPAGESCONTENTS:",
-    "original": "The Angular service worker exposes debugging information under \nthe `ngsw/` virtual directory. Currently, the single exposed URL \nis `ngsw/state`. Here is an example of this debug page's contents:",
+    "original": "The Angular service worker exposes debugging information under\nthe `ngsw/` virtual directory. Currently, the single exposed URL\nis `ngsw/state`. Here is an example of this debug page's contents:",
     "translation": "Angular Service Worker 会在虚拟目录 `ngsw/` 下暴露出调试信息。\n目前，它暴露的唯一的 URL 是 `ngsw/state`。\n下面是这个调试页面中的一段范例内容：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31123,19 +31771,19 @@
   },
   {
     "key": "EXISTINGCLIENTSONLY:THESERVICEWORKERDOESNOTHAVEACLEANCOPYOFTHELATESTKNOWNVERSIONOFTHEAPPOLDERCACHEDVERSIONSARESAFETOUSESOEXISTINGTABSCONTINUETORUNFROMCACHEBUTNEWLOADSOFTHEAPPWILLBESERVEDFROMTHENETWORK",
-    "original": "* `EXISTING_CLIENTS_ONLY`: the service worker does not have a \nclean copy of the latest known version of the app. Older cached \nversions are safe to use, so existing tabs continue to run from \ncache, but new loads of the app will be served from the network.",
+    "original": "* `EXISTING_CLIENTS_ONLY`: the service worker does not have a\nclean copy of the latest known version of the app. Older cached\nversions are safe to use, so existing tabs continue to run from\ncache, but new loads of the app will be served from the network.",
     "translation": "`EXISTING_CLIENTS_ONLY`：这个 Service Worker 没有该应用的最新已知版本的干净副本。\n  较旧的缓存版本可以被安全的使用，所以现有的选项卡将继续使用较旧的版本运行本应用，\n  但新的应用将从网络上加载。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "SAFEMODE:THESERVICEWORKERCANNOTGUARANTEETHESAFETYOFUSINGCACHEDDATAEITHERANUNEXPECTEDERROROCCURREDORALLCACHEDVERSIONSAREINVALIDALLTRAFFICWILLBESERVEDFROMTHENETWORKRUNNINGASLITTLESERVICEWORKERCODEASPOSSIBLE",
-    "original": "* `SAFE_MODE`: the service worker cannot guarantee the safety of \nusing cached data. Either an unexpected error occurred or all \ncached versions are invalid. All traffic will be served from the \nnetwork, running as little service worker code as possible.",
+    "original": "* `SAFE_MODE`: the service worker cannot guarantee the safety of\nusing cached data. Either an unexpected error occurred or all\ncached versions are invalid. All traffic will be served from the\nnetwork, running as little service worker code as possible.",
     "translation": "`SAFE_MODE`：Service Worker 不能保证使用缓存数据的安全性。\n  发生了意外错误或所有缓存版本都无效。\n  这时所有的流量都将从网络提供，尽量少运行 Service Worker 中的代码。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "INBOTHCASESTHEPARENTHETICALANNOTATIONPROVIDESTHEERRORTHATCAUSEDTHESERVICEWORKERTOENTERTHEDEGRADEDSTATE",
-    "original": "In both cases, the parenthetical annotation provides the \nerror that caused the service worker to enter the degraded state.",
+    "original": "In both cases, the parenthetical annotation provides the\nerror that caused the service worker to enter the degraded state.",
     "translation": "在这两种情况下，后面的括号注解中都会提供导致 Service Worker 进入降级状态的错误信息。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31177,7 +31825,7 @@
   },
   {
     "key": "INTHISEXAMPLETHESERVICEWORKERHASONEVERSIONOFTHEAPPCACHEDANDBEINGUSEDTOSERVETWODIFFERENTTABSNOTETHATTHISVERSIONHASHISTHELATESTMANIFESTHASHLISTEDABOVEBOTHCLIENTSAREONTHELATESTVERSIONEACHCLIENTISLISTEDBYITSIDFROMTHECLIENTSAPIINTHEBROWSER",
-    "original": "In this example, the service worker has one version of the app cached and \nbeing used to serve two different tabs. Note that this version hash \nis the \"latest manifest hash\" listed above. Both clients are on the \nlatest version. Each client is listed by its ID from the `Clients` \nAPI in the browser.",
+    "original": "In this example, the service worker has one version of the app cached and\nbeing used to serve two different tabs. Note that this version hash\nis the \"latest manifest hash\" listed above. Both clients are on the\nlatest version. Each client is listed by its ID from the `Clients`\nAPI in the browser.",
     "translation": "在这个例子中，Service Worker 拥有一个版本的应用程序缓存并用它服务于两个不同的选项卡。\n请注意，这个版本哈希值是上面列出的“最新清单的哈希”。\n它的两个客户运行的都是最新版本。每个客户都用浏览器中 `Clients` API的 ID 列了出来。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31189,13 +31837,13 @@
   },
   {
     "key": "THEIDLETASKQUEUEISTHEQUEUEOFALLPENDINGTASKSTHATHAPPENINTHEBACKGROUNDINTHESERVICEWORKERIFTHEREAREANYTASKSINTHEQUEUETHEYARELISTEDWITHADESCRIPTIONINTHISEXAMPLETHESERVICEWORKERHASONESUCHTASKSCHEDULEDAPOSTINITIALIZATIONOPERATIONINVOLVINGANUPDATECHECKANDCLEANUPOFSTALECACHES",
-    "original": "The Idle Task Queue is the queue of all pending tasks that happen \nin the background in the service worker. If there are any tasks \nin the queue, they are listed with a description. In this example, \nthe service worker has one such task scheduled, a post-initialization \noperation involving an update check and cleanup of stale caches.",
+    "original": "The Idle Task Queue is the queue of all pending tasks that happen\nin the background in the service worker. If there are any tasks\nin the queue, they are listed with a description. In this example,\nthe service worker has one such task scheduled, a post-initialization\noperation involving an update check and cleanup of stale caches.",
     "translation": "空闲任务队列是 Service Worker 中所有在后台发生的未决任务的队列。\n如果这个队列中存在任何任务，则列出它们的描述。\n在这个例子中，Service Worker 安排的任务是一个用于更新检查和清除过期缓存的后期初始化操作。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "THELASTUPDATETICKRUNCOUNTERSGIVETHETIMESINCESPECIFICEVENTSHAPPENEDRELATEDTOTHEIDLEQUEUETHELASTUPDATERUNCOUNTERSHOWSTHELASTTIMEIDLETASKSWEREACTUALLYEXECUTEDLASTUPDATETICKSHOWSTHETIMESINCETHELASTEVENTAFTERWHICHTHEQUEUEMIGHTBEPROCESSED",
-    "original": "The last update tick/run counters give the time since specific \nevents happened related to the idle queue. The \"Last update run\" \ncounter shows the last time idle tasks were actually executed. \n\"Last update tick\" shows the time since the last event after \nwhich the queue might be processed.",
+    "original": "The last update tick/run counters give the time since specific\nevents happened related to the idle queue. The \"Last update run\"\ncounter shows the last time idle tasks were actually executed.\n\"Last update tick\" shows the time since the last event after\nwhich the queue might be processed.",
     "translation": "最后的 tick/run 计数器给出了与特定事件发生有关的空闲队列中的时间。\n“Last update run” 计数器显示的是上次执行空闲任务的时间。\n“Last update tick” 显示的是自上次事件以来可能要处理的队列的时间。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31219,25 +31867,25 @@
   },
   {
     "key": "BROWSERSSUCHASCHROMEPROVIDEDEVELOPERTOOLSFORINTERACTINGWITHSERVICEWORKERSSUCHTOOLSCANBEPOWERFULWHENUSEDPROPERLYBUTTHEREAREAFEWTHINGSTOKEEPINMIND",
-    "original": "Browsers such as Chrome provide developer tools for interacting \nwith service workers. Such tools can be powerful when used properly, \nbut there are a few things to keep in mind.",
+    "original": "Browsers such as Chrome provide developer tools for interacting\nwith service workers. Such tools can be powerful when used properly,\nbut there are a few things to keep in mind.",
     "translation": "Chrome 等浏览器提供了能与 Service Worker 交互的开发者工具。\n这些工具在使用得当时非常强大，但也要牢记一些事情。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "WHENUSINGDEVELOPERTOOLSTHESERVICEWORKERISKEPTRUNNINGINTHEBACKGROUNDANDNEVERRESTARTSTHISCANCAUSEBEHAVIORWITHDEVTOOLSOPENTODIFFERFROMBEHAVIORAUSERMIGHTEXPERIENCE",
-    "original": "* When using developer tools, the service worker is kept running \nin the background and never restarts. This can cause behavior with Dev\nTools open to differ from behavior a user might experience.",
+    "original": "* When using developer tools, the service worker is kept running\nin the background and never restarts. This can cause behavior with Dev\nTools open to differ from behavior a user might experience.",
     "translation": "使用开发人员工具时，Service Worker 将继续在后台运行，并且不会重新启动。\n  这可能会导致开着 Dev Tools 时的行为与用户实际遇到的行为不一样。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "IFYOULOOKINTHECACHESTORAGEVIEWERTHECACHEISFREQUENTLYOUTOFDATERIGHTCLICKTHECACHESTORAGETITLEANDREFRESHTHECACHES",
-    "original": "* If you look in the Cache Storage viewer, the cache is frequently \nout of date. Right click the Cache Storage title and refresh the caches.",
+    "original": "* If you look in the Cache Storage viewer, the cache is frequently\nout of date. Right click the Cache Storage title and refresh the caches.",
     "translation": "如果你查看缓存存储器的查看器，缓存就会经常过期。右键单击缓存存储器的标题并刷新缓存。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "STOPPINGANDSTARTINGTHESERVICEWORKERINTHESERVICEWORKERPANETRIGGERSACHECKFORUPDATES",
-    "original": "Stopping and starting the service worker in the Service Worker \npane triggers a check for updates.",
+    "original": "Stopping and starting the service worker in the Service Worker\npane triggers a check for updates.",
     "translation": "在 Service Worker 页停止并重新启动这个 Service Worker 将会触发一次更新检查。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31249,19 +31897,19 @@
   },
   {
     "key": "LIKEANYCOMPLEXSYSTEMBUGSORBROKENCONFIGURATIONSCANCAUSETHEANGULARSERVICEWORKERTOACTINUNFORESEENWAYSWHILEITSDESIGNATTEMPTSTOMINIMIZETHEIMPACTOFSUCHPROBLEMSTHEANGULARSERVICEWORKERCONTAINSSEVERALFAILSAFEMECHANISMSINCASEANADMINISTRATOREVERNEEDSTODEACTIVATETHESERVICEWORKERQUICKLY",
-    "original": "Like any complex system, bugs or broken configurations can cause \nthe Angular service worker to act in unforeseen ways. While its \ndesign attempts to minimize the impact of such problems, the \nAngular service worker contains several failsafe mechanisms in case \nan administrator ever needs to deactivate the service worker quickly.",
+    "original": "Like any complex system, bugs or broken configurations can cause\nthe Angular service worker to act in unforeseen ways. While its\ndesign attempts to minimize the impact of such problems, the\nAngular service worker contains several failsafe mechanisms in case\nan administrator ever needs to deactivate the service worker quickly.",
     "translation": "像任何复杂的系统一样，错误或损坏的配置可能会导致 Angular Service Worker 以不可预知的方式工作。\n虽然它在设计时就尝试将此类问题的影响降至最低，但是，如果管理员需要快速停用 Service Worker，\nAngular Service Worker 也包含多种故障保护机制。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
-    "key": "##FAILSAFE",
-    "original": "## Fail-safe",
-    "translation": "## 故障保护机制",
+    "key": "###FAILSAFE",
+    "original": "### Fail-safe",
+    "translation": "### 故障保护机制",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
   {
     "key": "TODEACTIVATETHESERVICEWORKERREMOVEORRENAMETHENGSWCONFIGJSONFILEWHENTHESERVICEWORKERSREQUESTFORNGSWJSONRETURNSA404THENTHESERVICEWORKERREMOVESALLOFITSCACHESANDDEREGISTERSITSELFESSENTIALLYSELFDESTRUCTING",
-    "original": "To deactivate the service worker, remove or rename the \n`ngsw-config.json` file. When the service worker's request \nfor `ngsw.json` returns a `404`, then the service worker \nremoves all of its caches and de-registers itself, \nessentially self-destructing.",
+    "original": "To deactivate the service worker, remove or rename the\n`ngsw-config.json` file. When the service worker's request\nfor `ngsw.json` returns a `404`, then the service worker\nremoves all of its caches and de-registers itself,\nessentially self-destructing.",
     "translation": "要停用 Service Worker，请删除或重命名 `ngsw-config.json` 文件。\n当 Service Worker 对 `ngsw.json` 的请求返回 `404` 时，Service Worker 就会删除它的所有缓存并注销自己，本质上就是自毁。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-devops.md"
   },
@@ -31307,6 +31955,12 @@
     "translation": "# Service Worker 快速起步",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
+  {
+    "key": "THISDOCUMENTEXPLAINSHOWTOENABLEANGULARSERVICEWORKERSUPPORTINYOURCLIPROJECTSITTHENUSESASIMPLEEXAMPLETOSHOWYOUASERVICEWORKERINACTIONDEMONSTRATINGLOADINGANDBASICCACHING",
+    "original": "This document explains how to enable Angular service worker support in your CLI projects. It then uses a simple example to show you a service worker in action, demonstrating loading and basic caching.",
+    "translation": "本文档解释了如何在 CLI 项目中启用对 Angular Service Worker 的支持。稍后它会用一个简单的范例来向你展示 Service Worker 实践，包括加载和基础的缓存功能。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
+  },
   {
     "key": "####PREREQUISITES",
     "original": "#### Prerequisites",
@@ -31326,159 +31980,81 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "BEGINNINGINANGULAR500YOUCANEASILYENABLEANGULARSERVICEWORKERSUPPORTINANYCLIPROJECTTHISDOCUMENTEXPLAINSHOWTOENABLEANGULARSERVICEWORKERSUPPORTINNEWANDEXISTINGPROJECTSITTHENUSESASIMPLEEXAMPLETOSHOWYOUASERVICEWORKERINACTIONDEMONSTRATINGLOADINGANDBASICCACHING",
-    "original": "Beginning in Angular 5.0.0, you can easily enable Angular service worker support in any CLI project. This document explains how to enable Angular service worker support in new and existing projects. It then uses a simple example to show you a service worker in action, demonstrating loading and basic caching.",
-    "translation": "从 Angular 5.0.0 开始，你就可以轻松为任何 CLI 项目启用 Angular Service Worker 的支持了。\n这个文档解释了你要如何在新项目和现有项目中启用 Angular Service Worker 的支持。\n然后使用一个简单的例子为你展示 Service Worker 实战，以演示加载和基本的缓存功能。",
+    "key": "ANGULARV6INCLUDINGANGULARCLIV6",
+    "original": "* Angular v6, including Angular CLI v6.",
+    "translation": "Angular v6，也包括 Angular CLI v6。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "##ADDINGASERVICEWORKERTOANEWAPPLICATION",
-    "original": "## Adding a service worker to a new application",
-    "translation": "## 为新项目添加 Service Worker",
+    "key": "##ADDINGASERVICEWORKERTOYOURPROJECT",
+    "original": "## Adding a service worker to your project",
+    "translation": "## 为你的项目添加 Service Worker",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "IFYOUREGENERATINGANEWCLIPROJECTYOUCANUSETHECLITOSETUPTHEANGULARSERVICEWORKERASPARTOFCREATINGTHEPROJECTTODOSOADDTHESERVICEWORKERFLAGTOTHENGNEWCOMMAND:",
-    "original": "If you're generating a new CLI project, you can use the CLI to set up the Angular service worker as part of creating the project. To do so, add the `--service-worker` flag to the `ng new`  command:",
-    "translation": "如果你正在生成一个新的 CLI 项目，可以 使用 CLI 在创建项目时就准备好 Angular Service Worker。\n只要在 `ng new` 命令中添加 `--service-worker` 标志就可以了：",
+    "key": "TOSETUPTHEANGULARSERVICEWORKERINYOURPROJECTUSETHECLICOMMANDNGADDANGULARPWAITTAKESCAREOFCONFIGURINGYOURAPPTOUSESERVICEWORKERSBYADDINGTHESERVICEWORKERPACKAGEALONGWITHSETTINGUPTHENECESSARYSUPPORTFILES",
+    "original": "To set up the Angular service worker in your project, use the CLI command `ng add @angular/pwa`. It takes care of configuring your app to use service workers by adding the `service-worker` package along \nwith setting up the necessary support files.",
+    "translation": "要让你的项目支持 Angular Service Worker，可以使用 CLI 命令 `ng add @angular/pwa`。它会添加 `service-worker` 包，并建立必要的支持文件，小心翼翼地配置你的应用，以便使用 Service Worker。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "THESERVICEWORKERFLAGTAKESCAREOFCONFIGURINGYOURAPPTOUSESERVICEWORKERSBYADDINGTHESERVICEWORKERPACKAGEALONGWITHSETTINGUPTHENECESSARYFILESTOSUPPORTSERVICEWORKERSFORINFORMATIONONTHEDETAILSSEETHEFOLLOWINGSECTIONWHICHCOVERSTHEPROCESSINDETAILASITSHOWSYOUHOWTOADDASERVICEWORKERMANUALLYTOANEXISTINGAPP",
-    "original": "The `--service-worker` flag takes care of configuring your app to \nuse service workers by adding the `service-worker` package along \nwith setting up the necessary files to support service workers. \nFor information on the details, see the following section \nwhich covers the process in detail as it shows you how to add a \nservice worker manually to an existing app.",
-    "translation": "`--service-worker` 标志会通过添加 `service-worker` 包及其它必须的文件，来帮你配置好 Service Worker。\n这个过程的细节和向现有项目中手动添加 Service Worker 的支持是一样的。要了解详情，参见下面的部分。",
+    "key": "THEABOVECOMMANDCOMPLETESTHEFOLLOWINGACTIONS:",
+    "original": "The above command completes the following actions:",
+    "translation": "上述命令完成了如下步骤：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "##ADDINGASERVICEWORKERTOANEXISTINGAPP",
-    "original": "## Adding a service worker to an existing app",
-    "translation": "## 向现有工程中添加 Service Worker",
+    "key": "1ADDSTHEANGULARSERVICEWORKERPACKAGETOYOURPROJECT",
+    "original": "1. Adds the `@angular/service-worker` package to your project.",
+    "translation": "把 @angular/service-worker 添加到你的项目中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "TOADDASERVICEWORKERTOANEXISTINGAPP:",
-    "original": "To add a service worker to an existing app:",
-    "translation": "要把 Service Worker 添加到现有应用中，就要：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "1ADDTHESERVICEWORKERPACKAGE",
-    "original": "1. Add the service worker package.",
-    "translation": "添加 Service Worker 包。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "2ENABLESERVICEWORKERBUILDSUPPORTINTHECLI",
-    "original": "2. Enable service worker build support in the CLI.",
+    "key": "2ENABLESSERVICEWORKERBUILDSUPPORTINTHECLI",
+    "original": "2. Enables service worker build support in the CLI.",
     "translation": "在 CLI 中启用 Service Worker 的构建支持。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "3IMPORTANDREGISTERTHESERVICEWORKER",
-    "original": "3. Import and register the service worker.",
-    "translation": "导入并注册这个 Service Worker。",
+    "key": "3IMPORTSANDREGISTERSTHESERVICEWORKERINTHEAPPMODULE",
+    "original": "3. Imports and registers the service worker in the app module.",
+    "translation": "在应用模块中导入并注册 Service Worker。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "4CREATETHESERVICEWORKERCONFIGURATIONFILEWHICHSPECIFIESTHECACHINGBEHAVIORSANDOTHERSETTINGS",
-    "original": "4. Create the service worker configuration file, which specifies the caching behaviors and other settings.",
-    "translation": "创建 Service Worker 的配置文件，它指定了缓存行为和其它设置。",
+    "key": "4UPDATESTHEINDEXHTMLFILE:",
+    "original": "4. Updates the `index.html` file:",
+    "translation": "修改 `index.html` 文件：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "5BUILDTHEPROJECT",
-    "original": "5. Build the project.",
-    "translation": "构建该项目。",
+    "key": "INCLUDESALINKTOADDTHEMANIFESTJSONFILE",
+    "original": "* Includes a link to add the `manifest.json` file.",
+    "translation": "包含要添加到 `manifest.json` 文件中的链接。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "###STEP1:ADDTHESERVICEWORKERPACKAGE",
-    "original": "### Step 1: Add the service worker package",
-    "translation": "### 步骤 1：添加 Service Worker 包",
+    "key": "ADDSMETATAGSFORTHEMECOLOR",
+    "original": "* Adds meta tags for `theme-color`.",
+    "translation": "为 `theme-color` 添加 meta 标签。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "ADDTHEPACKAGEANGULARSERVICEWORKERUSINGTHEYARNUTILITYASSHOWNHERE:",
-    "original": "Add the package `@angular/service-worker`, using the yarn utility as shown here:",
-    "translation": "添加 `@angular/service-worker` 包，使用 yarn 工具时的用法如下：",
+    "key": "5INSTALLSICONFILESTOSUPPORTTHEINSTALLEDPROGRESSIVEWEBAPPPWA",
+    "original": "5. Installs icon files to support the installed Progressive Web App (PWA).",
+    "translation": "创建图标文件，以支持安装渐进式应用（PWA）。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "###STEP2:ENABLESERVICEWORKERBUILDSUPPORTINTHECLI",
-    "original": "### Step 2: Enable service worker build support in the CLI",
-    "translation": "### 步骤 2：在 CLI 中启用 Service Worker 的构建支持",
+    "key": "6CREATESTHESERVICEWORKERCONFIGURATIONFILECALLEDNGSWCONFIGJSONGUIDESERVICEWORKERCONFIGWHICHSPECIFIESTHECACHINGBEHAVIORSANDOTHERSETTINGS",
+    "original": "6. Creates the service worker configuration file called [`ngsw-config.json`](/guide/service-worker-config), which specifies the caching behaviors and other settings.",
+    "translation": "创建一个名叫 [`ngsw-config.json`](/guide/service-worker-config) 的 Service Worker 配置文件，它会用来指定缓存的行为以及其它设定。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "TOENABLETHEANGULARSERVICEWORKERTHECLIMUSTGENERATEANANGULARSERVICEWORKERMANIFESTATBUILDTIMETOCAUSETHECLITOGENERATETHEMANIFESTFORANEXISTINGPROJECTSETTHESERVICEWORKERFLAGTOTRUEINTHEPROJECTSANGULARCLIJSONFILEASSHOWNHERE:",
-    "original": "To enable the Angular service worker, the CLI must generate an Angular service worker manifest at build time. To cause the CLI to generate the manifest for an existing project, set the `serviceWorker` flag to `true` in the project's `.angular-cli.json` file as shown here:",
-    "translation": "要启用 Angular Service Worker，CLI 必须在构建时生成一个 Angular Service Worker 的 `manifest` 文件。\n要让 CLI 为现有项目生成 `manifest`，就要在该项目的 `.angular-cli.json` 文件中 `serviceWorker` 标识设置为 `true`。命令如下：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "###STEP3:IMPORTANDREGISTERTHESERVICEWORKER",
-    "original": "### Step 3: Import and register the service worker",
-    "translation": "### 步骤 3：导入并注册 Service Worker",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "TOIMPORTANDREGISTERTHEANGULARSERVICEWORKER:",
-    "original": "To import and register the Angular service worker:",
-    "translation": "要导入并注册 Angular Service Worker 就要：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "ATTHETOPOFTHEROOTMODULESRCAPPAPPMODULETSIMPORTSERVICEWORKERMODULEANDENVIRONMENT",
-    "original": "At the top of the root module, `src/app/app.module.ts`, import `ServiceWorkerModule` and `environment`.",
-    "translation": "在根模块 `src/app/app.module.ts` 的顶部导入 `ServiceWorkerModule` 和 `environment`。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "ADDSERVICEWORKERMODULETOTHENGMODULEIMPORTSARRAYUSETHEREGISTERHELPERTOTAKECAREOFREGISTERINGTHESERVICEWORKERTAKINGCARETODISABLETHESERVICEWORKERWHENNOTRUNNINGINPRODUCTIONMODE",
-    "original": "Add `ServiceWorkerModule` to the `@NgModule` `imports` array. Use the `register()` helper to take care of registering the service worker, taking care to disable the service worker when not running in production mode.",
-    "translation": "把 `ServiceWorkerModule` 添加到 `@NgModule` 的 `imports` 数组中。使用 `register()` 来帮助管理 Service Worker 的注册并在非生产环境下运行时禁用 Service Worker。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "THEFILENGSWWORKERJSISTHENAMEOFTHEPREBUILTSERVICEWORKERSCRIPTWHICHTHECLICOPIESINTODISTTODEPLOYALONGWITHYOURSERVER",
-    "original": "The file `ngsw-worker.js` is the name of the prebuilt service worker script, which the CLI copies into `dist/` to deploy along with your server.",
-    "translation": "`ngsw-worker.js` 文件是内置的 Service Worker 脚本的名字，CLI 会把它复制到 `dist/` 目录下，让它随你的服务器一起发布。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "###STEP4:CREATETHECONFIGURATIONFILENGSWCONFIGJSON",
-    "original": "### Step 4: Create the configuration file, `ngsw-config.json`",
-    "translation": "### 步骤 4：创建配置文件 `ngsw-config.json`",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "THEANGULARCLINEEDSASERVICEWORKERCONFIGURATIONFILECALLEDNGSWCONFIGJSONTHECONFIGURATIONFILECONTROLSHOWTHESERVICEWORKERCACHESFILESANDDATARESOURCES",
-    "original": "The Angular CLI needs a service worker configuration file, called `ngsw-config.json`. The configuration file controls how the service worker caches files and data \nresources.",
-    "translation": "Angular CLI 需要一个名叫 `ngsw-config.json` 的 Service Worker 配置文件。\n这个配置文件会控制 Service Worker 如何缓存各个文件和数据资源。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "YOUCANBEGINWITHTHEBOILERPLATEVERSIONFROMTHECLIWHICHCONFIGURESSENSIBLEDEFAULTSFORMOSTAPPLICATIONS",
-    "original": "You can begin with the boilerplate version from the CLI, which configures sensible defaults for most applications.",
-    "translation": "你可以从 CLI 创建的样板项目开始，它已经配置好了适合大多数应用的默认选项。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "ALTERNATELYSAVETHEFOLLOWINGASSRCNGSWCONFIGJSON:",
-    "original": "Alternately, save the following as `src/ngsw-config.json`:",
-    "translation": "另外，你也可以把下列内容保存为 `src/ngsw-config.json`：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "###STEP5:BUILDTHEPROJECT",
-    "original": "### Step 5: Build the project",
-    "translation": "### 步骤 5：构建本项目",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
-  },
-  {
-    "key": "FINALLYBUILDTHEPROJECT:",
-    "original": "Finally, build the project:",
-    "translation": "最后，构建本项目：",
+    "key": "NOWBUILDTHEPROJECT:",
+    "original": "Now, build the project:",
+    "translation": "现在，构建本项目：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
@@ -31506,8 +32082,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
   {
-    "key": "BECAUSENGSERVEDOESNOTWORKWITHSERVICEWORKERSYOUMUSTUSEASEPERATEHTTPSERVERTOTESTYOURPROJECTLOCALLYYOUCANUSEANYHTTPSERVERTHEEXAMPLEBELOWUSESTHEHTTPSERVERHTTPS:WWWNPMJSCOMPACKAGEHTTPSERVERPACKAGEFROMNPMTOREDUCETHEPOSSIBILITYOFCONFLICTSTESTONADEDICATEDPORT",
-    "original": "Because `ng serve` does not work with service workers, you must use a seperate HTTP server to test your project locally. You can use any HTTP server. The example below uses the [http-server](https://www.npmjs.com/package/http-server) package from npm. To reduce the possibility of conflicts, test on a dedicated port.",
+    "key": "BECAUSENGSERVEDOESNOTWORKWITHSERVICEWORKERSYOUMUSTUSEASEPARATEHTTPSERVERTOTESTYOURPROJECTLOCALLYYOUCANUSEANYHTTPSERVERTHEEXAMPLEBELOWUSESTHEHTTPSERVERHTTPS:WWWNPMJSCOMPACKAGEHTTPSERVERPACKAGEFROMNPMTOREDUCETHEPOSSIBILITYOFCONFLICTSTESTONADEDICATEDPORT",
+    "original": "Because `ng serve` does not work with service workers, you must use a separate HTTP server to test your project locally. You can use any HTTP server. The example below uses the [http-server](https://www.npmjs.com/package/http-server) package from npm. To reduce the possibility of conflicts, test on a dedicated port.",
     "translation": "由于 `ng serve` 对 Service Worker 无效，所以必须用一个独立的 HTTP 服务器在本地测试你的项目。\n你可以使用任何 HTTP 服务器。下面这个例子使用来自 npm 中的 [http-server](https://www.npmjs.com/package/http-server) 包。\n为了减小端口冲突的可能性，我们在一个专用端口上进行测试。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-getting-started.md"
   },
@@ -31824,9 +32400,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-intro.md"
   },
   {
-    "key": "TOSUPPORTTHESEBEHAVIORSTHEANGULARSERVICEWORKERLOADSAMANIFESTFILEFROMTHESERVERTHEMANIFESTDESCRIBESTHERESOURCESTOCACHEANDINCLUDESHASHESOFEVERYFILESCONTENTSWHENANUPDATETOTHEAPPLICATIONISDEPLOYEDTHECONTENTSOFTHEMANIFESTCHANGEINFORMINGTHESERVICEWORKERTHATANEWVERSIONOFTHEAPPLICATIONSHOULDBEDOWNLOADEDANDCACHEDTHISMANIFESTISGENERATEDFROMAUSERPROVIDEDCONFIGURATIONFILECALLEDNGSWCONFIGJSONBYUSINGABUILDTOOLSUCHASTHEANGULARCLI",
-    "original": "To support these behaviors, the Angular service worker loads a *manifest* file from the server. The manifest describes the resources to cache and includes hashes of every file's contents. When an update to the application is deployed, the contents of the manifest change, informing the service worker that a new version of the application should be downloaded and cached. This manifest is generated from a user-provided configuration file called `ngsw-config.json`, by using a build tool such as the Angular CLI.",
-    "translation": "要支持这些行为，Angular 的 Service Worker 会从服务器上下载一个 `manifest` 文件。\n这个 `manifest` 文件描述要缓存的资源，并包含每个文件内容的哈希值。\n当发布了应用的一个新版本时，`manifest` 的内容就会改变，通知 Service Worker 应该下载并缓存应用的一个新版本了。\n这个 manifest 是从用户使用 Angular CLI 等构建工具提供的一个名叫 `ngsw-config.json` 的文件中生成的。",
+    "key": "TOSUPPORTTHESEBEHAVIORSTHEANGULARSERVICEWORKERLOADSAMANIFESTFILEFROMTHESERVERTHEMANIFESTDESCRIBESTHERESOURCESTOCACHEANDINCLUDESHASHESOFEVERYFILESCONTENTSWHENANUPDATETOTHEAPPLICATIONISDEPLOYEDTHECONTENTSOFTHEMANIFESTCHANGEINFORMINGTHESERVICEWORKERTHATANEWVERSIONOFTHEAPPLICATIONSHOULDBEDOWNLOADEDANDCACHEDTHISMANIFESTISGENERATEDFROMACLIGENERATEDCONFIGURATIONFILECALLEDNGSWCONFIGJSON",
+    "original": "To support these behaviors, the Angular service worker loads a *manifest* file from the server. The manifest describes the resources to cache and includes hashes of every file's contents. When an update to the application is deployed, the contents of the manifest change, informing the service worker that a new version of the application should be downloaded and cached. This manifest is generated from a CLI-generated configuration file called `ngsw-config.json`.",
+    "translation": "要支持这些行为，Angular 的 Service Worker 会从服务器上下载一个 `manifest` 文件。\n这个 `manifest` 文件描述要缓存的资源，并包含每个文件内容的哈希值。\n当发布了应用的一个新版本时，`manifest` 的内容就会改变，通知 Service Worker 应该下载并缓存应用的一个新版本了。\n这个 manifest 是从 CLI 生成的一个名叫 `ngsw-config.json` 的文件中生成的。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-intro.md"
   },
   {
@@ -31841,24 +32417,6 @@
     "translation": "## 前提条件",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-intro.md"
   },
-  {
-    "key": "TOUSEANGULARSERVICEWORKERSYOUMUSTHAVETHEFOLLOWINGANGULARANDCLIVERSIONS:",
-    "original": "To use Angular service workers, you must have the following Angular and CLI versions:",
-    "translation": "要想使用 Angular Service Worker，你要使用下列 Angular 和 CLI 版本：",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-intro.md"
-  },
-  {
-    "key": "ANGULAR500ORLATER",
-    "original": "* Angular 5.0.0 or later.",
-    "translation": "Angular 5.0.0 或更高。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-intro.md"
-  },
-  {
-    "key": "ANGULARCLI160ORLATER",
-    "original": "* Angular CLI 1.6.0 or later.",
-    "translation": "Angular CLI 1.6.0 或更高。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/service-worker-intro.md"
-  },
   {
     "key": "YOURAPPLICATIONMUSTRUNINAWEBBROWSERTHATSUPPORTSSERVICEWORKERSCURRENTLYTHELATESTVERSIONSOFCHROMEANDFIREFOXARESUPPORTEDTOLEARNABOUTOTHERBROWSERSTHATARESERVICEWORKERREADYSEETHECANIUSEHTTP:CANIUSECOM#FEATSERVICEWORKERSPAGE",
     "original": "Your application must run in a web browser that supports service workers. Currently, the latest versions of Chrome and Firefox are supported. To learn about other browsers that are service worker ready, see the [Can I Use](http://caniuse.com/#feat=serviceworkers) page.",
@@ -32232,9 +32790,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/setup.md"
   },
   {
-    "key": "MAKESUREYOUHAVENODEANDNPMINSTALLEDGUIDESETUP#INSTALLPREREQUISITESWHATIFYOUDONTHAVENODEANDNPM",
-    "original": "Make sure you have [node and npm installed](guide/setup#install-prerequisites \"What if you don't have node and npm?\").",
-    "translation": "确定你已经安装了 [node 和 npm](guide/setup#install-prerequisites \"如果你没有 node 和 npm？\")。",
+    "key": "MAKESUREYOUHAVENODEJSANDNPMINSTALLEDGUIDESETUP#INSTALLPREREQUISITESWHATIFYOUDONTHAVENODEJSANDNPM",
+    "original": "Make sure you have [Node.js® and npm installed](guide/setup#install-prerequisites \"What if you don't have Node.js and npm?\").",
+    "translation": "确定你已经安装了 [Node.js® 和 npm](guide/setup#install-prerequisites \"如果你没有 Node.js 和 npm？\")。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/setup.md"
   },
   {
@@ -32382,15 +32940,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/setup.md"
   },
   {
-    "key": "##APPENDIX:NODEANDNPM",
-    "original": "## Appendix: node and npm",
+    "key": "##APPENDIX:NODEJSANDNPM",
+    "original": "## Appendix: Node.js and npm",
     "translation": "## 附录：node 与 npm",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/setup.md"
   },
   {
-    "key": "NODEJSANDNPMAREESSENTIALTOMODERNWEBDEVELOPMENTWITHANGULARANDOTHERPLATFORMSNODEPOWERSCLIENTDEVELOPMENTANDBUILDTOOLSTHENPMPACKAGEMANAGERITSELFANODEAPPLICATIONINSTALLSJAVASCRIPTLIBRARIES",
-    "original": "Node.js and npm are essential to modern web development with Angular and other platforms.\nNode powers client development and build tools.\nThe _npm_ package manager, itself a _node_ application, installs JavaScript libraries.",
-    "translation": "Node.js 和 npm 对使用 Angular 和其他平台进行现代网络开发是至关重要的。\nNode 驱动客户端开发和构建工具。\n*npm* 包管理器本身是 *node* 应用，用于安装 JavaScript 库。",
+    "key": "NODEJSHTTPS:NODEJSORGENANDTHENPMHTTPS:WWWNPMJSCOMPACKAGEMANAGERAREESSENTIALTOMODERNWEBDEVELOPMENTWITHANGULARANDOTHERPLATFORMSNODEJSPOWERSCLIENTDEVELOPMENTANDBUILDTOOLSTHENPMPACKAGEMANAGERWHICHISITSELFANODEJSAPPLICATIONINSTALLSJAVASCRIPTLIBRARIES",
+    "original": "[Node.js](https://nodejs.org/en/) and the [npm](https://www.npmjs.com/) package manager are essential to modern web development with Angular and other platforms.\nNode.js powers client development and build tools.\nThe _npm_ package manager, which is itself a _Node.js_ application, installs JavaScript libraries.",
+    "translation": "[Node.js](https://nodejs.org/en/) 和 [npm](https://www.npmjs.com/) 包管理器对使用 Angular 和其他平台进行现代网络开发是至关重要的。\nNode.js 用来支持客户端开发和构建工具。*npm* 包管理器本身就是一个 *Node.js* 应用，用于安装 JavaScript 库。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/setup.md"
   },
   {
@@ -32400,15 +32958,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/setup.md"
   },
   {
-    "key": "VERIFYTHATYOUARERUNNINGNODEV4XXORHIGHERANDNPM3XXORHIGHERBYRUNNINGTHECOMMANDSNODEVANDNPMVINATERMINALCONSOLEWINDOWOLDERVERSIONSPRODUCEERRORS",
-    "original": "**Verify that you are running node `v4.x.x` or higher and npm `3.x.x` or higher**\nby running the commands `node -v` and `npm -v` in a terminal/console window.\nOlder versions produce errors.",
-    "translation": "在终端/控制器窗口运行命令 `node -v` 和 `npm -v`，来**确认你运行的 node 是 `v4.x.x` 或更高，npm 为 `3.x.x` 或更高。**\n老版本会产生错误。",
+    "key": "VERIFYTHATYOUARERUNNINGNODEJSV8XORHIGHERANDNPM5XORHIGHERBYRUNNINGTHECOMMANDSNODEVANDNPMVINATERMINALCONSOLEWINDOWOLDERVERSIONSPRODUCEERRORS",
+    "original": "**Verify that you are running Node.js `v8.x` or higher and npm `5.x` or higher**\nby running the commands `node -v` and `npm -v` in a terminal/console window.\nOlder versions produce errors.",
+    "translation": "在终端/控制器窗口运行命令 `node -v` 和 `npm -v`，来**确认你运行的 Node.js 是 `v8.x` 或更高，npm 为 `5.x` 或更高。**\n老版本会产生错误。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/setup.md"
   },
   {
-    "key": "WERECOMMENDNVMHTTPS:GITHUBCOMCREATIONIXNVMFORMANAGINGMULTIPLEVERSIONSOFNODEANDNPMYOUMAYNEEDNVMHTTPS:GITHUBCOMCREATIONIXNVMIFYOUALREADYHAVEPROJECTSRUNNINGONYOURMACHINETHATUSEOTHERVERSIONSOFNODEANDNPM",
-    "original": "We recommend [nvm](https://github.com/creationix/nvm) for managing multiple versions of node and npm.\nYou may need [nvm](https://github.com/creationix/nvm) if you already have projects running on your machine that\nuse other versions of node and npm.",
-    "translation": "我们推荐使用 [nvm](https://github.com/creationix/nvm) 来管理多版本 node 和 npm。\n    如果你的电脑上已经有使用其他版本 node 和 npm 的项目，你可能需要 nvm。",
+    "key": "WERECOMMENDNVMHTTPS:GITHUBCOMCREATIONIXNVMFORMANAGINGMULTIPLEVERSIONSOFNODEJSANDNPMYOUMAYNEEDNVMHTTPS:GITHUBCOMCREATIONIXNVMIFYOUALREADYHAVEPROJECTSRUNNINGONYOURMACHINETHATUSEOTHERVERSIONSOFNODEJSANDNPM",
+    "original": "We recommend [nvm](https://github.com/creationix/nvm) for managing multiple versions of Node.js and npm.\nYou may need [nvm](https://github.com/creationix/nvm) if you already have projects running on your machine that use other versions of Node.js and npm.",
+    "translation": "我们推荐使用 [nvm](https://github.com/creationix/nvm) 来管理多版本 Node.js 和 npm。\n    如果你的电脑上已经有使用其他版本 Node.js 和 npm 的项目，你可能需要 nvm。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/setup.md"
   },
   {
@@ -32676,45 +33234,27 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/singleton-services.md"
   },
   {
-    "key": "ANINJECTORCREATEDFROMAMODULEDEFINITIONWILLHAVESERVICESWHICHARESINGLETONSWITHRESPECTTOTHATINJECTORTOCONTROLTHELIFETIMEOFSERVICESONECONTROLSTHECREATIONANDDESTRUCTIONOFINJECTORSFOREXAMPLEAROUTEWILLHAVEANASSOCIATEDMODULEWHENTHEROUTEISACTIVATEDANINJECTORISCREATEDFROMTHATMODULEASACHILDOFTHECURRENTINJECTORWHENYOUNAVIGATEAWAYFROMTHEROUTETHEINJECTORISDESTROYEDTHISMEANSTHATSERVICESDECLAREDINAROUTEMODULEWILLHAVEALIFETIMEEQUALTOTHATOFTHEROUTESIMILARLYSERVICESPROVIDEDINANAPPLICATIONMODULEWILLHAVETHESAMELIFETIMEOFTHEAPPLICATIONHENCESINGLETON",
-    "original": "An injector created from a module definition will have services which are singletons with respect to\nthat injector. To control the lifetime of services, one controls the creation and destruction of\ninjectors. For example, a route will have an associated module. When the route is activated, an\ninjector is created from that module as a child of the current injector. When you navigate away from\nthe route, the injector is destroyed. This means that services declared in a route module will have\na lifetime equal to that of the route. Similarly, services provided in an application module will\nhave the same lifetime of the application, hence singleton.",
-    "translation": "那些在定义模块时创建的注入器将会拥有一些服务，这些服务对于该注入器来说都是单例的。要控制这些服务的生命周期，其实就是控制注入器的创建和销毁。\n比如，路由定义中就可以有一个关联模块。当激活该路由时，就会给那个模块创建一个新注入器，并将其作为当前注入器的子注入器。当离开该路由时，这个新注入器也就被销毁了。\n这也意味着在这个模块中声明的那些服务也随之销毁了，它们的生命周期与该路由完全相同。\n类似的，在应用模块中提供的那些服务的生命周期也等同于该应用，因此是单例的。",
+    "key": "THEREARETWOWAYSTOMAKEASERVICEASINGLETONINANGULAR:",
+    "original": "There are two ways to make a service a singleton in Angular:",
+    "translation": "在 Angular 中有两种方式来生成单例服务：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/singleton-services.md"
   },
   {
-    "key": "THEFOLLOWINGEXAMPLEMODULEISCALLEDASACONVENTIONCOREMODULETHISUSEOFNGMODULECREATESORGANIZATIONALINFRASTRUCTUREANDGIVESYOUAWAYOFPROVIDINGSERVICESFROMADESIGNATEDNGMODULE",
-    "original": "The following example module is called, as a convention, `CoreModule`. This use of `@NgModule` creates organizational infrastructure and gives you\na way of providing services from a designated NgModule.",
-    "translation": "下面的范例模块习惯上叫做 `CoreModule`。`@NgModule` 用来创建结构良好的基础设施，让你能够在一个指定的模块中提供服务。",
+    "key": "DECLARETHATTHESERVICESHOULDBEPROVIDEDINTHEAPPLICATIONROOT",
+    "original": "* Declare that the service should be provided in the application root.",
+    "translation": "声明该服务应该在应用的根上提供。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/singleton-services.md"
   },
   {
-    "key": "HERECOREMODULEPROVIDESTHEUSERSERVICEANDBECAUSEAPPMODULEIMPORTSCOREMODULEANYSERVICESTHATCOREMODULEPROVIDESAREAVAILABLETHROUGHOUTTHEAPPBECAUSEITISAROOTOFTHEINJECTORTREEITWILLALSOBEASINGLETONBECAUSETHEINJECTORLIFETIMEOFTHEAPPMODULEISFORTHEDURATIONOFTHEAPPLICATION",
-    "original": "Here, `CoreModule` provides the `UserService`, and because `AppModule`\nimports `CoreModule`, any services that `CoreModule` provides are available\nthroughout the app, because it is a root of the injector tree. It will also be a singleton because the injector lifetime of the `AppModule` is for the duration of the application.",
-    "translation": "这里的 `CoreModule` 提供了 `UserService`，并且由于 `AppModule` 导入了 `CoreModule`，所以 `CoreModule` 中提供的任何服务也能在整个应用中使用，因为它是注入器树的根节点。\n它还是单例的，因为在该应用运行期间，该注入器的生命周期等同于 `AppModule` 的。",
+    "key": "INCLUDETHESERVICEINTHEAPPMODULEORINAMODULETHATISONLYIMPORTEDBYTHEAPPMODULE",
+    "original": "* Include the service in the `AppModule` or in a module that is only imported by the `AppModule`.",
+    "translation": "把该服务包含在 `AppModule` 或某个只会被 `AppModule` 导入的模块中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/singleton-services.md"
   },
   {
-    "key": "ANGULARREGISTERSTHEUSERSERVICEPROVIDERWITHTHEAPPROOTINJECTORMAKINGASINGLETONINSTANCEOFTHEUSERSERVICEAVAILABLETOANYCOMPONENTTHATNEEDSITWHETHERTHATCOMPONENTISEAGERLYORLAZILYLOADED",
-    "original": "Angular registers the `UserService` provider with the app root\ninjector, making a singleton instance of the `UserService`\navailable to any component that needs it,\nwhether that component is eagerly or lazily loaded.",
-    "translation": "Angular 使用应用的根注入器注册了 `UserService` 提供商，可以让任何需要它的组件（无论它是立即加载的还是惰性加载的）都能使用 `UserService` 的单例。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/singleton-services.md"
-  },
-  {
-    "key": "THEROOTAPPMODULECOULDREGISTERTHEUSERSERVICEDIRECTLYBUTASTHEAPPGROWSITCOULDHAVEOTHERSERVICESANDCOMPONENTSLIKESPINNERSMODALSANDSOONTOKEEPYOURAPPORGANIZEDCONSIDERUSINGAMODULESUCHASCOREMODULETHISTECHNIQUESIMPLIFIESTHEROOTAPPMODULEINITSCAPACITYASORCHESTRATOROFTHEAPPLICATIONASAWHOLE",
-    "original": "The root `AppModule` could register the `UserService` directly,\nbut as the app grows, it could have other services and\ncomponents like spinners, modals, and so on. To\nkeep your app organized, consider using a module such as `CoreModule`.\nThis technique simplifies the root `AppModule` in its\ncapacity as orchestrator of the application as a whole.",
-    "translation": "根模块 `AppModule` 当然也可以直接注册 `UserService`，不过随着应用的成长，可能还会出现其它的服务和组件，比如 列表框、模态框等等。\n要想保持你应用的良好结构，就要考虑使用诸如 `CoreModule` 这样的模块。\n这种方式简化了根模块 `AppModule`，让它只需要扮演整个应用的总指挥，而不必事必躬亲。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/singleton-services.md"
-  },
-  {
-    "key": "NOWYOUCANINJECTSUCHSERVICESINTOCOMPONENTSASNEEDEDINTERMSOFANGULARNGMODULESYOUONLYNEEDTODEFINETHESERVICESINONENGMODULESEEJSMODULESVSNGMODULESGUIDENGMODULEVSJSMODULEFORMOREINFORMATIONONHOWTODIFFERENTIATEBETWEENTHETWO",
-    "original": "Now you can inject such services into components as needed. In terms of\nAngular NgModules, you only need to define the services in one `@NgModule`.\nSee [JS Modules vs. NgModules](guide/ngmodule-vs-jsmodule) for\nmore information on how to differentiate between the two.",
-    "translation": "现在，你可以把这些服务注入到需要它们的各个组件中了。\n从 Angular 模块的角度来说，你只需要把这些服务定义在一个 `@NgModule` 中。\n要想深入了解两者的区别，参见 [JS 模块 vs. NgModule](guide/ngmodule-vs-jsmodule)。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/singleton-services.md"
-  },
-  {
-    "key": "ASAGENERALRULEIMPORTMODULESWITHPROVIDERSEXACTLYONCEPREFERABLYINTHEAPPLICATIONSROOTMODULETHATSALSOUSUALLYTHEBESTPLACETOCONFIGUREWRAPANDOVERRIDETHEM",
-    "original": "As a general rule, import modules with providers _exactly once_,\npreferably in the application's _root module_.\nThat's also usually the best place to configure, wrap, and override them.",
-    "translation": "作为一个通用的规则，应该*只导入一次*带提供商的模块，最好在应用的*根模块*中。\n那里也是配置、包装和改写这些服务的最佳位置。",
+    "key": "BEGINNINGWITHANGULAR60THEPREFERREDWAYTOCREATEASINGLETONSERVICESISTOSPECIFYONTHESERVICETHATITSHOULDBEPROVIDEDINTHEAPPLICATIONROOTTHISISDONEBYSETTINGPROVIDEDINTOROOTONTHESERVICESINJECTABLEDECORATOR:",
+    "original": "Beginning with Angular 6.0, the preferred way to create a singleton services is to specify on the service that it should be provided in the application root. This is done by setting `providedIn` to `root` on the service's `@Injectable` decorator:",
+    "translation": "从 Angular 6.0 开始，创建单例服务的首选方式是在那个服务类上指定它应该在应用的根上提供。只要在该服务的 `@Injectable` 装饰器上把 `providedIn` 设置为 `root` 就可以了：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/singleton-services.md"
   },
   {
@@ -36306,9 +36846,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/styleguide.md"
   },
   {
-    "key": "DOPROVIDESERVICESTOTHEANGULARINJECTORATTHETOPMOSTCOMPONENTWHERETHEYWILLBESHARED",
-    "original": "**Do** provide services to the Angular injector at the top-most component where they will be shared.",
-    "translation": "**坚持**将服务提供到共享范围内的顶级组件的 Angular 注入器。",
+    "key": "DOPROVIDEASERVICEWITHTHEAPPROOTINJECTORINTHEINJECTABLEDECORATOROFTHESERVICE",
+    "original": "**Do** provide a service with the app root injector in the `@Injectable` decorator of the service.",
+    "translation": "**坚持**在服务的 `@Injectable` 装饰器上指定通过应用的根注入器提供服务。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/styleguide.md"
   },
   {
@@ -36318,15 +36858,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/styleguide.md"
   },
   {
-    "key": "WHYWHENPROVIDINGTHESERVICETOATOPLEVELCOMPONENTTHATINSTANCEISSHAREDANDAVAILABLETOALLCHILDCOMPONENTSOFTHATTOPLEVELCOMPONENT",
-    "original": "**Why?** When providing the service to a top level component,\nthat instance is shared and available to all child components of that top level component.",
-    "translation": "**为何？**在顶层组件提供服务时，该服务实例在所有子组件中可见并共享。",
+    "key": "WHYWHENYOUPROVIDETHESERVICETOAROOTINJECTORTHATINSTANCEOFTHESERVICEISSHAREDANDAVAILABLEINEVERYCLASSTHATNEEDSTHESERVICETHISISIDEALWHENASERVICEISSHARINGMETHODSORSTATE",
+    "original": "**Why?** When you provide the service to a root injector, that instance of the service is shared and available in every class that needs the service. This is ideal when a service is sharing methods or state.",
+    "translation": "**为何？**当你在根注入器上提供该服务时，该服务实例在每个需要该服务的类中是共享的。当服务要共享方法或状态时，这是最理想的选择。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/styleguide.md"
   },
   {
-    "key": "WHYTHISISIDEALWHENASERVICEISSHARINGMETHODSORSTATE",
-    "original": "**Why?** This is ideal when a service is sharing methods or state.",
-    "translation": "**为何？**服务是共享方法或状态的理想载体。",
+    "key": "WHYWHENYOUREGISTERASERVICEINTHEINJECTABLEDECORATOROFTHESERVICEOPTIMIZATIONTOOLSSUCHASTHOSEUSEDBYTHECLISPRODUCTIONBUILDSCANPERFORMTREESHAKINGANDREMOVESERVICESTHATARENTUSEDBYYOURAPP",
+    "original": "**Why?** When you register a service in the `@Injectable` decorator of the service, optimization tools such as those used by the CLI's production builds can perform tree shaking and remove services that aren't used by your app.",
+    "translation": "**为何？**当你在服务的 `@Injectable` 中注册服务时，CLI 生产环境构建时使用的优化工具可以进行摇树优化，从而移除那些你的应用中从未用过的服务。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/styleguide.md"
   },
   {
@@ -39438,15 +39978,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
-    "key": "YOUCANFINETUNEMANYOPTIONSBYEDITINGTHEKARMACONFJSFILEINTHEPROJECTROOTFOLDERANDTHETESTTSFILEINTHESRCFOLDER",
-    "original": "You can fine-tune many options by editing the `karma.conf.js` file in the project root folder and\nthe `test.ts` file in the `src/` folder.",
-    "translation": "不过你也可以通过编辑项目根目录下的 `karma.conf.js` 文件以及 `src/` 目录下的 `test.ts` 文件来微调很多选项。",
+    "key": "YOUCANFINETUNEMANYOPTIONSBYEDITINGTHEKARMACONFJSANDTHETESTTSFILESINTHESRCFOLDER",
+    "original": "You can fine-tune many options by editing the `karma.conf.js` and\nthe `test.ts` files in the `src/` folder.",
+    "translation": "不过你也可以通过编辑 `src/` 目录下的 `karma.conf.js` 和 `test.ts` 文件来微调很多选项。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
-    "key": "THEKARMACONFJSFILEISAPARTIALKARMACONFIGURATIONFILETHECLICONSTRUCTSTHEFULLRUNTIMECONFIGURATIONINMEMORYBASEDONAPPLICATIONSTRUCTURESPECIFIEDINTHEANGULARCLIJSONFILESUPPLEMENTEDBYKARMACONFJS",
-    "original": "The `karma.conf.js` file is a partial karma configuration file.\nThe CLI constructs the full runtime configuration in memory,based on application structure specified in the `.angular-cli.json` file, supplemented by `karma.conf.js`.",
-    "translation": "`karma.conf.js` 文件是 karma 配置文件的一部分。\nCLI 会基于 `.angular-cli.json` 文件中指定的项目结构和 `karma.conf.js` 文件，来在内存中构建出完整的运行时配置。",
+    "key": "THEKARMACONFJSFILEISAPARTIALKARMACONFIGURATIONFILETHECLICONSTRUCTSTHEFULLRUNTIMECONFIGURATIONINMEMORYBASEDONAPPLICATIONSTRUCTURESPECIFIEDINTHEANGULARJSONFILESUPPLEMENTEDBYKARMACONFJS",
+    "original": "The `karma.conf.js` file is a partial karma configuration file.\nThe CLI constructs the full runtime configuration in memory,based on application structure specified in the `angular.json` file, supplemented by `karma.conf.js`.",
+    "translation": "`karma.conf.js` 文件是 karma 配置文件的一部分。\nCLI 会基于 `angular.json` 文件中指定的项目结构和 `karma.conf.js` 文件，来在内存中构建出完整的运行时配置。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
@@ -39738,21 +40278,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
-    "key": "THEHEROSERVICEMETHODSRETURNOBSERVABLESSUBSCRIBETOTHEMETHODOBSERVABLETOACAUSEITTOEXECUTEANDBASSERTTHATTHEMETHODSUCCEEDSORFAILS",
-    "original": "The `HeroService` methods return _Observables_.\n_Subscribe_ to the method observable to (a) cause it to execute and (b)\nassert that the method succeeds or fails.",
-    "translation": "`HttpService` 中的方法会返回*可观察对象*。*订阅*这些方法返回的可观察对象会让它开始执行，并且断言这些方法是成功了还是失败了。",
+    "key": "THEHEROSERVICEMETHODSRETURNOBSERVABLESYOUMUSTSUBSCRIBETOANOBSERVABLETOACAUSEITTOEXECUTEANDBASSERTTHATTHEMETHODSUCCEEDSORFAILS",
+    "original": "The `HeroService` methods return `Observables`. You must\n_subscribe_ to an observable to (a) cause it to execute and (b)\nassert that the method succeeds or fails.",
+    "translation": "`HttpService` 中的方法会返回 `Observables`。*订阅*这些方法返回的可观察对象会让它开始执行，并且断言这些方法是成功了还是失败了。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
-    "key": "THESUBSCRIBEMETHODTAKESASUCCESSANDFAILCALLBACKMAKESUREYOUPROVIDEBOTHCALLBACKSSOTHATYOUCAPTUREERRORS",
-    "original": "The `subscribe()` method takes a success and fail callback.\nMake sure you provide _both_ callbacks so that you capture errors.",
-    "translation": "`subscribe()` 方法接受一个成功回调和一个失败回调。\n你要确保同时提供了这两个回调，以便捕获错误。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
-  },
-  {
-    "key": "NEGLECTINGTODOSOPRODUCESANASYNCHRONOUSUNCAUGHTOBSERVABLEERRORTHATTHETESTRUNNERWILLLIKELYATTRIBUTETOACOMPLETELYDIFFERENTTEST",
-    "original": "Neglecting to do so produces an asynchronous uncaught observable error that\nthe test runner will likely attribute to a completely different test.",
-    "translation": "如果忽略这些异步调用中未捕获的错误，测试运行器可能会得出截然不同的测试结论。",
+    "key": "THESUBSCRIBEMETHODTAKESASUCCESSNEXTANDFAILERRORCALLBACKMAKESUREYOUPROVIDEBOTHCALLBACKSSOTHATYOUCAPTUREERRORSNEGLECTINGTODOSOPRODUCESANASYNCHRONOUSUNCAUGHTOBSERVABLEERRORTHATTHETESTRUNNERWILLLIKELYATTRIBUTETOACOMPLETELYDIFFERENTTEST",
+    "original": "The `subscribe()` method takes a success (`next`) and fail (`error`) callback.\nMake sure you provide _both_ callbacks so that you capture errors. \nNeglecting to do so produces an asynchronous uncaught observable error that\nthe test runner will likely attribute to a completely different test.",
+    "translation": "`subscribe()` 方法接受一个成功回调 (`next`) 和一个失败 (`error`) 回调。\n你要确保同时提供了这两个回调，以便捕获错误。\n如果忽略这些异步调用中未捕获的错误，测试运行器可能会得出截然不同的测试结论。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
@@ -40663,7 +41197,7 @@
   },
   {
     "key": "THESPYISDESIGNEDSUCHTHATANYCALLTOGETQUOTERECEIVESANOBSERVABLEWITHATESTQUOTEUNLIKETHEREALGETQUOTEMETHODTHISSPYBYPASSESTHESERVERANDRETURNSASYNCHRONOUSOBSERVABLEWHOSEVALUEISAVAILABLEIMMEDIATELY",
-    "original": "The spy is designed such that any call to `getQuote` receives an Observable with a test quote.\nUnlike the real `getQuote()` method, this spy bypasses the server\nand returns a synchronous Observable whose value is available immediately.",
+    "original": "The spy is designed such that any call to `getQuote` receives an observable with a test quote.\nUnlike the real `getQuote()` method, this spy bypasses the server\nand returns a synchronous observable whose value is available immediately.",
     "translation": "这个间谍的设计是：任何对 `getQuote` 的调用都会收到一个包含测试引文的可观察对象。\n和真正的 `getQuote()` 方法不同，这个间谍跳过了服务器，直接返回了一个能立即解析出值的同步型可观察对象。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
@@ -40788,15 +41322,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
-    "key": "RXJSDEFERHTTP:REACTIVEXIODOCUMENTATIONOPERATORSDEFERHTMLRETURNSANOBSERVABLEITTAKESAFACTORYFUNCTIONTHATRETURNSEITHERAPROMISEORANOBSERVABLEWHENSOMETHINGSUBSCRIBESTODEFERSOBSERVABLEITADDSTHESUBSCRIBERTOANEWOBSERVABLECREATEDWITHTHATFACTORY",
-    "original": "[RxJS `defer()`](http://reactivex.io/documentation/operators/defer.html) returns an observable.\nIt takes a factory function that returns either a promise or an observable.\nWhen something subscribes to _defer_'s observable,\nit adds the subscriber to a new observable created with that factory.",
-    "translation": "[RxJS `defer()`](http://reactivex.io/documentation/operators/defer.html) （延期）返回一个可观察对象。\n它获取一个工厂函数，这个工厂函数或者返回 Promise 或者返回 Observable。\n当有人订阅了这个 `defer` 的可观察对象时，它就会把这个订阅者添加到由那个工厂函数创建的新的可观察对象中。",
+    "key": "THERXJSDEFEROPERATORHTTP:REACTIVEXIODOCUMENTATIONOPERATORSDEFERHTMLRETURNSANOBSERVABLEITTAKESAFACTORYFUNCTIONTHATRETURNSEITHERAPROMISEORANOBSERVABLEWHENSOMETHINGSUBSCRIBESTODEFERSOBSERVABLEITADDSTHESUBSCRIBERTOANEWOBSERVABLECREATEDWITHTHATFACTORY",
+    "original": "The [RxJS `defer()` operator](http://reactivex.io/documentation/operators/defer.html) returns an observable.\nIt takes a factory function that returns either a promise or an observable.\nWhen something subscribes to _defer_'s observable,\nit adds the subscriber to a new observable created with that factory.",
+    "translation": "[RxJS 的 `defer()` （延期）操作符](http://reactivex.io/documentation/operators/defer.html) 会返回一个可观察对象。\n它获取一个工厂函数，这个工厂函数或者返回 Promise 或者返回 Observable。\n当有人订阅了这个 `defer` 的可观察对象时，它就会把这个订阅者添加到由那个工厂函数创建的新的可观察对象中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
-    "key": "RXJSDEFERTRANSFORMTHEPROMISERESOLVEINTOANEWOBSERVABLETHATLIKEHTTPCLIENTEMITSONCEANDCOMPLETESSUBSCRIBERSWILLBEUNSUBSCRIBEDAFTERTHEYRECEIVETHEDATAVALUE",
-    "original": "RxJS `defer()` transform the `Promise.resolve()` into a new observable that, \nlike `HttpClient`, emits once and completes.\nSubscribers will be unsubscribed after they receive the data value.",
-    "translation": "RxJS `defer()` 会把 `Promise.resolve()` 转换成一个新的可观察对象，然后像 `HttpClient` 那样的发出一个值，然后结束。\n订阅者将会在接收到这个数据值之后自动被取消订阅。",
+    "key": "THEDEFEROPERATORTRANSFORMSTHEPROMISERESOLVEINTOANEWOBSERVABLETHATLIKEHTTPCLIENTEMITSONCEANDCOMPLETESSUBSCRIBERSAREUNSUBSCRIBEDAFTERTHEYRECEIVETHEDATAVALUE",
+    "original": "The `defer()` operator transforms the `Promise.resolve()` into a new observable that, \nlike `HttpClient`, emits once and completes.\nSubscribers are unsubscribed after they receive the data value.",
+    "translation": "`defer()` 操作符会把 `Promise.resolve()` 转换成一个新的可观察对象，然后像 `HttpClient` 那样的发出一个值，然后结束。\n订阅者将会在接收到这个数据值之后自动被取消订阅。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
@@ -41490,15 +42024,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
-    "key": "THEHERODETAILCOMPONENTNEEDSTHEIDPARAMETERSOITCANFETCHTHECORRESPONDINGHEROVIATHEHERODETAILSERVICE",
-    "original": "The `HeroDetail` component needs the `id` parameter so it can fetch \nthe corresponding hero via the `HeroDetailService`.",
-    "translation": "`HeroDetailComponent` 组件需要一个 `id` 参数，以便通过 `HeroDetailService` 获取相应的英雄。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
-  },
-  {
-    "key": "THECOMPONENTHASTOGETTHEIDFROMTHEACTIVATEDROUTEPARAMMAPPROPERTYWHICHISANOBSERVABLE",
-    "original": "The component has to get the `id` from the `ActivatedRoute.paramMap` property\nwhich is an _Observable_.",
-    "translation": "该组件只能从 `ActivatedRoute.paramMap` 属性中获取这个 `id`，这个属性是一个 `Observable`。",
+    "key": "THEHERODETAILCOMPONENTNEEDSTHEIDPARAMETERSOITCANFETCHTHECORRESPONDINGHEROVIATHEHERODETAILSERVICETHECOMPONENTHASTOGETTHEIDFROMTHEACTIVATEDROUTEPARAMMAPPROPERTYWHICHISANOBSERVABLE",
+    "original": "The `HeroDetail` component needs the `id` parameter so it can fetch \nthe corresponding hero via the `HeroDetailService`. \nThe component has to get the `id` from the `ActivatedRoute.paramMap` property\nwhich is an `Observable`.",
+    "translation": "`HeroDetailComponent` 组件需要一个 `id` 参数，以便通过 `HeroDetailService` 获取相应的英雄。\n该组件只能从 `ActivatedRoute.paramMap` 属性中获取这个 `id`，这个属性是一个 `Observable`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
@@ -42456,9 +42984,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
-    "key": "ITTAKESTWOARGUMENTS:THECOMPONENTTYPETOOVERRIDEHERODETAILCOMPONENTANDANOVERRIDEMETADATAOBJECTTHEOVERIDEMETADATAOBJECT#METADATAOVERRIDEOBJECTISAGENERICDEFINEDASFOLLOWS:",
-    "original": "It takes two arguments: the component type to override (`HeroDetailComponent`) and an override metadata object.\nThe [overide metadata object](#metadata-override-object) is a generic defined as follows:",
-    "translation": "它接受两个参数：要改写的组件类（`HeroDetailComponent`），以及用于改写的元数据对象：",
+    "key": "ITTAKESTWOARGUMENTS:THECOMPONENTTYPETOOVERRIDEHERODETAILCOMPONENTANDANOVERRIDEMETADATAOBJECTTHEOVERRIDEMETADATAOBJECT#METADATAOVERRIDEOBJECTISAGENERICDEFINEDASFOLLOWS:",
+    "original": "It takes two arguments: the component type to override (`HeroDetailComponent`) and an override metadata object.\nThe [override metadata object](#metadata-override-object) is a generic defined as follows:",
+    "translation": "它接受两个参数：要改写的组件类型（`HeroDetailComponent`），以及用于改写的元数据对象。\n[用于改写的元数据对象](#metadata-override-object)是一个泛型，其定义如下：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/testing.md"
   },
   {
@@ -43687,8 +44215,8 @@
   },
   {
     "key": "NODEHTTPS:WWWNPMJSCOMPACKAGETYPESNODEFORCODETHATREFERENCESOBJECTSINTHENODEJSENVIRONMENTYOUCANVIEWANEXAMPLEINTHEWEBPACKGUIDEWEBPACKPAGE",
-    "original": "* [node](https://www.npmjs.com/package/@types/node) for code that references objects in the *nodejs* environment;\nyou can view an example in the [webpack](guide/webpack) page.",
-    "translation": "[node](https://www.npmjs.com/package/@types/node)是为了在 *nodejs* 环境中引用对象的代码提供的类型定义。在[webpack](guide/webpack)页面可以看到例子。",
+    "original": "* [node](https://www.npmjs.com/package/@types/node) for code that references objects in the *Node.js®* environment;\nyou can view an example in the [webpack](guide/webpack) page.",
+    "translation": "[node](https://www.npmjs.com/package/@types/node)是为了在 *Node.js®* 环境中引用对象的代码提供的类型定义。在[webpack](guide/webpack)页面可以看到例子。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/typescript-configuration.md"
   },
   {
@@ -43746,9 +44274,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/universal.md"
   },
   {
-    "key": "DOWNLOADTHEFINISHEDSAMPLECODEGENERATEDZIPSUNIVERSALUNIVERSALZIPWHICHRUNSINANODEEXPRESSHTTPS:EXPRESSJSCOMSERVER",
-    "original": "[Download the finished sample code](generated/zips/universal/universal.zip),\nwhich runs in a [node express](https://expressjs.com/) server.",
-    "translation": "你可以[下载最终的范例代码](generated/zips/universal/universal.zip)，并将其运行在一个 [node express](https://expressjs.com/) 服务器中。",
+    "key": "DOWNLOADTHEFINISHEDSAMPLECODEGENERATEDZIPSUNIVERSALUNIVERSALZIPWHICHRUNSINANODEJSEXPRESSHTTPS:EXPRESSJSCOMSERVER",
+    "original": "[Download the finished sample code](generated/zips/universal/universal.zip),\nwhich runs in a [Node.js® Express](https://expressjs.com/) server.",
+    "translation": "你可以[下载最终的范例代码](generated/zips/universal/universal.zip)，并将其运行在一个 [Node.js® Express](https://expressjs.com/) 服务器中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/universal.md"
   },
   {
@@ -43956,9 +44484,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/universal.md"
   },
   {
-    "key": "INTHISEXAMPLETHEANGULARCLICOMPILESANDBUNDLESTHEUNIVERSALVERSIONOFTHEAPPWITHTHEAOTAHEADOFTIMECOMPILERGUIDEAOTCOMPILERANODEEXPRESSWEBSERVERTURNSCLIENTREQUESTSINTOTHEHTMLPAGESRENDEREDBYUNIVERSAL",
-    "original": "In this example, the Angular CLI compiles and bundles the Universal version of the app with the\n[AOT (Ahead-of-Time) compiler](guide/aot-compiler).\nA node/express web server turns client requests into the HTML pages rendered by Universal.",
-    "translation": "在这个例子中，Angular CLI 会使用 [AOT (预先) 编译器](guide/aot-compiler)对该应用的 Universal 版本进行编译和打包。\nNode 的 Express Web 服务器会把客户端请求转换成由 Universal 渲染出的页面。",
+    "key": "INTHISEXAMPLETHEANGULARCLICOMPILESANDBUNDLESTHEUNIVERSALVERSIONOFTHEAPPWITHTHEAOTAHEADOFTIMECOMPILERGUIDEAOTCOMPILERANODEJSEXPRESSWEBSERVERTURNSCLIENTREQUESTSINTOTHEHTMLPAGESRENDEREDBYUNIVERSAL",
+    "original": "In this example, the Angular CLI compiles and bundles the Universal version of the app with the\n[AOT (Ahead-of-Time) compiler](guide/aot-compiler).\nA Node.js® Express web server turns client requests into the HTML pages rendered by Universal.",
+    "translation": "在这个例子中，Angular CLI 会使用 [AOT (预先) 编译器](guide/aot-compiler)对该应用的 Universal 版本进行编译和打包。\nNode.js® 的 Express Web 服务器会把客户端请求转换成由 Universal 渲染出的页面。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/universal.md"
   },
   {
@@ -44706,9 +45234,171 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/universal.md"
   },
   {
-    "key": "#UPGRADINGFROMANGULARJS",
-    "original": "# Upgrading from AngularJS",
-    "translation": "# 从 AngularJS 升级",
+    "key": "#UPDATINGYOURANGULARPROJECTS",
+    "original": "# Updating your Angular projects",
+    "translation": "# 升级你的 Angular 项目",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "JUSTLIKEWEBANDTHEENTIREWEBECOSYSTEMANGULARISCONTINUOUSLYIMPROVINGANGULARBALANCESCONTINUOUSIMPROVEMENTWITHASTRONGFOCUSONSTABILITYANDMAKINGUPDATESEASYKEEPINGYOURANGULARAPPUPTODATEENABLESYOUTOTAKEADVANTAGEOFLEADINGEDGENEWFEATURESASWELLASOPTIMIZATIONSANDBUGFIXES",
+    "original": "Just like Web and the entire web ecosystem, Angular is continuously improving. Angular balances continuous improvement with a strong focus on stability and making updates easy. Keeping your Angular app up-to-date enables you to take advantage of leading-edge new features, as well as optimizations and bug fixes.",
+    "translation": "就像 Web 及其整个生态系统一样，Angular 也在持续改进中。Angular 平衡了持续改进与强调稳定性之间的冲突，努力让升级变得更简单。让 Angular 应用始终保持最新，可以让你获得前沿的新特性所带来的好处，还有各种优化和 Bug 修复。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "THISDOCUMENTCONTAINSINFORMATIONANDRESOURCESTOHELPYOUKEEPYOURANGULARAPPSANDLIBRARIESUPTODATE",
+    "original": "This document contains information and resources to help you keep your Angular apps and libraries up-to-date.",
+    "translation": "本文档包含一些信息和资源，来帮助你持续更新 Angular 的应用和库。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "FORINFORMATIONABOUTOURVERSIONINGPOLICYANDPRACTICESMDASHINCLUDINGSUPPORTANDDEPRECATIONPRACTICESASWELLASTHERELEASESCHEDULEMDASHSEEANGULARVERSIONINGANDRELEASESGUIDERELEASESANGULARVERSIONINGANDRELEASES",
+    "original": "For information about our versioning policy and practices&mdash;including \nsupport and deprecation practices, as well as the release schedule&mdash;see [Angular versioning and releases](guide/releases \"Angular versioning and releases\").",
+    "translation": "要了解我们的版本策略和实践（包括支持的和反对的实践，以及发布计划），请参见 [Angular 的版本与发布](guide/releases \"Angular versioning and releases\")。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "IFYOUARECURRENTLYUSINGANGULARJSSEEUPGRADINGFROMANGULARJSGUIDEUPGRADEUPGRADINGFROMANGULARJSANGULARJSISTHENAMEFORALLV1XVERSIONSOFANGULAR",
+    "original": "If you are currently using AngularJS, see [Upgrading from AngularJS](guide/upgrade \"Upgrading from Angular JS\"). _AngularJS_ is the name for all v1.x versions of Angular.",
+    "translation": "如果你正在使用 AngularJS，参见[从 AngularJS 升级](guide/upgrade \"Upgrading from Angular JS\")。*AngularJS* 是专用于 Angular v1.x 的名字。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "##GETTINGNOTIFIEDOFNEWRELEASES",
+    "original": "## Getting notified of new releases",
+    "translation": "## 获得新版本的发布通知",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "TOBENOTIFIEDWHENNEWRELEASESAREAVAILABLEFOLLOWANGULARHTTPS:TWITTERCOMANGULARANGULARONTWITTERONTWITTERORSUBSCRIBETOTHEANGULARBLOGHTTPS:BLOGANGULARIOANGULARBLOG",
+    "original": "To be notified when new releases are available, follow [@angular](https://twitter.com/angular \"@angular on Twitter\") on Twitter or subscribe to the [Angular blog](https://blog.angular.io \"Angular blog\").",
+    "translation": "要想获得新版本发布通知，请关注 Twitter 上的 [@angular](https://twitter.com/angular \"@angular on Twitter\") 或订阅 [Angular 官方博客](https://blog.angular.io \"Angular blog\")。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "##LEARNINGABOUTNEWFEATURES",
+    "original": "## Learning about new features",
+    "translation": "## 了解最新特性",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "WHATSNEWWHATSCHANGEDWESHARETHEMOSTIMPORTANTTHINGSYOUNEEDTOKNOWONTHEANGULARBLOGINRELEASEANNOUNCEMENTSHTTPS:BLOGANGULARIOTAGGEDRELEASE20NOTESANGULARBLOGRELEASEANNOUNCEMENTS",
+    "original": "What's new? What's changed? We share the most important things you need to know on the Angular blog in [release announcements]( https://blog.angular.io/tagged/release%20notes \"Angular blog - release announcements\").",
+    "translation": "有什么新特性？有哪些变化？我们会在 Angular 官方博客的[发布声明]( https://blog.angular.io/tagged/release%20notes \"Angular blog - release announcements\")中和你共享那些最重要的信息。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "TOREVIEWACOMPLETELISTOFCHANGESORGANIZEDBYVERSIONSEETHEANGULARCHANGELOGHTTPS:GITHUBCOMANGULARANGULARBLOBMASTERCHANGELOGMDANGULARCHANGELOG",
+    "original": "To review a complete list of changes, organized by version, see the [Angular change log](https://github.com/angular/angular/blob/master/CHANGELOG.md \"Angular change log\").",
+    "translation": "要查看完整的按版本组织的变更列表，参见 [Angular 更改记录](https://github.com/angular/angular/blob/master/CHANGELOG.md \"Angular change log\")。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "##CHECKINGYOURVERSIONOFANGULAR",
+    "original": "## Checking your version of Angular",
+    "translation": "## 检查你的 Angular 版本",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "TOCHECKYOURAPPSVERSIONOFANGULAR:FROMWITHINYOURPROJECTDIRECTORYUSETHENGVERSIONCOMMAND",
+    "original": "To check your app's version of Angular: From within your project directory, use the `ng version` command.",
+    "translation": "要检查你的应用的 Angular 版本，就到项目目录下执行 `ng version` 命令。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "##FINDINGTHECURRENTVERSIONOFANGULAR",
+    "original": "## Finding the current version of Angular",
+    "translation": "## 查看 Angular 的当前版本",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "THEMOSTRECENTSTABLERELEASEDVERSIONOFANGULARAPPEARSINTHEANGULARDOCUMENTATIONHTTPS:ANGULARIODOCSANGULARDOCUMENTATIONATTHEBOTTOMOFTHELEFTSIDENAVIGATIONFOREXAMPLESTABLEV529",
+    "original": "The most recent stable released version of Angular appears in the [Angular documentation](https://angular.io/docs \"Angular documentation\") at the bottom of the left side navigation. For example, `stable (v5.2.9)`.",
+    "translation": "在 [Angular 文档站](https://angular.io/docs \"Angular documentation\")左侧导航栏的底部可以看到 Angular 最新的稳定版版本号。比如 `stable (v5.2.9)`。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "YOUCANALSOFINDTHEMOSTCURRENTVERSIONOFANGULARBYUSINGTHECLICOMMANDNGUPDATEHTTPS:GITHUBCOMANGULARANGULARCLIWIKIUPDATEANGULARCLIUPDATEDOCUMENTATIONBYDEFAULTNGUPDATEWITHOUTADDITIONALARGUMENTSLISTSTHEUPDATESTHATAREAVAILABLETOYOU",
+    "original": "You can also find the most current version of Angular by using the [CLI command `ng update`](https://github.com/angular/angular-cli/wiki/update \"Angular CLI update documentation\"). By default, `ng update` (without additional arguments) lists the updates that are available to you.",
+    "translation": "你还可以使用 [CLI 命令 `ng update`](https://github.com/angular/angular-cli/wiki/update \"Angular CLI update documentation\") 发现 Angular 的最新版本。默认情况下，`ng update`（不需要其它参数）会列出你可用的所有更新。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "##UPDATINGYOURENVIRONMENTANDAPPS",
+    "original": "## Updating your environment and apps",
+    "translation": "## 升级你的环境和应用",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "TOMAKEUPDATINGEASYWEPROVIDECOMPLETEINSTRUCTIONSINTHEINTERACTIVEANGULARUPDATEGUIDEHTTPS:UPDATEANGULARIOANGULARUPDATEGUIDE",
+    "original": "To make updating easy, we provide complete instructions in the interactive [Angular Update Guide](https://update.angular.io/ \"Angular Update Guide\").",
+    "translation": "为了让升级更简单，我们在交互式 [Angular 升级指南](https://update.angular.io/ \"Angular Update Guide\")中提供了完整的操作指令。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "THEANGULARUPDATEGUIDEPROVIDESCUSTOMIZEDUPDATEINSTRUCTIONSBASEDONTHECURRENTANDTARGETVERSIONSTHATYOUSPECIFYITINCLUDESBASICANDADVANCEDUPDATEPATHSTOMATCHTHECOMPLEXITYOFYOURAPPLICATIONSITALSOINCLUDESTROUBLESHOOTINGINFORMATIONANDANYRECOMMENDEDMANUALCHANGESTOHELPYOUGETTHEMOSTOUTOFTHENEWRELEASE",
+    "original": "The Angular Update Guide provides customized update instructions, based on the current and target versions that you specify. It includes basic and advanced update paths, to match the complexity of your applications. It also includes troubleshooting information and any recommended manual changes to help you get the most out of the new release.",
+    "translation": "Angular 升级指南提供了自定义的升级指令，基于当前版本和你指定的目标版本。它包括简单的和高级的升级路径，以适应你应用中的各种复杂情况。它还包括诊断信息和建议的手动修改动作，以帮助你获得最新版本。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "FORSIMPLEUPDATESTHECLICOMMANDNGUPDATEHTTPS:GITHUBCOMANGULARANGULARCLIWIKIUPDATEANGULARCLIUPDATEDOCUMENTATIONISALLYOUNEEDWITHOUTADDITIONALARGUMENTSNGUPDATELISTSTHEUPDATESTHATAREAVAILABLETOYOUANDPROVIDESRECOMMENDEDSTEPSTOUPDATEYOURAPPLICATIONTOTHEMOSTCURRENTVERSION",
+    "original": "For simple updates, the [CLI command `ng update`](https://github.com/angular/angular-cli/wiki/update \"Angular CLI update documentation\") is all you need. Without additional arguments, `ng update` lists the updates that are available to you and provides recommended steps to update your application to the most current version.",
+    "translation": "对于简单的升级工作，执行[CLI 命令 `ng update`](https://github.com/angular/angular-cli/wiki/update \"Angular CLI update documentation\")就是你所要做的一切。不带额外参数时，`ng update` 会列出你可用的更新版本，并提供建议的升级步骤，来把你的应用升级到最新版本上来。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "##RESOURCESUMMARY",
+    "original": "## Resource summary",
+    "translation": "## 资源汇总",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "RELEASEANNOUNCEMENTS:ANGULARBLOGRELEASEANNOUNCEMENTSHTTPS:BLOGANGULARIOTAGGEDRELEASE20NOTESANGULARBLOGANNOUNCEMENTSABOUTRECENTRELEASES",
+    "original": "* Release announcements: [Angular blog - release announcements](https://blog.angular.io/tagged/release%20notes \"Angular blog announcements about recent releases\")",
+    "translation": "发布声明：[Angular 博客 - 发布声明](https://blog.angular.io/tagged/release%20notes \"Angular blog announcements about recent releases\")",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "RELEASEANNOUNCEMENTSOLDER:ANGULARBLOGANNOUNCEMENTSABOUTRELEASESPRIORTOAUGUST2017HTTPS:BLOGANGULARJSORGSEARCHQAVAILABLEBYDATETRUEANGULARBLOGANNOUNCEMENTSABOUTRELEASESPRIORTOAUGUST2017",
+    "original": "* Release announcements (older): [Angular blog - announcements about releases prior to August 2017](https://blog.angularjs.org/search?q=available&by-date=true \"Angular blog announcements about releases prior to August 2017\")",
+    "translation": "发布声明（旧的）：[Angular 博客 - 2017 年 8 月以前的](https://blog.angularjs.org/search?q=available&by-date=true \"Angular blog announcements about releases prior to August 2017\")",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "RELEASEDETAILS:ANGULARCHANGELOGHTTPS:GITHUBCOMANGULARANGULARBLOBMASTERCHANGELOGMDANGULARCHANGELOG",
+    "original": "* Release details: [Angular change log](https://github.com/angular/angular/blob/master/CHANGELOG.md \"Angular change log\")",
+    "translation": "发布详情：[Angular 变更记录](https://github.com/angular/angular/blob/master/CHANGELOG.md \"Angular change log\")",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "UPDATEINSTRUCTIONS:ANGULARUPDATEGUIDEHTTPS:UPDATEANGULARIOANGULARUPDATEGUIDE",
+    "original": "* Update instructions: [Angular Update Guide](https://update.angular.io/ \"Angular Update Guide\")",
+    "translation": "升级指南：[Angular 升级向导](https://update.angular.io/ \"Angular Update Guide\")",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "UPDATECOMMANDREFERENCE:ANGULARCLIUPDATEDOCUMENTATIONHTTPS:GITHUBCOMANGULARANGULARCLIWIKIUPDATEANGULARCLIUPDATEDOCUMENTATION",
+    "original": "* Update command reference: [Angular CLI update documentation](https://github.com/angular/angular-cli/wiki/update \"Angular CLI update documentation\")",
+    "translation": "升级命令参考文档：[Angular CLI 升级文档](https://github.com/angular/angular-cli/wiki/update \"Angular CLI update documentation\")",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "VERSIONINGRELEASESUPPORTANDDEPRECATIONPRACTICES:ANGULARVERSIONINGANDRELEASESGUIDERELEASESANGULARVERSIONINGANDRELEASES",
+    "original": "* Versioning, release, support, and deprecation practices: [Angular versioning and releases](guide/releases \"Angular versioning and releases\")",
+    "translation": "版本、发布、支持与废弃的实践：[Angular 的版本与发布](guide/releases \"Angular versioning and releases\")",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "RELEASESCHEDULE:ANGULARVERSIONINGANDRELEASESGUIDERELEASES#SCHEDULEANGULARVERSIONINGANDRELEASES",
+    "original": "* Release schedule: [Angular versioning and releases](guide/releases#schedule \"Angular versioning and releases\")",
+    "translation": "发布计划：[Angular 的版本与发布](guide/releases#schedule \"Angular versioning and releases\")",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/updating.md"
+  },
+  {
+    "key": "#UPGRADINGFROMANGULARJSTOANGULAR",
+    "original": "# Upgrading from AngularJS to Angular",
+    "translation": "# 从 AngularJS 升级到 Angular",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/upgrade.md"
   },
   {
@@ -46111,7 +46801,7 @@
   },
   {
     "key": "THEMETHODSNOWRETURNOBSERVABLESOFTYPEPHONEDATAANDPHONEDATATHISISATYPEYOUDONTHAVEYETADDASIMPLEINTERFACEFORIT:",
-    "original": "The methods now return Observables of type `PhoneData` and `PhoneData[]`. This is\na type you don't have yet. Add a simple interface for it:",
+    "original": "The methods now return observables of type `PhoneData` and `PhoneData[]`. This is\na type you don't have yet. Add a simple interface for it:",
     "translation": "该方法现在返回一个 `Phone` 类型或 `Phone[]` 类型的可观察对象(Observable)。\n这是一个你从未用过的类型，因此你得为它新增一个简单的接口：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/upgrade.md"
   },
@@ -46153,13 +46843,13 @@
   },
   {
     "key": "NOWTHEREARETWOANGULARJSCOMPONENTSUSINGANANGULARSERVICETHECOMPONENTSDONTNEEDTOBEAWAREOFTHISTHOUGHTHEFACTTHATTHESERVICERETURNSOBSERVABLESANDNOTPROMISESISABITOFAGIVEAWAYINANYCASEWHATYOUVEACHIEVEDISAMIGRATIONOFASERVICETOANGULARWITHOUTHAVINGTOYETMIGRATETHECOMPONENTSTHATUSEIT",
-    "original": "Now there are two AngularJS components using an Angular service!\nThe components don't need to be aware of this, though the fact that the\nservice returns Observables and not Promises is a bit of a giveaway.\nIn any case, what you've achieved is a migration of a service to Angular\nwithout having to yet migrate the components that use it.",
+    "original": "Now there are two AngularJS components using an Angular service!\nThe components don't need to be aware of this, though the fact that the\nservice returns observables and not promises is a bit of a giveaway.\nIn any case, what you've achieved is a migration of a service to Angular\nwithout having to yet migrate the components that use it.",
     "translation": "这里的两个 AngularJS 控制器在使用 Angular 的服务！控制器不需要关心这一点，尽管实际上该服务返回的是可观察对象(Observable)，而不是承诺(Promise)。\n无论如何，你达到的效果都是把服务移植到 Angular，而不用被迫移植组件来使用它。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/upgrade.md"
   },
   {
     "key": "YOUCOULDUSETHETOPROMISEMETHODOFOBSERVABLETOTURNTHOSEOBSERVABLESINTOPROMISESINTHESERVICEINMANYCASESTHATREDUCETHENUMBEROFCHANGESTOTHECOMPONENTCONTROLLERS",
-    "original": "You could use the `toPromise` method of `Observable` to turn those\nObservables into Promises in the service. In many cases that reduce\nthe number of changes to the component controllers.",
+    "original": "You could use the `toPromise` method of `Observable` to turn those\nobservables into promises in the service. In many cases that reduce\nthe number of changes to the component controllers.",
     "translation": "你也能使用 `Observable` 的 `toPromise` 方法来在服务中把这些可观察对象转变成承诺，以进一步减小组件控制器中需要修改的代码量。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/upgrade.md"
   },
@@ -47178,9 +47868,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/visual-studio-2015.md"
   },
   {
-    "key": "VERIFYTHATYOUARERUNNINGNODEVERSION46XORGREATERANDNPM3XXORGREATERBYRUNNINGNODEVANDNPMVINATERMINALWINDOWOLDERVERSIONSPRODUCEERRORS",
-    "original": "**Verify that you are running node version `4.6.x` or greater, and npm `3.x.x` or greater**\nby running `node -v` and `npm -v` in a terminal window.\nOlder versions produce errors.",
-    "translation": "在终端或者控制台中运行 `node -v` 和 `npm -v`，**请确认你的 Node 版本为 `4.6.x` 或更高，npm 的版本为 `3.x.x` 或更高**。老版本会引起错误。",
+    "key": "VERIFYTHATYOUARERUNNINGNODEJSVERSION8XORGREATERANDNPM5XORGREATERBYRUNNINGNODEVANDNPMVINATERMINALWINDOWOLDERVERSIONSPRODUCEERRORS",
+    "original": "**Verify that you are running Node.js version `8.x` or greater, and npm `5.x` or greater**\nby running `node -v` and `npm -v` in a terminal window.\nOlder versions produce errors.",
+    "translation": "在终端或者控制台中运行 `node -v` 和 `npm -v`，**请确认你的 Node.js 版本为 `8.x` 或更高，npm 的版本为 `5.x` 或更高**。老版本会引起错误。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/guide/visual-studio-2015.md"
   },
   {
@@ -48791,6 +49481,18 @@
     "translation": "这样 Angular CLI 就创建了一个带默认应用及其支持文件的新项目。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt0.md"
   },
+  {
+    "key": "YOUCANADDPREPACKAGEDFUNCTIONALITYTOANEWPROJECTBYUSINGTHENGADDCOMMANDTHENGADDCOMMANDTRANSFORMSAPROJECTBYAPPLYINGTHESCHEMATICSINTHESPECIFIEDPACKAGEFORMOREINFORMATIONSEETHEANGULARCLIDOCUMENTATIONHTTPS:GITHUBCOMANGULARANGULARCLIWIKIADDANGULARCLIDOCUMENTATION",
+    "original": "You can add pre-packaged functionality to a new project by using the `ng add` command. The `ng add` command transforms a project by applying the schematics in the specified package. \nFor more information, see the [Angular CLI documentation.](https://github.com/angular/angular-cli/wiki/add \"Angular CLI documentation\")",
+    "translation": "你可以使用 `ng add` 命令往新项目中添加一些预先打包好的功能。\n`ng add` 命令会通过应用来自特定 NPM 包中的图纸（schematic）来转换此项目。\n要了解更多，参见 [Angular CLI 文档](https://github.com/angular/angular-cli/wiki/add \"Angular CLI documentation\")。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt0.md"
+  },
+  {
+    "key": "ANGULARMATERIALPROVIDESSCHEMATICSFORTYPICALAPPLAYOUTSSEETHEANGULARMATERIALDOCUMENTATIONHTTPS:MATERIALANGULARIOGUIDESANGULARMATERIALDOCUMENTATIONFORDETAILS",
+    "original": "Angular Material provides schematics for typical app layouts. \nSee the [Angular Material documentation](https://material.angular.io/guides \"Angular Material documentation\") for details.",
+    "translation": "比如 Angular Material 就为一些典型布局提供了图纸。参见 [Angular Material 文档](https://material.angular.io/guides \"Angular Material documentation\")。",
+    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt0.md"
+  },
   {
     "key": "##SERVETHEAPPLICATION",
     "original": "## Serve the application",
@@ -49914,14 +50616,14 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt3.md"
   },
   {
-    "key": "INTHISPAGEYOULLTAKETHEFIRSTSTEPINTHATDIRECTIONBYMOVINGTHEHERODETAILSINTOASEPARATEREUSABLEHERODETAILSCOMPONENT",
-    "original": "In this page, you'll take the first step in that direction by moving the hero details into a separate, reusable `HeroDetailsComponent`.",
+    "key": "INTHISPAGEYOULLTAKETHEFIRSTSTEPINTHATDIRECTIONBYMOVINGTHEHERODETAILSINTOASEPARATEREUSABLEHERODETAILCOMPONENT",
+    "original": "In this page, you'll take the first step in that direction by moving the hero details into a separate, reusable `HeroDetailComponent`.",
     "translation": "本页面中，你将迈出第一步 —— 把英雄详情移入一个独立的、可复用的 `HeroDetailComponent`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt3.md"
   },
   {
-    "key": "THEHEROESCOMPONENTWILLONLYPRESENTTHELISTOFHEROESTHEHERODETAILSCOMPONENTWILLPRESENTDETAILSOFASELECTEDHERO",
-    "original": "The `HeroesComponent` will only present the list of heroes.\nThe `HeroDetailsComponent` will present details of a selected hero.",
+    "key": "THEHEROESCOMPONENTWILLONLYPRESENTTHELISTOFHEROESTHEHERODETAILCOMPONENTWILLPRESENTDETAILSOFASELECTEDHERO",
+    "original": "The `HeroesComponent` will only present the list of heroes.\nThe `HeroDetailComponent` will present details of a selected hero.",
     "translation": "`HeroesComponent` 将仅仅用来表示英雄列表。\n`HeroDetailComponent` 将用来表示所选英雄的详情。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt3.md"
   },
@@ -50232,8 +50934,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "THECOMMANDGENERATESSKELETONHEROSERVICECLASSINSRCAPPHEROSERVICETSTHEHEROSERVICECLASSSHOULDLOOKLIKETHEBELOW",
-    "original": "The command generates skeleton `HeroService` class in `src/app/hero.service.ts`\nThe `HeroService` class should look like the below.",
+    "key": "THECOMMANDGENERATESSKELETONHEROSERVICECLASSINSRCAPPHEROSERVICETSTHEHEROSERVICECLASSSHOULDLOOKLIKETHEFOLLOWINGEXAMPLE",
+    "original": "The command generates skeleton `HeroService` class in `src/app/hero.service.ts`\nThe `HeroService` class should look like the following example.",
     "translation": "该命令会在 `src/app/hero.service.ts` 中生成 `HeroService` 类的骨架。\n`HeroService` 类的代码如下：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
@@ -50244,21 +50946,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "NOTICETHATTHENEWSERVICEIMPORTSTHEANGULARINJECTABLESYMBOLANDANNOTATESTHECLASSWITHTHEINJECTABLEDECORATOR",
-    "original": "Notice that the new service imports the Angular `Injectable` symbol and annotates\nthe class with the `@Injectable()` decorator.",
-    "translation": "注意，这个新的服务导入了 Angular 的 `Injectable` 符号，并且给这个服务类添加了 `@Injectable()` 装饰器。",
+    "key": "NOTICETHATTHENEWSERVICEIMPORTSTHEANGULARINJECTABLESYMBOLANDANNOTATESTHECLASSWITHTHEINJECTABLEDECORATORTHISMARKSTHECLASSASONETHATPARTICIPATESINTHEDEPENDENCYINJECTIONSYSTEMTHEHEROSERVICECLASSISGOINGTOPROVIDEANINJECTABLESERVICEANDITCANALSOHAVEITSOWNINJECTEDDEPENDENCIESITDOESNTHAVEANYDEPENDENCIESYETBUTITWILLSOON#INJECTMESSAGESERVICE",
+    "original": "Notice that the new service imports the Angular `Injectable` symbol and annotates\nthe class with the `@Injectable()` decorator. This marks the class as one that participates in the _dependency injection system_. The `HeroService` class is going to provide an injectable service, and it can also have its own injected dependencies.\nIt doesn't have any dependencies yet, but [it will soon](#inject-message-service).",
+    "translation": "注意，这个新的服务导入了 Angular 的 `Injectable` 符号，并且给这个服务类添加了 `@Injectable()` 装饰器。\n它把这个类标记为*依赖注入系统*的参与者之一。`HeroService` 类将会提供一个可注入的服务，并且它还可以拥有自己的待注入的依赖。\n目前它还没有依赖，但是[很快就会有了](#inject-message-service)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "THEINJECTABLEDECORATORTELLSANGULARTHATTHISSERVICEMIGHTITSELFHAVEINJECTEDDEPENDENCIESITDOESNTHAVEDEPENDENCIESNOWBUTITWILLSOON#INJECTMESSAGESERVICEWHETHERITDOESORITDOESNTITSGOODPRACTICETOKEEPTHEDECORATOR",
-    "original": "The `@Injectable()` decorator tells Angular that this service _might_ itself\nhave injected dependencies.\nIt doesn't have dependencies now but [it will soon](#inject-message-service).\nWhether it does or it doesn't, it's good practice to keep the decorator.",
-    "translation": "`@Injectable()` 装饰器告诉 Angular 这个服务本身*可能*拥有被注入的依赖。\n目前它还没有依赖，但是[很快就会有了](#inject-message-service)。\n无论它会不会有，总是给服务加上这个装饰器都是一种好的做法。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
-  },
-  {
-    "key": "THEANGULARSTYLEGUIDELINESGUIDESTYLEGUIDE#STYLE0704STRONGLYRECOMMENDKEEPINGITANDTHELINTERENFORCESTHISRULE",
-    "original": "The Angular [style guidelines](guide/styleguide#style-07-04) strongly recommend keeping it\nand the linter enforces this rule.",
-    "translation": "Angular 的[风格指南](guide/styleguide#style-07-04)强烈建议加上，而且 linter（代码检查器） 也会确保这条规则。",
+    "key": "THEINJECTABLEDECORATORACCEPTSAMETADATAOBJECTFORTHESERVICETHESAMEWAYTHECOMPONENTDECORATORDIDFORYOURCOMPONENTCLASSES",
+    "original": "The `@Injectable()` decorator accepts a metadata object for the service, the same way the `@Component()` decorator did for your component classes.",
+    "translation": "`@Injectable()` 装饰器会接受该服务的元数据对象，就像 `@Component()` 对组件类的作用一样。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
@@ -50304,45 +51000,45 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "YOUMUSTPROVIDETHEHEROSERVICEINTHEDEPENDENCYINJECTIONSYSTEMBEFOREANGULARCANINJECTITINTOTHEHEROESCOMPONENTASYOUWILLDOBELOW#INJECT",
-    "original": "You must _provide_ the `HeroService` in the _dependency injection system_\nbefore Angular can _inject_ it into the `HeroesComponent`, \nas you will do [below](#inject).",
-    "translation": "在要求 Angular 把 `HeroService` 注入到 `HeroesComponent` 之前，你必须先把这个服务*提供给依赖注入系统*。[稍后](#inject)你就要这么做。",
+    "key": "YOUMUSTMAKETHEHEROSERVICEAVAILABLETOTHEDEPENDENCYINJECTIONSYSTEMBEFOREANGULARCANINJECTITINTOTHEHEROESCOMPONENTASYOUWILLDOBELOW#INJECTYOUDOTHISBYREGISTERINGAPROVIDERAPROVIDERISSOMETHINGTHATCANCREATEORDELIVERASERVICEINTHISCASEITINSTANTIATESTHEHEROSERVICECLASSTOPROVIDETHESERVICE",
+    "original": "You must make the `HeroService` available to the dependency injection system \nbefore Angular can _inject_ it into the `HeroesComponent`, \nas you will do [below](#inject). You do this by registering a _provider_. A provider is something that can create or deliver a service; in this case, it instantiates the `HeroService` class to provide the service.",
+    "translation": "在要求 Angular 把 `HeroService` 注入到 `HeroesComponent` 之前，你必须先把这个服务*提供给依赖注入系统*。[稍后](#inject)你就要这么做。\n你可以通过注册*提供商*来做到这一点。提供商用来创建和交付服务，在这个例子中，它会对 `HeroService` 类进行实例化，以提供该服务。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "THEREARESEVERALWAYSTOPROVIDETHEHEROSERVICE:INTHEHEROESCOMPONENTINTHEAPPCOMPONENTINTHEAPPMODULEEACHOPTIONHASPROSANDCONS",
-    "original": "There are several ways to provide the `HeroService`: \nin the `HeroesComponent`, in the `AppComponent`, in the `AppModule`.\nEach option has pros and cons.",
-    "translation": "有很多途径可以提供 `HeroService`：在 `HeroesComponent` 中、在 `AppComponent` 中，或在 `AppModule` 中。\n每个选项都各有优缺点。",
+    "key": "NOWYOUNEEDTOMAKESURETHATTHEHEROSERVICEISREGISTEREDASTHEPROVIDEROFTHISSERVICEYOUAREREGISTERINGITWITHANINJECTORWHICHISTHEOBJECTTHATISRESPONSIBLEFORCHOOSINGANDINJECTINGTHEPROVIDERWHEREITISREQUIRED",
+    "original": "Now, you need to make sure that the `HeroService` is registered as the provider of this service. \nYou are registering it with an _injector_, which is the object that is responsible for choosing and injecting the provider where it is required.",
+    "translation": "现在，你需要确保 `HeroService` 已经作为该服务的提供商进行过注册。\n你要用一个*注入器*注册它。注入器就是一个对象，负责在需要时选取和注入该提供商。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "THISTUTORIALCHOOSESTOPROVIDEITINTHEAPPMODULE",
-    "original": "This tutorial chooses to provide it in the `AppModule`.",
-    "translation": "这节课选择在 `AppModule` 中提供它。",
+    "key": "BYDEFAULTTHEANGULARCLICOMMANDNGGENERATESERVICEREGISTERSAPROVIDERWITHTHEROOTINJECTORFORYOURSERVICEBYINCLUDINGPROVIDERMETADATAINTHEINJECTABLEDECORATOR",
+    "original": "By default, the Angular CLI command `ng generate service` registers a provider with the _root injector_ for your service by including provider metadata in the `@Injectable` decorator.",
+    "translation": "默认情况下，Angular CLI 命令 `ng generate service` 会通过给 `@Injectable` 装饰器添加元数据的形式，为该服务把提供商注册到*根注入器*上。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "THATSSUCHAPOPULARCHOICETHATYOUCOULDHAVETOLDTHECLITOPROVIDEITTHEREAUTOMATICALLYBYAPPENDINGMODULEAPP",
-    "original": "That's such a popular choice that you could have told the CLI to provide it there automatically\nby appending `--module=app`.",
-    "translation": "这是一个常用的选择，因此你可以通过 `--module=app` 选项让 CLI 自动把它提供给 `AppModule`。",
+    "key": "IFYOULOOKATTHEINJECTABLESTATEMENTRIGHTBEFORETHEHEROSERVICECLASSDEFINITIONYOUCANSEETHATTHEPROVIDEDINMETADATAVALUEISROOT:",
+    "original": "If you look at the `@Injectable()` statement right before the `HeroService` class definition, you can see that the `providedIn` metadata value is 'root':",
+    "translation": "如果你看看 `HeroService` 紧前面的 `@Injectable()` 语句定义，就会发现 `providedIn` 元数据的值是 'root'：",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "SINCEYOUDIDNOTYOULLHAVETOPROVIDEITYOURSELF",
-    "original": "Since you did not, you'll have to provide it yourself.",
-    "translation": "如果不这样做，你就要自行提供它。",
+    "key": "WHENYOUPROVIDETHESERVICEATTHEROOTLEVELANGULARCREATESASINGLESHAREDINSTANCEOFHEROSERVICEANDINJECTSINTOANYCLASSTHATASKSFORITREGISTERINGTHEPROVIDERINTHEINJECTABLEMETADATAALSOALLOWSANGULARTOOPTIMIZEANAPPBYREMOVINGTHESERVICEIFITTURNSOUTNOTTOBEUSEDAFTERALL",
+    "original": "When you provide the service at the root level, Angular creates a single, shared instance of `HeroService` and injects into any class that asks for it. \nRegistering the provider in the `@Injectable` metadata also allows Angular to optimize an app by removing the service if it turns out not to be used after all.",
+    "translation": "当你在顶层提供该服务时，Angular 就会为 `HeroService` 创建一个单一的、共享的实例，并把它注入到任何想要它的类上。\n在 `@Injectable` 元数据中注册该提供商，还能让 Angular 可以通过移除那些完全没有用过的服务，来进行优化。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "OPENTHEAPPMODULECLASSIMPORTTHEHEROSERVICEANDADDITTOTHENGMODULEPROVIDERSARRAY",
-    "original": "Open the `AppModule` class, import the `HeroService`, and add it to the `@NgModule.providers` array.",
-    "translation": "打开 `AppModule` 类，导入 `HeroService`，并把它加入 `@NgModule.providers` 数组中。",
+    "key": "IFYOUNEEDTOYOUCANREGISTERPROVIDERSATDIFFERENTLEVELS:INTHEHEROESCOMPONENTINTHEAPPCOMPONENTINTHEAPPMODULEFORINSTANCEYOUCOULDHAVETOLDTHECLITOPROVIDETHESERVICEATTHEMODULELEVELAUTOMATICALLYBYAPPENDINGMODULEAPP",
+    "original": "If you need to, you can register providers at different levels: \nin the `HeroesComponent`, in the `AppComponent`, in the `AppModule`. \nFor instance, you could have told the CLI to provide the service at the module level automatically by appending `--module=app`.",
+    "translation": "如果需要，你也可以在不同的层次上注册提供商 —— 在 `HeroesComponent` 中、在 `AppComponent` 中，或在 `AppModule` 中。\n比如，你可以通过附加 `--module=app` 参数来告诉 CLI 要自动在模块级提供该服务。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "THEPROVIDERSARRAYTELLSANGULARTOCREATEASINGLESHAREDINSTANCEOFHEROSERVICEANDINJECTINTOANYCLASSTHATASKSFORIT",
-    "original": "The `providers` array tells Angular to create a single, shared instance of `HeroService`\nand inject into any class that asks for it.",
-    "translation": "`providers` 数组会告诉 Angular 创建 `HeroService` 的单一、共享的实例，并且把它注入到任何请求注入它的类中。",
+    "key": "TOLEARNMOREABOUTPROVIDERSANDINJECTORSSEETHEDEPENDENCYINJECTIONGUIDEGUIDEDEPENDENCYINJECTION",
+    "original": "To learn more about providers and injectors, see the [Dependency Injection guide](guide/dependency-injection).",
+    "translation": "要了解更多，参见[依赖注入指南](guide/dependency-injection)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
@@ -50357,12 +51053,6 @@
     "translation": "这是一个过渡性的代码范例，它将会允许你提供并使用 `HeroService`。此刻的代码和[最终代码](#final-code-review)相差很大。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
-  {
-    "key": "LEARNMOREABOUTPROVIDERSINTHEPROVIDERSGUIDEPROVIDERSGUIDE",
-    "original": "Learn more about _providers_ in the [Providers](guide/providers) guide.",
-    "translation": "要进一步了解*提供商*，参见[服务提供商](guide/providers)一章。",
-    "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
-  },
   {
     "key": "##UPDATEHEROESCOMPONENT",
     "original": "## Update `HeroesComponent`",
@@ -50376,9 +51066,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "DELETETHEHEROESIMPORTASYOUWONTNEEDTHATANYMOREIMPORTTHEHEROSERVICEINSTEAD",
-    "original": "Delete the `HEROES` import as you won't need that anymore.\nImport the `HeroService` instead.",
-    "translation": "删除 `HEROES` 导入，你以后不会再用它了。\n转而导入 `HeroService`。",
+    "key": "DELETETHEHEROESIMPORTBECAUSEYOUWONTNEEDTHATANYMOREIMPORTTHEHEROSERVICEINSTEAD",
+    "original": "Delete the `HEROES` import, because you won't need that anymore.\nImport the `HeroService` instead.",
+    "translation": "删除 `HEROES` 的导入语句，因为你以后不会再用它了。\n转而导入 `HeroService`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
@@ -50670,9 +51360,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "USETHECLITOCREATETHEMESSAGESERVICEINSRCAPPTHEMODULEAPPOPTIONTELLSTHECLITOPROVIDETHISSERVICE#PROVIDEINTHEAPPMODULE",
-    "original": "Use the CLI to create the `MessageService` in `src/app`. \nThe `--module=app` option tells the CLI to  [_provide_ this service](#provide) in the `AppModule`,",
-    "translation": "使用 CLI 在 `src/app` 中创建 `MessageService`。\n`--module=app` 选项告诉 CLI 在 `AppModule` 中[提供这个服务](#provide)。",
+    "key": "USETHECLITOCREATETHEMESSAGESERVICEINSRCAPP",
+    "original": "Use the CLI to create the `MessageService` in `src/app`.",
+    "translation": "使用 CLI 在 `src/app` 中创建 `MessageService`。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
@@ -50742,8 +51432,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "MODIFYTHECONSTRUCTORWITHAPARAMETERTHATDECLARESAPUBLICMESSAGESERVICEPROPERTYANGULARWILLINJECTTHESINGLETONMESSAGESERVICEINTOTHATPROPERTYWHENITCREATESTHEHEROSERVICE",
-    "original": "Modify the constructor with a parameter that declares a **public** `messageService` property.\nAngular will inject the singleton `MessageService` into that property \nwhen it creates the `HeroService`.",
+    "key": "MODIFYTHECONSTRUCTORWITHAPARAMETERTHATDECLARESAPUBLICMESSAGESERVICEPROPERTYANGULARWILLINJECTTHESINGLETONMESSAGESERVICEINTOTHATPROPERTYWHENITCREATESTHEMESSAGESCOMPONENT",
+    "original": "Modify the constructor with a parameter that declares a **public** `messageService` property.\nAngular will inject the singleton `MessageService` into that property \nwhen it creates the `MessagesComponent`.",
     "translation": "修改构造函数，添加一个 **public** 的 `messageService` 属性。\nAngular 将会在创建 `MessagesComponent` 的实例时 把 `MessageService` 的实例注入到这个属性中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
@@ -50832,9 +51522,9 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
-    "key": "YOUPROVIDEDTHEHEROSERVICEINTHEROOTAPPMODULESOTHATITCANBEINJECTEDANYWHERE",
-    "original": "* You _provided_ the `HeroService` in the root `AppModule` so that it can be injected anywhere.",
-    "translation": "你在根模块 `AppModule` 中提供了 `HeroService` 服务，以便在别处可以注入它。",
+    "key": "YOUREGISTEREDTHEHEROSERVICEASTHEPROVIDEROFITSSERVICEATTHEROOTLEVELSOTHATITCANBEINJECTEDANYWHEREINTHEAPP",
+    "original": "* You registered the `HeroService` as the _provider_ of its service at the root level so that it can be injected anywhere in the app.",
+    "translation": "你在根注入器中把 `HeroService` 注册为该服务的提供商，以便在别处可以注入它。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
   {
@@ -50857,7 +51547,7 @@
   },
   {
     "key": "YOUUSEDRXJSOFTORETURNANOBSERVABLEOFMOCKHEROESOBSERVABLEHERO",
-    "original": "* You used RxJS `of()` to return an _Observable_ of mock heroes (`Observable<Hero[]>`).",
+    "original": "* You used RxJS `of()` to return an observable of mock heroes (`Observable<Hero[]>`).",
     "translation": "你使用 RxJS 的 `of()` 方法返回了一个模拟英雄数据的*可观察对象* (`Observable<Hero[]>`)。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt4.md"
   },
@@ -51432,8 +52122,8 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt5.md"
   },
   {
-    "key": "YOUREUSINGANGULARINTERPOLATIONBINDINGGUIDETEMPLATESYNTAX#INTERPOLATIONWITHINTHENGFORREPEATERTOINSERTTHECURRENTINTERATIONSHEROIDINTOEACHROUTERLINK#ROUTERLINK",
-    "original": "You're using Angular [interpolation binding](guide/template-syntax#interpolation) within the `*ngFor` repeater \nto insert the current interation's `hero.id` into each \n[`routerLink`](#routerlink).",
+    "key": "YOUREUSINGANGULARINTERPOLATIONBINDINGGUIDETEMPLATESYNTAX#INTERPOLATIONWITHINTHENGFORREPEATERTOINSERTTHECURRENTITERATIONSHEROIDINTOEACHROUTERLINK#ROUTERLINK",
+    "original": "You're using Angular [interpolation binding](guide/template-syntax#interpolation) within the `*ngFor` repeater \nto insert the current iteration's `hero.id` into each \n[`routerLink`](#routerlink).",
     "translation": "你正在 `*ngFor` 复写器中使用 Angular 的[插值表达式](guide/template-syntax#interpolation)来把当前迭代的 `hero.id` 插入到每个 [`routerLink`](#routerlink) 中。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt5.md"
   },
@@ -51864,15 +52554,15 @@
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt6.md"
   },
   {
-    "key": "IMPORTTHEINMEMORYWEBAPIMODULEANDTHEINMEMORYDATASERVICECLASSWHICHYOUWILLCREATEINAMOMENT",
-    "original": "Import the `InMemoryWebApiModule` and the `InMemoryDataService` class, \nwhich you will create in a moment.",
-    "translation": "导入 `InMemoryWebApiModule` 和 `InMemoryDataService` 类（你很快就要创建它）。",
+    "key": "IMPORTTHEHTTPCLIENTINMEMORYWEBAPIMODULEANDTHEINMEMORYDATASERVICECLASSWHICHYOUWILLCREATEINAMOMENT",
+    "original": "Import the `HttpClientInMemoryWebApiModule` and the `InMemoryDataService` class, \nwhich you will create in a moment.",
+    "translation": "导入 `HttpClientInMemoryWebApiModule` 和 `InMemoryDataService` 类（你很快就要创建它）。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt6.md"
   },
   {
-    "key": "ADDTHEINMEMORYWEBAPIMODULETOTHENGMODULEIMPORTSARRAYMDASHAFTERIMPORTINGTHEHTTPCLIENTMDASHWHILECONFIGURINGITWITHTHEINMEMORYDATASERVICE",
-    "original": "Add the `InMemoryWebApiModule` to the `@NgModule.imports` array&mdash;\n_after importing the `HttpClient`_,\n&mdash;while configuring it with the `InMemoryDataService`.",
-    "translation": "把 `InMemoryWebApiModule` 添加到 `@NgModule.imports` 数组中（放在 `HttpClient` 之后），\n然后使用 `InMemoryDataService` 来配置它。",
+    "key": "ADDTHEHTTPCLIENTINMEMORYWEBAPIMODULETOTHENGMODULEIMPORTSARRAYMDASHAFTERIMPORTINGTHEHTTPCLIENTMDASHWHILECONFIGURINGITWITHTHEINMEMORYDATASERVICE",
+    "original": "Add the `HttpClientInMemoryWebApiModule` to the `@NgModule.imports` array&mdash;\n_after importing the `HttpClient`_,\n&mdash;while configuring it with the `InMemoryDataService`.",
+    "translation": "把 `HttpClientInMemoryWebApiModule` 添加到 `@NgModule.imports` 数组中（放在 `HttpClient` 之后），\n然后使用 `InMemoryDataService` 来配置它。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt6.md"
   },
   {
@@ -51985,7 +52675,7 @@
   },
   {
     "key": "INGENERALANOBSERVABLECANRETURNMULTIPLEVALUESOVERTIMEANOBSERVABLEFROMHTTPCLIENTALWAYSEMITSASINGLEVALUEANDTHENCOMPLETESNEVERTOEMITAGAIN",
-    "original": "In general, an `Observable` _can_ return multiple values over time.\nAn `Observable` from `HttpClient` always emits a single value and then completes, never to emit again.",
+    "original": "In general, an observable _can_ return multiple values over time.\nAn observable from `HttpClient` always emits a single value and then completes, never to emit again.",
     "translation": "通常，`Observable` *可以*在一段时间内返回多个值。\n但来自 `HttpClient` 的 `Observable` 总是发出一个值，然后结束，再也不会发出其它值。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt6.md"
   },
@@ -52621,7 +53311,7 @@
   },
   {
     "key": "INSTEADTHENGONINITMETHODPIPESTHESEARCHTERMSOBSERVABLETHROUGHASEQUENCEOFRXJSOPERATORSTHATREDUCETHENUMBEROFCALLSTOTHESEARCHHEROESULTIMATELYRETURNINGANOBSERVABLEOFTIMELYHEROSEARCHRESULTSEACHAHERO",
-    "original": "Instead, the `ngOnInit()` method pipes the `searchTerms` _observable_  through a sequence of RxJS operators that reduce the number of calls to the `searchHeroes()`,\nultimately returning an _observable_ of timely hero search results (each a `Hero[]`).",
+    "original": "Instead, the `ngOnInit()` method pipes the `searchTerms` observable through a sequence of RxJS operators that reduce the number of calls to the `searchHeroes()`,\nultimately returning an observable of timely hero search results (each a `Hero[]`).",
     "translation": "应该怎么做呢？`ngOnInit()` 往 `searchTerms` 这个可观察对象的处理管道中加入了一系列 RxJS 操作符，用以缩减对 `searchHeroes()` 的调用次数，并最终返回一个可及时给出英雄搜索结果的可观察对象（每次都是 `Hero[]` ）。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt6.md"
   },
@@ -52639,8 +53329,8 @@
   },
   {
     "key": "DISTINCTUNTILCHANGEDENSURESTHATAREQUESTISSENTONLYIFTHEFILTERTEXTCHANGED",
-    "original": "* `distinctUntilChanged` ensures that a request is sent only if the filter text changed.",
-    "translation": "`distinctUntilChanged` 会确保只在过滤条件变化时才发送请求。",
+    "original": "* `distinctUntilChanged()` ensures that a request is sent only if the filter text changed.",
+    "translation": "`distinctUntilChanged()` 会确保只在过滤条件变化时才发送请求。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt6.md"
   },
   {
@@ -52747,7 +53437,7 @@
   },
   {
     "key": "YOULEARNEDHOWTOUSEOBSERVABLES",
-    "original": "* You learned how to use Observables.",
+    "original": "* You learned how to use observables.",
     "translation": "你学会了如何使用“可观察对象”。",
     "sourceFile": "/Users/twer/private/GDE/angular-cn/aio/content/tutorial/toh-pt6.md"
   },