Los módulos son una parte integral de cualquier aplicación poderosa y, a menudo, nos ayudan a separar claramente y organizar unidades de código en proyectos.
Métodos para implementar módulos en JS:
1. Representación literal de objetos
2. Modo de módulo
3. Módulo AMD
4. Módulo CommonJS
5. Módulo de armonía de ECMAScript
Objeto literal
Los literales de objetos no necesitan ser instanciados utilizando el nuevo operador, pero no se pueden usar al comienzo de una declaración, porque el comienzo puede interpretarse como el comienzo de un bloque. Fuera del objeto, se pueden agregar nuevos miembros al objeto literal utilizando la siguiente declaración de asignación, myModule.Property = "SomeValue".
var mymodule = {myProperty: "someValue", myconfig: {useCaching: true, idioma: "en"}, // método básico mymethod: function () {// ...}, // información de salida basada en la configuración actual mymethod2: function () {console.log ("Caching es:"+((this.myconfing.useCating. "habilitado": "deshabilitado"); }, // Reescribe la configuración actual mymethod3: function (newConfig) {if (typeof newConfig === "Object") {this.myconfig = newConfig; console.log (this.myconfig.language); }},}; mymodule.mymethod3 ({lenguaje: "fr", usecaching: falso})El uso de literales de objetos ayuda a encapsular y organizar el código.
En JavaScript, el patrón del módulo se utiliza para simular aún más el concepto de clases, en qué manera un objeto separado puede tener métodos y variables públicas/privadas, bloqueando así partes especiales del alcance global.
El patrón del módulo utiliza cierres para encapsular el estado y la organización "privada". Proporciona una forma de envolver una combinación de métodos y variables públicas/privadas para evitar fugas al alcance global y conflictos con las interfaces de otros desarrolladores. A través de este modo, solo necesita devolver una API pública, y todo lo demás se mantiene en un cierre privado.
En el modo de módulo, debido a la existencia de cierres, las variables y los métodos declarados solo están disponibles dentro del modo, pero las variables y los métodos definidos en el objeto de retorno están disponibles para usuarios externos.
Implementación del modo de módulo
var testModule = (function () {var contador = 0; return {incrementCounter: function () {return ++ contador;}, reseTCounter: function () {console.log ("Valor de contador anterior a reinicio" +contador); contador = 0;}}}) (); // aumenta el contador testModule.inceNcementCunter (); // verificar el contador y volver testModule.resetCounter ();La otra parte del código es que incrementCounter () y resetcounter () no se pueden leer directamente. La variable de contador en realidad está completamente aislada del alcance global, por lo que actúa como una variable privada cuya existencia se limita al cierre del módulo, porque el único código que puede acceder a su alcance son estas dos funciones. El método anterior ha establecido efectivamente el espacio de nombres, por lo que en el código de prueba, todas las llamadas deben prefijarse.
// Modo de módulo que contiene espacios de nombres, variables públicas y privadas var mynamspace = (function () {// private contador variable var myPrivateVar = 0; // función privada var myPrivatEmethod = function (foo) {console.log (foo);}; return {// public variable mupublicvar: "foo", // función pública que llama privado variables y métodos privados myPublicFunction: function (bar) {myPrivateVar ++;Variables globales de referencia
JavaScript tiene una característica llamada variables globales implícitas. Independientemente de si una variable se ha utilizado o no, el intérprete JavaScript invierte la cadena de alcance para encontrar la declaración VAR de toda la variable. Si no se encuentra el var, el intérprete supone que la variable es una variable global. Si la variable se usa para la operación de asignación, si no existe antes, el intérprete lo creará automáticamente. Esto significa que es muy fácil de usar o crear variables globales en los cierres anónimos, pero lo más difícil es que el código es difícil de administrar, especialmente cuando las personas que leen el código ven muchas diferencian entre qué variables son globales y cuáles son locales.
Afortunadamente, en funciones anónimas, podemos proporcionar una alternativa relativamente simple. Podemos pasar variables globales en funciones anónimas como un parámetro y usarlas. En comparación con las variables globales implícitas, es clara y rápida. Tomemos un ejemplo:
// Global Module var myModule = (function (jq, _) {function privateMethod1 () {jq (". Contenedor"). Html (test);} return {publicMethod: function () {privateMethod1 ();}}}) (jQuery, _); mymodule.publicMethod (); // Global Module var myModule = (function () {// module Object var module = {}; privateVariale = "hello"; function privateMethod () {//...}Module.publicProperty = "foobar"; module.publicemethod = function () {} mods de retorno;};};};Declarar variables globales sin implementarlas y también puede apoyar el concepto de introducción global
Todavía hay ciertas deficiencias en el modo módulo:
1. Dado que accedemos a los miembros públicos y privados de manera diferente, cuando queremos cambiar la visibilidad, en realidad tenemos que modificar cada existencia que haya usado ese miembro.
2. No podemos acceder a los miembros privados agregados al método más adelante.
3. No se puede crear pruebas unitarias automatizadas para miembros privados, y se agrega una complejidad adicional cuando se deben solucionar errores.
4. Los desarrolladores no pueden extender fácilmente métodos privados
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.