recherche
Maisoninterface Webjs tutorielCompré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.
Déclaration
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
es6数组怎么去掉重复并且重新排序es6数组怎么去掉重复并且重新排序May 05, 2022 pm 07:08 PM

去掉重复并排序的方法:1、使用“Array.from(new Set(arr))”或者“[…new Set(arr)]”语句,去掉数组中的重复元素,返回去重后的新数组;2、利用sort()对去重数组进行排序,语法“去重数组.sort()”。

JavaScript的Symbol类型、隐藏属性及全局注册表详解JavaScript的Symbol类型、隐藏属性及全局注册表详解Jun 02, 2022 am 11:50 AM

本篇文章给大家带来了关于JavaScript的相关知识,其中主要介绍了关于Symbol类型、隐藏属性及全局注册表的相关问题,包括了Symbol类型的描述、Symbol不会隐式转字符串等问题,下面一起来看一下,希望对大家有帮助。

原来利用纯CSS也能实现文字轮播与图片轮播!原来利用纯CSS也能实现文字轮播与图片轮播!Jun 10, 2022 pm 01:00 PM

怎么制作文字轮播与图片轮播?大家第一想到的是不是利用js,其实利用纯CSS也能实现文字轮播与图片轮播,下面来看看实现方法,希望对大家有所帮助!

JavaScript对象的构造函数和new操作符(实例详解)JavaScript对象的构造函数和new操作符(实例详解)May 10, 2022 pm 06:16 PM

本篇文章给大家带来了关于JavaScript的相关知识,其中主要介绍了关于对象的构造函数和new操作符,构造函数是所有对象的成员方法中,最早被调用的那个,下面一起来看一下吧,希望对大家有帮助。

JavaScript面向对象详细解析之属性描述符JavaScript面向对象详细解析之属性描述符May 27, 2022 pm 05:29 PM

本篇文章给大家带来了关于JavaScript的相关知识,其中主要介绍了关于面向对象的相关问题,包括了属性描述符、数据描述符、存取描述符等等内容,下面一起来看一下,希望对大家有帮助。

javascript怎么移除元素点击事件javascript怎么移除元素点击事件Apr 11, 2022 pm 04:51 PM

方法:1、利用“点击元素对象.unbind("click");”方法,该方法可以移除被选元素的事件处理程序;2、利用“点击元素对象.off("click");”方法,该方法可以移除通过on()方法添加的事件处理程序。

整理总结JavaScript常见的BOM操作整理总结JavaScript常见的BOM操作Jun 01, 2022 am 11:43 AM

本篇文章给大家带来了关于JavaScript的相关知识,其中主要介绍了关于BOM操作的相关问题,包括了window对象的常见事件、JavaScript执行机制等等相关内容,下面一起来看一下,希望对大家有帮助。

foreach是es6里的吗foreach是es6里的吗May 05, 2022 pm 05:59 PM

foreach不是es6的方法。foreach是es3中一个遍历数组的方法,可以调用数组的每个元素,并将元素传给回调函数进行处理,语法“array.forEach(function(当前元素,索引,数组){...})”;该方法不处理空数组。

See all articles

Outils d'IA chauds

Undresser.AI Undress

Undresser.AI Undress

Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover

AI Clothes Remover

Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool

Undress AI Tool

Images de déshabillage gratuites

Clothoff.io

Clothoff.io

Dissolvant de vêtements AI

AI Hentai Generator

AI Hentai Generator

Générez AI Hentai gratuitement.

Article chaud

R.E.P.O. Crystals d'énergie expliqués et ce qu'ils font (cristal jaune)
2 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌
Repo: Comment relancer ses coéquipiers
4 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌
Hello Kitty Island Adventure: Comment obtenir des graines géantes
4 Il y a quelques semainesBy尊渡假赌尊渡假赌尊渡假赌

Outils chauds

PhpStorm version Mac

PhpStorm version Mac

Le dernier (2018.2.1) outil de développement intégré PHP professionnel

Dreamweaver Mac

Dreamweaver Mac

Outils de développement Web visuel

Listes Sec

Listes Sec

SecLists est le compagnon ultime du testeur de sécurité. Il s'agit d'une collection de différents types de listes fréquemment utilisées lors des évaluations de sécurité, le tout en un seul endroit. SecLists contribue à rendre les tests de sécurité plus efficaces et productifs en fournissant facilement toutes les listes dont un testeur de sécurité pourrait avoir besoin. Les types de listes incluent les noms d'utilisateur, les mots de passe, les URL, les charges utiles floues, les modèles de données sensibles, les shells Web, etc. Le testeur peut simplement extraire ce référentiel sur une nouvelle machine de test et il aura accès à tous les types de listes dont il a besoin.

DVWA

DVWA

Damn Vulnerable Web App (DVWA) est une application Web PHP/MySQL très vulnérable. Ses principaux objectifs sont d'aider les professionnels de la sécurité à tester leurs compétences et leurs outils dans un environnement juridique, d'aider les développeurs Web à mieux comprendre le processus de sécurisation des applications Web et d'aider les enseignants/étudiants à enseigner/apprendre dans un environnement de classe. Application Web sécurité. L'objectif de DVWA est de mettre en pratique certaines des vulnérabilités Web les plus courantes via une interface simple et directe, avec différents degrés de difficulté. Veuillez noter que ce logiciel

MinGW - GNU minimaliste pour Windows

MinGW - GNU minimaliste pour Windows

Ce projet est en cours de migration vers osdn.net/projects/mingw, vous pouvez continuer à nous suivre là-bas. MinGW : un port Windows natif de GNU Compiler Collection (GCC), des bibliothèques d'importation et des fichiers d'en-tête librement distribuables pour la création d'applications Windows natives ; inclut des extensions du runtime MSVC pour prendre en charge la fonctionnalité C99. Tous les logiciels MinGW peuvent fonctionner sur les plates-formes Windows 64 bits.