Resumen

Antes de ES6, para lograr la modularización se usaban RequireJS o seaJS (que son bibliotecas de modularización basadas en la especificación AMD y en la especificación CMD, respectivamente).

ES6 introdujo la modularización. Su idea de diseño es poder determinar las dependencias de los módulos, así como las variables de entrada y salida, en tiempo de compilación.

La modularización de ES6 se divide en dos módulos: exportación (export) e importación (import).

Características

Los módulos de ES6 activan automáticamente el modo estricto, sin importar si añades o no en la cabecera del módulo.use strict;。

En los módulos se pueden importar y exportar variables de varios tipos, como funciones, objetos, cadenas, números, valores booleanos, clases, etc.

Cada módulo tiene su propio contexto. Las variables declaradas dentro de cada módulo son variables locales y no contaminan el ámbito global.

Cada módulo se carga solo una vez (es singleton). Si se vuelve a cargar el mismo archivo en el mismo directorio, se lee directamente desde la memoria.

export e import

Uso básico

Los módulos importan y exportan variables de varios tipos, como cadenas, números, funciones, clases.

  • Las declaraciones de funciones y clases exportadas deben tener un nombre (esto se considera aparte con el comando export default).
  • No solo se pueden exportar declaraciones, sino también referencias (por ejemplo, funciones).
  • El comando export puede aparecer en cualquier posición del módulo, pero debe estar en el nivel superior del módulo.
  • El comando import se eleva a la cabecera de todo el módulo y se ejecuta primero.
/*-----export [test.js]-----*/ let myName = "Tom"; let myAge = 20; let myfn = function(){ return "My name is" + myName + "! I'm '" + myAge + "years old." } let myClass = class myClass { static a = "yeah!"; } export { myName, myAge, myfn, myClass } /*-----import [xxx.js]-----*/ import { myName, myAge, myfn, myClass } from "./test.js"; console.log(myfn());// My name is Tom! I'm 20 years old. console.log(myAge);// 20 console.log(myName);// Tom console.log(myClass.a );// yeah!

Se recomienda usar llaves para especificar un conjunto de variables a exportar y escribirlas al final del archivo, definiendo claramente las interfaces exportadas.

Las funciones y clases necesitan tener un nombre correspondiente. Exportar al final del archivo también evita que no haya un nombre correspondiente.

Uso de as

Los nombres de las interfaces exportadas con el comando export deben tener una correspondencia uno a uno con las variables internas del módulo.

Los nombres de las variables importadas deben ser iguales a los nombres de las interfaces exportadas; es decir, el orden puede no ser el mismo.

/*-----export [test.js]-----*/ let myName = "Tom"; export { myName as exportName } /*-----import [xxx.js]-----*/ import { exportName } from "./test.js"; console.log(exportName);// TomUsoasRedefinir el nombre de la interfaz exportada, ocultando las variables internas del módulo./*-----export [test1.js]-----*/ let myName = "Tom"; export { myName } /*-----export [test2.js]-----*/ let myName = "Jerry"; export { myName } /*-----import [xxx.js]-----*/ import { myName as name1 } from "./test1.js"; import { myName as name2 } from "./test2.js"; console.log(name1);// Tom console.log(name2);// Jerry

Cuando los nombres de las interfaces de exportación de diferentes módulos se repiten, se usa as para redefinir los nombres de las variables.

Características del comando import

Propiedad de solo lecturaNo se permite reasignar la referencia de la interfaz dentro de la secuencia de comandos que carga el módulo. Es decir, se puede modificar el valor de las propiedades si el tipo de la variable importada es un objeto, pero no se puede modificar el valor si el tipo de la variable importada es un tipo primitivo.

import {a} from "./xxx.js" a = {}; // error import {a} from "./xxx.js" a.foo = "hello"; // a = { foo : 'hello' }

Patrón singletonSi se ejecuta repetidamente la misma sentencia import, solo se ejecutará una vez, no varias. Al importar el mismo módulo declarando diferentes referencias de interfaz, se declararán las variables correspondientes, pero el import solo se ejecuta una vez.

import { a } "./xxx.js"; import { a } "./xxx.js"; //Equivale a `import { a } "./xxx.js";` import { a } from "./xxx.js"; import { b } from "./xxx.js"; //Equivale a `import { a, b } from "./xxx.js";`

Característica de ejecución estática: import se ejecuta de forma estática, por lo que no se pueden usar expresiones ni variables.

import { "f" + "oo" } from "methods"; // error let module = "methods"; import { foo } from module; // error if (true) { import { foo } from "method1"; } else { import { foo } from "method2"; } // error

El comando export default

  • En un archivo o módulo, puede haber varios export e import, pero solo un export default.
  • En export default, default es la variable de interfaz que se exporta.
  • Al exportar mediante export, al importar se deben usar { }; con export default no es necesario.
  • Los miembros expuestos con export default pueden recibirse con cualquier variable.
var a = "My name is Tom!"; export default a; //Solo uno. export default var c = "error"; //error, default ya es la variable de exportación correspondiente, no puede ir seguido de una declaración de variable. import b from "./xxx.js"; //No se necesitan {}, se recibe con cualquier variable.

Uso compuesto

Nota.: import() es una propuesta, por ahora no se explicará en profundidad.

export e import se pueden usar en el mismo módulo, con las siguientes características de uso:

  • Se puede renombrar la interfaz de exportación, incluido default.
  • Al combinar export e import, también se puede exportar todo; las interfaces exportadas por el módulo actual sobrescribirán las heredadas.
export { foo, bar } from "methods"; //Es aproximadamente equivalente a las dos sentencias siguientes, pero con el método de importación/exportación anterior, este módulo no importa foo ni bar. import { foo, bar } from "methods"; export { foo, bar }; /*------- Característica 1 --------*/ //Renombrado normal export { foo as bar } from "methods"; //Exportar foo como default. export { foo as default } from "methods"; //Exportar default como foo. export { default as foo } from "methods"; /*------- Característica 2 --------*/ export * from "methods";