What is the benefit of AngularJS Strict DI mode?

Recently I come across with AngularJS Strict DI mode. What is the purpose & benefit of using it? Will we gain significant performance improvement by using it especially on mobile devices?

I try to apply it to my code and I did not do any annotation when writing the code. However, I have my code to be minify, and ng-annotate during build. But why is that after I add Strict DI mode to my code I still get the error saying “Explicit annotation required”?

Strict DI Mode basically throws errors when, at run time, it is found a piece of code that is not compliant to minification; but note that the code may be right and without logical-syntactical errors.

Citing the documentation:

if this attribute is present on the app element, the injector will be created in “strict-di” mode. This means that the application will fail to invoke functions which do not use explicit function annotation (and are thus unsuitable for minification), as described in the Dependency Injection guide, and useful debugging info will assist in tracking down the root of these bugs.

For example this code triggers an error because ($scope, $http, $filter) are not explicitly injected using $inject or giving to the .controller(A,B) method an array as second field.

angular.module("myApp", [])
// BadController cannot be invoked, because
// the dependencies to be injected are not
// explicitly listed.
.controller("BadController", function($scope, $http, $filter) {
  // ...

Right snippet:

angular.module("myApp", [])
  .controller("GoodController1", GoodController1);

GoodController1.$inject = ["$scope", "$http", "$filter"];

function GoodController1($scope, $http, $filter){}


angular.module("myApp", [])
              ["$scope", "$http", "$filter", function ($scope, $http, $filter){

In order to answer at your question there is no significant performance improvement by using it. It only grant to you the minifiability error safeness. This because minification changes variables names breaking your code when for example you use $scope without explicit annotation.

Read More:   Hide/show element with a boolean

You can also add strict-di like this:

 angular.bootstrap(document, ['app'], {
        strictDi: true

when using angular meteor es6 type applications.

Angular strict DI enforces code minifyability.

When your code is minified the names of the parameters are shortened, which breaks angular’s DI. To counter that problem angular has added two(maybe more now) alternative ways to add dependency’s.

Perhaps the most common way and the one used by ng-annotate is placing an array instead of an function as the second parameter. The dependency’s are the string’s before the last element in the array, the string’s are the dependency names.


angular.module('app', ['dependency']).controller('myCtrl', ['myFirstDep',

Your ng-annotate is probably not running before angular does it’s checks. Make sure you are NOT running uglify together with annotate, do it explicitly BEFORE. If your code is throwing error, then most likely there is somewhere that the annotation was not made.

Good practice is using strict-di. App must fail to run when invoke functions that don’t use explicit function annotation. This means that the methods used must be declared. Using the ng-strict-di will ensure that app is confirming with dependency injection guideline and will fail to run if not.

You can achieve that by using ng-strict-di:

<html ng-app="myApp" ng-strict-di>

See developer guide:

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Similar Posts