Introduction

The goal of this style guide is to present a set of best practices and style guidelines for one AngularJS application. These best practices are collected from:

0. AngularJS source code
1. Source code or articles I've read
2. My own experience

Note 1: this is still a draft of the style guide, its main goal is to be community-driven so filling the gaps will be greatly appreciated by the whole community.

Note 2: before following any of the guidelines in the translations of the English document, make sure they are up-to date. The latest version of the AngularJS style guide is in the current document.

In this style guide you won't find common guidelines for JavaScript development. Such can be found at:

0. Google's JavaScript style guide
1. Mozilla's JavaScript style guide
2. GitHub's JavaScript style guide
3. Douglas Crockford's JavaScript style guide
4. Airbnb JavaScript style guide

For AngularJS development recommended is the Google's JavaScript style guide.

In AngularJS's GitHub wiki there is a similar section by ProLoser, you can check it here.

Table of content

• General
  • Directory structure
  • Markup
  • Optimize the digest cycle
  • Others
• Modules
• Controllers
• Directives
• Filters
• Services
• Templates
• Routing
• i18n
• Contribution
• Contributors

General

Directory structure

Since a large AngularJS application has many components it's best to structure it in a directory hierarchy. There are two main approaches:

• Creating high-level divisions by component types and lower-level divisions by functionality.

In this way the directory structure will look like:

.
├── app
│   ├── app.js
│   ├── controllers
│   │   ├── home
│   │   │   ├── FirstCtrl.js
│   │   │   └── SecondCtrl.js
│   │   └── about
│   │       └── ThirdCtrl.js
│   ├── directives
│   │   ├── home
│   │   │   └── directive1.js
│   │   └── about
│   │       ├── directive2.js
│   │       └── directive3.js
│   ├── filters
│   │   ├── home
│   │   └── about
│   └── services
│       ├── CommonService.js
│       ├── cache
│       │   ├── Cache1.js
│       │   └── Cache2.js
│       └── models
│           ├── Model1.js
│           └── Model2.js
├── partials
├── lib
└── test

• Creating high-level divisions by functionality and lower-level divisions by component types.

Here is its layout:

.
├── app
│   ├── app.js
│   ├── common
│   │   ├── controllers
│   │   ├── directives
│   │   ├── filters
│   │   └── services
│   ├── home
│   │   ├── controllers
│   │   │   ├── FirstCtrl.js
│   │   │   └── SecondCtrl.js
│   │   ├── directives
│   │   │   └── directive1.js
│   │   ├── filters
│   │   │   ├── filter1.js
│   │   │   └── filter2.js
│   │   └── services
│   │       ├── service1.js
│   │       └── service2.js
│   └── about
│       ├── controllers
│       │   └── ThirdCtrl.js
│       ├── directives
│       │   ├── directive2.js
│       │   └── directive3.js
│       ├── filters
│       │   └── filter3.js
│       └── services
│           └── service3.js
├── partials
├── lib
└── test

• In case the directory name contains multiple words, use lisp-case syntax:

app
 ├── app.js
 └── my-complex-module
     ├── controllers
     ├── directives
     ├── filters
     └── services

• Put all the files associated with the given directive (i.e. templates, CSS/SASS files, JavaScript) in a single folder. If you choose to use this style be consistent and use it everywhere along your project.

app
└── directives
    ├── directive1
    │   ├── directive1.html
    │   ├── directive1.js
    │   └── directive1.sass
    └── directive2
        ├── directive2.html
        ├── directive2.js
        └── directive2.sass

This approach can be combined with both directory structures above.

• The unit tests for a given component should be located in the directory where the component is. This way when you make changes to a given component finding its test is easy. The tests also act as documentation and show use cases.

services
├── cache
│   ├── cache1.js
│   └── cache1.spec.js
└── models
    ├── model1.js
    └── model1.spec.js

• The app.js file should contains route definitions, configuration and/or manual bootstrap (if required).
• Each JavaScript file should only hold a single component. The file should be named with the component's name.
• Use AngularJS project structure template like Yeoman, ng-boilerplate.

Conventions about component naming can be found in each component section.

Markup

TLDR; Put the scripts at the bottom.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>MyApp</title>
</head>
<body>
  <div ng-app="myApp">
    <div ng-view></div>
  </div>
  <script src="angular.js"></script>
  <script src="app.js"></script>
</body>
</html>

Keep things simple and put AngularJS specific directives later. This way is easy to look to the code and find enhanced HTML by the framework (what improve the maintainibility).

<form class="frm" ng-submit="login.authenticate()">
  <div>
    <input class="ipt" type="text" placeholder="name" require ng-model="user.name">
  </div>
</form>

Other HTML atributes should follow the Code Guide's recommendation

Optimize the digest cycle

