anchor.diff:  :marked
     It's identical to *Carol*'s constructor except for the additional `@SkipSelf` decorator.
     
  +  除了添加了一个额外的`@SkipSelf`外，它和*Carol*的构造函数一样。
  +  
     `@SkipSelf` is essential for two reasons:
  +  
  +  使用`@SkipSelf`主要是为了下面两个原因：
      
     1. It tell the injector to start its search for a `Parent` dependency in a component *above* itself,
     which *is* what parent means.
     
  +  1. 它告诉注入器从一个在自己*上面*的组件开始搜索一个`Parent`依赖。
  +  
     2. Angular throws a cyclic dependency error if we omit the `@SkipSelf` decorator.
     
  +  2. 如果我们缺少`@SkipSelf`装饰器的话，Angular会抛出一个循环依赖错误。
  +  
       `Cannot instantiate cyclic dependency! (BethComponent -> Parent -> BethComponent)`
  +    
  +    `不能创建循环依赖实例！(BethComponent -> Parent -> BethComponent)`
   
     Here's *Alice*, *Barry* and family in action:
  +  
  +  这里是*Alice*，*Barry*和该家庭的实际代码：
   
   figure.image-display
     img(src="/resources/images/cookbooks/dependency-injection/alice.png" alt="Alice in action")
  
positive.code: .l-main-section
  :marked
    ## Break circularities with a forward class reference (*forwardRef*)
    
    The order of class declaration matters in TypeScript.
    We can't refer directly to a class until it's been defined.
    
    This isn't usually a problem, especially if we adhere to the recommended *one class per file* rule.
    But sometimes circular references are unavoidable. 
    We're in a bind when class 'A refers to class 'B' and 'B' refers to 'A'.
    One of them has to be defined first. 
    
    The Angular `forwardRef` function creates an *indirect* reference that Angular can resolve later.
    
    The *Parent Finder* sample is full of circular class references that are impossible to break.
    
    In the [*Alex/Cathy* example](#known-parent) above:
    
    * the `AlexComponent` lists the `CathyComponent` in its component metadata `directives` array
    so it can display *Cathy* in its template.
    
    * the `CathyComponent` constructor injects the parent `AlexComponent` which means that the `alex` parameter
    of its constructor has the `AlexComponent` type.
    
    *Alex* refers to *Cathy* and *Cathy* refers to *Alex*. We're stuck. We must define one of them first. 
    
    We defined *Alex* first and built its `C_DIRECTIVES` array with a forward reference to *Cathy*: 
  +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','C_DIRECTIVES','parent-finder.component.ts (C_DIRECTIVES)')(format='.')
  :marked
  .l-sub-section
  
negative.code:   Imagine one branch of a component hierarchy: *Alice* -> *Barry* -> *Carol*. 
    Both *Alice* and *Barry* implement the `Parent` *class-interface*.
    
    想象一下一个组件层次的一个分支为：*Alice* -> *Barry* -> *Carol*。
    *Alice*和*Barry*两个都实现`父级`*类-接口*。
    
    *Barry* is the problem. He needs to reach his parent, *Alice*, and also be a parent to *Carol*.
    That means he must both *inject* the `Parent` *class-interface* to get *Alice* and
    *provide* a `Parent` to satisfy *Carol*.
    
    *Barry*是一个问题。他需要访问它的父级*Alice*，同时他也是*Carol*的父级。这个意味着它必须同时*注入*`父级`*类-接口*来得到*Alice*，和*提供*一个`父级`来满足*Carol*。
    
    Here's *Barry*:
    下面是*Barry*：
  +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','barry','parent-finder.component.ts (BarryComponent)')(format='.')
  :marked
    *Barry*'s `providers` array looks just like [*Alex*'s](#alex-providers).
    If we're going to keep writing [*alias providers*](#useexisting) like this we should create a [helper function](#provideparent).
    
    *Barry*的`providers`数组看起来像[*Alex*的]（#alex-providers).
    如果我们一直要像这样编写[*别名providers*](#useexisting)的话，我们应该建立一个[帮助函数](#provideparent)。
    
    For now, focus on *Barry*'s constructor:
    眼下，集中主意*Barry*的构造函数：
  +makeTabs(
    'cb-dependency-injection/ts/app/parent-finder.component.ts, cb-dependency-injection/ts/app/parent-finder.component.ts',
    'barry-ctor, carol-ctor',
  