Les modules font partie intégrante de toute application puissante et nous aident souvent clairement à séparer et à organiser les unités de code dans des projets.
Méthodes pour implémenter des modules dans JS:
1. Représentation littérale d'objet
2. mode module
3. Module AMD
4. Module CommonJS
5.Cmascript Harmony Module
Objet littéral
Les littéraux d'objets n'ont pas besoin d'être instanciés à l'aide du nouvel opérateur, mais ne peuvent pas être utilisés au début d'une déclaration, car le début peut être interprété comme le début d'un bloc. En dehors de l'objet, de nouveaux membres peuvent être ajoutés à l'objet littéral en utilisant l'instruction d'affectation suivante, mymodule.property = "SomeValue".
var mymodule = {myProperty: "SomeValue", MyConfig: {UseCaching: true, Language: "en"}, // Méthode de base MyMethod: fonction () {// ...}, // Informations de sortie basées sur la configuration actuelle MyMethod2: Function () {console.Log ("L'adhésion est:" + (this.myConfing.uscaching)? "activé": "désactivé"); }, // Réécrivez la configuration actuelle myMethod3: fonction (newConfig) {if (typeof newConfig === "Object") {this.myConfig = newConfig; console.log (this.myConfig.Language); }},}; mymodule.myméthod3 ({langage: "Fr", usecaching: false})L'utilisation des littéraux d'objets aide à encapsuler et à organiser le code.
En JavaScript, le modèle de module est utilisé pour simuler davantage le concept de classes, de quelle manière un objet séparé peut avoir des méthodes et des variables publiques / privées, bloquant ainsi des pièces spéciales de la portée globale.
Le modèle de module utilise des fermetures pour résumer l'état et l'organisation «privés». Il fournit un moyen d'envelopper un mélange de méthodes et de variables publiques / privées pour empêcher les fuites de la portée mondiale et entre en conflit avec les interfaces d'autres développeurs. Grâce à ce mode, il vous suffit de retourner une API publique et tout le reste est maintenu dans une fermeture privée.
En mode module, en raison de l'existence de fermetures, des variables et des méthodes déclarées ne sont disponibles que dans le mode, mais les variables et méthodes définies sur l'objet de retour sont disponibles pour les utilisateurs externes.
Implémentation du mode module
var testModule = (function () {var compter = 0; return {incmentCounter: function () {return ++ compter;}, resetcounter: function () {console.log ("compteur de compteur avant de réinitialiser" + compteur); TestModule.ResetCounter ();L'autre partie du code est que IncmenmentCounter () et ResetCounter () ne peuvent pas être lus directement. La variable de comptoir est en fait complètement isolée de la portée globale, donc elle agit comme une variable privée dont l'existence est limitée à la fermeture du module, car le seul code qui peut accéder à sa portée est ces deux fonctions. La méthode ci-dessus a efficacement défini l'espace de noms, donc dans le code de test, tous les appels doivent être préfixés.
// mode module contenant des variables d'espace de noms, publiques et privées var mynamspace = (function () {// Counter privé variable var myprivatevar = 0; // function private var myprivateMethod = function (foo) {console.log (foo);}; return {// public variable muublicvar: "foo", // public fure MyPublicFunction: fonction (bar) {myPrivateVar ++;Référence Variables globales
JavaScript a une fonctionnalité appelée variables globales implicites. Peu importe si une variable a été utilisée ou non, l'interprète JavaScript inverse la chaîne de portée pour trouver la déclaration VAR de toute la variable. Si le VAR n'est pas trouvé, l'interprète suppose que la variable est une variable globale. Si la variable est utilisée pour le fonctionnement de l'affectation, si elle n'existe pas auparavant, l'interprète le créera automatiquement. Cela signifie qu'il est très facile à utiliser ou à créer des variables globales dans les fermetures anonymes, mais la chose la plus difficile est que le code est difficile à gérer, surtout lorsque les personnes qui lisent le code voient beaucoup de différenciation entre les variables globales et lesquelles sont locales.
Heureusement, dans les fonctions anonymes, nous pouvons fournir une alternative relativement simple. Nous pouvons transmettre des variables globales en fonctions anonymes comme paramètre et les utiliser. Par rapport aux variables globales implicites, elle est claire et rapide. Prenons un exemple:
// module global var myModule = (fonction (jq, _) {fonction privateMethod1 () {jq (". Contener"). Html (test);} return {publicMethod: function () {privatethod1 ();}}}) (jquet, _); mymodule.publicMethod (); // module global var mymodule = (function () {// module objet var module = {}; privatevariale = "hello"; function privateMethod () {//...}Module.publicProperty = "foobar"; module.publiceMeThod = function () {} return module;););Déclarer les variables globales sans les mettre en œuvre et peuvent également soutenir le concept d'introduction globale
Il y a encore certaines lacunes en mode module:
1. Étant donné que nous accédons aux membres publics et privés différemment, lorsque nous voulons changer la visibilité, nous devons en fait modifier chaque existence qui a jamais utilisé ce membre.
2. Nous ne pouvons pas accéder à ces membres privés ajoutés à la méthode plus tard.
3. Impossible de créer des tests unitaires automatisés pour les membres privés, et une complexité supplémentaire est ajoutée lorsque les bogues doivent être corrigés.
4. Les développeurs ne peuvent pas facilement étendre les méthodes privées
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.