# `$injector` (service in module `AUTO` )

Improve this doc

## Description

`$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 ways are all valid way 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. NOTE: This does not work with minification, and obfuscation tools since these tools change the argument names.

#### `$inject` Annotation

By adding a `$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

- ### annotate(fn)

  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']);

  This method does not work with code minfication / 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(tempFn);

        // 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

  - `fn – {function|Array.<string|Function>} –`

    Function for which dependent service names need to be retrieved as described above.

  #### Returns

  `{Array.<string>}` –

  The names of the services which the function requires.

- ### get(name)

  Return an instance of the service.

  #### Parameters

  - `name – {string} –`

    The name of the instance to retrieve.

  #### Returns

  `{*}` –

  The instance.

- ### 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

  - `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`.

- ### invoke(fn, self, locals)

  Invoke the method and supply the method arguments from the `$injector`.

  #### Parameters

  - `fn – {!function} –`

    The function to invoke. The function arguments come form the function annotation.

  - `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.