Compréhension approfondie de l'injection de dépendances dans les compétences Javascript_javascript

Tôt ou tard, vous devrez utiliser les abstractions d'autres développeurs, c'est-à-dire que vous vous fierez au code d'autres personnes. J'adorerais les modules sans dépendance (sans dépendance), mais c'est difficile à réaliser. Même les jolis composants de la boîte noire que vous créez reposent plus ou moins sur quelque chose. C’est là qu’intervient l’injection de dépendances. La capacité à gérer efficacement les dépendances est désormais une nécessité absolue. Cet article résume mon exploration du problème et certaines de ses solutions.

1. Objectif
Imaginez que nous ayons deux modules. Le premier est responsable du service de requête Ajax (service) et le second est le routage (routeur).

Copier le code Le code est le suivant :

var service = function() {
return { name: 'Service' };
>
var router = function() {
return { name: 'Router' };
}

Nous avons une autre fonction à utiliser pour ces deux modules.

Copier le code Le code est le suivant :

var doSomething = function(other) {
var s = service();
var r = router();
};

Pour la rendre plus intéressante, cette fonction accepte un paramètre. Bien sûr, on peut utiliser le code ci-dessus, mais il n’est évidemment pas assez flexible. Que se passe-t-il si nous voulons utiliser ServiceXML ou ServiceJSON, ou si nous avons besoin de modules de test. Nous ne pouvons pas résoudre le problème simplement en modifiant le corps de la fonction. Premièrement, nous pouvons résoudre les dépendances via les paramètres de la fonction. C'est-à-dire :

Copier le code Le code est le suivant :

var doSomething = function(service , router, other ) {
var s = service();
var r = router();
};

Nous obtenons ce que nous voulons en passant des paramètres supplémentaires, cependant, cela Apportera de nouveaux problèmes. Imaginez si nos méthodes doSomething étaient dispersées dans notre code. Si nous devons modifier les dépendances, nous ne pouvons pas modifier tous les fichiers qui appellent la fonction.

Nous avons besoin d'un outil qui puisse nous aider à le faire. C’est le problème que l’injection de dépendances tente de résoudre. Écrivons quelques objectifs que notre solution d'injection de dépendances devrait atteindre :

Nous devrions pouvoir enregistrer les dépendances
1. L'injection doit prendre une fonction et renvoyer une fonction dont nous avons besoin
2 Nous ne pouvons pas trop écrire - nous devons rationaliser et belle syntaxe
3. .L'injection doit conserver la portée de la fonction transmise
4. La fonction transmise doit être capable d'accepter des paramètres personnalisés, pas seulement des descriptions de dépendances
5 C'est une liste de contrôle parfaite, implémentons-la.
3. Méthode RequireJS/AMD
Vous avez peut-être entendu parler de RequireJS, c'est un bon choix pour résoudre l'injection de dépendances.

Copier le code Le code est le suivant :

define(['service', 'router '], fonction(service, routeur) {                                                                                                                                              . L'ordre des paramètres ici est important. Comme mentionné ci-dessus, écrivons un module appelé injector qui accepte la même syntaxe.

Copier le code

Le code est le suivant :var doSomething = injector.resolve([' service', 'routeur'], function(service, routeur, autre) { expect(service().name).to.be('Service');

expect(router().name). to.be ('Routeur');

expect(other).to.be('Other');
});

doSomething("Autre");
Je devrais avant de continuer Pour expliquer clairement le contenu du corps de la fonction doSomething, j'utilise expect.js (la bibliothèque d'assertions) juste pour m'assurer que le code que j'écris se comporte de la même manière que ce à quoi je m'attends, reflétant un peu la méthode TDD (développement piloté par les tests).
Commençons par notre module d'injection. Il s'agit d'un excellent modèle singleton, il peut donc bien fonctionner dans différentes parties de notre programme.

Copier le code

Le code est le suivant :

var injector = {
dépendances : {},
registre : fonction (clé, valeur) {
this.dependencies[key] = valeur;
},
résoudre : fonction (deps, func, scope) {

>
}

Il s'agit d'un objet très simple avec deux méthodes, une pour stocker les propriétés. Ce que nous faisons, c'est vérifier le tableau deps et rechercher la réponse dans la variable de dépendances. Il ne reste plus qu'à appeler la méthode .apply et transmettre les paramètres de la méthode func précédente.

Copier le code Le code est le suivant :

resolve: function(deps, func, scope ) {
var args = [];
for(var i=0; i if(this.dependencies[d]) {
args.push (this.Dependencies [d]);
} else {
Lancer une nouvelle erreur ("Canon't Resolve" d);
func.apply(scope || {}, args.concat(Array.prototype.slice.call(arguments, 0)));
}
}

la portée est facultative Oui, Array.prototype.slice.call(arguments, 0) est nécessaire pour convertir la variable arguments en un véritable tableau. Jusqu'ici, tout va bien. Notre test a réussi. Le problème avec cette implémentation est que nous devons écrire deux fois les parties requises et nous ne pouvons pas mélanger leur ordre. Les paramètres personnalisés supplémentaires viennent toujours après les dépendances.

4. Méthode de réflexion
Selon la définition de Wikipédia, la réflexion fait référence à la capacité d'un programme à inspecter et à modifier la structure et le comportement d'un objet au moment de l'exécution. En termes simples, dans le contexte de JavaScript, cela fait spécifiquement référence à la lecture et à l'analyse du code source d'un objet ou d'une fonction. Complétons la fonction doSomething mentionnée au début de l'article. Si vous affichez doSomething.tostring() dans la console. Vous obtiendrez la chaîne suivante :

Copiez le code Le code est le suivant :" function (service , router, other) {

var s = service();

var r = router();
}"

La chaîne renvoyée par cette méthode nous donne la possibilité parcourir les paramètres, et plus important encore, pouvoir obtenir leurs noms. C'est en fait ainsi qu'Angular implémente son injection de dépendances. J'étais un peu paresseux et j'ai directement intercepté l'expression régulière pour obtenir des paramètres dans le code angulaire.

Copier le code Le code est le suivant :/^functions*[^(]* (s* ([^)]*))/m

Nous pouvons modifier le code de résolution comme suit :

Copier le code Le code est le suivant : resolve: function() {

var func, deps, scope, args = [], self = this;

func = arguments [0];
deps = func.toString().match(/^functions*[^(]*(s*([^)]*))/m)[1].replace(/ /g, '').split (',');
scope = arguments[1] || {};
return function() {
var a = Array.prototype.slice.call(arguments, 0 );
for(var i=0; i var d = deps[i];
args.push(self.dependencies[d] && d != ' ' ? self.dependencies [d] : a.shift());
}
} func.apply(scope || {}, args);
}    
}

On exécute l'expression régulière Les résultats des autres)", "service, routeur, autre"]

On dirait que nous n’avons besoin que du deuxième élément. Une fois que nous avons effacé les espaces et divisé la chaîne, nous obtenons le tableau deps. Il n'y a qu'un seul gros changement :

Copiez le code Le code est le suivant :

var a = Array.prototype .slice.call(arguments, 0);
...
args.push(self.dependencies[d] && d != '' ? self.dependencies[d] : a. shift());

Nous parcourons le tableau des dépendances et essayons de l'obtenir à partir de l'objet arguments si un élément manquant est trouvé. Heureusement, lorsque le tableau est vide, la méthode shift renvoie simplement undefined au lieu de générer une erreur (grâce à l'idée du Web). La nouvelle version de l'injecteur peut être utilisée comme suit :

Copiez le code Le code est le suivant :

var doSomething = injector.resolve(function(service, other, router) {
expect(service().name).to.be('Service');
expect(router().name ).to.be( 'Routeur');
expect(other).to.be('Autre');
});
doSomething("Autre");

Il n'est pas nécessaire de réécrire les dépendances et elles peuvent être perturbées. Cela fonctionne toujours et nous avons réussi à reproduire la magie d'Angular.

Cependant, cette approche n'est pas parfaite, ce qui pose un très gros problème avec les injections de type réflexe. La compression brisera notre logique car elle modifie les noms des paramètres et nous ne pourrons pas maintenir le mappage correct. Par exemple, doSometing() peut ressembler à ceci une fois compressé :

Copier le code Le code est le suivant :

var doSomething=function(e,t,n){var r=e();var i=t()}
La solution proposée par l'équipe Angular ressemble à :

var doSomething = injector.resolve(['service', 'router', function(service, routeur) {

}]);

Cela ressemble beaucoup à la solution avec laquelle nous avons commencé. Je n'ai pas pu trouver de meilleure solution, j'ai donc décidé de combiner les deux approches. Vous trouverez ci-dessous la version finale de l'injecteur.

Copier le code Le code est le suivant :

var injector = {
dépendances : {},
register : function(key, value) {
this.dependencies[key] = value;
},
solve : function() {
var func, deps, scope , args = [], self = this;
if(typeof arguments[0] === 'string') {
func = arguments[1];
deps = arguments[0].replace( / /g , '').split(',');
scope = arguments[2] || {};
} else {
func = arguments[0];
deps = func.toString ().match(/^functions*[^(]*(s*([^)]*))/m)[1].replace(/ /g, '').split(',' );
            scope = arguments[1]                                                                                                                                      i = 0; i & lt; deps.Length; {
var d = DEPS [i]; && d! = ''? Auto.dépendances [d] : a.shift ());
Le visiteur résolu accepte deux ou trois paramètres. S'il y a deux paramètres, c'est en fait le même que celui écrit plus tôt dans l'article. Cependant, s'il y a trois paramètres, il convertira le premier paramètre et remplira le tableau deps, voici un exemple de test :

Copier le code Le code est le suivant :

var doSomething = injector.resolve('router,,service', function(a, b, c) {
expect(a().name ).to .be('Router');
expect(b).to.be('Other');
expect(c().name).to.be('Service');
} );
doSomething("Other");

Vous remarquerez peut-être qu'il y a deux virgules après le premier paramètre - notez qu'il ne s'agit pas d'une faute de frappe. La valeur nulle représente en fait le paramètre « Autre » (espace réservé). Cela montre comment nous contrôlons l’ordre des arguments.

5. Injecter directement Scope
Parfois, j'utilise la troisième variable d'injection, qui implique la portée de la fonction opérationnelle (en d'autres termes, l'objet this). Par conséquent, il n’est souvent pas nécessaire d’utiliser cette variable.

Copier le code Le code est le suivant :

var injector = {
dépendances : {},
register : function(key, value) {
this.dependencies[key] = value;
},
solve : function(deps, func, scope) {
var args = [ ];
scope = scope || {};
for(var i=0; i if(this.dependencies [d] ) {
                scope[d] = this }
return function() {
                func.apply(scope || {}, Array.prototype.slice.call(arguments, 0)) ;                                                         Tout ce que nous faisons, c'est ajouter des dépendances à la portée. L'avantage est que le développeur n'a plus besoin d'écrire des paramètres de dépendance ; ils font déjà partie de la portée de la fonction.




Copier le code

Le code est le suivant :

var doSomething = injector.resolve([' service', 'router'], function(other) {expect(this.service().name).to.be('Service');expect(this.router().name). to.be ('Routeur'); expect(other).to.be('Other');});doSomething("Autre");

6. Conclusion

En fait, la plupart d'entre nous ont utilisé l'injection de dépendances, mais nous ne nous en sommes pas rendu compte. Même si vous ne connaissez pas le terme, vous l'avez probablement utilisé un million de fois dans votre code. J'espère que cet article pourra approfondir votre compréhension.