diff --git a/aio/content/guide/upgrade.md b/aio/content/guide/upgrade.md
index 57abc9f30a..e9e6f0384c 100644
--- a/aio/content/guide/upgrade.md
+++ b/aio/content/guide/upgrade.md
@@ -53,8 +53,8 @@ much more easy to work with than others. There are a few key techniques
 and patterns that you can apply to future proof apps even before you
 begin the migration.
 
-AngularJS 应用程序的组织方式有很多种。当我们想把它们升级到 Angular 的时候，
-有些做起来会比其它的更容易些。即使在我们开始升级之前，也有一些关键的技术和模式可以让我们将来升级时更轻松。
+AngularJS 应用程序的组织方式有很多种。当你想把它们升级到 Angular 的时候，
+有些做起来会比其它的更容易些。即使在开始升级之前，也有一些关键的技术和模式可以让你将来升级时更轻松。
 
 {@a follow-the-angular-styleguide}
 
@@ -94,7 +94,7 @@ There are a few rules in particular that will make it much easier to do
   each controller, component, service, and filter is in its own source file.
 
    [单一规则](https://github.com/johnpapa/angular-styleguide/blob/master/a1/README.md#single-responsibility)
-  规定每个文件应该只放一个组件。这不仅让组件更容易浏览和查找，而且还让我们能逐个迁移它们的语言和框架。
+  规定每个文件应该只放一个组件。这不仅让组件更容易浏览和查找，而且还让你能逐个迁移它们的语言和框架。
   在这个范例程序中，每个控制器、工厂和过滤器都位于各自的源文件中。
 
 * The [Folders-by-Feature Structure](https://github.com/johnpapa/angular-styleguide/blob/master/a1/README.md#folders-by-feature-structure)
@@ -125,9 +125,9 @@ doesn't work that well if you have to load all those files to the HTML page with
 <script> tags. Especially when you also have to maintain those tags in the correct
 order. That's why it's a good idea to start using a *module loader*.
 
-当我们把应用代码分解到每个文件中只放一个组件的粒度后，我们通常会得到一个由大量相对较小的文件组成的项目结构。
+当你把应用代码分解到每个文件中只放一个组件的粒度后，通常会得到一个由大量相对较小的文件组成的项目结构。
 这比组织成少量大文件要整洁得多，但如果你不得不通过 `<script>` 标签在 HTML 页面中加载所有这些文件，那就不好玩了。
-尤其是当你不得不自己按正确的顺序维护这些标签时更是如此，那我们就要开始使用*模块加载器*了。
+尤其是当你不得不自己按正确的顺序维护这些标签时更是如此，就要开始使用*模块加载器*了。
 
 Using a module loader such as [SystemJS](https://github.com/systemjs/systemjs),
 [Webpack](http://webpack.github.io/), or [Browserify](http://browserify.org/)
@@ -140,15 +140,15 @@ in the correct order.
 
 使用模块加载器，比如[SystemJS](https://github.com/systemjs/systemjs)、
 [Webpack](http://webpack.github.io/)或[Browserify](http://browserify.org/)，
-可以让我们在程序中使用 TypeScript 或 ES2015 语言内置的模块系统。
-我们可以使用 `import` 和 `export` 特性来明确指定哪些代码应该以及将会被在程序的不同部分之间共享。
-对于 ES5 程序来说，我们可以改用 CommonJS 风格的 `require` 和 `module.exports` 特性代替。
+可以让你在程序中使用 TypeScript 或 ES2015 语言内置的模块系统。
+你可以使用 `import` 和 `export` 特性来明确指定哪些代码应该以及将会被在程序的不同部分之间共享。
+对于 ES5 程序来说，可以改用 CommonJS 风格的 `require` 和 `module.exports` 特性代替。
 无是论哪种情况，模块加载器都会按正确的顺序加载程序中用到的所有代码。
 
 When moving applications into production, module loaders also make it easier
 to package them all up into production bundles with batteries included.
 
-当我们的应用程序投入生产环境时，模块加载器也会让把所有这些文件打成完整的产品包变得容易一些。
+当要把应用程序投入生产环境时，模块加载器也会让你把所有这些文件打成完整的产品包变得容易一些。
 
 ### Migrating to TypeScript
 
@@ -160,7 +160,7 @@ This means there's one less thing to learn and think about during the actual upg
 It also means you can start using TypeScript features in your AngularJS code.
 
 Angular 升级计划的一部分是引入 TypeScript，即使在开始升级之前，引入 TypeScript 编译器也是有意义的。
-这意味着等真正升级的时候需要学习和思考的东西会更少，并且我们可以在 AngularJS 代码中开始使用 TypeScript 的特性。
+这意味着等真正升级的时候需要学习和思考的东西会更少，并且你可以在 AngularJS 代码中开始使用 TypeScript 的特性。
 
 Since TypeScript is a superset of ECMAScript 2015, which in turn is a superset
 of ECMAScript 5, "switching" to TypeScript doesn't necessarily require anything
@@ -171,7 +171,7 @@ Additional steps like the following can give us much more bang for the buck:
 TypeScript 是 ECMAScript 2015 的超集，而 ES2015 又是 ECMAScript 5 的超集。
 这意味着除了安装一个 TypeScript 编译器，并把文件名都从 `*.js` 改成 `*.ts` 之外，其实什么都不用做。
 当然，如果仅仅这样做也没什么大用，也没什么有意思的地方。
-下面这些额外的步骤可以让我们打起精神：
+下面这些额外的步骤可以让你打起精神：
 
 * For applications that use a module loader, TypeScript imports and exports
   (which are really ECMAScript 2015 imports and exports) can be used to organize
@@ -195,7 +195,7 @@ TypeScript 是 ECMAScript 2015 的超集，而 ES2015 又是 ECMAScript 5 的超
   closer to becoming Angular service and component classes, which will make
   life easier after the upgrade.
 
-   服务和控制器可以转成*类*。这样我们就能一步步接近 Angular 的服务和组件类了，这样等到我们开始升级时，也会更简单。
+   服务和控制器可以转成*类*。这样它们就能一步步接近 Angular 的服务和组件类了，也会让升级变得简单一点。
 
 ### Using Component Directives
 
@@ -205,7 +205,7 @@ In Angular, components are the main primitive from which user interfaces
 are built. You define the different portions of the UI as components and
 compose them into a full user experience.
 
-在 Angular 中，组件是用来构建用户界面的主要元素。我们把 UI 中的不同部分定义成组件，然后在模板中使用这些组件合成出最终的 UI。
+在 Angular 中，组件是用来构建用户界面的主要元素。你把 UI 中的不同部分定义成组件，然后在模板中使用这些组件合成出最终的 UI。
 
 You can also do this in AngularJS, using *component directives*. These are
 directives that define their own templates, controllers, and input/output bindings -
@@ -214,7 +214,7 @@ component directives are much easier to migrate to Angular than applications
 built with lower-level features like `ng-controller`,  `ng-include`, and scope
 inheritance.
 
-我们在 AngularJS 中也能这么做。那就是一种定义了自己的模板、控制器和输入/输出绑定的指令 —— 跟 Angular 中对组件的定义是一样的。
+你在 AngularJS 中也能这么做。那就是一种定义了自己的模板、控制器和输入/输出绑定的指令 —— 跟 Angular 中对组件的定义是一样的。
 要迁移到 Angular，通过组件型指令构建的应用程序会比直接用 `ng-controller`、`ng-include` 和作用域继承等底层特性构建的要容易得多。
 
 To be Angular compatible, an AngularJS component directive should configure
@@ -333,8 +333,8 @@ since there's a natural coexistence between the two frameworks during the
 transition period.
 
 不管要升级什么，Angular 中的 `ngUpgrade` 库都会是一个非常有用的工具 —— 除非是小到没功能的应用。
-借助它，我们可以在同一个应用程序中混用并匹配 AngularJS 和 Angular 的组件，并让它们实现无缝的互操作。
-这意味着我们不用被迫一次性做完所有的升级工作，因为在整个演进过程中，这两个框架可以很自然的和睦相处。
+借助它，你可以在同一个应用程序中混用并匹配 AngularJS 和 Angular 的组件，并让它们实现无缝的互操作。
+这意味着你不用被迫一次性做完所有的升级工作，因为在整个演进过程中，这两个框架可以很自然的和睦相处。
 
 ### How ngUpgrade Works
 
@@ -352,8 +352,8 @@ framework, and AngularJS code in the AngularJS framework. Both of these are the
 actual, fully featured versions of the frameworks. There is no emulation going on,
 so you can expect to have all the features and natural behavior of both frameworks.
 
-当使用 `UpgradeModule` 时，我们实际上在*同时运行两个版本的 Angular*。所有 Angular 的代码运行在 Angular 框架中，而 AngularJS 的代码运行在 AngularJS 框架中。所有这些都是真实的、全功能的框架版本。
-没有进行任何仿真，所以我们可以认为同时存在着这两个框架的所有特性和自然行为。
+当使用 `UpgradeModule` 时，你实际上在*同时运行两个版本的 Angular*。所有 Angular 的代码运行在 Angular 框架中，而 AngularJS 的代码运行在 AngularJS 框架中。所有这些都是真实的、全功能的框架版本。
+没有进行任何仿真，所以你可以认为同时存在着这两个框架的所有特性和自然行为。
 
 What happens on top of this is that components and services managed by one
 framework can interoperate with those from the other framework. This happens
@@ -440,14 +440,14 @@ Even accounting for these differences you can still have dependency injection
 interoperability. The `UpgradeModule` resolves the differences and makes
 everything work seamlessly:
 
-就算有这么多不同点，也并不妨碍我们在依赖注入时进行互操作。`UpgradeModule` 解决了这些差异，并让它们无缝的对接：
+就算有这么多不同点，也并不妨碍你在依赖注入时进行互操作。`UpgradeModule` 解决了这些差异，并让它们无缝的对接：
 
 * You can make AngularJS services available for injection to Angular code
   by *upgrading* them. The same singleton instance of each service is shared
   between the frameworks. In Angular these services will always be in the
   *root injector* and available to all components.
 
-   通过升级它们，我们就能让那些在 AngularJS 中能被注入的服务在 Angular 的代码中可用。
+   通过升级它们，你就能让那些在 AngularJS 中能被注入的服务也可用于 Angular 的代码中。
   在框架之间共享的是服务的同一个单例对象。在 Angular 中，这些外来服务总是被放在*根注入器*中，并可用于所有组件。
   它们总是具有*字符串令牌* —— 跟它们在 AngularJS 中的令牌相同。
 
@@ -457,9 +457,9 @@ everything work seamlessly:
   When you register a downgraded service, you must explicitly specify a *string token* that you want to
   use in AngularJS.
 
-   通过降级它们，我们也能让那些在 Angular 中能被注入的服务在 AngularJS 的代码中可用。
+   通过降级它们，你也能让那些在 Angular 中能被注入的服务在 AngularJS 的代码中可用。
   只有那些来自 Angular 根注入器的服务才能被降级。同样的，在框架之间共享的是同一个单例对象。
-  当我们注册一个要降级的服务时，要明确指定一个打算在 AngularJS 中使用的*字符串令牌*。
+  当你注册一个要降级的服务时，要明确指定一个打算在 AngularJS 中使用的*字符串令牌*。
 
 <figure>
   <img src="generated/images/guide/upgrade/injectors.png" alt="The two injectors in a hybrid application">
@@ -475,7 +475,7 @@ communicate with each other by using the input and output bindings
 of their respective frameworks, which ngUpgrade bridges together. They may also
 communicate through shared injected dependencies, as described above.
 
-在混合式应用中，我们能同时发现那些来自 AngularJS 和 Angular 中组件和指令的 DOM。
+在混合式应用中，同时存在来自 AngularJS 和 Angular 中组件和指令的 DOM。
 这些组件通过它们各自框架中的输入和输出绑定来互相通讯，它们由 `UpgradeModule` 桥接在一起。
 它们也能通过共享被注入的依赖彼此通讯，就像前面所说的那样。
 
@@ -501,8 +501,8 @@ Beyond that, you may interleave the two frameworks.
 You always cross the boundary between the two frameworks by one of two
 ways:
 
-更进一步说，我们可以按照需要，任意穿插使用这两个框架。
-使用下面的两种方式之一，我们可以自由穿梭于这两个框架的边界：
+更进一步说，你可以按照需要，任意穿插使用这两个框架。
+使用下面的两种方式之一，你可以在这两个框架之间自由穿梭：
 
 1. By using a component from the other framework: An AngularJS template
    using an Angular component, or an Angular template using an
@@ -525,8 +525,8 @@ switch between framework boundaries occurs. However, that switch only
 happens to the elements in the template of that component. Consider a situation
 where you use an Angular component from AngularJS like this:
 
-当我们使用一个属于另一个框架的组件时，就会发生一个跨框架边界的切换。不过，这种切换只发生在该组件元素的*子节点*上。
-考虑一个场景，我们从 AngularJS 中使用一个 Angular 组件，就像这样：
+当你使用一个属于另一个框架的组件时，就会发生一次跨框架边界的切换。不过，这种切换只发生在该组件元素的*子节点*上。
+考虑一个场景，你从 AngularJS 中使用一个 Angular 组件，就像这样：
 
 <code-example language="html" escape="html">
 
@@ -554,7 +554,7 @@ After every event that occurs, `scope.$apply()` gets called. This is done either
 automatically by the framework, or manually by you.
 
 AngularJS 中的变更检测全是关于 `scope.$apply()` 的。在每个事件发生之后，`scope.$apply()` 就会被调用。
-这或者由框架自动调用，或者在某些情况下由我们自己的代码手动调用。它是发生变更检测以及更新数据绑定的时间点。
+这或者由框架自动调用，或者在某些情况下由你自己的代码手动调用。
 
 In Angular things are different. While change detection still
 occurs after every event, no one needs to call `scope.$apply()` for
@@ -596,8 +596,8 @@ regardless of whether it is in AngularJS on Angular. The
 is no need to remove such calls from existing code. Those calls just trigger
 additional AngularJS change detection checks in a hybrid application.
 
-在实践中，我们不用在自己的代码中调用 `$apply()`，而不用管这段代码是在 AngularJS 还是 Angular 中。
-`UpgradeModule` 都替我们做了。我们仍然*可以*调用 `$apply()`，也就是说我们不必从现有代码中移除此调用。
+在实践中，你不用在自己的代码中调用 `$apply()`，而不用管这段代码是在 AngularJS 还是 Angular 中。
+`UpgradeModule` 都替你做了。你仍然*可以*调用 `$apply()`，也就是说你不必从现有代码中移除此调用。
 在混合式应用中，这些调用只会触发一次额外的 AngularJS 变更检测。
 
 When you downgrade an Angular component and then use it from AngularJS,
@@ -607,8 +607,8 @@ are set. You can also hook into the changes by implementing the
 [OnChanges](api/core/OnChanges) interface in the component,
 just like you could if it hadn't been downgraded.
 
-当我们降级一个 Angular 组件，然后把它用于 AngularJS 中时，组件的输入属性就会被 AngularJS 的变更检测体系监视起来。
-当那些输入属性发生变化时，组件中相应的属性就会被设置。我们也能通过实现[OnChanges](api/core/OnChanges)
+当你降级一个 Angular 组件，然后把它用于 AngularJS 中时，组件的输入属性就会被 AngularJS 的变更检测体系监视起来。
+当那些输入属性发生变化时，组件中相应的属性就会被设置。你也能通过实现[OnChanges](api/core/OnChanges)
 接口来挂钩到这些更改，就像它未被降级时一样。
 
 Correspondingly, when you upgrade an AngularJS component and use it from Angular,
@@ -617,7 +617,7 @@ will be hooked into Angular change detection. They will be treated
 as regular Angular inputs. Their values will be written to the upgraded component's
 scope (or controller) when they change.
 
-相应的，当我们把 AngularJS 的组件升级给 Angular 使用时，在这个组件型指令的 `scope`(或 `bindToController`)中定义的所有绑定，
+相应的，当你把 AngularJS 的组件升级给 Angular 使用时，在这个组件型指令的 `scope`(或 `bindToController`)中定义的所有绑定，
 都将被挂钩到 Angular 的变更检测体系中。它们将和标准的 Angular 输入属性被同等对待，并当它们发生变化时设置回 scope(或控制器)上。
 
 ### Using UpgradeModule with Angular _NgModules_
@@ -627,7 +627,7 @@ scope (or controller) when they change.
 Both AngularJS and Angular have their own concept of modules
 to help organize an application into cohesive blocks of functionality.
 
-AngularJS 还是 Angular 都有自己的模块概念，来帮你我们把应用组织成一些紧密相关的功能块。
+AngularJS 还是 Angular 都有自己的模块概念，来帮你把应用组织成一些内聚的功能块。
 
 Their details are quite different in architecture and implementation.
 In AngularJS, you add Angular assets to the `angular.module` property.
@@ -635,17 +635,17 @@ In Angular, you create one or more classes adorned with an `NgModule` decorator
 that describes Angular assets in metadata. The differences blossom from there.
 
 它们在架构和实现的细节上有着显著的不同。
-在 AngularJS 中，我们会把 AngularJS 的资源添加到 `angular.module` 属性上。
-在 Angular 中，我们会创建一个或多个带有 `NgModule` 装饰器的类，这些装饰器用来在元数据中描述 Angular 资源。差异主要来自这里。
+在 AngularJS 中，你要把 AngularJS 的资源添加到 `angular.module` 属性上。
+在 Angular 中，你要创建一个或多个带有 `NgModule` 装饰器的类，这些装饰器用来在元数据中描述 Angular 资源。差异主要来自这里。
 
 In a hybrid application you run both versions of Angular at the same time.
 That means that you need at least one module each from both AngularJS and Angular.
 You will import `UpgradeModule` inside the NgModule, and then use it for
 bootstrapping the AngularJS module.
 
-在混合式应用中，我们同时运行了两个版本的 Angular。
-这意味着我们至少需要 AngularJS 和 Angular 各提供一个模块。
-当我们使用 AngularJS 的模块进行引导时，就得把 Anuglar 2 的模块传给 `UpgradeModule`。我们来看看怎么做。
+在混合式应用中，你同时运行了两个版本的 Angular。
+这意味着你至少需要 AngularJS 和 Angular 各提供一个模块。
+当你使用 AngularJS 的模块进行引导时，就得把 Angular 的模块传给 `UpgradeModule`。
 
 <div class="l-sub-section">
 
@@ -663,12 +663,12 @@ To bootstrap a hybrid application, you must bootstrap each of the Angular and
 AngularJS parts of the application. You must bootstrap the Angular bits first and
 then ask the `UpgradeModule` to bootstrap the AngularJS bits next.
 
-要想引导混合式应用，我们在应用中必须同时引导 Angular 和 AngularJS。要先引导 Angular ，然后再调用 `UpgradeModule` 来引导 AngularJS。
+要想引导混合式应用，就必须在应用中分别引导 Angular 和 AngularJS 应用的一部分。你必须先引导 Angular ，然后再调用 `UpgradeModule` 来引导 AngularJS。
 
 In an AngularJS application you have a root AngularJS module, which will also
 be used to bootstrap the AngularJS application.
 
-在 AngularJS 应用中有一个 AngularJS 的根模块，我们用它来引导 AngularJS 应用。
+在 AngularJS 应用中有一个 AngularJS 的根模块，它用于引导 AngularJS 应用。
 
 <code-example path="upgrade-module/src/app/ajs-bootstrap/app.module.ts" region="ng1module" title="app.module.ts">
 
@@ -680,11 +680,11 @@ directive somewhere on the HTML page. But for hybrid applications, you manually
 manual JavaScript [`angular.bootstrap`](https://docs.angularjs.org/api/ng/function/angular.bootstrap)
 method even before switching them to hybrid mode.
 
-单纯的 AngularJS 应用可以在 HTML 页面中使用 `ng-app` 指令进行引导，但对于混合式应用我们要通过 `UpgradeModule` 模块进行手动引导。因此，在切换成混合式应用之前，最好先把 AngularJS 改写成使用 [`angular.bootstrap`](https://docs.angularjs.org/api/ng/function/angular.bootstrap) 进行手动引导的方式。
+单纯的 AngularJS 应用可以在 HTML 页面中使用 `ng-app` 指令进行引导，但对于混合式应用你要通过 `UpgradeModule` 模块进行手动引导。因此，在切换成混合式应用之前，最好先把 AngularJS 改写成使用 [`angular.bootstrap`](https://docs.angularjs.org/api/ng/function/angular.bootstrap) 进行手动引导的方式。
 
 Say you have an `ng-app` driven bootstrap such as this one:
 
-比如我们现在有这样一个通过 `ng-app` 进行引导的应用：
+比如你现在有这样一个通过 `ng-app` 进行引导的应用：
 
 <code-example path="upgrade-module/src/index-ng-app.html">
 
@@ -694,7 +694,7 @@ You can remove the `ng-app` and `ng-strict-di` directives from the HTML
 and instead switch to calling `angular.bootstrap` from JavaScript, which
 will result in the same thing:
 
-我们可以从 HTML 中移除 `ng-app` 和 `ng-strict-di` 指令，改为从 JavaScript 中调用 `angular.bootstrap`，它能达到同样效果：
+你可以从 HTML 中移除 `ng-app` 和 `ng-strict-di` 指令，改为从 JavaScript 中调用 `angular.bootstrap`，它能达到同样效果：
 
 <code-example path="upgrade-module/src/app/ajs-bootstrap/app.module.ts" region="bootstrap" title="app.module.ts">
 
@@ -743,13 +743,13 @@ The `upgrade.bootstrap` method takes the exact same arguments as [angular.bootst
 Note that you do not add a `bootstrap` declaration to the `@NgModule` decorator, since
 AngularJS will own the root template of the application.
 
-注意，我们不需要在 `@NgModule` 中加入 `bootstrap` 声明，因为 AngularJS 控制着该应用的根模板。
+注意，你不需要在 `@NgModule` 中加入 `bootstrap` 声明，因为 AngularJS 控制着该应用的根模板。
 
 </div>
 
 Now you can bootstrap `AppModule` using the `platformBrowserDynamic.bootstrapModule` method.
 
-现在，我们就可以使用 `platformBrowserDynamic.bootstrapModule` 方法来启动 `AppModule` 了。
+现在，你就可以使用 `platformBrowserDynamic.bootstrapModule` 方法来启动 `AppModule` 了。
 
 <code-example path="upgrade-module/src/app/ajs-a-hybrid-bootstrap/app.module.ts" region="bootstrap" title="app.module.ts'">
 
@@ -758,7 +758,7 @@ Now you can bootstrap `AppModule` using the `platformBrowserDynamic.bootstrapMod
 Congratulations! You're running a hybrid application! The
 existing AngularJS code works as before _and_ you're ready to start adding Angular code.
 
-恭喜！我们就要开始运行 AngularJS+2 的混合式应用程序了！所有现存的 AngularJS 代码会像以前一样正常工作，但是我们现在也同样可以运行 Angular 代码了。
+恭喜！你就要开始运行 AngularJS+2 的混合式应用程序了！所有现存的 AngularJS 代码会像以前一样正常工作，但是你现在也同样可以运行 Angular 代码了。
 
 ### Using Angular Components from AngularJS Code
 
@@ -771,12 +771,12 @@ code. One of the more common patterns for doing that is to use an Angular compon
 in an AngularJS context. This could be a completely new component or one that was
 previously AngularJS but has been rewritten for Angular.
 
-一旦我们开始运行混合式应用，我们就可以开始逐渐升级代码了。做这件事的一种更常见的模式就是在 AngularJS 的上下文中使用 Angular 的组件。
+一旦你开始运行混合式应用，你就可以开始逐渐升级代码了。一种更常见的工作模式就是在 AngularJS 的上下文中使用 Angular 的组件。
 该组件可能是全新的，也可能是把原本 AngularJS 的组件用 Angular 重写而成的。
 
 Say you have a simple Angular component that shows information about a hero:
 
-假设我们有一个简单的用来显示英雄信息的 Angular 组件：
+假设你有一个简单的用来显示英雄信息的 Angular 组件：
 
 <code-example path="upgrade-module/src/app/downgrade-static/hero-detail.component.ts" title="hero-detail.component.ts">
 
@@ -786,8 +786,8 @@ If you want to use this component from AngularJS, you need to *downgrade* it
 using the `downgradeComponent()` method. The result is an AngularJS
 *directive*, which you can then register in the AngularJS module:
 
-如果我们想在 AngularJS 中使用这个组件，我们就得用 `downgradeComponent()` 方法把它*降级*。
-如果我们这么做，就会得到一个 AngularJS 的*指令*，我们可以把它注册到 AngularJS 的模块中：
+如果你想在 AngularJS 中使用这个组件，就得用 `downgradeComponent()` 方法把它*降级*。
+其结果是一个 AngularJS 的*指令*，你可以把它注册到 AngularJS 的模块中：
 
 <code-example path="upgrade-module/src/app/downgrade-static/app.module.ts" region="downgradecomponent" title="app.module.ts">
 
@@ -796,13 +796,13 @@ using the `downgradeComponent()` method. The result is an AngularJS
 Because `HeroDetailComponent` is an Angular component, you must also add it to the
 `declarations` in the `AppModule`.
 
-由于 `HeroDetailComponent` 是一个 Angular 组件，所以我们必须同时把它加入 `AppModule` 的 `declarations` 字段中。
+由于 `HeroDetailComponent` 是一个 Angular 组件，所以你必须同时把它加入 `AppModule` 的 `declarations` 字段中。
 
 And because this component is being used from the AngularJS module, and is an entry point into
 the Angular application, you must add it to the `entryComponents` for the
 NgModule.
 
-并且由于这个组件在 AngularJS 模块中使用，也是我们 Angular 应用的一个入口点，我们还需要
+并且由于这个组件在 AngularJS 模块中使用，也是你 Angular 应用的一个入口点，你还需要
 将它加入到 Angular 模块的 `entryComponents` 列表中。
 
 <code-example path="upgrade-module/src/app/downgrade-static/app.module.ts" region="ngmodule" title="app.module.ts">
@@ -820,7 +820,7 @@ All Angular components, directives and pipes must be declared in an NgModule.
 The net result is an AngularJS directive called `heroDetail`, that you can
 use like any other directive in AngularJS templates.
 
-这里我们得到的是一个叫做 `heroDetail` 的 AngularJS 指令，我们可以像用其它指令一样把它用在 AngularJS 模板中。
+最终的结果是一个叫做 `heroDetail` 的 AngularJS 指令，你可以像用其它指令一样把它用在 AngularJS 模板中。
 
 <code-example path="upgrade-module/src/index-downgrade-static.html" region="usecomponent">
 
@@ -863,7 +863,7 @@ Note that even though you are in an AngularJS template, **you're using Angular
 attribute syntax to bind the inputs and outputs**. This is a requirement for downgraded
 components. The expressions themselves are still regular AngularJS expressions.
 
-注意，虽然我们正在 AngularJS 的模板中，**但却在使用 Angular 的属性(Attribute)语法来绑定到输入属性与输出属性**。
+注意，虽然你正在 AngularJS 的模板中，**但却在使用 Angular 的属性(Attribute)语法来绑定到输入属性与输出属性**。
 这是降级的组件本身要求的。而表达式本身仍然是标准的 AngularJS 表达式。
 
 <div class="callout is-important">
@@ -877,7 +877,7 @@ for downgraded components. It has to do with input or output names that consist
 of multiple words. In Angular, you would bind these attributes using camelCase:
 
 为降级过的组件使用 Angular 的属性(Attribute)语法规则时有一个值得注意的例外。
-它适用于由多个单词组成的输入或输出属性。在 Angular 中，我们要使用小驼峰命名法绑定这些属性：
+它适用于由多个单词组成的输入或输出属性。在 Angular 中，你要使用小驼峰命名法绑定这些属性：
 
 <code-example format="">
 
@@ -887,7 +887,7 @@ of multiple words. In Angular, you would bind these attributes using camelCase:
 
 But when using them from AngularJS templates, you must use kebab-case:
 
-但是从 AngularJS 的模板中使用它们时，我们得使用中线命名法：
+但是从 AngularJS 的模板中使用它们时，你得使用中线命名法：
 
 <code-example format="">
 
@@ -907,8 +907,8 @@ Since this is an AngularJS template, you can still use other AngularJS
 directives on the element, even though it has Angular binding attributes on it.
 For example, you can easily make multiple copies of the component using `ng-repeat`:
 
-由于这是一个 AngularJS 模板，虽然它已经有了 Angular 中绑定的属性(Attribute)，我们仍可以在这个元素上使用其它 AngularJS 指令。
-例如，我们可以用 `ng-repeat` 简单的制作该组件的多份拷贝：
+由于这是一个 AngularJS 模板，虽然它已经有了 Angular 中绑定的属性(Attribute)，你仍可以在这个元素上使用其它 AngularJS 指令。
+例如，你可以用 `ng-repeat` 简单的制作该组件的多份拷贝：
 
 <code-example path="upgrade-module/src/index-downgrade-io.html" region="userepeatedcomponent">
 
@@ -928,10 +928,10 @@ and work your way down. This too can be done using the `UpgradeModule`.
 You can *upgrade* AngularJS component directives and then use them from
 Angular.
 
-现在，我们已经能在 Angular 中写一个组件，并把它用于 AngularJS 代码中了。
-当我们从低级组件开始移植，并往上走时，这非常有用。但在另外一些情况下，从相反的方向进行移植会更加方便：
+现在，你已经能在 Angular 中写一个组件，并把它用于 AngularJS 代码中了。
+当你从低级组件开始移植，并往上走时，这非常有用。但在另外一些情况下，从相反的方向进行移植会更加方便：
 从高级组件开始，然后往下走。这也同样能用 `UpgradeModule` 完成。
-我们可以*升级*AngularJS 组件型指令，然后从 Angular 中用它们。
+你可以*升级*AngularJS 组件型指令，然后从 Angular 中用它们。
 
 Not all kinds of AngularJS directives can be upgraded. The directive
 really has to be a *component directive*, with the characteristics
@@ -957,9 +957,9 @@ By creating a new Angular **directive** that extends `UpgradeComponent` and doin
 inside its constructor, you have a fully upgraded AngularJS component to be used inside Angular.
 All that is left is to add it to `AppModule`'s `declarations` array.
 
-我们可以使用 `UpgradeComponent` 方法来把这个组件*升级*到 Angular。
+你可以使用 `UpgradeComponent` 方法来把这个组件*升级*到 Angular。
 具体方法是创建一个 Angular**指令**，继承 `UpgradeComponent`，在其构造函数中进行 `super` 调用，
-这样我们就得到一个完全升级的 AngularJS 组件，并且可以 Angular 中使用。
+这样你就得到一个完全升级的 AngularJS 组件，并且可以 Angular 中使用。
 剩下是工作就是把它加入到 `AppModule` 的 `declarations` 数组。
 
 <code-example path="upgrade-module/src/app/upgrade-static/hero-detail.component.ts" region="hero-detail-upgrade" title="hero-detail.component.ts">
@@ -989,7 +989,7 @@ provide the inputs and outputs using **Angular template syntax**,
 observing the following rules:
 
 升级后的组件也可能有输入属性和输出属性，它们是在原 AngularJS 组件型指令的 scope/controller 绑定中定义的。
-当我们从 Angular 模板中使用该组件时，我们要使用**Angular 模板语法**来提供这些输入属性和输出属性，但要遵循下列规则：
+当你从 Angular 模板中使用该组件时，就要使用**Angular 模板语法**来提供这些输入属性和输出属性，但要遵循下列规则：
 
 <table>
 
@@ -1123,7 +1123,7 @@ observing the following rules:
 For example, imagine a hero detail AngularJS component directive
 with one input and one output:
 
-举个例子，假设我们在 AngularJS 中有一个表示“英雄详情”的组件型指令，它带有一个输入属性和一个输出属性：
+举个例子，假设 AngularJS 中有一个表示“英雄详情”的组件型指令，它带有一个输入属性和一个输出属性：
 
 <code-example path="upgrade-module/src/app/upgrade-io/hero-detail.component.ts" region="hero-detail-io" title="hero-detail.component.ts">
 
@@ -1132,7 +1132,7 @@ with one input and one output:
 You can upgrade this component to Angular, annotate inputs and outputs in the upgrade directive,
 and then provide the input and output using Angular template syntax:
 
-我们可以把这个组件升级到 Angular，然后使用 Angular 的模板语法提供这个输入属性和输出属性：
+你可以把这个组件升级到 Angular，然后使用 Angular 的模板语法提供这个输入属性和输出属性：
 
 <code-example path="upgrade-module/src/app/upgrade-io/hero-detail.component.ts" region="hero-detail-io-upgrade" title="hero-detail.component.ts">
 
@@ -1154,7 +1154,7 @@ is also possible. While there is no such thing as transclusion in Angular,
 there is a very similar concept called *content projection*. The `UpgradeModule`
 is able to make these two features interoperate.
 
-如果我们在 AngularJS 模板中使用降级后的 Angular 组件时，可能会需要把模板中的一些内容投影进那个组件。
+如果你在 AngularJS 模板中使用降级后的 Angular 组件时，可能会需要把模板中的一些内容投影进那个组件。
 这也是可能的，虽然在 Angular 中并没有透传(transclude)这样的东西，但它有一个非常相似的概念，叫做*内容投影*。
 `UpgradeModule` 也能让这两个特性实现互操作。
 
@@ -1171,7 +1171,7 @@ When using the component from AngularJS, you can supply contents for it. Just
 like they would be transcluded in AngularJS, they get projected to the location
 of the `<ng-content>` tag in Angular:
 
-当从 AngularJS 中使用该组件时，我们可以为它提供内容。正如它们将在 AngularJS 中被透传一样，
+当从 AngularJS 中使用该组件时，你可以为它提供内容。正如它们将在 AngularJS 中被透传一样，
 它们也在 Angular 中被投影到了 `<ng-content>` 标签所在的位置：
 
 <code-example path="upgrade-module/src/index-ajs-to-a-projection.html" region="usecomponent">
@@ -1197,8 +1197,8 @@ Just as you can project AngularJS content into Angular components,
 you can *transclude* Angular content into AngularJS components, whenever
 you are using upgraded versions from them.
 
-就像我们能把 AngularJS 的内容投影进 Angular 组件一样，我们也能把 Angular 的内容*透传*进 AngularJS 的组件，
-但不管怎样，我们都要使用它们升级过的版本。
+就像可以把 AngularJS 的内容投影进 Angular 组件一样，你也能把 Angular 的内容*透传*进 AngularJS 的组件，
+但不管怎样，你都要使用它们升级过的版本。
 
 When an AngularJS component directive supports transclusion, it may use
 the `ng-transclude` directive in its template to mark the transclusion
@@ -1213,7 +1213,7 @@ point:
 If you upgrade this component and use it from Angular, you can populate
 the component tag with contents that will then get transcluded:
 
-如果我们升级这个组件，并把它用在 Angular 中，我们就能把准备透传的内容放进这个组件的标签中。
+如果你升级这个组件，并把它用在 Angular 中，你就能把准备透传的内容放进这个组件的标签中。
 
 <code-example path="upgrade-module/src/app/a-to-ajs-transclusion/container.component.ts" title="container.component.ts">
 
@@ -1228,7 +1228,7 @@ some AngularJS dependencies into your Angular code.
 Maybe you have some business logic still in AngularJS services.
 Maybe you want access to AngularJS's built-in services like `$location` or `$timeout`.
 
-当运行一个混合式应用时，我们可能会遇到这种情况：我们需要把某些 AngularJS 的依赖注入到 Angular 代码中。
+当运行一个混合式应用时，可能会遇到这种情况：你需要把某些 AngularJS 的依赖注入到 Angular 代码中。
 这可能是因为某些业务逻辑仍然在 AngularJS 服务中，或者需要某些 AngularJS 的内置服务，比如 `$location` 或 `$timeout`。
 
 In these situations, it is possible to *upgrade* an AngularJS provider to
@@ -1236,7 +1236,7 @@ Angular. This makes it possible to then inject it somewhere in Angular
 code. For example, you might have a service called `HeroesService` in AngularJS:
 
 在这些情况下，把一个 AngularJS 提供商*升级到*Angular 也是有可能的。这就让它将来有可能被注入到 Angular 代码中的某些地方。
-比如，我们可能在 AngularJS 中有一个名叫 `HeroesService` 的服务：
+比如，你可能在 AngularJS 中有一个名叫 `HeroesService` 的服务：
 
 <code-example path="upgrade-module/src/app/ajs-to-a-providers/heroes.service.ts" title="heroes.service.ts">
 
@@ -1245,7 +1245,7 @@ code. For example, you might have a service called `HeroesService` in AngularJS:
 You can upgrade the service using a Angular [factory provider](guide/dependency-injection#factory-providers)
 that requests the service from the AngularJS `$injector`.
 
-我们可以 Angular 的[工厂提供商（factory provider）](guide/dependency-injection#factory-providers)升级该服务，
+你可以 Angular 的[工厂提供商（factory provider）](guide/dependency-injection#factory-providers)升级该服务，
 它从 AngularJS 的 `$injector` 请求服务。Angular 依赖的名称由你确定：
 
 Many developers prefer to declare the factory provider in a separate `ajs-upgraded-providers.ts` file
@@ -1257,7 +1257,7 @@ delete them once the upgrade is over.
 It's also recommended to export the `heroesServiceFactory` function so that Ahead-of-Time
 compilation can pick it up.
 
-我们还建议导出 `heroesServiceFactory` 函数，以便 AOT 编译器可以拿到它们。
+同时，建议导出 `heroesServiceFactory` 函数，以便 AOT 编译器可以拿到它们。
 
 <code-example path="upgrade-module/src/app/ajs-to-a-providers/ajs-upgraded-providers.ts" title="ajs-upgraded-providers.ts">
 
@@ -1281,7 +1281,7 @@ affect how the dependency is handled, it enables the benefits of static type
 checking. This is not required though, and any AngularJS service, factory, or
 provider can be upgraded.
 
-在这个例子中，我们升级了服务类。当我们注入它时，我们可以使用 TypeScript 类型注解来获得这些额外的好处。
+在这个例子中，你升级了服务类。当注入它时，你可以使用 TypeScript 类型注解来获得这些额外的好处。
 它没有影响该依赖的处理过程，同时还得到了启用静态类型检查的好处。
 任何 AngularJS 中的服务、工厂和提供商都能被升级 —— 尽管这不是必须的。
 
@@ -1296,12 +1296,12 @@ Angular dependencies, so that you can use them from AngularJS. This can be
 useful when you start migrating services to Angular or creating new services
 in Angular while retaining components written in AngularJS.
 
-除了能升级 AngularJS 依赖之外，我们还能*降级*Angular 的依赖，以便我们能在 AngularJS 中使用它们。
-当我们已经开始把服务移植到 Angular 或在 Angular 中创建新服务，但同时还有一些用 AngularJS 写成的组件时，这会非常有用。
+除了能升级 AngularJS 依赖之外，你还能*降级*Angular 的依赖，以便在 AngularJS 中使用它们。
+当你已经开始把服务移植到 Angular 或在 Angular 中创建新服务，但同时还有一些用 AngularJS 写成的组件时，这会非常有用。
 
 For example, you might have an Angular service called `Heroes`:
 
-例如，我们可能有一个 Angular 的 `Heroes` 服务：
+例如，你可能有一个 Angular 的 `Heroes` 服务：
 
 <code-example path="upgrade-module/src/app/a-to-ajs-providers/heroes.ts" title="heroes.ts">
 
@@ -1309,7 +1309,7 @@ For example, you might have an Angular service called `Heroes`:
 
 Again, as with Angular components, register the provider with the `NgModule` by adding it to the module's `providers` list.
 
-仿照 Angular 组件，我们通过把该提供商加入 `NgModule` 的 `providers` 列表中来注册它。
+仿照 Angular 组件，把该提供商加入 `NgModule` 的 `providers` 列表中，以注册它。
 
 <code-example path="upgrade-module/src/app/a-to-ajs-providers/app.module.ts" region="ngmodule" title="app.module.ts">
 
@@ -1319,7 +1319,7 @@ Now wrap the Angular `Heroes` in an *AngularJS factory function* using `downgrad
 and plug the factory into an AngularJS module.
 The name of the AngularJS dependency is up to you:
 
-现在，我们使用 `upgradeAdapter.downgradeNg2Provider()` 来把 Angular 的 `Heroes` 包装成*AngularJS 的工厂函数*，并把这个工厂注册进 AngularJS 的模块中。
+现在，用 `upgradeAdapter.downgradeNg2Provider()` 来把 Angular 的 `Heroes` 包装成*AngularJS 的工厂函数*，并把这个工厂注册进 AngularJS 的模块中。
 依赖在 AngularJS 中的名字你可以自己定：
 
 <code-example path="upgrade-module/src/app/a-to-ajs-providers/app.module.ts" region="register" title="app.module.ts">
@@ -1344,20 +1344,20 @@ The setup for an hybrid app is mostly the same as described in
 [the Ahead-of-time Compilation chapter](guide/aot-compiler)
 save for differences in `index.html` and `main-aot.ts`
 
-我们也可以其它 Angular 应用一样在混合式应用中发挥 AOT 编译的优势。
+你也可以其它 Angular 应用一样在混合式应用中发挥 AOT 编译的优势。
 对混合式应用的设置过程和[预编译](guide/aot-compiler)章节中所讲的几乎完全一样，不同点在于 `index.html` 和 `main-aot.ts` 中。
 
 The `index.html` will likely have script tags loading AngularJS files, so the `index.html`
 for AOT must also load those files.
 An easy way to copy them is by adding each to the `copy-dist-files.js` file.
 
-我们的 `index.html` 仍然需要 script 标签来加载 AngularJS 的文件，因此我们使用 AOT 编译的 `index.html` 也需要加载那些文件。
+`index.html` 仍然需要 script 标签来加载 AngularJS 的文件，因此供 AOT 编译的 `index.html` 也需要加载那些文件。
 复制它们的简单方案是把它们全都添加到 `copy-dist-files.js` 文件中。
 
 You'll need to use the generated `AppModuleFactory`, instead of the original `AppModule` to
 bootstrap the hybrid app:
 
-我们还要使用所生成的 `AppModuleFactory` 而不是原来的 `AppModule` 来引导一个混合式应用：
+你还要使用所生成的 `AppModuleFactory` 而不是原来的 `AppModule` 来引导一个混合式应用：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/main-aot.ts" title="app/main-aot.ts">
 
@@ -1365,7 +1365,7 @@ bootstrap the hybrid app:
 
 And that's all you need do to get the full benefit of AOT for Angular apps!
 
-这就是我们为获取 Angular 应用的 AOT 优势所要做的一切。
+这就是你为获取 Angular 应用的 AOT 优势所要做的一切。
 
 ## PhoneCat Upgrade Tutorial
 
@@ -1377,27 +1377,27 @@ from [the original AngularJS tutorial](https://docs.angularjs.org/tutorial),
 which is where many of us began our Angular adventures. Now you'll see how to
 bring that application to the brave new world of Angular.
 
-在本节和下节中，我们将看一个完整的例子，它使用 `upgrade` 模块准备和升级了一个应用程序。
+在本节和下节中，你将看一个完整的例子，它使用 `upgrade` 模块准备和升级了一个应用程序。
 该应用就是来自[原 AngularJS 教程](https://docs.angularjs.org/tutorial)中的[Angular PhoneCat](https://github.com/angular/angular-phonecat)。
-那是我们很多人当初开始 Angular 探险之旅的起点。
-现在，我们来看看如何把该应用带入 Angular 的美丽新世界。
+那是我们当初开始 Angular 探险之旅的起点。
+现在，你会看到如何把该应用带入 Angular 的美丽新世界。
 
 During the process you'll learn how to apply the steps outlined in the
 [preparation guide](guide/upgrade#preparation). You'll align the application
 with Angular and also start writing in TypeScript.
 
-这期间，我们将学到如何在实践中应用[准备指南](guide/upgrade#preparation)中列出的那些重点步骤：
-我们先让该应用向 Angular 看齐，然后为它引入 SystemJS 模块加载器和 TypeScript。
+这期间，你将学到如何在实践中应用[准备指南](guide/upgrade#preparation)中列出的那些重点步骤：
+你先让该应用向 Angular 看齐，然后为它引入 SystemJS 模块加载器和 TypeScript。
 
 To follow along with the tutorial, clone the
 [angular-phonecat](https://github.com/angular/angular-phonecat) repository
 and apply the steps as you go.
 
-要跟随本教程，请先把[angular-phonecat](https://github.com/angular/angular-phonecat)仓库克隆到本地，并跟我们一起应用这些步骤。
+要跟随本教程，请先把[angular-phonecat](https://github.com/angular/angular-phonecat)仓库克隆到本地，并应用这些步骤。
 
 In terms of project structure, this is where the work begins:
 
-在项目结构方面，我们工作的起点是这样的：
+在项目结构方面，工作的起点是这样的：
 
 <div class='filetree'>
 
@@ -1698,16 +1698,16 @@ a successful upgrade.
 Since you're going to be writing Angular code in TypeScript, it makes sense to
 bring in the TypeScript compiler even before you begin upgrading.
 
-因为我们将使用 TypeScript 编写 Angular 的代码，所以在开始升级之前，我们把 TypeScript 的编译器设置好是很合理的。
+因为你将使用 TypeScript 编写 Angular 的代码，所以在开始升级之前，先要把 TypeScript 的编译器设置好。
 
 You'll also start to gradually phase out the Bower package manager in favor
 of NPM, installing all new dependencies using NPM, and eventually removing Bower from the project.
 
-我们还将开始逐步淘汰 Bower 包管理器，换成我们更喜欢的 NPM。后面我们将使用 NPM 来安装新的依赖包，并最终从项目中移除 Bower。
+你还将开始逐步淘汰 Bower 包管理器，换成 NPM。后面你将使用 NPM 来安装新的依赖包，并最终从项目中移除 Bower。
 
 Begin by installing TypeScript to the project.
 
-让我们先把 TypeScript 包安装到项目中。
+先把 TypeScript 包安装到项目中。
 
 <code-example format="">
 
@@ -1719,7 +1719,7 @@ Install type definitions for the existing libraries that
 you're using but that don't come with prepackaged types: AngularJS and the
 Jasmine unit test framework.
 
-我们还要为那些没有自带类型信息的库（比如 AngularJS 和 Jasmine）安装类型定义文件。
+还要为那些没有自带类型信息的库（比如 AngularJS 和 Jasmine）安装类型定义文件。
 
 <code-example format="">
 
@@ -1732,14 +1732,14 @@ as described in the [TypeScript Configuration](guide/typescript-configuration) g
 The `tsconfig.json` file tells the TypeScript compiler how to turn your TypeScript files
 into ES5 code bundled into CommonJS modules.
 
-我们还应该配置 TypeScript 编译器，以便它能理解我们的项目结构。我们要往项目目录下添加一个 `tsconfig.json` 文件，
-就像在[搭建本地开发环境](guide/setup)中做过的那样。它将告诉 TypeScript 编译器，该如何编译我们的源文件。
+你还应该要往项目目录下添加一个 `tsconfig.json` 文件，
+就像在 [TypeScript 配置](guide/typescript-configuration)中讲过的那样。
 `tsconfig.json` 文件会告诉 TypeScript 编译器如何把 TypeScript 文件转成 ES5 代码，并打包进 CommonJS 模块中。
 
 Finally, you should add some npm scripts in `package.json` to compile the TypeScript files to
 JavaScript (based on the `tsconfig.json` configuration file):
 
-最后，我们应该把下列 npm 脚本添加到 `package.json` 中，用于把 TypeScript 文件编译成 JavaScript （根据 `tsconfig.json` 的配置）：
+最后，你应该把下列 npm 脚本添加到 `package.json` 中，用于把 TypeScript 文件编译成 JavaScript （根据 `tsconfig.json` 的配置）：
 
 <code-example format="">
 
@@ -1773,15 +1773,15 @@ compiled JavaScript is what actually gets executed. If you start
 the project HTTP server with `npm start`, you should see the fully functional
 application in your browser.
 
-我们要做的下一件事是把 JavaScript 文件转换成 TypeScript 文件。
-由于 TypeScript 是 ECMAScript 2015 的一个超集，而 ES2015 又是 ECMAScript 5 的超集，所以我们可以简单的把文件的扩展名从 `.js` 换成 `.ts`，
+接下来，把 JavaScript 文件转换成 TypeScript 文件。
+由于 TypeScript 是 ECMAScript 2015 的一个超集，而 ES2015 又是 ECMAScript 5 的超集，所以你可以简单的把文件的扩展名从 `.js` 换成 `.ts`，
 它们还是会像以前一样工作。由于 TypeScript 编译器仍在运行，它会为每一个 `.ts` 文件生成对应的 `.js` 文件，而真正运行的是编译后的 `.js` 文件。
 如果你用 `npm start` 开启了本项目的 HTTP 服务器，你会在浏览器中看到一个功能完好的应用。
 
 Now that you have TypeScript though, you can start benefiting from some of its
 features. There's a lot of value the language can provide to AngularJS applications.
 
-有了 TypeScript，我们就可以从它的一些特性中获益了。此语言可以为 AngularJS 应用提供很多价值。
+有了 TypeScript，你就可以从它的一些特性中获益了。此语言可以为 AngularJS 应用提供很多价值。
 
 For one thing, TypeScript is a superset of ES2015. Any app that has previously
 been written in ES5 - like the PhoneCat example has - can with TypeScript
@@ -1798,16 +1798,16 @@ actually partially already happened because of the AngularJS typings you install
 TypeScript are checking that you are calling AngularJS APIs correctly when you do
 things like register components to Angular modules.
 
-我们能做的另一件事就是把*类型安全*添加到代码中。这实际上已经部分完成了，因为我们已经安装了 AngularJS 的类型定义。
-当我们正确调用 AngularJS 的 API 时，TypeScript 会帮我们检查它 —— 比如往 Angular 模块中注册组件。
+你能做的另一件事就是把*类型安全*添加到代码中。这实际上已经部分完成了，因为你已经安装了 AngularJS 的类型定义。
+TypeScript 会帮你检查是否正确调用了 AngularJS 的 API，—— 比如往 Angular 模块中注册组件。
 
 But you can also start adding *type annotations* to get even more
 out of TypeScript's type system. For instance, you can annotate the checkmark
 filter so that it explicitly expects booleans as arguments. This makes it clearer
 what the filter is supposed to do.
 
-我们还能开始把*类型注解*添加到自己的代码中，来从 TypeScript 的类型系统中获得更多帮助。
-比如，我们可以给 `checkmark` 过滤器加上注解，表明它期待一个 `boolean` 类型的参数。
+你还能开始把*类型注解*添加到自己的代码中，来从 TypeScript 的类型系统中获得更多帮助。
+比如，你可以给 `checkmark` 过滤器加上注解，表明它期待一个 `boolean` 类型的参数。
 这可以更清楚的表明此过滤器打算做什么
 
 <code-example path="upgrade-phonecat-1-typescript/app/core/checkmark/checkmark.filter.ts" title="app/core/checkmark/checkmark.filter.ts">
@@ -1817,7 +1817,7 @@ what the filter is supposed to do.
 In the `Phone` service, you can explicitly annotate the `$resource` service dependency
 as an `angular.resource.IResourceService` - a type defined by the AngularJS typings.
 
-在 `Phone` 服务中，我们可以明确的把 `$resource` 服务声明为 `angular.resource.IResourceService`，一个 AngularJS 类型定义提供的类型。
+在 `Phone` 服务中，你可以明确的把 `$resource` 服务声明为 `angular.resource.IResourceService`，一个 AngularJS 类型定义提供的类型。
 
 <code-example path="upgrade-phonecat-1-typescript/app/core/phone/phone.service.ts" title="app/core/phone/phone.service.ts">
 
@@ -1827,8 +1827,8 @@ You can apply the same trick to the application's route configuration file in `a
 where you are using the location and route services. By annotating them accordingly TypeScript
 can verify you're calling their APIs with the correct kinds of arguments.
 
-我们可以在应用的路由配置中使用同样的技巧，那里我们用到了 location 和 route 服务。
-一旦给它们提供了类型信息，TypeScript 就能检查我们是否在用类型的正确参数来调用它们了。
+你可以在应用的路由配置中使用同样的技巧，那里你用到了 location 和 route 服务。
+一旦为它们提供了类型信息，TypeScript 就能检查你是否在用类型的正确参数来调用它们了。
 
 <code-example path="upgrade-phonecat-1-typescript/app/app.config.ts" title="app/app.config.ts">
 
@@ -1841,7 +1841,7 @@ you installed are not officially maintained by the Angular team,
 but are quite comprehensive. It is possible to make an AngularJS 1.x application
 fully type-annotated with the help of these definitions.
 
-我们用 typings 工具安装的这个[AngularJS.x 类型定义文件](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/angularjs)
+你用安装的这个[AngularJS.x 类型定义文件](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/angularjs)
 并不是由 Angular 开发组维护的，但它也已经足够全面了。借助这些类型定义的帮助，它可以为 AngularJS.x 程序加上全面的类型注解。
 
 If this is something you wanted to do, it would be a good idea to enable
@@ -1850,9 +1850,9 @@ cause the TypeScript compiler to display a warning when there's any code that
 does not yet have type annotations. You could use it as a guide to inform
 us about how close you are to having a fully annotated project.
 
-如果我们想这么做，那么在 `tsconfig.json` 中启用 `noImplicitAny` 配置项就是一个好主意。
+如果你想这么做，就在 `tsconfig.json` 中启用 `noImplicitAny` 配置项。
 这样，如果遇到什么还没有类型注解的代码，TypeScript 编译器就会显示一个警告。
-我们可以用它作为指南，告诉我们现在与一个完全类型化的项目距离还有多远。
+你可以用它作为指南，告诉你现在与一个完全类型化的项目距离还有多远。
 
 </div>
 
@@ -1861,15 +1861,15 @@ can turn component controllers into classes. That way they'll be a step
 closer to becoming Angular component classes, which will make life
 easier once you upgrade.
 
-我们能用的另一个 TypeScript 特性是*类*。具体来讲，我们可以把控制器转换成类。
-这种方式下，我们离成为 Angular 组件类就又近了一步，它会令我们的升级之路变得更简单。
+你能用的另一个 TypeScript 特性是*类*。具体来讲，你可以把控制器转换成类。
+这种方式下，你离成为 Angular 组件类就又近了一步，它会令你的升级之路变得更简单。
 
 AngularJS expects controllers to be constructor functions. That's exactly what
 ES2015/TypeScript classes are under the hood, so that means you can just plug in a
 class as a component controller and AngularJS will happily use it.
 
 AngularJS 期望控制器是一个构造函数。这实际上就是 ES2015/TypeScript 中的类，
-这也就意味着只要我们把一个类注册为组件控制器，AngularJS 就会愉快的使用它。
+这也就意味着只要你把一个类注册为组件控制器，AngularJS 就会愉快的使用它。
 
 Here's what the new class for the phone list component controller looks like:
 
@@ -1895,13 +1895,13 @@ referred to in the template, but for the sake of clarity you should define all o
 controller members.
 
 该类还声明了另外三个成员：电话列表、当前排序键的名字和搜索条件。
-这些东西我们以前就加到了控制器上，只是从来没有在任何地方显式定义过它们。最后一个成员从未真正在 TypeScript 代码中用过，
-因为它只是在模板中被引用过。但为了清晰起见，我们还是应该定义出此控制器应有的所有成员。
+这些东西你以前就加到了控制器上，只是从来没有在任何地方显式定义过它们。最后一个成员从未真正在 TypeScript 代码中用过，
+因为它只是在模板中被引用过。但为了清晰起见，你还是应该定义出此控制器应有的所有成员。
 
 In the Phone detail controller, you'll have two members: One for the phone
 that the user is looking at and another for the URL of the currently displayed image:
 
-在电话详情控制器中，我们有两个成员：一个是用户正在查看的电话，另一个是正在显示的图像：
+在电话详情控制器中，你有两个成员：一个是用户正在查看的电话，另一个是正在显示的图像：
 
 <code-example path="upgrade-phonecat-1-typescript/app/phone-detail/phone-detail.component.ts" title="app/phone-detail/phone-detail.component.ts">
 
@@ -1910,7 +1910,7 @@ that the user is looking at and another for the URL of the currently displayed i
 This makes the controller code look a lot more like Angular already. You're
 all set to actually introduce Angular into the project.
 
-这已经让我们的控制器代码看起来更像 Angular 了。我们的准备工作做好了，可以引进 Angular 到项目中了。
+这已经让你的控制器代码看起来更像 Angular 了。你的准备工作做好了，可以引进 Angular 到项目中了。
 
 If you had any AngularJS services in the project, those would also be
 a good candidate for converting to classes, since like controllers,
@@ -1920,8 +1920,8 @@ factory. So you won't be doing anything to it in the preparation stage.
 You'll instead turn it directly into an Angular service.
 
 如果项目中有任何 AngularJS 的服务，它们也是转换成类的优秀候选人，像控制器一样，它们也是构造函数。
-但是在本项目中，我们只有一个 `Phone` 工厂，这有点特别，因为它是一个 `ngResource` 工厂。
-所以我们不会在准备阶段中处理它，而是在下一节中直接把它转换成 Angular 服务。
+但是在本项目中，你只有一个 `Phone` 工厂，这有点特别，因为它是一个 `ngResource` 工厂。
+所以你不会在准备阶段中处理它，而是在下一节中直接把它转换成 Angular 服务。
 
 ### Installing Angular
 
@@ -1933,9 +1933,9 @@ upgrade of PhoneCat. You'll do this incrementally with the help of
 By the time you're done, you'll be able to remove AngularJS from the project
 completely, but the key is to do this piece by piece without breaking the application.
 
-我们已经完成了准备工作，接下来就开始把 PhoneCat 升级到 Angular。
-我们将在 Angular[升级模块](guide/upgrade#upgrading-with-ngupgrade)的帮助下增量式的完成此项工作。
-等我们完成的那一刻，就能把 AngularJS 从项目中完全移除了，但其中的关键是在不破坏此程序的前提下一小块一小块的完成它。
+准备工作做完了，接下来就开始把 PhoneCat 升级到 Angular。
+你将在 Angular[升级模块](guide/upgrade#upgrading-with-ngupgrade)的帮助下增量式的完成此项工作。
+做完这些之后，就能把 AngularJS 从项目中完全移除了，但其中的关键是在不破坏此程序的前提下一小块一小块的完成它。
 
 <div class="alert is-important">
 
@@ -1943,7 +1943,7 @@ The project also contains some animations.
 You won't upgrade them in this version of the guide.
 Turn to the [Angular animations](guide/animations) guide to learn about that.
 
-该项目还包含一些动画，在此指南的当前版本我们先不升级它，等到后面的发行版再改。
+该项目还包含一些动画，在此指南的当前版本你先不升级它，请到 [Angular 动画](guide/animations)中进一步学习。
 
 </div>
 
@@ -1951,7 +1951,7 @@ Install Angular into the project, along with the SystemJS module loader.
 Take a look at the results of the [Setup](guide/setup) instructions
 and get the following configurations from there:
 
-我们来使用 SystemJS 模块加载器把 Angular 安装到项目中。
+用 SystemJS 模块加载器把 Angular 安装到项目中。
 看看[搭建本地开发环境](guide/setup)中的指南，并从那里获得如下配置：
 
 * Add Angular and the other new dependencies to `package.json`
@@ -1977,8 +1977,8 @@ but first you need to do some directory path adjustments.
 You'll need to load files from `node_modules` and the project root instead of
 from the `/app` directory as you've been doing to this point.
 
-我们可以通过 `index.html` 来把 Angular 的依赖快速加载到应用中，
-但首先，我们得做一些目录结构调整。这是因为我们正准备从 `node_modules` 中加载文件，然而目前项目中的每一个文件都是从 `/app` 目录下加载的。
+很快你就可以通过 `index.html` 来把 Angular 的依赖快速加载到应用中，
+但首先，你得做一些目录结构调整。这是因为你正准备从 `node_modules` 中加载文件，然而目前项目中的每一个文件都是从 `/app` 目录下加载的。
 
 Move the `app/index.html` file to the project root directory. Then change the
 development server root path in `package.json` to also point to the project root
@@ -1997,7 +1997,7 @@ want to have to change all the image and data paths used in the application code
 the development setup. For that reason, you'll add a `<base>` tag to `index.html`, which will
 cause relative URLs to be resolved back to the `/app` directory:
 
-现在，我们能把项目根目录下的每一样东西发给浏览器了。但我们不想为了适应开发环境中的设置，被迫修改应用代码中用到的所有图片和数据的路径。因此，我们往 `index.html` 中添加一个 `<base>` 标签，它将导致各种相对路径被解析回 `/app` 目录：
+现在，你就能把项目根目录下的每一样东西发给浏览器了。但你*不想*为了适应开发环境中的设置，被迫修改应用代码中用到的所有图片和数据的路径。因此，你要往 `index.html` 中添加一个 `<base>` 标签，它将导致各种相对路径被解析回 `/app` 目录：
 
 <code-example path="upgrade-phonecat-2-hybrid/index.html" region="base" title="index.html">
 
@@ -2007,8 +2007,8 @@ Now you can load Angular via SystemJS. You'll add the Angular polyfills and the
 SystemJS config to the end of the `<head>` section, and then you'll use `System.import`
 to load the actual application:
 
-现在我们可以通过 SystemJS 加载 Angular 了。我们将把 Angular 的腻子脚本(polyfills)
-和 SystemJS 的配置加到 `<head>` 区的末尾，然后，我们就用 `System.import` 来加载实际的应用：
+现在你可以通过 SystemJS 加载 Angular 了。你还要把 Angular 的腻子脚本(polyfills)
+和 SystemJS 的配置加到 `<head>` 区的末尾，然后，你能就用 `System.import` 来加载实际的应用了：
 
 <code-example path="upgrade-phonecat-2-hybrid/index.html" region="angular" title="index.html">
 
@@ -2017,17 +2017,17 @@ to load the actual application:
 You also need to make a couple of adjustments
 to the `systemjs.config.js` file installed during [setup](guide/setup).
 
-我们还需要对[环境设置](guide/setup)期间安装的 `systemjs.config.js` 文件做一些调整。
+你还需要对[环境设置](guide/setup)期间安装的 `systemjs.config.js` 文件做一些调整。
 
 Point the browser to the project root when loading things through SystemJS,
 instead of using the  `<base>` URL.
 
-我们要在通过 SystemJS 加载期间为浏览器指出项目的根在哪里，而不再使用 `<base>` URL。
+在 SystemJS 加载期间为浏览器指出项目的根在哪里，而不再使用 `<base>` URL。
 
 Install the `upgrade` package via `npm install @angular/upgrade --save`
 and add a mapping for the `@angular/upgrade/static` package.
 
-我们还要通过 `npm install @angular/upgrade --save` 来安装 `upgrade` 包，并为 `@angular/upgrade/static` 包添加一个映射。
+再通过 `npm install @angular/upgrade --save` 安装 `upgrade` 包，并为 `@angular/upgrade/static` 包添加一个映射。
 
 <code-example path="upgrade-phonecat-2-hybrid/systemjs.config.1.js" region="paths" title="systemjs.config.js">
 
@@ -2043,7 +2043,7 @@ Rename it to `app.module.ajs.ts` and update the corresponding script name in the
 The file contents remain:
 
 现在，创建一个名叫 `AppModule` 的根 `NgModule` 类。
-我们已经有了一个名叫 `app.module.ts` 的文件，其中存放着 AngularJS 的模块。
+这里已经有了一个名叫 `app.module.ts` 的文件，其中存放着 AngularJS 的模块。
 把它改名为 `app.module.ng1.ts`，同时也要在 `index.html` 中更新对应的脚本名。
 文件的内容保留：
 
@@ -2067,7 +2067,7 @@ Next, you'll bootstrap the application as a *hybrid application*
 that supports both AngularJS and Angular components. After that,
 you can start converting the individual pieces to Angular.
 
-接下来，我们把该应用程序引导改装为一个同时支持 AngularJS 和 Angular 的*混合式应用*。
+接下来，你把该应用程序引导改装为一个同时支持 AngularJS 和 Angular 的*混合式应用*。
 然后，就能开始把这些不可分割的小块转换到 Angular 了。
 
 The application is currently bootstrapped using the AngularJS `ng-app` directive
@@ -2075,8 +2075,8 @@ attached to the `<html>` element of the host page. This will no longer work in t
 app. Switch to the [ngUpgrade bootstrap](#bootstrapping-hybrid-applications) method
 instead.
 
-我们的应用现在是使用宿主页面中附加到 `<html>` 元素上的 `ng-app` 指令引导的。
-但在混合式应用中，它不再工作了。我们得用[ngUpgrade bootstrap](#bootstrapping-hybrid-applications)方法代替。
+本应用现在是使用宿主页面中附加到 `<html>` 元素上的 `ng-app` 指令引导的。
+但在混合式应用中，不能再这么用了。你得用[ngUpgrade bootstrap](#bootstrapping-hybrid-applications)方法代替。
 
 First, remove the `ng-app` attribute from `index.html`.
 Then import `UpgradeModule` in the `AppModule`, and override its `ngDoBootstrap` method:
@@ -2092,8 +2092,8 @@ The arguments are the same as you would pass to `angular.bootstrap` if you were
 bootstrapping AngularJS: the root element of the application; and an array of the
 AngularJS 1.x modules that you want to load.
 
-注意，我们正在从内部的 `ngDoBootstrap` 中引导 AngularJS 模块。
-它的参数和我们在手动引导 AngularJS 时传给 `angular.bootstrap` 的是一样的：应用的根元素，和所要加载的 AngularJS 1.x 模块的数组。
+注意，你正在从内部的 `ngDoBootstrap` 中引导 AngularJS 模块。
+它的参数和你在手动引导 AngularJS 时传给 `angular.bootstrap` 的是一样的：应用的根元素，和所要加载的 AngularJS 1.x 模块的数组。
 
 Finally, bootstrap the `AppModule` in `src/main.ts`.
 This file has been configured as the application entrypoint in `systemjs.config.js`,
@@ -2108,7 +2108,7 @@ so it is already being loaded by the browser.
 Now you're running both AngularJS and Angular at the same time. That's pretty
 exciting! You're not running any actual Angular components yet. That's next.
 
-现在，我们同时运行着 AngularJS 和 Angular。漂亮！不过我们还没有运行什么实际的 Angular 组件，接下来我们就做这件事。
+现在，你同时运行着 AngularJS 和 Angular。漂亮！不过你还没有运行什么实际的 Angular 组件，这就是接下来要做的。
 
 <div class="l-sub-section">
 
@@ -2133,7 +2133,7 @@ loaded correctly.
 
 AngularJS 是日前是通过 `index.html` 中的 script 标签加载，这意味着整个应用是作为一个全局变量进行访问的，
 使用同一个 `angular` 变量的实例。
-但如果我们使用 `import * as angular from 'angular'`，我还需要彻底修改 AngularJS 应用中加载每个文件的方式，
+但如果你使用 `import * as angular from 'angular'`，我还需要彻底修改 AngularJS 应用中加载每个文件的方式，
 确保 AngularJS 应用被正确加载。
 
 This is a considerable effort and it often isn't worth it, especially since you are in the
@@ -2141,8 +2141,8 @@ process of moving your code to Angular.
 Instead, declare `angular` as `angular.IAngularStatic` to indicate it is a global variable
 and still have full typing support.
 
-这需要相当多的努力，通常也不值得去做，特别是我们的应用正在朝着 Angular 前进。
-但如果我们声明 `angular` 为 `angular.IAngularStatic`，指明它是一个全局变量，
+这需要相当多的努力，通常也不值得去做，特别是当你正在朝着 Angular 前进时。
+但如果你把 `angular` 声明为 `angular.IAngularStatic`，指明它是一个全局变量，
 仍然可以获得全面的类型支持。
 
 </div>
@@ -2156,8 +2156,8 @@ resides in `app/core/phone/phone.service.ts` and makes it possible for component
 to load phone information from the server. Right now it's implemented with
 ngResource and you're using it for two things:
 
-我们要移植到 Angular 的第一块是 `Phone` 工厂(位于 `app/js/core/phones.factory.ts`)，
-并且让它能帮助控制器从服务器上加载电话信息。目前，它是用 `ngResource` 实现的，我们用它做两件事：
+你要移植到 Angular 的第一个片段是 `Phone` 工厂(位于 `app/js/core/phones.factory.ts`)，
+并且让它能帮助控制器从服务器上加载电话信息。目前，它是用 `ngResource` 实现的，你用它做两件事：
 
 * For loading the list of all phones into the phone list component.
 
@@ -2170,11 +2170,11 @@ ngResource and you're using it for two things:
 You can replace this implementation with an Angular service class, while
 keeping the controllers in AngularJS land.
 
-我们可以用 Angular 的服务类来替换这个实现，而把控制器继续留在 AngularJS 的地盘上。
+你可以用 Angular 的服务类来替换这个实现，而把控制器继续留在 AngularJS 的地盘上。
 
 In the new version, you import the Angular HTTP module and call its `Http` service instead of `ngResource`.
 
-在这个新版本中，我们导入了 Angular 的 HTTP 模块，并且用它的 `Http` 服务替换掉 `NgResource`。
+在这个新版本中，你导入了 Angular 的 HTTP 模块，并且用它的 `Http` 服务替换掉 `NgResource`。
 
 Re-open the `app.module.ts` file, import and add `HttpModule` to the `imports` array of the `AppModule`:
 
@@ -2187,7 +2187,7 @@ Re-open the `app.module.ts` file, import and add `HttpModule` to the `imports` a
 Now you're ready to upgrade the Phone service itself. Replace the ngResource-based
 service in `phone.service.ts` with a TypeScript class decorated as `@Injectable`:
 
-现在，我们已经准备好了升级 `Phones` 服务本身。我们将为 `phone.service.ts` 文件中基于 ngResource 的服务加上 `@Injectable` 装饰器：
+现在，你已经准备好了升级 `Phones` 服务本身。你将为 `phone.service.ts` 文件中基于 ngResource 的服务加上 `@Injectable` 装饰器：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/core/phone/phone.service.ts" region="classdef" title="app/core/phone/phone.service.ts (skeleton)" linenums="false">
 
@@ -2201,7 +2201,7 @@ Angular decorators but still need to have their dependencies injected.
 
 `@Injectable` 装饰器将把一些依赖注入相关的元数据附加到该类上，让 Angular 知道它的依赖信息。
 就像在[依赖注入指南](guide/dependency-injection)中描述过的那样，
-这是一个标记装饰器，我们要把它用在那些没有其它 Angular 装饰器，并且自己有依赖注入的类上。
+这是一个标记装饰器，你要把它用在那些没有其它 Angular 装饰器，并且自己有依赖注入的类上。
 
 In its constructor the class expects to get the `Http` service. It will
 be injected to it and it is stored as a private field. The service is then
@@ -2219,7 +2219,7 @@ The methods now return Observables of type `PhoneData` and `PhoneData[]`. This i
 a type you don't have yet. Add a simple interface for it:
 
 该方法现在返回一个 `Phone` 类型或 `Phone[]` 类型的可观察对象(Observable)。
-这是一个我们从未用过的类型，因此我们得为它新增一个简单的接口：
+这是一个你从未用过的类型，因此你得为它新增一个简单的接口：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/core/phone/phone.service.ts" region="phonedata-interface" title="app/core/phone/phone.service.ts (interface)" linenums="false">
 
@@ -2246,14 +2246,14 @@ Here's the full, final code for the service:
 Notice that you're importing the `map` operator of the RxJS `Observable` separately.
 Do this for every RxJS operator.
 
-注意，我们单独导入了 RxJS `Observable` 中的 `map` 操作符。
-我们需要对想用的所有 RxJS 操作符这么做，因为 Angular 默认不会加载所有 RxJS 操作符。
+注意，你单独导入了 RxJS `Observable` 中的 `map` 操作符。
+你需要对想用的所有 RxJS 操作符这么做，因为 Angular 默认不会加载所有 RxJS 操作符。
 
 The new `Phone` service has the same features as the original, `ngResource`-based service.
 Because it's an Angular service, you register it with the `NgModule` providers:
 
 这个新的 `Phone` 服务具有和老的基于 `ngResource` 的服务相同的特性。
-因为它是 Angular 服务，我们通过 `NgModule` 的 `providers` 数组来注册它：
+因为它是 Angular 服务，你通过 `NgModule` 的 `providers` 数组来注册它：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/app.module.ts" region="phone" title="app.module.ts">
 
@@ -2264,15 +2264,15 @@ by SystemJS, you should **remove the &lt;script&gt; tag** for the service from `
 This is something you'll do to all components as you upgrade them. Simultaneously
 with the AngularJS to Angular upgrade you're also migrating code from scripts to modules.
 
-现在，我们正在用 SystemJS 加载 `phone.service.ts`，我们应该从 `index.html` 中**移除该服务的 `<script>` 标签**。
-这也是我们在升级所有组件时将会做的事。在从 AngularJS 向 Angular 升级的同时，我们也把代码从脚本移植为模块。
+现在，你正在用 SystemJS 加载 `phone.service.ts`，你应该从 `index.html` 中**移除该服务的 `<script>` 标签**。
+这也是你在升级所有组件时将会做的事。在从 AngularJS 向 Angular 升级的同时，你也把代码从脚本移植为模块。
 
 At this point, you can switch the two components to use the new service
 instead of the old one.  While you `$inject` it as the downgraded `phone` factory,
 it's really an instance of the `Phone` class and you annotate its type accordingly:
 
-这时，我们可以把两个控制器从使用老的服务切换成使用新的。我们像降级过的 `phones` 工厂一样 `$inject` 它，
-但它实际上是一个 `Phones` 类的实例，并且我们可以据此注解它的类型：
+这时，你可以把两个控制器从使用老的服务切换成使用新的。你像降级过的 `phones` 工厂一样 `$inject` 它，
+但它实际上是一个 `Phones` 类的实例，并且你可以据此注解它的类型：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/phone-list/phone-list.component.ajs.ts" title="app/phone-list/phone-list.component.ts">
 
@@ -2289,7 +2289,7 @@ In any case, what you've achieved is a migration of a service to Angular
 without having to yet migrate the components that use it.
 
 这里的两个 AngularJS 控制器在使用 Angular 的服务！控制器不需要关心这一点，尽管实际上该服务返回的是可观察对象(Observable)，而不是承诺(Promise)。
-无论如何，我们达到的效果都是把服务移植到 Angular，而不用被迫移植组件来使用它。
+无论如何，你达到的效果都是把服务移植到 Angular，而不用被迫移植组件来使用它。
 
 <div class="alert is-helpful">
 
@@ -2297,7 +2297,7 @@ You could use the `toPromise` method of `Observable` to turn those
 Observables into Promises in the service. In many cases that reduce
 the number of changes to the component controllers.
 
-我们也能使用 `Observable` 的 `toPromise` 方法来在服务中把这些可观察对象转变成承诺，以进一步减小组件控制器中需要修改的代码量。
+你也能使用 `Observable` 的 `toPromise` 方法来在服务中把这些可观察对象转变成承诺，以进一步减小组件控制器中需要修改的代码量。
 
 </div>
 
@@ -2309,8 +2309,8 @@ Upgrade the AngularJS components to Angular components next.
 Do it one component at a time while still keeping the application in hybrid mode.
 As you make these conversions, you'll also define your first Angular *pipes*.
 
-接下来，我们把 AngularJS 的控制器升级成 Angular 的组件。我们每次升级一个，同时仍然保持应用运行在混合模式下。
-在做转换的同时，我们还将自定义首个 Angular*管道*。
+接下来，把 AngularJS 的控制器升级成 Angular 的组件。每次升级一个，同时仍然保持应用运行在混合模式下。
+在做转换的同时，你还将自定义首个 Angular*管道*。
 
 Look at the phone list component first. Right now it contains a TypeScript
 controller class and a component definition object. You can morph this into
@@ -2318,9 +2318,9 @@ an Angular component by just renaming the controller class and turning the
 AngularJS component definition object into an Angular `@Component` decorator.
 You can then also remove the static `$inject` property from the class:
 
-让我们先看看电话列表组件。它目前包含一个 TypeScript 控制器类和一个组件定义对象。重命名控制器类，
-并把 AngularJS 的组件定义对象更换为 Angular `@Component` 装饰器，这样我们就把它变形为 Angular
-的组件了。然后，我们还从类中移除静态 `$inject` 属性。
+先看看电话列表组件。它目前包含一个 TypeScript 控制器类和一个组件定义对象。重命名控制器类，
+并把 AngularJS 的组件定义对象更换为 Angular `@Component` 装饰器，这样你就把它变形为 Angular
+的组件了。然后，你还要从类中移除静态 `$inject` 属性。
 
 <code-example path="upgrade-phonecat-2-hybrid/app/phone-list/phone-list.component.ts" region="initialclass" title="app/phone-list/phone-list.component.ts">
 
@@ -2331,14 +2331,14 @@ should go. In AngularJS you do matching based on component names, but in Angular
 have these explicit selectors. This one will match elements with the name `phone-list`,
 just like the AngularJS version did.
 
-`selector` 属性是一个 CSS 选择器，用来定义组件应该被放在页面的哪。在 AngularJS，我们基于组件名字来匹配，
-但是在 Angular 中，我们要有一个专门指定的选择器。本组件将会对应元素名字 `phone-list`，和 AngularJS 版本一样。
+`selector` 属性是一个 CSS 选择器，用来定义组件应该被放在页面的哪。在 AngularJS 中，你会基于组件名字来匹配，
+但是在 Angular 中，你要显式指定这些选择器。本组件将会对应元素名字 `phone-list`，和 AngularJS 版本一样。
 
 Now convert the template of this component into Angular syntax.
 The search controls replace the AngularJS `$ctrl` expressions
 with Angular's two-way `[(ngModel)]` binding syntax:
 
-现在，我们还需要将组件的模版也转换为 Angular 语法。在搜索控件中，我们要为把 AngularJS 的 `$ctrl` 表达式替换成 Angular 的双向绑定语法 `[(ngModel)]`：
+现在，将组件的模版也转换为 Angular 语法。在搜索控件中，把 AngularJS 的 `$ctrl` 表达式替换成 Angular 的双向绑定语法 `[(ngModel)]`：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/phone-list/phone-list.template.html" region="controls" title="app/phone-list/phone-list.template.html (search controls)" linenums="false">
 
@@ -2348,9 +2348,9 @@ Replace the list's `ng-repeat` with an `*ngFor` as
 [described in the Template Syntax page](guide/template-syntax#directives).
 Replace the image tag's `ng-src` with a binding to the native `src` property.
 
-我们需要把列表中的 `ng-repeat` 替换为 `*ngFor` 以及它的 `let var of iterable` 语法，
+把列表中的 `ng-repeat` 替换为 `*ngFor` 以及它的 `let var of iterable` 语法，
 该语法在[模板语法指南中讲过](guide/template-syntax#directives)。
-对于图片，我们可以把 `img` 标签的 `ng-src` 替换为一个标准的 `src` 属性(property)绑定。
+再把 `img` 标签的 `ng-src` 替换为一个标准的 `src` 属性(property)绑定。
 
 <code-example path="upgrade-phonecat-2-hybrid/app/phone-list/phone-list.template.html" region="list" title="app/phone-list/phone-list.template.html (phones)" linenums="false">
 
@@ -2364,12 +2364,12 @@ The built-in AngularJS `filter` and `orderBy` filters do not exist in Angular,
 so you need to do the filtering and sorting yourself.
 
 Angular 中并不存在 AngularJS 中内置的 `filter` 和 `orderBy` 过滤器。
-所以我们得自己实现进行过滤和排序。
+所以你得自己实现进行过滤和排序。
 
 You replaced the `filter` and `orderBy` filters with bindings to the `getPhones()` controller method,
 which implements the filtering and ordering logic inside the component itself.
 
-我们把 `filter` 和 `orderBy` 过滤器改成绑定到控制器中的 `getPhones()` 方法，通过该方法，组件本身实现了过滤和排序逻辑。
+你把 `filter` 和 `orderBy` 过滤器改成绑定到控制器中的 `getPhones()` 方法，通过该方法，组件本身实现了过滤和排序逻辑。
 
 <code-example path="upgrade-phonecat-2-hybrid/app/phone-list/phone-list.component.ts" region="getphones" title="app/phone-list/phone-list.component.ts">
 
@@ -2379,8 +2379,8 @@ Now you need to downgrade the Angular component so you can use it in AngularJS.
 Instead of registering a component, you register a `phoneList` *directive*,
 a downgraded version of the Angular component.
 
-现在我们需要降级我们的 Angular 组件，这样我们就可以在 AngularJS 中使用它。
-我们需要注册一个 `phoneList`*指令*，而不是注册一个组件，它是一个降级版的 Angular 组件。
+现在你需要降级你的 Angular 组件，这样你就可以在 AngularJS 中使用它了。
+你要注册一个 `phoneList`*指令*，而不是注册一个组件，它是一个降级版的 Angular 组件。
 
 The `as angular.IDirectiveFactory` cast tells the TypeScript compiler
 that the return value of the `downgradeComponent` method is a directive factory.
@@ -2398,7 +2398,7 @@ finally add it to `entryComponents` since you downgraded it:
 
 新的 `PhoneListComponent` 使用 Angular 的 `ngModel` 指令，它位于 `FormsModule` 中。
 把 `FormsModule` 添加到 `NgModule` 的 `imports` 中，并声明新的 `PhoneListComponent` 组件，
-最后由我们把它降级了，添加到 `entryComponents`：
+最后，把降级的结果添加到 `entryComponents`中：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/app.module.ts" region="phonelist" title="app.module.ts">
 
@@ -2428,7 +2428,7 @@ You intend to inject it into the new `PhoneDetailsComponent`.
 
 AngularJS 注入器具有 AngularJS 路由器的依赖，叫做 `$routeParams`。
 它被注入到了 `PhoneDetails` 中，但 `PhoneDetails` 现在还是一个 AngularJS 控制器。
-我们应该把它注入到新的 `PhoneDetailsComponent` 中。
+你要把它注入到新的 `PhoneDetailsComponent` 中。
 
 Unfortunately, AngularJS dependencies are not automatically available to Angular components.
 You must upgrade this service via a [factory provider](guide/upgrade#making-angularjs-dependencies-injectable-to-angular)
@@ -2436,7 +2436,7 @@ to make `$routeParams` an Angular injectable.
 Do that in a new file called `ajs-upgraded-providers.ts` and import it in `app.module.ts`:
 
 不幸的是，AngularJS 的依赖不会自动在 Angular 的组件中可用。
-我们必须使用[工厂提供商（factory provider）](guide/upgrade#making-angularjs-dependencies-injectable-to-angular)
+你必须使用[工厂提供商（factory provider）](guide/upgrade#making-angularjs-dependencies-injectable-to-angular)
 来把 `$routeParams` 包装成 Angular 的服务提供商。
 新建一个名叫 `ajs-upgraded-providers.ts` 的文件，并且在 `app.module.ts` 中导入它：
 
@@ -2450,8 +2450,7 @@ Do that in a new file called `ajs-upgraded-providers.ts` and import it in `app.m
 
 Convert the phone detail component template into Angular syntax as follows:
 
-我们现在也要把该组件的模板转变成 Angular 的语法。
-这里是它完整的新模板：
+把该组件的模板转变成 Angular 的语法，代码如下：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/phone-detail/phone-detail.template.html" title="app/phone-detail/phone-detail.template.html">
 
@@ -2463,12 +2462,12 @@ There are several notable changes here:
 
 * You've removed the `$ctrl.` prefix from all expressions.
 
-   我们从所有表达式中移除了 `$ctrl.` 前缀。
+   你从所有表达式中移除了 `$ctrl.` 前缀。
 
 * You've replaced `ng-src` with property
   bindings for the standard `src` property.
 
-   正如我们在电话列表中做过的那样，我们把 `ng-src` 替换成了标准的 `src` 属性绑定。
+   正如你在电话列表中做过的那样，你把 `ng-src` 替换成了标准的 `src` 属性绑定。
 
 * You're using the property binding syntax around `ng-class`. Though Angular
   does have [a very similar `ngClass`](guide/template-syntax#directives)
@@ -2476,18 +2475,18 @@ There are several notable changes here:
   In Angular, you always specify  in the template when an attribute's value is
   a property expression, as opposed to a literal string.
 
-   我们在 `ng-class` 周围使用了属性绑定语法。虽然 Angular 中有一个
+   你在 `ng-class` 周围使用了属性绑定语法。虽然 Angular 中有一个
   和 AngularJS 中[非常相似的 `ngClass`](guide/template-syntax#directives)指令，
   但是它的值不会神奇的作为表达式进行计算。在 Angular 中，模板中的属性(Attribute)值总是被作为
   属性(Property)表达式计算，而不是作为字符串字面量。
 
 * You've replaced `ng-repeat`s with `*ngFor`s.
 
-   我们把 `ng-repeat` 替换成了 `*ngFor`。
+   你把 `ng-repeat` 替换成了 `*ngFor`。
 
 * You've replaced `ng-click` with an event binding for the standard `click`.
 
-   我们把 `ng-click` 替换成了一个到标准 `click` 事件的绑定。
+   你把 `ng-click` 替换成了一个到标准 `click` 事件的绑定。
 
 * You've wrapped the whole template in an `ngIf` that causes it only to be
   rendered when there is a phone present. You need this because when the component
@@ -2496,10 +2495,10 @@ There are several notable changes here:
   when you try to refer to properties on undefined objects. You need to be explicit
   about cases where this is expected.
 
-   我们把整个模板都包裹进了一个 `ngIf` 中，这导致只有当存在一个电话时它才会渲染。我们必须这么做，
-  是因为组件首次加载时我们还没有 `phone` 变量，这些表达式就会引用到一个不存在的值。
-  和 AngularJS 不同，当我们尝试引用未定义对象上的属性时，Angular 中的表达式不会默默失败。
-  我们必须明确指出这种情况是我们所期望的。
+   你把整个模板都包裹进了一个 `ngIf` 中，这导致只有当存在一个电话时它才会渲染。你必须这么做，
+  是因为组件首次加载时你还没有 `phone` 变量，这些表达式就会引用到一个不存在的值。
+  和 AngularJS 不同，当你尝试引用未定义对象上的属性时，Angular 中的表达式不会默默失败。
+  你必须明确指出这种情况是你所期望的。
 
 Add `PhoneDetailComponent` component to the `NgModule` _declarations_ and _entryComponents_:
 
@@ -2511,7 +2510,7 @@ Add `PhoneDetailComponent` component to the `NgModule` _declarations_ and _entry
 
 You should now also remove the phone detail component &lt;script&gt; tag from `index.html`.
 
-我们现在应该从 `index.html` 中移除电话详情组件的&lt;script>。
+你现在应该从 `index.html` 中移除电话详情组件的&lt;script>。
 
 #### Add the _CheckmarkPipe_
 
@@ -2520,7 +2519,7 @@ You should now also remove the phone detail component &lt;script&gt; tag from `i
 The AngularJS directive had a `checkmark` _filter_.
 Turn that into an Angular **pipe**.
 
-AngularJS 指令中有一个 `checkmark`*过滤器*，我们把它转换成 Angular 的**管道**。
+AngularJS 指令中有一个 `checkmark`*过滤器*，把它转换成 Angular 的**管道**。
 
 There is no upgrade method to convert filters into pipes.
 You won't miss it.
@@ -2529,7 +2528,7 @@ The implementation is the same as before, repackaged in the `transform` method.
 Rename the file to `checkmark.pipe.ts` to conform with Angular conventions:
 
 没有什么升级方法能把过滤器转换成管道。
-但我们也并不需要它。
+但你也并不需要它。
 把过滤器函数转换成等价的 Pipe 类非常简单。
 实现方式和以前一样，但把它们包装进 `transform` 方法中就可以了。
 把该文件改名成 `checkmark.pipe.ts`，以符合 Angular 中的命名约定：
@@ -2541,7 +2540,7 @@ Rename the file to `checkmark.pipe.ts` to conform with Angular conventions:
 Now import and declare the newly created pipe and
 remove the filter &lt;script&gt; tag from `index.html`:
 
-当我们做这个修改时，也要同时从 `core` 模块文件中移除对该过滤器的注册。该模块的内容变成了：
+现在，导入并声明这个新创建的管道，同时从 `index.html` 文件中移除该过滤器的`<script>` 标签：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/app.module.ts" region="checkmarkpipe" title="app.module.ts">
 
@@ -2554,12 +2553,12 @@ remove the filter &lt;script&gt; tag from `index.html`:
 To use AOT with a hybrid app, you have to first set it up like any other Angular application,
 as shown in [the Ahead-of-time Compilation chapter](guide/aot-compiler).
 
-要在混合式应用中使用 AOT 编译，我们首先要像其它 Angular 应用一样设置它，就像[AOT 编译一章](guide/aot-compiler)所讲的那样。
+要在混合式应用中使用 AOT 编译，你首先要像其它 Angular 应用一样设置它，就像[AOT 编译一章](guide/aot-compiler)所讲的那样。
 
 Then change `main-aot.ts` to bootstrap the `AppComponentFactory` that was generated
 by the AOT compiler:
 
-然后，我们就要修改 `main-aot.ts` 的引导代码，通过所生成的 `AppComponentFactory` 来引导 AngularJS 应用：
+然后修改 `main-aot.ts` 的引导代码，通过所生成的 `AppComponentFactory` 来引导 AngularJS 应用：
 
 <code-example path="upgrade-phonecat-2-hybrid/app/main-aot.ts" title="app/main-aot.ts">
 
@@ -2568,7 +2567,7 @@ by the AOT compiler:
 You need to load all the AngularJS files you already use in `index.html` in `aot/index.html`
 as well:
 
-我们还要把在 `index.html` 中已经用到的所有 AngularJS 文件加载到 `aot/index.html` 中：
+你还要把在 `index.html` 中已经用到的所有 AngularJS 文件加载到 `aot/index.html` 中：
 
 <code-example path="upgrade-phonecat-2-hybrid/aot/index.html" title="aot/index.html">
 
@@ -2599,7 +2598,7 @@ And that's all you need to use AOT while upgrading your app!
 At this point, you've replaced all AngularJS application components with
 their Angular counterparts, even though you're still serving them from the AngularJS router.
 
-此刻，我们已经把所有 AngularJS 的组件替换成了它们在 Angular 中的等价物，不过我们仍然在 AngularJS 路由器中使用它们。
+此刻，你已经把所有 AngularJS 的组件替换成了它们在 Angular 中的等价物，不过你仍然在 AngularJS 路由器中使用它们。
 
 #### Add the Angular router
 
@@ -2619,7 +2618,7 @@ at the top of the applications component tree.
 You don't yet have such a root component, because the app is still managed as an AngularJS app.
 Create a new `app.component.ts` file with the following `AppComponent` class:
 
-我们还没有这样一个根组件，因为该应用仍然是像一个 AngularJS 应用那样被管理的。
+你还没有这样一个根组件，因为该应用仍然是像一个 AngularJS 应用那样被管理的。
 创建新的 `app.component.ts` 文件，放入像这样的 `AppComponent` 类：
 
 <code-example path="upgrade-phonecat-3-final/app/app.component.ts" title="app/app.component.ts">
@@ -2689,7 +2688,7 @@ insert its view into the host web page.
 You must also remove the bootstrap of the AngularJS module from `ngDoBootstrap()` in `app.module.ts`
 and the `UpgradeModule` import.
 
-我们还要从 `app.module.ts` 中移除调用 `ngDoBootstrap()` 来引导 AngularJS 模块的代码，以及对 `UpgradeModule` 的导入代码。
+你还要从 `app.module.ts` 中移除调用 `ngDoBootstrap()` 来引导 AngularJS 模块的代码，以及对 `UpgradeModule` 的导入代码。
 
 <code-example path="upgrade-phonecat-3-final/app/app.module.ts" title="app/app.module.ts">
 
@@ -2699,7 +2698,7 @@ And since you are routing to `PhoneListComponent` and `PhoneDetailComponent` dir
 using a route template with a `<phone-list>` or `<phone-detail>` tag, you can do away with their
 Angular selectors as well.
 
-而且，由于我们现在直接路由到 `PhoneListComponent` 和 `PhoneDetailComponent`，而不在使用带 `<phone-list>` 或 `<phone-detail>` 标签的路由模板，因此我们同样不再需要它们的 Angular 选择器。
+而且，由于你现在直接路由到 `PhoneListComponent` 和 `PhoneDetailComponent`，而不再使用带 `<phone-list>` 或 `<phone-detail>` 标签的路由模板，因此你同样不再需要它们的 Angular 选择器。
 
 #### Generate links for each phone
 
@@ -2709,8 +2708,8 @@ You no longer have to hardcode the links to phone details in the phone list.
 You can generate data bindings for each phone's `id` to the `routerLink` directive
 and let that directive construct the appropriate URL to the `PhoneDetailComponent`:
 
-在电话列表中，我们不用再被迫硬编码电话详情的链接了。
-我们可以通过把每个电话的 `id` 绑定到 `routerLink` 指令来生成它们了，该指令的构造函数会为 `PhoneDetailComponent` 生成正确的 URL：
+在电话列表中，你不用再被迫硬编码电话详情的链接了。
+你可以通过把每个电话的 `id` 绑定到 `routerLink` 指令来生成它们了，该指令的构造函数会为 `PhoneDetailComponent` 生成正确的 URL：
 
 <code-example path="upgrade-phonecat-3-final/app/phone-list/phone-list.template.html" region="list" title="app/phone-list/phone-list.template.html (list with links)" linenums="false">
 
@@ -2742,7 +2741,7 @@ Angular 路由器会传入不同的路由参数。
 
 You are now running a pure Angular application!
 
-我们现在运行的就是纯正的 Angular 应用了！
+你现在运行的就是纯正的 Angular 应用了！
 
 ### Say Goodbye to AngularJS
 
@@ -2752,7 +2751,7 @@ It is time to take off the training wheels and let the application begin
 its new life as a pure, shiny Angular app. The remaining tasks all have to
 do with removing code - which of course is every programmer's favorite task!
 
-终于可以把辅助训练的轮子摘下来了！让我们的应用作为一个纯粹、闪亮的 Angular 程序开始它的新生命吧。
+终于可以把辅助训练的轮子摘下来了！让你的应用作为一个纯粹、闪亮的 Angular 程序开始它的新生命吧。
   剩下的所有任务就是移除代码 —— 这当然是每个程序员最喜欢的任务！
 
 The application is still bootstrapped as a hybrid app.
@@ -2781,7 +2780,7 @@ Since you no longer have downgraded components, you no longer list them
 in `entryComponents`.
 
 还要删除所有的 `downgradeInjectable()` 或 `downgradeComponent()` 以及与 AngularJS 相关的工厂或指令声明。
-因为我们不再需要降级任何组件了，也不再需要把它们列在 `entryComponents` 中。
+因为你不再需要降级任何组件了，也不再需要把它们列在 `entryComponents` 中。
 
 <code-example path="upgrade-phonecat-3-final/app/app.module.ts" title="app.module.ts">
 
@@ -2790,7 +2789,7 @@ in `entryComponents`.
 You may also completely remove the following files. They are AngularJS
 module configuration files and not needed in Angular:
 
-我们还要完全移除了下列文件。它们是 AngularJS 的模块配置文件和类型定义文件，在 Angular 中不需要了：
+你还要完全移除了下列文件。它们是 AngularJS 的模块配置文件和类型定义文件，在 Angular 中不需要了：
 
 * `app/app.module.ajs.ts`
 
@@ -2808,7 +2807,7 @@ The external typings for AngularJS may be uninstalled as well. The only ones
 you still need are for Jasmine and Angular polyfills.
 The `@angular/upgrade` package and its mapping in `systemjs.config.js` can also go.
 
-还需要反安装 AngularJS 的外部类型定义文件。我们现在只需要 Jasmine 的那些。
+还需要卸载 AngularJS 的外部类型定义文件。你现在只需要留下 Jasmine 和 Angular 所需的腻子脚本。
 `systemjs.config.js` 中的 `@angular/upgrade` 包及其映射也可以移除了。
 
 <code-example format="">
@@ -2831,7 +2830,7 @@ When you're done, this is what it should look like:
 That is the last you'll see of AngularJS! It has served us well but now
 it's time to say goodbye.
 
-这是我们最后一次看到 AngularJS 了！它曾经带给我们很多帮助，不过现在，是时候说再见了。
+这是你最后一次看到 AngularJS 了！它曾经带给你很多帮助，不过现在，该说再见了。
 
 ## Appendix: Upgrading PhoneCat Tests
 
@@ -2858,16 +2857,16 @@ test suite should keep passing with just minor modifications. You
 didn't change how the application behaves from the user's point of view.
 
 PhoneCat 项目中同时有基于 Protractor 的 E2E 测试和一些基于 Karma 的单元测试。
-对这两者来说，E2E 测试的转换要容易得多：根据定义，E2E 测试通过与应用中显示的这些 UI 元素互动，从*外部*访问我们的应用来进行测试。
-E2E 测试实际上并不关心这些应用中各部件的内部结构。这也意味着，虽然我们已经修改了此应用程序，
-但是 E2E 测试套件仍然应该能像以前一样全部通过。因为从用户的角度来说，我们并没有改变应用的行为。
+对这两者来说，E2E 测试的转换要容易得多：根据定义，E2E 测试通过与应用中显示的这些 UI 元素互动，从*外部*访问你的应用来进行测试。
+E2E 测试实际上并不关心这些应用中各部件的内部结构。这也意味着，虽然你已经修改了此应用程序，
+但是 E2E 测试套件仍然应该能像以前一样全部通过。因为从用户的角度来说，你并没有改变应用的行为。
 
 During TypeScript conversion, there is nothing to do to keep E2E tests
 working. But when you change the bootstrap to that of a Hybrid app,
 you must make a few changes.
 
-在转成 TypeScript 期间，我们不用做什么就能让 E2E 测试正常工作。
-只有当我们想做些修改而把组件及其模板升级到 Angular 时才需要做些处理。
+在转成 TypeScript 期间，你不用做什么就能让 E2E 测试正常工作。
+只有当你想做些修改而把组件及其模板升级到 Angular 时才需要做些处理。
 
 Update the `protractor-conf.js` to sync with hybrid apps:
 
@@ -2883,8 +2882,8 @@ When you start to upgrade components and their templates to Angular, you'll make
 because the E2E tests have matchers that are specific to AngularJS.
 For PhoneCat you need to make the following changes in order to make things work with Angular:
 
-当我们开始组件和模块升级到 Angular 时，还需要一系列后续的修改。
-这是因为 E2E 测试有一些匹配器是 AngularJS 中特有的。对于 PhoneCat 来说，为了让它能在 Angular 下工作，我们得做下列修改：
+当你开始组件和模块升级到 Angular 时，还需要一系列后续的修改。
+这是因为 E2E 测试有一些匹配器是 AngularJS 中特有的。对于 PhoneCat 来说，为了让它能在 Angular 下工作，你得做下列修改：
 
 <table>
 
@@ -3045,7 +3044,7 @@ an AngularJS app anymore, but instead it should find *Angular apps* from
 the page.
 
 当引导方式从 `UpgradeModule` 切换到纯 Angular 的时，AngularJS 就从页面中完全消失了。
-此时，我们需要告诉 Protractor，它不用再找 AngularJS 应用了，而是从页面中查找 *Angular* 应用。
+此时，你需要告诉 Protractor，它不用再找 AngularJS 应用了，而是从页面中查找 *Angular* 应用。
 于是在 `protractor-conf.js` 中做下列修改：
 
 Replace the `ng12Hybrid` previously added with the following in `protractor-conf.js`:
@@ -3064,8 +3063,8 @@ service is no longer present after the upgrade, replace those calls with ones
 that use WebDriver's generic URL APIs instead. The first of these is
 the redirection spec:
 
-同样，我们的测试代码中有两个 Protractor API 调用内部使用了 `$location`。该服务没有了，
-我们就得把这些调用用一个 WebDriver 的通用 URL API 代替。第一个 API 是“重定向(redirect)”规约：
+同样，`PhoneCat` 的测试代码中有两个 Protractor API 调用内部使用了 `$location`。该服务没有了，
+你就得把这些调用用一个 WebDriver 的通用 URL API 代替。第一个 API 是“重定向(redirect)”规约：
 
 <code-example path="upgrade-phonecat-3-final/e2e-spec.ts" region="redirect" title="e2e-tests/scenarios.ts">
 
@@ -3098,7 +3097,7 @@ For instance, in the phone detail component spec, you can use ES2015
 features like arrow functions and block-scoped variables and benefit from the type
 definitions of the AngularJS services you're consuming:
 
-比如，在这个电话详情组件的规约中，我们不仅用到了 ES2015 中的箭头函数和块作用域变量这些特性，还为所用的一些
+比如，在这个电话详情组件的规约中，你不仅用到了 ES2015 中的箭头函数和块作用域变量这些特性，还为所用的一些
 AngularJS 服务提供了类型定义。
 
 <code-example path="upgrade-phonecat-1-typescript/app/phone-detail/phone-detail.component.spec.ts" title="app/phone-detail/phone-detail.component.spec.ts">
@@ -3109,8 +3108,8 @@ Once you start the upgrade process and bring in SystemJS, configuration changes
 are needed for Karma. You need to let SystemJS load all the new Angular code,
 which can be done with the following kind of shim file:
 
-一旦我们开始了升级过程并引入了 SystemJS，还需要对 Karma 进行配置修改。
-我们需要让 SystemJS 加载所有的 Angular 新代码，
+一旦你开始了升级过程并引入了 SystemJS，还需要对 Karma 进行配置修改。
+你需要让 SystemJS 加载所有的 Angular 新代码，
 
 <code-example path="upgrade-phonecat-2-hybrid/karma-test-shim.1.js" title="karma-test-shim.js">
 
@@ -3134,8 +3133,8 @@ Once done, you can load SystemJS and other dependencies, and also switch the con
 for loading application files so that they are *not* included to the page by Karma. You'll let
 the shim and SystemJS load them.
 
-一旦这些完成了，我们就能加载 SystemJS 和其它依赖，并切换配置文件来加载那些应用文件，而*不用*在 Karma 页面中包含它们。
-我们要让这个 shim 文件和 SystemJS 去加载它们。
+一旦这些完成了，你就能加载 SystemJS 和其它依赖，并切换配置文件来加载那些应用文件，而*不用*在 Karma 页面中包含它们。
+你要让这个 shim 文件和 SystemJS 去加载它们。
 
 <code-example path="upgrade-phonecat-2-hybrid/karma.conf.ajs.js" region="files" title="karma.conf.js">
 
@@ -3144,7 +3143,7 @@ the shim and SystemJS load them.
 Since the HTML templates of Angular components will be loaded as well, you must help
 Karma out a bit so that it can route them to the right paths:
 
-由于 Angular 组件中的 HTML 模板也同样要被加载，所以我们得帮 Karma 一把，帮它在正确的路径下找到这些模板：
+由于 Angular 组件中的 HTML 模板也同样要被加载，所以你得帮 Karma 一把，帮它在正确的路径下找到这些模板：
 
 <code-example path="upgrade-phonecat-2-hybrid/karma.conf.ajs.js" region="html" title="karma.conf.js">
 
@@ -3163,7 +3162,7 @@ as the pipe has no dependencies:
 The unit test for the phone service is a bit more involved. You need to switch from the mocked-out
 AngularJS `$httpBackend` to a mocked-out Angular Http backend.
 
-`Phone` 服务的测试会牵扯到一点别的。我们需要把模拟版的 AngularJS `$httpBackend` 服务切换到模拟板的 Angular Http 后端。
+`Phone` 服务的测试会牵扯到一点别的。你需要把模拟版的 AngularJS `$httpBackend` 服务切换到模拟板的 Angular Http 后端。
 
 <code-example path="upgrade-phonecat-2-hybrid/app/core/phone/phone.service.spec.ts" title="app/core/phone/phone.service.spec.ts">
 
@@ -3172,7 +3171,7 @@ AngularJS `$httpBackend` to a mocked-out Angular Http backend.
 For the component specs, you can mock out the `Phone` service itself, and have it provide
 canned phone data. You use Angular's component unit testing APIs for both components.
 
-对于组件的规约，我们可以模拟出 `Phone` 服务本身，并且让它提供电话的数据。我们可以对这些组件使用 Angular 的组件单元测试 API。
+对于组件的规约，你可以模拟出 `Phone` 服务本身，并且让它提供电话的数据。你可以对这些组件使用 Angular 的组件单元测试 API。
 
 <code-example path="upgrade-phonecat-2-hybrid/app/phone-detail/phone-detail.component.spec.ts" title="app/phone-detail/phone-detail.component.spec.ts">
 
@@ -3186,7 +3185,7 @@ Finally, revisit both of the component tests when you switch to the Angular
 router. For the details component, provide a mock of Angular `ActivatedRoute` object
 instead of using the AngularJS `$routeParams`.
 
-最后，当我们切换到 Angular 路由时，我们需要重新过一遍这些组件测试。对详情组件来说，我们需要提供一个 Angular
+最后，当你切换到 Angular 路由时，需要重新过一遍这些组件测试。对详情组件来说，你需要提供一个 Angular
 `RouteParams` 的 mock 对象，而不再用 AngularJS 中的 `$routeParams`。
 
 <code-example path="upgrade-phonecat-3-final/app/phone-detail/phone-detail.component.spec.ts" region="activatedroute" title="app/phone-detail/phone-detail.component.spec.ts">