• Watch only the most vital variables. When required to invoke the $digest loop explicitly (it should happen only in exceptional cases), invoke it only when required (for example: when using real-time communication, don't cause a $digest loop in each received message).
• For content that is initialized only once and then never changed, use single-time watchers like bindonce for older versions of AngularJS or one-time bindings in AngularJS >=1.3.0.
• Make the computations in $watch as simple as possible. Making heavy and slow computations in a single $watch will slow down the whole application (the $digest loop is done in a single thread because of the single-threaded nature of JavaScript).
• When watching collections, do not watch them deeply when not strongly required. Better use $watchCollection, which performs a shallow check for equility of the result of the watched expression and the previous value of the expression's evaluation.
• Set third parameter in $timeout function to false to skip the $digest loop when no watched variables are impacted by the invocation of the $timeout callback function.
• When dealing with big collections, which change rarely, use immutable data structures.

Others

• Use:
  • $timeout instead of setTimeout
  • $interval instead of setInterval
  • $window instead of window
  • $document instead of document
  • $http instead of $.ajax

This will make your testing easier and in some cases prevent unexpected behaviour (for example, if you missed $scope.$apply in setTimeout).

• Automate your workflow using tools like:

  • Yeoman
  • Gulp
  • Grunt
  • Bower

• Use promises ($q) instead of callbacks. It will make your code look more elegant and clean, and save you from callback hell.

• Use $resource instead of $http when possible. The higher level of abstraction will save you from redundancy.

• Use an AngularJS pre-minifier (ng-annotate) for preventing problems after minification.

• Don't use globals. Resolve all dependencies using Dependency Injection, this will prevent bugs and monkey patching when testing.

• Do not pollute your $scope. Only add functions and variables that are being used in the templates.

• Prefer the usage of controllers instead of ngInit. The only appropriate use of ngInit is for aliasing special properties of ngRepeat. Besides this case, you should use controllers rather than ngInit to initialize values on a scope.

• Do not use $ prefix for the names of variables, properties and methods. This prefix is reserved for AngularJS usage.

• When resolving dependencies through the DI mechanism of AngularJS, sort the dependencies by their type - the built-in AngularJS dependencies should be first, followed by your custom ones:

module.factory('Service', function ($rootScope, $timeout, MyCustomDependency1, MyCustomDependency2) {
  return {
    //Something
  };
});

Modules

• Modules should be named with lowerCamelCase. For indicating that module b is submodule of module a you can nest them by using namespacing like: a.b.

There are two common ways for structuring the modules:

0. By functionality
1. By component type

Currently there's not a big difference, but the first way looks cleaner. Also, if lazy-loading modules is implemented (currently not in the AngularJS roadmap), it will improve the app's performance.

Controllers

• Do not manipulate DOM in your controllers, this will make your controllers harder for testing and will violate the Separation of Concerns principle. Use directives instead.
• The naming of the controller is done using the controller's functionality (for example shopping cart, homepage, admin panel) and the substring Ctrl in the end. The controllers are named UpperCamelCase (HomePageCtrl, ShoppingCartCtrl, AdminPanelCtrl, etc.).
• The controllers should not be defined as globals (even though AngularJS allows this, it is a bad practice to pollute the global namespace).
• Use the following syntax for defining controllers:

function MyCtrl(dependency1, dependency2, ..., dependencyn) {
  // ...
}
module.controller('MyCtrl', MyCtrl);

In order to prevent problems with minification, you can automatically generate the array definition syntax from the standard one using tools like ng-annotate (and grunt task grunt-ng-annotate).

• If using array definition syntax, use the original names of the controller's dependencies. This will help you produce more readable code:

function MyCtrl(s) {
  // ...
}

module.controller('MyCtrl', ['$scope', MyCtrl]);

which is less readable than:

function MyCtrl($scope) {
  // ...
}
module.controller('MyCtrl', ['$scope', MyCtrl]);

This especially applies to a file that has so much code that you'd need to scroll through. This would possibly cause you to forget which variable is tied to which dependency.

• Make the controllers as lean as possible. Abstract commonly used functions into a service.
• Communicate within different controllers using method invocation (possible when a child wants to communicate with its parent) or $emit, $broadcast and $on methods. The emitted and broadcasted messages should be kept to a minimum.
• Make a list of all messages which are passed using $emit, $broadcast and manage it carefully because of name collisions and possible bugs.

Example:

// app.js
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Custom events:
  - 'authorization-message' - description of the message
    - { user, role, action } - data format
      - user - a string, which contains the username
      - role - an ID of the role the user has
      - action - specific ation the user tries to perform
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

• When you need to format data encapsulate the formatting logic into a filter and declare it as dependency:

function myFormat() {
  return function () {
    // ...
  };
}
module.filter('myFormat', myFormat);

function MyCtrl($scope, myFormatFilter) {
  // ...
}

module.controller('MyCtrl', MyCtrl);

• In case of nested controllers use "nested scoping" (the controllerAs syntax):

app.js

module.config(function ($routeProvider) {
  $routeProvider
    .when('/route', {
      templateUrl: 'partials/template.html',
      controller: 'HomeCtrl',
      controllerAs: 'home'
    });
});

HomeCtrl

function HomeCtrl() {
  this.bindingValue = 42;
}

template.html

<div ng-bind="home.bindingValue"></div>

Directives

• Name your directives with lowerCamelCase.
• Use scope instead of $scope in your link function. In the compile, post/pre link functions you have already defined arguments which will be passed when the function is invoked, you won't be able to change them using DI. This style is also used in AngularJS's source code.
• Use custom prefixes for your directives to prevent name collisions with third-party libraries.
• Do not use ng or ui prefixes since they are reserved for AngularJS and AngularJS UI usage.
• DOM manipulations must be done only through directives.
• Create an isolated scope when you develop reusable components.
• Use directives as attributes or elements instead of comments or classes, this will make your code more readable.
• Use scope.$on('$destroy', fn) for cleaning up. This is especially useful when you're wrapping third-party plugins as directives.
• Do not forget to use $sce when you should deal with untrusted content.

Filters

• Name your filters with lowerCamelCase.
• Make your filters as light as possible. They are called often during the $digest loop so creating a slow filter will slow down your app.
• Do a single thing in your filters, keep them coherent. More complex manipulations can be achieved by piping existing filters.

Services

This section includes information about the service component in AngularJS. It is not dependent of the way of definition (i.e. as provider, .factory, .service), except if explicitly mentioned.

• Use camelCase to name your services.

  • UpperCamelCase (PascalCase) for naming your services, used as constructor functions i.e.:

    function MainCtrl($scope, User) {
      $scope.user = new User('foo', 42);
    }
    
    module.controller('MainCtrl', MainCtrl);
    
    function User(name, age) {
      this.name = name;
      this.age = age;
    }
    
    module.factory('User', function () {
      return User;
    });

  • lowerCamelCase for all other services.

• Encapsulate all the business logic in services.

• Services representing the domain preferably a service instead of a factory. In this way we can take advantage of the "klassical" inheritance easier:

function Human() {
  //body
}
Human.prototype.talk = function () {
  return "I'm talking";
};

function Developer() {
  //body
}
Developer.prototype = Object.create(Human.prototype);
Developer.prototype.code = function () {
  return "I'm coding";
};

myModule.service('Human', Human);
myModule.service('Developer', Developer);

• For session-level cache you can use $cacheFactory. This should be used to cache results from requests or heavy computations.
• If given service requires configuration define the service as provider and configure it in the config callback like:

angular.module('demo', [])
.config(function ($provide) {
  $provide.provider('sample', function () {
    var foo = 42;
    return {
      setFoo: function (f) {
        foo = f;
      },
      $get: function () {
        return {
          foo: foo
        };
      }
    };
  });
});

var demo = angular.module('demo');

demo.config(function (sampleProvider) {
  sampleProvider.setFoo(41);
});

Templates

• Use ng-bind or ng-cloak instead of simple {{ }} to prevent flashing content.
• Avoid writing complex expressions in the templates.
• When you need to set the src of an image dynamically use ng-src instead of src with {{ }} template.
• When you need to set the href of an anchor tag dynamically use ng-href instead of href with {{ }} template.
• Instead of using scope variable as string and using it with style attribute with {{ }}, use the directive ng-style with object-like parameters and scope variables as values:

<script>
...
$scope.divStyle = {
  width: 200,
  position: 'relative'
};
...
</script>

<div ng-style="divStyle">my beautifully styled div which will work in IE</div>;

Routing

• Use resolve to resolve dependencies before the view is shown.
• Do not place explicit RESTful calls inside the resolve callback. Isolate all the requests inside appropriate services. This way you can enable caching and follow the separation of concerns principle.

i18n

• For newer versions of the framework (>=1.4.0) use the built-in i18n tools, when using older versions (<1.4.0) use angular-translate.

Contribution

Since the goal of this style guide is to be community-driven, contributions are greatly appreciated. For example, you can contribute by extending the Testing section or by translating the style guide to your language.

Contributors

mgechev	pascalockert	morizotter	ericguirbal	mainyaa	elfinxx

agnislav	rubystream	lukaszklis	susieyy	cironunes	cavarzan

guiltry	tornad	jmblog	kuzzmi	dreame4	dchest

clbn	apetro	valgreens	bitdeli-chef	bradgearon	astalker

gsamokovarov	grvcoelho	bargaorobalo	hermankan	jabhishek	jesselpalmer

olov	capaj	jordanyee	nacyot	mariolamacchia	kirstein

mo-gr	cryptojuice	johnnyghost	vorktanamobay	sahat	gitter-badger

thomastuts	grapswiz	coderhaoxin	ntaoo	kuzmeig1