angular-docs-cn/public/docs/js/latest/api/di/Injector-class.jade

p.location-badge.
  exported from <a href="/angular2/di.html">angular2/di</a>
  defined in <a href="https://github.com/angular/angular/tree/master/modules/angular2/src/di/injector.js#L60">angular2/src/di/injector.js (line 60)</a>

:markdown
  A dependency injection container used for resolving dependencies.

  An `Injector` is a replacement for a `new` operator, which can automatically resolve the constructor dependencies.
  In typical use, application code asks for the dependencies in the constructor and they are resolved by the
  `Injector`.

  ## Example:

  Suppose that we want to inject an `Engine` into class `Car`, we would define it like this:

  ```javascript
  class Engine {
  }

  class Car {
    constructor(@Inject(Engine) engine) {
    }
  }

  ```

  Next we need to write the code that creates and instantiates the `Injector`. We then ask for the `root` object,
  `Car`, so that the `Injector` can recursively build all of that object's dependencies.

  ```javascript
  main() {
    var injector = Injector.resolveAndCreate([Car, Engine]);

    // Get a reference to the `root` object, which will recursively instantiate the tree.
    var car = injector.get(Car);
  }
  ```
  Notice that we don't use the `new` operator because we explicitly want to have the `Injector` resolve all of the
  object's dependencies automatically.

.l-main-section
  h2 Members
  .l-sub-section
    h3 constructor


    pre.prettyprint
      code.
        constructor(bindings:List&lt;ResolvedBinding&gt;, parent:Injector, defaultBindings:boolean, [object Object], [object Object], [object Object])

    :markdown





  .l-sub-section
    h3 asyncGet


    pre.prettyprint
      code.
        asyncGet(token, [object Object])

    :markdown
      Retrieves an instance from the injector asynchronously. Used with asynchronous bindings.






  .l-sub-section
    h3 createChildFromResolved


    pre.prettyprint
      code.
        createChildFromResolved(bindings:List&lt;ResolvedBinding&gt;, [object Object])

    :markdown
      Creates a child injector and loads a new set of <a href="ResolvedBinding-class.html"><code>ResolvedBinding</code></a>s into it.






  .l-sub-section
    h3 fromResolvedBindings


    pre.prettyprint
      code.
        fromResolvedBindings(bindings:List&lt;ResolvedBinding&gt;, {defaultBindings=false}={}, [object Object], [object Object])

    :markdown
      Creates an injector from previously resolved bindings. This bypasses resolution and flattening. This API is the
      recommended way to construct injectors in performance-sensitive parts.






  .l-sub-section
    h3 get


    pre.prettyprint
      code.
        get(token, [object Object])

    :markdown
      Retrieves an instance from the injector.






  .l-sub-section
    h3 getOptional


    pre.prettyprint
      code.
        getOptional(token, [object Object])

    :markdown
      Retrieves an instance from the injector.






  .l-sub-section
    h3 resolve


    pre.prettyprint
      code.
        resolve(bindings:List, [object Object])

    :markdown
      Turns a list of binding definitions into an internal resolved list of resolved bindings.

      A resolution is a process of flattening multiple nested lists and converting individual bindings into a
      list of <a href="ResolvedBinding-class.html"><code>ResolvedBinding</code></a>s. The resolution can be cached by `resolve` for the <a href="Injector-class.html"><code>Injector</code></a> for
      performance-sensitive code.






  .l-sub-section
    h3 resolveAndCreate


    pre.prettyprint
      code.
        resolveAndCreate(bindings:List, {defaultBindings=false}={}, [object Object], [object Object])

    :markdown
      Resolves bindings and creates an injector based on those bindings. This function is slower than the
      corresponding `fromResolvedBindings` because it needs to resolve bindings first. See `resolve` for the
      <a href="Injector-class.html"><code>Injector</code></a>.

      Prefer `fromResolvedBindings` in performance-critical code that creates lots of injectors.






  .l-sub-section
    h3 resolveAndCreateChild


    pre.prettyprint
      code.
        resolveAndCreateChild(bindings:List, [object Object])

    :markdown
      Creates a child injector and loads a new set of bindings into it.

      A resolution is a process of flattening multiple nested lists and converting individual bindings into a
      list of <a href="ResolvedBinding-class.html"><code>ResolvedBinding</code></a>s. The resolution can be cached by `resolve` for the <a href="Injector-class.html"><code>Injector</code></a> for
      performance-sensitive code.