anchor.diff:  .l-main-section
   :marked
     ### What is the _forRoot_ method?
  +  
  +  ### *forRoot*方法是什么？
   
     The `forRoot` static method is a convention that makes it easy for developers to configure the module's provider(s).
  +  
  +  静态方法`forRoot`是一个约定，它可以让开发人员更轻松的配置模块的提供商。
     
     The `RouterModule.forRoot` method is a good example. 
     Apps pass a `Routes` object to `RouterModule.forRoot` in order to configure the app-wide `Router` service with routes. 
     `RouterModule.forRoot` returns a [ModuleWithProviders](../api/core/index/ModuleWithProviders-interface.html). 
     We add that result to the `imports` list of the root `AppModule`.
  +  
  +  `RouterModule.forRoot`就是一个很好的例子。
  +  应用把一个`Routes`对象传给`RouterModule.forRoot`，为的就是使用路由配置全应用级的`Router`服务。
  +  `RouterModule.forRoot`返回一个[ModuleWithProviders](../api/core/index/ModuleWithProviders-interface.html)对象。
  +  我们把这个结果添加到根模块`AppModule`的`imports`列表中。
   
   .alert.is-important
     :marked
       Only call and import a `.forRoot` result in the root application module, `AppModule`.
       Importing it in any other module, particularly in a lazy loaded module,
       is contrary to the intent and is likely to produce a runtime error.
  +    
  +    只能在应用的根模块`AppModule`中调用并导入`.forRoot`的结果。
  +    在其它模块中导入它，特别是延迟加载模块中，是违反设计目标的并会导致一个运行时错误。
  +    
   :marked
     `RouterModule` also offers a `forChild` static method for configuring the routes of lazy loaded modules.
  +  
  +  `RouterModule`也提供了静态方法`forChild`，用于配置延迟加载模块的路由。
   
     **_forRoot_** and **_forChild_** are conventional names for methods that
     configure services in root and feature modules respectively.
     
  +  ***forRoot***和***forChild***都是方法的约定名称，它们分别用于在根模块和特性模块中配置服务。
  +  
     Angular doesn't recognize these names but Angular developers do.
     Follow this convention when you write similar modules with configurable service providers.
  +  
  +  Angular无法识别这些名字，但是Angular的开发人员可以。
  +  当你写类似的需要可配置的服务提供商时，请遵循这个约定。
   
   .l-hr
   
  
positive.code: :marked
    ### What if I import the same module twice?
    
    That's not a problem. When three modules all import Module 'A', 
    Angular evaluates Module 'A' once, the first time it encounters it, and does not do so again. 
  
    That's true at whatever level `A` appears in a hierarchy of imported modules.
    When Module 'B' imports Module 'A', Module 'C' imports 'B', and Module 'D' imports `[C, B, A]`,
    then 'D' triggers the evaluation of 'C' which triggers the evaluation of 'B' which evaluates 'A'.
    When Angular gets to the 'B' and 'A' in 'D', they're already cached and ready to go.
  
    Angular does not like modules with circular references so don't let Module 'A' import Module 'B' which imports Module 'A'.
  
  .l-hr 
  a#q-what-to-export
  .l-main-section
  :marked
    ### What should I export?
  
    Export [declarable](#q-declarable) classes that components in _other_ modules
    should be able to reference in their templates. These are your _public_ classes.
    If you don't export a class, it stays _private_, visible only to other component
    declared in this module.
  
    You _can_ export any declarable class &mdash; components, directives, and pipes &mdash; 
    whether it is declared in this module or in an imported module.
  
    You _can_ re-export entire imported modules which effectively re-exports all of their exported classes.
    A module can even export a module that it doesn't import. 
  
  .l-hr
  
  
negative.code: .l-main-section
  :marked
    ### Can I re-export classes and modules?
    
    ### 我可以重新导出类和模块吗？
  
    Absolutely!
    
    毫无疑问！
  
    Modules are a great way to selectively aggregate classes from other modules and
    re-export them in a consolidated, convenience module.
    
    模块是从其它模块中选取类并把它们重新导出成统一、便利的新模块的最佳方式。
  
    A module can re-export entire modules which effectively re-exports all of their exported classes.
    Angular's own `BrowserModule` exports a couple of modules like this:
    
    模块可以重新整体导出其它模块，这会导致重新导出它们导出的所有类。
    Angular自己的`BrowserModule`就重新导出了一组模块，例如：
    
  code-example.
    exports: [CommonModule, ApplicationModule]
  
  :marked
    A module can export a combination of its own declarations, selected imported classes, and imported modules.
    
    模块还能导出一个组合，其中可以包含它自己的可声明类、某些导入的类以及导入的模块。
    
  .l-sub-section
    :marked
      Don't bother re-exporting pure service modules.
      Pure service modules don't export [declarable](#q-declarable) classes that another module could use.
      For example, there is no point in re-exporting `HttpModule` because it doesn't export anything.
      It's only purpose is to add http service providers to the application as a whole.
      
      不要费心去导出纯服务类。
      纯服务类的模块不会导出任何可供其它模块使用的[可声明类](#q-declarable)。
      例如，不用重新导出`HttpModule`，因为它没有导出任何东西。
      它唯一的用途是把那些http服务提供商作为一个整体添加到应用中。
  
  .l-hr
  
  