What is the type friendly injection?

Question

In the AngularJS documentation, there is an explanation of the differences between a factory, a service, a value, a constant and a provider .

At the end, we have a compa

Answer 1

My interpretation of "type friendly injection":

Factories and Providers inject whatever is returned by the factory function and $get function respectively, which could be of any type and could potentially change dynamically at runtime. Whereas Service, Constant and Value injections are of a fixed type that Angular is aware of as it is well defined during the definition of the recipe. Hence they are type friendly injections.

Answer 2

I just asked myself the same question when looking at the very same table. :-)

My best guess interpretation of the values in that table row is that it actually means 'whether you can find out what created the service instance from the service instance itself', i.e. 'whether the service instance's constructor property is set to a meaningful function'.

Here's a more detailed interpretation for each of the recipes:

• factory: no, but can be yes if you construct the returned value by calling the new operator
• service: yes - will reference the service recipe function
• value/constant: yes, but only if you construct the value by calling the new operator
• provider: no, but can be yes if you construct the provider.$get method's return value by calling the new operator internally)

As it stands now, this part of the documentation seems unfinished and it is possible that the author had several ideas of what he wanted to show here but the final documentation managed to slip through the cracks & got published in some intermediate state.

Answer 3

In AngularJS, you can inject dependencies in multiple ways:

• in the directive link function by position
• in the directive definition by name
• in the controller function by name
• in the factory function by name
• in the service function by type

Type friendly injection allows you to implicity invoke a constructor function by reference:

myApp.service('Pattern', ["Infinity", RegExp]);

rather than by explicity using the new keyword:

myApp.factory('Pattern', 
 ["Infinity", function(Infinity) 
  {
  return new RegExp(Infinity);
  } 
 ]);

OR

function goInfinity(Infinity)
  {
  return new RegExp(Infinity);
  } 

goInfinity.$inject = ["Infinity"];
myApp.factory('Pattern', goInfinity);

The Service recipe produces a service just like the Value or Factory recipes, but it does so by invoking a constructor with the new operator. The constructor can take zero or more arguments, which represent dependencies needed by the instance of this type.

Eager initialization means that a constant recipe must return a constructor in order to use the aforementioned syntax:

function RegExpConstant() 
  {
  return new RegExp(Infinity);
  } 

myApp.constant('Pattern', RegExpConstant)

rather than returning a function, object, or literal value.

The nomenclature comes from Java:

A service is a well-known set of interfaces. A service provider is a specific implementation of a service. A factory is an object that returns an object reference to another object

References

• Dependency Injection in Angular 2

• The main goals of Angular 2 and how they will be achieved

• Vojta Jina: Dependency Injection - NG-Conf

• AngularJS: Developer Guide - Providers, Service Recipe

• AngularJS: The Bad Parts

• Dependency Injection: Syntax Sugar Over Function Composition

• ServiceFinder (JAX-WS RI)

Answer 4

Type here refers to:

• primitives,
• object literals,
• functions, or
• even an instance of a custom type

Factories and Providers are most flexible out of the Service, Constant, Value in terms of what they bind to the injector. Hence Angular can detect the type of object/primitive that is bound to Service, Constant, Value hence friendlier since we know the type upfront (design/build time).