Merge branch 'master' of https://github.com/johnpapa/angularjs-styleguide

Author: Bogatinov

README.md

@@ -1117,7 +1117,7 @@ While this guide explains the *what*, *why* and *how*, I find it helpful to see
 ### Restrict to Elements and Attributes
 ###### [Style [Y074](#style-y074)]
 
-  - When creating a directive that makes sense as a standalone element, allow restrict `E` (custom element) and optionally restrict `A` (custom attribute). Generally, if it could be its own control, `E` is appropriate. General guideline is allow `EA` but lean towards implementing as an element when its standalone and as an attribute when it enhances its existing DOM element.
+  - When creating a directive that makes sense as a stand-alone element, allow restrict `E` (custom element) and optionally restrict `A` (custom attribute). Generally, if it could be its own control, `E` is appropriate. General guideline is allow `EA` but lean towards implementing as an element when its stand-alone and as an attribute when it enhances its existing DOM element.
 
     *Why?*: It makes sense.
 
@@ -2556,6 +2556,31 @@ Unit testing helps maintain clean code, as such I included some of my recommenda
             .constant('moment', moment);
     })();
     ```
+    
+###### [Style [Y241](#style-y241)]
+
+  - Use constants for values that do not change and do not come from another service. When constants are used only for a module that may be reused in multiple applications, place constants in a file per module named after the module. Until this is required, keep constants in the main module in a `constants.js` file.
+
+    *Why?*: A value that may change, even infrequently, should be retrieved from a service so you do not have to change the source code. For example, a url for a data service could be placed in a constants but a better place would be to load it from a web service.
+
+    *Why?*: Constants can be injected into any angular component, including providers.
+
+    *Why?*: When an application is separated into modules that may be reused in other applications, each stand-alone module should be able to operate on its own including any dependent constants. 
+
+    ```javascript
+    // Constants used by the entire app
+    angular
+        .module('app.core')
+        .constant('moment', moment);
+
+    // Constants used only by the sales module
+    angular
+        .module('app.sales')
+        .constant('events', {
+            ORDER_CREATED: 'event_order_created',
+            INVENTORY_DEPLETED: 'event_inventory_depleted'
+        });
+    ```
 
 **[Back to top](#table-of-contents)**
 

i18n/it-IT.md

@@ -1255,7 +1255,9 @@ Nonostante questa guida spieghi i *cosa*, *come* e *perché*, trovo che sia di a
      
     *Perché?*: Porre la logica di start-up in una posizione consistente nel controller la rende semplice da localizzare, più consistente da testare e aiuta a prevenire la diffusione di logica su tutto il controller.
 
-    Nota: Se hai necessità di annullare condizionalmente il route prima di iniziare ad usare il controller, usa piuttosto una risoluzione nella route.
+    *Perché?*: La funzione `activate` del controller rende il riuso della logica adatto in caso di un refresh del controller/view, tiene la logica assieme, porta l'utente alla view più rapidamente, rende le animazini più facili su `ng-view` o `ui-view`e da la sensazione all'utente di istantaneità.
+    
+    Nota: Se hai necessità di annullare condizionalmente il route prima di iniziare ad usare il controller, usa piuttosto una [risoluzione nella route](#stile-y081).
     
   ```javascript
   /* evitare */
@@ -1294,10 +1296,16 @@ Nonostante questa guida spieghi i *cosa*, *come* e *perché*, trovo che sia di a
 ### Promesse risolte nel route
 ###### [Stile [Y081](#stile-y081)]
 
-  - Quando un controller dipende dalla dal fatto che una promessa sia risolta risolvi queste dipendenze nel `$routeProvider` prima che la logica del controller sia eseguita. Se hai bisogno di annullare condizionalmente una route prima che il controller sia attivato, usa un resolver della route.
+  - Quando un controller dipende dal fatto che una promessa sia risolta prima che il controller sia attivato, risolvi queste dipendenze nel `$routeProvider` prima che la logica del controller sia eseguita. Se hai bisogno di annullare condizionalmente una route prima che il controller sia attivato, usa un resolver della route.
+
+  - Usa la risoluzione della route quando decidi di annullare la route prima ancora di iniziara la transizione alla view.
 
     *Perché?*: Un controller può richiedere dei dati prima che si carichi. Quei dati potrebbero venire da una promessa di una factory su misura oppure [$http](https://docs.angularjs.org/api/ng/service/$http). Usando un [resolver della route](https://docs.angularjs.org/api/ngRoute/provider/$routeProvider) acconsenti che la promessa sia risolta prima che la logica del controller sia eseguita, così da poter prendere decisioni basandosi sui dati provenienti dalla promessa.
 
+    *Perché?*: Il codice è eseguito dopo la route e nella funzione di attivazione del controller. La view inizia il caricamento immediatamente. Il data binding è effettivo quando le promesse nella funzine di attivazione sono risolte. Una animazione di “attendere” può essere mostrata durante la transizione alla view (via ng-view o ui-view).
+
+    Nota: Il codice è eseguito prima il route per mezo di una promessa. Il rifiuto della promessa annulla la route. "resolve" fa attendere la view mentre viene risolta. Una animazione “attendere” può essere mostrata prima della risoluzione e durante tutta la transizione alla vista. Se desideri di arrivare alla view più in fretta e non hai bisogno di un punto di controllo per decidere se vuoi navigare alla view, considera piuttosto [Promesse di attivazione di un Controller](#stile-y080).
+
   ```javascript
   /* evitare */
   angular
@@ -1349,7 +1357,44 @@ Nonostante questa guida spieghi i *cosa*, *come* e *perché*, trovo che sia di a
         vm.movies = moviesPrepService.movies;
   }
   ```
+  
+    Note: L'esempio sotto mostra il punto di risoluzione della route in una funzione con il nome per cui è più semplice da fare il debug e più semplice da gestire nella iniezione delle dependenze.
+
+  ```javascript
+  /* meglio */
+
+  // route-config.js
+  angular
+      .module('app')
+      .config(config);
+
+  function config($routeProvider) {
+      $routeProvider
+          .when('/avengers', {
+              templateUrl: 'avengers.html',
+              controller: 'Avengers',
+              controllerAs: 'vm',
+              resolve: {
+                  moviesPrepService: moviesPrepService
+              }
+          });
+  }
+
+  function moviePrepService(movieService) {
+      return movieService.getMovies();
+  }
+
+  // avengers.js
+  angular
+      .module('app')
+      .controller('Avengers', Avengers);
 
+  Avengers.$inject = ['moviesPrepService'];
+  function Avengers(moviesPrepService) {
+        var vm = this;
+        vm.movies = moviesPrepService.movies;
+  }
+  ```
     Nota: La dipendenza del codice di esempio da `movieService` non è a prova di minificazione in se stessa. Per i dettagli su come rendere questo codice a prova di minificazione, vedi la sezione sulla [dependency injection](#manual-annotating-for-dependency-injection) e sulla [minificazione e annotazione](#minification-and-annotation).
 
 **[Torna all'inizio](#tavola-dei-contenuti)**