


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).
var service = function() {
return { name: 'Service' };
>
var router = function() {
return { name: 'Router' };
}
Nous avons une autre fonction à utiliser pour ces deux modules.
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 :
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.
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
});
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
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.
resolve: function(deps, func, scope ) {
var args = [];
for(var i=0; i
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.
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 :
}"
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.
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
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 :
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 :
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é :
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.
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 :
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.
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
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

Oui, le noyau du moteur de JavaScript est écrit en C. 1) Le langage C fournit des performances efficaces et un contrôle sous-jacent, qui convient au développement du moteur JavaScript. 2) Prendre le moteur V8 comme exemple, son noyau est écrit en C, combinant l'efficacité et les caractéristiques orientées objet de C. 3) Le principe de travail du moteur JavaScript comprend l'analyse, la compilation et l'exécution, et le langage C joue un rôle clé dans ces processus.

JavaScript est au cœur des sites Web modernes car il améliore l'interactivité et la dynamicité des pages Web. 1) Il permet de modifier le contenu sans rafraîchir la page, 2) manipuler les pages Web via Domapi, 3) prendre en charge les effets interactifs complexes tels que l'animation et le glisser-déposer, 4) Optimiser les performances et les meilleures pratiques pour améliorer l'expérience utilisateur.

C et JavaScript réalisent l'interopérabilité via WebAssembly. 1) Le code C est compilé dans le module WebAssembly et introduit dans un environnement JavaScript pour améliorer la puissance de calcul. 2) Dans le développement de jeux, C gère les moteurs de physique et le rendu graphique, et JavaScript est responsable de la logique du jeu et de l'interface utilisateur.

JavaScript est largement utilisé dans les sites Web, les applications mobiles, les applications de bureau et la programmation côté serveur. 1) Dans le développement de sites Web, JavaScript exploite DOM avec HTML et CSS pour réaliser des effets dynamiques et prend en charge des cadres tels que JQuery et React. 2) Grâce à la réactnative et ionique, JavaScript est utilisé pour développer des applications mobiles multiplateformes. 3) Le cadre électronique permet à JavaScript de créer des applications de bureau. 4) Node.js permet à JavaScript d'exécuter le côté du serveur et prend en charge les demandes simultanées élevées.

Python est plus adapté à la science et à l'automatisation des données, tandis que JavaScript est plus adapté au développement frontal et complet. 1. Python fonctionne bien dans la science des données et l'apprentissage automatique, en utilisant des bibliothèques telles que Numpy et Pandas pour le traitement et la modélisation des données. 2. Python est concis et efficace dans l'automatisation et les scripts. 3. JavaScript est indispensable dans le développement frontal et est utilisé pour créer des pages Web dynamiques et des applications à une seule page. 4. JavaScript joue un rôle dans le développement back-end via Node.js et prend en charge le développement complet de la pile.

C et C jouent un rôle essentiel dans le moteur JavaScript, principalement utilisé pour implémenter des interprètes et des compilateurs JIT. 1) C est utilisé pour analyser le code source JavaScript et générer une arborescence de syntaxe abstraite. 2) C est responsable de la génération et de l'exécution de bytecode. 3) C met en œuvre le compilateur JIT, optimise et compile le code de point chaud à l'exécution et améliore considérablement l'efficacité d'exécution de JavaScript.

L'application de JavaScript dans le monde réel comprend un développement frontal et back-end. 1) Afficher les applications frontales en créant une application de liste TODO, impliquant les opérations DOM et le traitement des événements. 2) Construisez RestulAPI via Node.js et Express pour démontrer les applications back-end.

Les principales utilisations de JavaScript dans le développement Web incluent l'interaction client, la vérification du formulaire et la communication asynchrone. 1) Mise à jour du contenu dynamique et interaction utilisateur via les opérations DOM; 2) La vérification du client est effectuée avant que l'utilisateur ne soumette les données pour améliorer l'expérience utilisateur; 3) La communication de rafraîchissement avec le serveur est réalisée via la technologie AJAX.


Outils d'IA chauds

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

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

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

SublimeText3 version anglaise
Recommandé : version Win, prend en charge les invites de code !

ZendStudio 13.5.1 Mac
Puissant environnement de développement intégré PHP

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.

Adaptateur de serveur SAP NetWeaver pour Eclipse
Intégrez Eclipse au serveur d'applications SAP NetWeaver.

Télécharger la version Mac de l'éditeur Atom
L'éditeur open source le plus populaire
