- service in module auto
$injector
is used to retrieve object instances as defined by provider, instantiate types, invoke methods, and load modules.
The following always holds true:
var $injector = angular.injector(); expect($injector.get('$injector')).toBe($injector); expect($injector.invoke(function($injector) { return $injector; })).toBe($injector);
Injection Function Annotation
JavaScript does not have annotations, and annotations are needed for dependency injection. The following are all valid ways of annotating function with injection arguments and are equivalent.
// inferred (only works if code not minified/obfuscated) $injector.invoke(function(serviceA){}); // annotated function explicit(serviceA) {}; explicit.$inject = ['serviceA']; $injector.invoke(explicit); // inline $injector.invoke(['serviceA', function(serviceA){}]);
Inference
In JavaScript calling toString()
on a function returns the function definition. The definition can then be parsed and the function arguments can be extracted. This method of discovering annotations is disallowed when the injector is in strict mode. NOTE: This does not work with minification, and obfuscation tools since these tools change the argument names.
$inject Annotation
By adding an $inject
property onto a function the injection parameters can be specified.
Inline
As an array of injection names, where the last item in the array is the function to call.
Methods
-
get(name, [caller]);
Return an instance of the service.
Parameters
Param Type Details name string
The name of the instance to retrieve.
caller (optional)string
An optional string to provide the origin of the function call for error messages.
Returns
*
The instance.
-
invoke(fn, [self], [locals]);
Invoke the method and supply the method arguments from the
$injector
.Parameters
Param Type Details fn function()
Array.<(string|function())>
The injectable function to invoke. Function parameters are injected according to the $inject Annotation rules.
self (optional)Object
The
this
for the invoked method.locals (optional)Object
Optional object. If preset then any argument names are read from this object first, before the
$injector
is consulted.Returns
*
the value returned by the invoked
fn
function. -
has(name);
Allows the user to query if the particular service exists.
Parameters
Param Type Details name string
Name of the service to query.
Returns
boolean
true
if injector has given service. -
instantiate(Type, [locals]);
Create a new instance of JS type. The method takes a constructor function, invokes the new operator, and supplies all of the arguments to the constructor function as specified by the constructor annotation.
Parameters
Param Type Details Type Function
Annotated constructor function.
locals (optional)Object
Optional object. If preset then any argument names are read from this object first, before the
$injector
is consulted.Returns
Object
new instance of
Type
. -
annotate(fn, [strictDi]);
Returns an array of service names which the function is requesting for injection. This API is used by the injector to determine which services need to be injected into the function when the function is invoked. There are three ways in which the function can be annotated with the needed dependencies.
Argument names
The simplest form is to extract the dependencies from the arguments of the function. This is done by converting the function into a string using
toString()
method and extracting the argument names.// Given function MyController($scope, $route) { // ... } // Then expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
You can disallow this method by using strict injection mode.
This method does not work with code minification / obfuscation. For this reason the following annotation strategies are supported.
The $inject property
If a function has an
$inject
property and its value is an array of strings, then the strings represent names of services to be injected into the function.// Given var MyController = function(obfuscatedScope, obfuscatedRoute) { // ... } // Define function dependencies MyController['$inject'] = ['$scope', '$route']; // Then expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
The array notation
It is often desirable to inline Injected functions and that's when setting the
$inject
property is very inconvenient. In these situations using the array notation to specify the dependencies in a way that survives minification is a better choice:// We wish to write this (not minification / obfuscation safe) injector.invoke(function($compile, $rootScope) { // ... }); // We are forced to write break inlining var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) { // ... }; tmpFn.$inject = ['$compile', '$rootScope']; injector.invoke(tmpFn); // To better support inline function the inline annotation is supported injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) { // ... }]); // Therefore expect(injector.annotate( ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}]) ).toEqual(['$compile', '$rootScope']);
Parameters
Param Type Details fn function()
Array.<(string|function())>
Function for which dependent service names need to be retrieved as described above.
strictDi (optional)boolean
Disallow argument name annotation inference.
(default: false)
Returns
Array.<string>
The names of the services which the function requires.