ES5和ES6中的Angular 2依赖注入

要在ES5中使用Angular 2，你需要这个脚本:

<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/2.0.0-beta.3/angular2-all.umd.js"></script>

它提供了一个全局变量，它包含了Angular 2的所有内容。现在您可以编写ng.core.Component而不是@Component注释。构造函数的第一个参数是可注入对象。

var Component = ng.core
  Component({
    selector: 'hello-cmp',
    template: 'Hello World!',
    viewProviders: [Service]
  .Class({
    constructor: [Service, function (service) { 
      ...
    }],
  });

并告诉注入器我们的service参数是Service的一个实例

Component.parameters = [[new ng.core.Inject(Service)]];

import {Component} from 'angular2/core';
import {Service} from './example.service';
let componentAnnotation = new Component({
  selector: 'world-time',
  inputs: ['timeZones'],
  providers: [Service],
  template: `
    ...
  `
});
export class ComponentExample {
   constructor(service) {
    this._service = service;
   }
...
}
WorldTimeComponent.annotations = [componentAnnotation];
WorldTimeComponent.parameters = [[Service]];

下面是一个ES6的例子。

但是你可以通过使用Babel来使用装饰器。启用optional[]=es7.decorators(在webpack中)或通过将配置设置为stage:1。

Injectable装饰器是Angular 2中TypeScript风格特有的。它允许通过TypeScript类型注释为DI隐式地注释类构造函数。它在TS中是多余的，在JS中是不必要的，因为注入的依赖是用Inject注释的。

Angular 2的注入(类和构造函数)应该在底层使用annotations和parameters静态属性进行注释。

annotations是一个数组，包含可注入类的new装饰符:

function SomeComponent(...) {}
SomeComponent.annotations = [new Componenent(...)];

parameters是一个数组，它包含了构造函数参数的装饰器，每个元素都是一个数组，其中包含了相应构造函数属性的new装饰器列表(类似于Angular 1.x中$inject属性的显式注释):

function Service(someService, anotherService) {}
Service.parameters = [
  [new Inject(SomeService)],
  [new Inject(AnotherService), new Optional, new SkipSelf]
];

所有的类装饰器都是从TypeDecorator扩展而来的，这意味着它们可以作为函数调用。在这种情况下，使用了所谓的DSL语法，它允许将decorator与Class helper函数链接:

var SomeComponent = Componenent(...).Class(...);

Class也可以单独使用，它从给定的定义对象构造一个新类，并允许用数组注释constructor方法(类似于Angular 1.x中的内联数组显式注释):

var SomeService = Class({
  constructor: [[new Inject(SomeService)], function (someService) {}]
});

Class helper在最新框架版本中已弃用。在ES5中，它应该被原始函数或第三方类帮助器取代。Componenent(...)(ComponentClass) .

Angular 2/4 ES6 with System.import

一个例子:

Promise.all([
  System.import('@angular/core'),
  System.import('@angular/platform-browser'),
  System.import('@angular/platform-browser-dynamic')
])
.then(([
  {Component, Inject, Injectable, Optional, NgModule, OpaqueToken},
  {BrowserModule},
  {platformBrowserDynamic}
]) => {
  const CONSTANT = { value: 'constant' };
  const CONSTANT_TOKEN = new OpaqueToken;
  const CONSTANT_PROVIDER = { provide: CONSTANT_TOKEN, useValue: CONSTANT };
  class Service {
    constructor(constant) {}
  }
  Service.parameters = [[new Inject(CONSTANT_TOKEN)]];
  class AppComponent {
    constructor(service, constant) {}
  }
  AppComponent.annotations = [new Component({
    selector: 'app',
    template: '...',
    providers: [Service, CONSTANT_PROVIDER]
  })];
  AppComponent.parameters = [[new Inject(Service)], [new Inject(CONSTANT_TOKEN)]];
  class AppModule {}
  AppModule.annotations = [new NgModule({
    imports: [BrowserModule],
    declarations: [AppComponent],
    bootstrap: [AppComponent]
  })];
  platformBrowserDynamic().bootstrapModule(AppModule);
})
.catch((err) => console.error(err));

一个例子:

var Class = ng.core.Class;
var Component = ng.core.Component;
var Inject = ng.core.Inject;
var Injectable = ng.core.Injectable;
var NgModule = ng.core.NgModule;
var OpaqueToken = ng.core.OpaqueToken;
var BrowserModule = ng.platformBrowser.BrowserModule;
var platformBrowserDynamic = ng.platformBrowserDynamic.platformBrowserDynamic;
var CONSTANT = { value: 'constant' };
var CONSTANT_TOKEN = new OpaqueToken;
var CONSTANT_PROVIDER = { provide: CONSTANT_TOKEN, useValue: CONSTANT };
// Class helper function that uses A1-flavoured inline array DI annotations
// and creates an annotated constructor
var Service = Class({
  constructor: [[new Inject(CONSTANT_TOKEN)], function (constant) {
    console.log('Service constructor', constant);
  }]
});
// can also be
// function Service(constant) {};
// Service.parameters = [[new Inject(...)], ...];
// when not being `new`ed, Component is a chainable factory that has Class helper method
var AppComponent = Component({
  selector: 'app', 
  template: '...',
  providers: [Service, CONSTANT_PROVIDER]
})
.Class({
  constructor: [
    [new Inject(Service)],
    [new Inject(CONSTANT_TOKEN)],
    function (service, constant) {
      console.log('AppComponent constructor', service, constant);
    }
  ]
});
// can also be
// function AppComponent(...) {};
// AppComponent.annotations = [new Component(...)];
// AppComponent.parameters = [[new Inject(...)], ...];
var AppModule = NgModule({
  imports: [BrowserModule],
  declarations: [AppComponent],
  bootstrap: [AppComponent]
})
.Class({ constructor: function () {} });
// can also be
// function AppModule() {};
// AppModule.annotations = [new NgModule(...)];
platformBrowserDynamic().bootstrapModule(AppModule);