@angular/core

inject

function

Injects a token from the currently active injector. inject is only supported in an injection context. It can be used during:

Construction (via the constructor) of a class being instantiated by the DI system, such as an @Injectable or @Component.
In the initializer for fields of such classes.
In the factory function specified for useFactory of a Provider or an @Injectable.
In the factory function specified for an InjectionToken.
In a stackframe of a function call in a DI context

API

function inject<T>(token: ProviderToken<T>): T;

@paramtokenProviderToken<T>

A token that represents a dependency that should be injected.

@returnsT

function inject<T>(token: ProviderToken<T>, flags?: InjectFlags | undefined): T | null;

@deprecated

prefer an options object instead of InjectFlags

@paramtokenProviderToken<T>

A token that represents a dependency that should be injected.

@paramflagsInjectFlags | undefined

Control how injection is executed. The flags correspond to injection strategies that can be specified with parameter decorators @Host, @Self, @SkipSelf, and @Optional.

@returnsT | null

function inject<T>(token: ProviderToken<T>, options: InjectOptions & { optional?: false | undefined; }): T;

@paramtokenProviderToken<T>

A token that represents a dependency that should be injected.

@paramoptionsInjectOptions & { optional?: false | undefined; }

Control how injection is executed. Options correspond to injection strategies that can be specified with parameter decorators @Host, @Self, @SkipSelf, and @Optional.

@returnsT

function inject<T>(token: ProviderToken<T>, options: InjectOptions): T | null;

@paramtokenProviderToken<T>

A token that represents a dependency that should be injected.

@paramoptionsInjectOptions

Control how injection is executed. Options correspond to injection strategies that can be specified with parameter decorators @Host, @Self, @SkipSelf, and @Optional.

@returnsT | null

function inject(token: HostAttributeToken): string;

@paramtokenHostAttributeToken

A token that represents a static attribute on the host node that should be injected.

@returnsstring

function inject(token: HostAttributeToken, options: { optional: true; }): string | null;

@paramtokenHostAttributeToken

A token that represents a static attribute on the host node that should be injected.

@paramoptions{ optional: true; }

@returnsstring | null

function inject(token: HostAttributeToken, options: { optional: false; }): string;

@paramtokenHostAttributeToken

A token that represents a static attribute on the host node that should be injected.

@paramoptions{ optional: false; }

@returnsstring

Usage Notes

In practice the inject() calls are allowed in a constructor, a constructor parameter and a field initializer:

          @Injectable({providedIn: 'root'})export class Car {  radio: Radio|undefined;  // OK: field initializer  spareTyre = inject(Tyre);  constructor() {    // OK: constructor body    this.radio = inject(Radio);  }}

It is also legal to call inject from a provider's factory:

          providers: [  {provide: Car, useFactory: () => {    // OK: a class factory    const engine = inject(Engine);    return new Car(engine);  }}]

Calls to the inject() function outside of the class creation context will result in error. Most notably, calls to inject() are disallowed after a class instance was created, in methods (including lifecycle hooks):

          @Component({ ... })export class CarComponent {  ngOnInit() {    // ERROR: too late, the component instance was already created    const engine = inject(Engine);    engine.start();  }}