Was ist in Angular 2 Opaque Token und was ist der Punkt?

update Angular4

In Angular4 OpaqueToken ist veraltet und wird ersetzt durch InjectionToken.
InjectionToken erlaubt es, einen generischen Typ-parameter.

export let APP_CONFIG = new InjectionToken<MyConfig>("app.config");

Siehe auch

• https://blog.thoughtram.io/angular/2016/05/23/opaque-tokens-in-angular-2.html
• https://angular.io/docs/ts/latest/api/core/index/OpaqueToken-class.html

original

Was? Was ist ein Angular2 token zu beginnen?

Was ist eine Opake Token? Für was wird es verwendet?

Ein token ist ein Schlüssel für die Anbieter von Angulars dependency injection.
Anbieter registriert sind, mit einem Schlüssel-Komponenten, Richtlinien und service-Klassen instanziiert DI-get Abhängigkeiten injiziert, die gesucht werden, die von Anbieter Schlüssel.

DI unterstützt-Typen, strings, OpaqueToken und-Objekte als Schlüssel.

export let APP_CONFIG = new OpaqueToken("app.config");

export let APP_CONFIG_2 = {};

providers: [
  MyService, //type is key and value
  {provide: MyService, useClass: MyFancyServiceImpl}, //type is key, `MyFancyServiceImpl` is the value (or rather the information how to create the value
  {provide: 'myservice', useClass: MyService}, //key is a string
  {provide: APP_CONFIG, useValue: {a: 'a', b: 'b'}} //key is an `OpaqueToken`
  {provide: APP_CONFIG_2, useValue: {a: 'a', b: 'b'}} //key is an object

]

//one of these decorators needs to be added to make DI work
@Injectable()
@Component()
@Directive()
@Pipe()
class MyComponent {
  //DI looks up a provider registered with the key `MyService` 
  constructor(private myService: MyService) {} 

  //Same as before but explicit
  constructor(@Inject(MyService) private myService: MyService) {} 

  //DI looks up a provider registered with the key 'myService'
  constructor(@Inject('myservice') private myService: MyService) {} 

  //DI looks up a provider registered with the `OpaqueKey` `APP_CONFIG`
  constructor(@Inject(APP_CONFIG) private myConfig: any) {} 

  //DI looks up a provider registered with the object `APP_CONFIG_2`
  constructor(@Inject(APP_CONFIG_2) private myConfig: any) {} 

Den Objekt-Schlüssel (APP_CONFIG_2) und die OpaqueToken (APP_CONFIG) müssen genau die gleiche Instanz. Ein anderes Beispiel mit dem gleichen Inhalt, wird nicht funktionieren. Dies macht es einfach, zu suchen, wo der Schlüssel deklariert ist und ob die Anbieter und die Injektion Ziel den gleichen Schlüssel verwenden.

Für einen string, kann es eine andere Instanz, dies bringt das Risiko, dass die gleiche Zeichenfolge verwendet wird, in verschiedenen Modulen und könnte zu Konflikten führen oder den falschen Anbieter eingespritzt wird.

InformationsquelleAutor der Antwort Günter Zöchbauer

Ich bin neu eckig 2, aber ich will versuchen, das zu interpretieren, was ich verstanden von https://blog.thoughtram.io/angular/2016/05/23/opaque-tokens-in-angular-2.html in einen einfachen code. CMIIW.

...
const CONFIG_ONE = {title: 'My awesome app'};
let configOneToken = 'config';  //'config' is an example of string-type token

const CONFIG_TWO = {title: 'My fantastic app'};
let configTwoToken = 'config';

providers = [
  { provide: configOneToken, useValue: CONFIG_ONE },
  { provide: configTwoToken, useValue: CONFIG_TWO }
];

Diesem Stück code wird ein Problem haben (die späteren überschreiben die alten), weil es Konflikt ('config' == 'config').
Es ist vielleicht zu offensichtlich und sinnlos in das Spielzeug-code, sondern in einer echten code, können wir möglicherweise nicht in der Lage sein zu identifizieren, die diesen Konflikt leicht, wenn einem der provider definiert ist, in einer Drittanbieter-Bibliothek.
So, um das zu beheben, wir können OpaqueToken wie im folgenden code.

...
const CONFIG_ONE = {title: 'My awesome app'};
const OPAQUE_TOKEN_ONE = new OpaqueToken('config'); //this is an example of object-type token

const CONFIG_TWO = {title: 'My fantastic app'};
const OPAQUE_TOKEN_TWO = new OpaqueToken('config');

providers = [
  { provide: OPAQUE_TOKEN_ONE, useValue: CONFIG_ONE },
  { provide: OPAQUE_TOKEN_TWO, useValue: CONFIG_TWO }
];

Zwei Instanzen derselben Klasse sind nie gleich sein kann (new OpaqueToken('config') != new OpaqueToken('config')) und somit die Vermeidung von Konflikten. Die OpaqueToken selbst nichts ist, sondern nur als einfaches Nichtstun. Klasse.

InformationsquelleAutor der Antwort elfan