A medida que nuestra aplicación crece, queremos dividirla en múltiples archivos, los llamados “módulos”. Un módulo puede contener una clase o una biblioteca de funciones para un propósito específico.
Durante mucho tiempo, JavaScript existió sin una sintaxis de módulo a nivel de lenguaje. Esto no era un problema, porque inicialmente los scripts eran pequeños y simples.
Pero con el tiempo los scripts se volvieron cada vez más complejos, por lo que la comunidad inventó una variedad de formas de organizar el código en módulos, bibliotecas especiales para cargar módulos a pedido.
Para nombrar algunos (por razones históricas):
- AMD – uno de los sistemas de módulos más antiguos, implementado inicialmente por la biblioteca require.js.
- CommonJS – el sistema de módulos creado para el servidor Node.js.
- UMD – un sistema de módulos más, sugerido como universal, compatible con AMD y CommonJS.
Todo esto se va convirtiendo lentamente en parte de la historia, pero aún podemos encontrarlos en viejos scripts.
El sistema de módulos a nivel de lenguaje apareció en el estándar en 2015, evolucionó gradualmente desde entonces, y ahora es soportado por todos los navegadores importantes y por Node.js. Así que de ahora en adelante estudiaremos los módulos de Javascript modernos.
Qué es un módulo?
Un módulo es simplemente un archivo. Un script es un módulo. Tan sencillo como eso.
Los módulos pueden cargarse entre sí y usar directivas especiales export e import para intercambiar funcionalidad, llamar a funciones de un módulo de otro:
- La palabra clave
exportetiqueta las variables y funciones que necesitan ser accesibles desde fuera del módulo actual. importpermite importar funcionalidades desde otros módulos.
Por ejemplo, si tenemos un archivo sayHi.js que exporta una función:
// 📁 sayHi.js
export function sayHi(user) {
alert(`Hello, ${user}!`);
}
…Luego, otro archivo puede importarlo y usarlo:
// 📁 main.js
import {sayHi} from './sayHi.js';
alert(sayHi); // function...
sayHi('John'); // Hello, John!
La directiva import carga el módulo por la ruta ./sayHi.js relativa a la del archivo actual, y asigna la función exportada sayHi a la variable correspondiente.
Ejecutemos el ejemplo en el navegador.
Como los módulos admiten palabras clave y características especiales, debemos decirle al navegador que un script debe tratarse como un módulo, utilizando el atributo <script type =" module ">.
Asi:
export function sayHi(user) {
return `Hello, ${user}!`;
}<!doctype html>
<script type="module">
import {sayHi} from './say.js';
document.body.innerHTML = sayHi('John');
</script>El navegador busca y evalúa automáticamente el módulo importado (y sus importaciones si es necesario), y luego ejecuta el script.
Si intenta abrir una página web localmente a través del protocolo file://, encontrará que las directivas import y export no funcionan. Use un servidor web local, como static-server, o use la capacidad de “servidor vivo” de su editor, como VS Code Live Server Extension para probar los módulos.
Características principales de los módulos
¿Qué hay de diferente en los módulos en comparación con los scripts “normales”?
Estas son las características principales, válidas tanto para el navegador como para JavaScript del lado del servidor.
Siempre en modo estricto
Los módulos siempre trabajan en modo estricto. Por ejemplo, asignar a una variable sin declarar nos dará un error.
<script type="module">
a = 5; // error
</script>
Alcance a nivel de módulo
Cada módulo tiene su propio alcance de nivel superior. En otras palabras, las variables y funciones de nivel superior de un módulo no se ven en otros scripts.
En el siguiente ejemplo, se importan dos scripts y hello.js intenta usar la variable user declarada en user.js. Falla, porque es un módulo separado (puedes ver el error en la consola):
alert(user); // no existe tal variable (cada módulo tiene variables independientes)let user = "John";<!doctype html>
<script type="module" src="user.js"></script>
<script type="module" src="hello.js"></script>Los módulos deben hacer export a lo que ellos quieren que esté accesible desde afuera, y hacer import de lo que necesiten.
user.jsdebe exportar la variableuser.hello.jsdebe importarla desde el módulouser.js.
En otra palabras, con módulos usamos import/export en lugar de depender de variables globales.
Esta es la variante correcta:
import {user} from './user.js';
document.body.innerHTML = user; // Johnexport let user = "John";<!doctype html>
<script type="module" src="hello.js"></script>En el navegador, hablando de páginas HTML, también existe el alcance independiente de nivel superior para cada <script type="module">:
Aquí hay dos scripts en la misma página, ambos type="module". No ven entre sí sus variables de nivel superior:
<script type="module">
// La variable sólo es visible en éste script de módulo
let user = "John";
</script>
<script type="module">
alert(user); // Error: user no está definido
</script>
En el navegador, podemos hacer que una variable sea global a nivel window si explícitamente la asignamos a la propiedad window, por ejemplo window.user = "John".
Así todos los scripts la verán, con o sin type="module".
Dicho esto, hacer este tipo de variables globales está muy mal visto. Por favor evítalas.
Un código de módulo se evalúa solo la primera vez cuando se importa
Si el mismo módulo se importa en varios otros módulos, su código se ejecuta solo una vez: en el primer import. Luego, sus exportaciones se otorgan a todos los importadores que siguen.
Eso tiene consecuencias importantes para las que debemos estar prevenidos.
Echemos un vistazo usando ejemplos:
Primero, si ejecutar un código de módulo trae efectos secundarios, como mostrar un mensaje, importarlo varias veces lo activará solamente una vez, la primera:
// 📁 alert.js
alert("Módulo es evaluado!");
// Importar el mismo módulo desde archivos distintos
// 📁 1.js
import `./alert.js`; // Módulo es evaluado!
// 📁 2.js
import `./alert.js`; // (no muestra nada)
El segundo import no muestra nada, porque el módulo ya fue evaluado.
Existe una regla: el código de módulos del nivel superior debe ser usado para la inicialización y creación de estructuras de datos internas específicas del módulo. Si necesitamos algo que pueda ser llamado varias veces debemos exportarlo como una función, como hicimos con el sayHi de arriba.
Consideremos un ejemplo más avanzado.
Digamos que un módulo exporta un objeto:
// 📁 admin.js
export let admin = {
name: "John"
};
Si este módulo se importa desde varios archivos, el módulo solo se evalúa la primera vez, se crea el objeto admin y luego se pasa a todos los importadores adicionales.
Todos los importadores obtienen exactamente este mismo y único objeto admin:
// 📁 1.js
import {admin} from './admin.js';
admin.name = "Pete";
// 📁 2.js
import {admin} from './admin.js';
alert(admin.name); // Pete
// Ambos, 1.js y 2.js, hacen referencia al mismo objeto admin
// Los cambios realizados en 1.js son visibles en 2.js
Como puedes ver, cuando 1.js cambia la propiedad name en el admin importado, entonces 2.js puede ver el nuevo admin.name.
Esto es porque el módulo se ejecuta solo una vez. Los exports son generados y luego compartidos entre importadores, entonces si algo cambia en el objeto admin, otros importadores lo verán.
Tal comportamiento es en verdad muy conveniente, porque nos permite configurar módulos.
En otras palabras, un módulo puede brindar una funcionalidad genérica que necesite ser configurada. Por ejemplo, la autenticación necesita credenciales. Entonces se puede exportar un objeto de configuración esperando que el código externo se lo asigne.
Aquí está el patrón clásico:
- Un módulo exporta algún medio de configuración, por ejemplo un objeto configuración.
- En el primer import lo inicializamos, escribimos en sus propiedades. Los scripts de la aplicación de nivel superior pueden hacerlo.