Différence entre javascript modularisation et dépendance Injection

Question

Quelle est la différence avec la modularisation d'un code javascript (avec browserify par exemple) et l'injection de dépendance?

Sont-ils synonymes? Est-ce que les deux vont ensemble? Ou est-ce que je manque un point?

Answer 1

La modularisation fait référence à la rupture du code en "paquets" individuels et indépendants.
L'injection de dépendances fait référence à des références non codées en dur à d'autres modules.

A titre d'exemple pratique, vous pouvez écrire des modules qui ne sont pas par injection de dépendance:

import { Foo } from 'foo'; 

export function Bar() { 
    return Foo.baz(); 
} 

Ici vous avez deux modules, mais ce module importe un autre module spécifique hardcoded.

Le même module écrit en utilisant l'injection de dépendance:

export function Bar(foo) { 
    return foo.baz(); 
} 

Ensuite, quelqu'un d'autre peut l'utiliser comme:

import { Foo } from 'foo'; 
import { Bar } from 'bar'; 

Bar(Foo()); 

Vous injectez au moment de l'appel de la dépendance Foo, au lieu de hardcoding la dépendance .

Answer 2

Vous pouvez consulter cette article:

Les modules sont des fragments de code qui mettent en œuvre certaines fonctionnalités et sont écrits en utilisant des techniques spécifiques. Il n'y a pas de schéma de modularisation out-of-the-box dans le langage JavaScript. La prochaine spécification ECMAScript 6 tend à résoudre ce problème en introduisant le concept de module dans le langage JavaScript lui-même. C'est le futur.

et Dependency injection in JavaScript

L'objectif

Disons que nous avons deux modules. Le premier est un service qui fait des requêtes Ajax et le second est un routeur.

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

Nous avons une autre fonction qui a besoin de ces modules.

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

Et pour faire les choses un peu plus intéressant la fonction doit accepter un paramètre plus. Bien sûr, nous pourrions utiliser le code ci-dessus, mais ce n'est pas vraiment flexible. Que faire si nous voulons utiliser ServiceXML ou ServiceJSON. Ou si nous voulons mockup certains des modules pour des fins de test . Nous ne pouvons pas simplement modifier le corps de la fonction. Le première chose que nous venons tous avec est de passer les dépendances en tant que paramètres à la fonction. I.e. .:

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

En faisant cela, nous passons la mise en œuvre exacte du module que nous voulons. Cependant cela apporte un nouveau problème. Imaginez si nous avons faire quelque chose partout dans notre code. Que se passera-t-il si nous avons besoin d'une troisième dépendance . Nous ne pouvons pas éditer tous les appels de la fonction. Donc, nous avons besoin d'un instrument qui fera cela pour nous. C'est ce que les injecteurs de dépendance tentent de résoudre.Écrivons quelques objectifs que nous voulons atteindre:

• nous devrions être en mesure d'enregistrer les dépendances
• l'injecteur doit accepter une fonction et retourne une fonction qui obtient en quelque sorte les ressources nécessaires
• nous devrions pas écrire beaucoup, nous avons besoin de syntaxe courte et agréable
• l'injecteur doit garder la portée de la fonction passée
• la fonction passée devrait être en mesure d'accepter des arguments personnalisés, non seulement les dépendances décrites

Une belle liste n'est-ce pas. Plongez-y.