AngularJS
Fournisseurs
Recherche…
Syntaxe
- constante (nom, valeur);
- valeur (nom, valeur);
- factory (nom, $ getFn);
- service (nom, constructeur);
- fournisseur (nom, fournisseur);
Remarques
Les fournisseurs sont des objets singleton pouvant être injectés, par exemple, dans d'autres services, contrôleurs et directives. Tous les fournisseurs sont enregistrés en utilisant différentes "recettes", où le Provider est le plus flexible. Toutes les recettes possibles sont:
- Constant
- Valeur
- Usine
- Un service
- Fournisseur
Les services, les usines et les fournisseurs sont tous initialisés paresseux, le composant est initialisé uniquement si l'application en dépend.
Les décorateurs sont étroitement liés aux fournisseurs. Les décorateurs sont utilisés pour intercepter le service ou la création d'usine afin de modifier son comportement ou de le remplacer (en partie).
Constant
Constant est disponible à la fois dans les phases de configuration et d'exécution.
angular.module('app',[])
.constant('endpoint', 'http://some.rest.endpoint') // define
.config(function(endpoint) {
// do something with endpoint
// available in both config- and run phases
})
.controller('MainCtrl', function(endpoint) { // inject
var vm = this;
vm.endpoint = endpoint; // usage
});
<body ng-controller="MainCtrl as vm">
<div>endpoint = {{ ::vm.endpoint }}</div>
</body>
point de terminaison = http: //some.rest.endpoint
Valeur
Value est disponible dans les phases de configuration et d'exécution.
angular.module('app',[])
.value('endpoint', 'http://some.rest.endpoint') // define
.run(function(endpoint) {
// do something with endpoint
// only available in run phase
})
.controller('MainCtrl', function(endpoint) { // inject
var vm = this;
vm.endpoint = endpoint; // usage
});
<body ng-controller="MainCtrl as vm">
<div>endpoint = {{ ::vm.endpoint }}</div>
</body>
point de terminaison = http: //some.rest.endpoint
Usine
Factory est disponible en phase d'exécution.
La recette Factory construit un nouveau service en utilisant une fonction avec zéro ou plusieurs arguments (ce sont des dépendances sur d'autres services). La valeur de retour de cette fonction est l'instance de service créée par cette recette.
Factory peut créer un service de n'importe quel type, qu'il s'agisse d'une primitive, d'un littéral d'objet, d'une fonction ou même d'une instance d'un type personnalisé.
angular.module('app',[])
.factory('endpointFactory', function() {
return {
get: function() {
return 'http://some.rest.endpoint';
}
};
})
.controller('MainCtrl', function(endpointFactory) {
var vm = this;
vm.endpoint = endpointFactory.get();
});
<body ng-controller="MainCtrl as vm">
<div>endpoint = {{::vm.endpoint }}</div>
</body>
point de terminaison = http: //some.rest.endpoint
Un service
Service est disponible en phase d'exécution.
La recette Service produit un service tout comme les recettes Value ou Factory, mais en appelant un constructeur avec le nouvel opérateur . Le constructeur peut prendre zéro ou plusieurs arguments, qui représentent des dépendances nécessaires à l'instance de ce type.
angular.module('app',[])
.service('endpointService', function() {
this.get = function() {
return 'http://some.rest.endpoint';
};
})
.controller('MainCtrl', function(endpointService) {
var vm = this;
vm.endpoint = endpointService.get();
});
<body ng-controller="MainCtrl as vm">
<div>endpoint = {{::vm.endpoint }}</div>
</body>
point de terminaison = http: //some.rest.endpoint
Fournisseur
Provider est disponible dans les phases de configuration et d'exécution.
La recette du fournisseur est définie syntaxiquement comme un type personnalisé qui implémente une méthode
$get.Vous devez utiliser la recette du fournisseur uniquement lorsque vous souhaitez exposer une API pour la configuration à l'échelle de l'application qui doit être effectuée avant le démarrage de l'application. Cela n'est généralement intéressant que pour les services réutilisables dont le comportement peut varier légèrement d'une application à l'autre.
angular.module('app',[])
.provider('endpointProvider', function() {
var uri = 'n/a';
this.set = function(value) {
uri = value;
};
this.$get = function() {
return {
get: function() {
return uri;
}
};
};
})
.config(function(endpointProviderProvider) {
endpointProviderProvider.set('http://some.rest.endpoint');
})
.controller('MainCtrl', function(endpointProvider) {
var vm = this;
vm.endpoint = endpointProvider.get();
});
<body ng-controller="MainCtrl as vm">
<div>endpoint = {{::vm.endpoint }}</div>
</body>
point de terminaison = http: //some.rest.endpoint
Sans phase de config , le résultat serait
point final = n / a
