anchor.diff:  .l-main-section
   :marked
     ### Should I import _BrowserModule_ or _CommonModule_?
  +  
  +  ### 我该导入*BrowserModule*还是*CommonModule*？
   
     The **root application module** (`AppModule`) of almost every browser application
     should import `BrowserModule` from `@angular/platform-browser`.
     
  +  几乎每个要在浏览器中使用的应用的**根模块**（`AppModule`）都应该从`@angular/platform-browser`中导入`BrowserModule`。
  +  
     `BrowserModule` provides services that are essential to launch and run a browser app.
  +  
  +  `BrowserModule`提供了启动和运行浏览器应用的那些基本的服务提供商。
   
     `BrowserModule` also re-exports `CommonModule` from `@angular/common`
     which means that component in the `AppModule` module also have access to
     the Angular directives every app needs such as `NgIf` and `NgFor`.
     
  +  `BrowserModule`还从`@angular/common`中重新导出了`CommonModule`，这意味着`AppModule`中的组件也同样可以访问那些每个应用都需要的Angular指令，如`NgIf`和`NgFor`。
  +  
     _Do not import_ `BrowserModule` in any other module.
     *Feature modules* and *lazy loaded modules* should import `CommonModule` instead.
     They need the common directives. They don't need to re-install the app-wide providers. 
  +  
  +  在其它任何模块中都*不要导入*`BrowserModule`。
  +  *特性模块*和*延迟加载模块*应该改成导入`CommonModule`。
  +  它们需要通用的指令。它们不需要重新初始化全应用级的提供商。
  +  
   .l-sub-section
     :marked
       `BrowserModule` throws an error if you try to lazy load  a module that imports it.
  +    
  +    如果你想在延迟加载模块中导入它，`BrowserModule`就会抛出一个错误。
  +    
   :marked
     Importing `CommonModule` also frees feature modules for use on _any_ target platform, not just browsers,
     a fact of some interest to authors of cross-platform libraries.
  +  
  +  特性模块中导入`CommonModule`可以让它能用在任何目标平台上，不仅是浏览器。那些跨平台库的作者应该喜欢这种方式的。
   
   .l-hr 
   a#q-reimport
  
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
    ### Why is a service provided in a feature module visible everywhere?
    
    ### 为什么服务提供商在特性模块中的任何地方都是可见的？
  
    Providers listed in the `@NgModule.providers` of a bootstrapped module have **application scope**.
    Adding a service provider to `@NgModule.providers` effectively publishes the service to the entire application.
    
    列在引导模块的`@NgModule.providers`中的服务提供商具有**全应用级作用域**。
    往`NgModule.providers`中添加服务提供商将导致该服务被发布到整个应用中。
  
    When we import a module,
    Angular adds the module's service providers (the contents of its `providers` list)
    to the application _root injector_.
    
    当我们导入一个模块时，Angular就会把该模块的服务提供商（也就是它的`providers`列表中的内容）加入该应用的*根注入器*中。
  
    This makes the provider visible to every class in the application that knows the provider's lookup token.
    
    这会让该提供商对应用中所有知道该提供商令牌（token）的类都可见。
  
    This is by design. 
    Extensibility through module imports is a primary goal of the Angular module system.
  