Comparando CommonJS y AMD/RequireJS

Introducción

A diferencia de los servidores web como Apache y Microsoft IIS, ambos preconfigurados, node.js es bastante diferente. Con node.js, los desarrolladores construyen servidores web desde cero. Se espera que las habilidades de codificación de un desarrollador salvaguarden el servidor web. Así, Node.js se diferencia de Apache y del resto.

En este artículo, nos centraremos en dos módulos principales del sistema – AMD y Common.js – en node.js. Antes de comparar los dos, debemos discutir las diferencias entre los dos módulos del sistema. Dos preguntas guía que nos ayudan a comparar los dos son: cuál es más rápido cuando se cargan módulos en o desde el navegador y cómo convertir un módulo de sistema para heredar algunas características de otro módulo de sistema.

Este artículo no se centrará en los fundamentos de node.js amd javascript. No cubrirá temas como «cómo instalar node.js», «cómo usar npm o nave para instalar paquetes» o «diferentes versiones de node.js para diferentes proyectos». Nuestro propósito es resolver la confusión entre AMD y Common.js. Por lo tanto, vamos a enfatizar ligeramente en los módulos del núcleo en node.js, un par de funciones y variables, y eventualmente dirigir nuestra atención a AMD y Common.js y cómo podemos convertir uno de los módulos del sistema para cargar los módulos más rápido en el navegador.

Núcleo, archivo y módulos externos de node

En node.js, hay tres módulos principales importantes; Núcleo, archivo y módulos externos de node. Vamos a empezar con el módulo de archivo primero porque es más fácil de entender.

• Módulo de archivo:
  A diferencia de los otros dos modelos, el modelo de archivo es un modelo basado en rutas relativas. ¿Por qué? Digamos que vas a exportar un módulo a través de la siguiente sintaxis:

 module.exports = foo { 'something' : 123 } ; 

 var foo = function () { console.log('foo called'); };

var b = function () { console.log('b called'); }; 

module.exports = { b : b };

module.exports.bar = function () {console.log('bar called');}; 

module.exports.bas = function () {console.log('bas called');};

La forma en que se cargan o importan los módulos en archivos es bastante diferente a la de los módulos core y external_node; por lo que los otros dos también se conocen como módulos no basados en rutas relativas.

Nota: hay diversas formas de exportar módulos/archivos en node.js. La función anónima es otra de las formas de exportar un módulo desde un archivo.

• Módulos del núcleo:
  Los siguientes módulos que incluyen los tres módulos principales en node.js son los módulos del núcleo. Los Core Modules son módulos basados en no-relativos. Son muy diferentes de los módulos de archivo, especialmente cuando se requieren (o se importan) módulos en archivos.

Por ejemplo, si consumiéramos el módulo path en node.js, que arregla las barras inclinadas para que sean específicas del sistema operativo, se encarga de . y .. en la ruta, y también elimina las barras inclinadas duplicadas, no incluiríamos la ruta relativa:

var require = require('path') console.log (path.normalize ('/foo/bar/......'));

• módulos external_node:
  Estos módulos se encuentran en algún lugar entre el núcleo y los módulos basados en archivos. Los módulos external_node son bastante similares a los basados en archivos, especialmente cuando se exporta un módulo.

module.exports = function () {console.log('called node modules!');} 

Sin embargo, cuando se cargan módulos, se vuelven bastante diferentes.

var bar = require('bas');bas(); // 

Además, node.js proporciona algunos globales importantes con características útiles, que no discutiremos en detalle. timer,console, _filename y_dirname, y process son todos ejemplos de globales importantes en node.js. Por ejemplo, _filename y _dirname están disponibles en todos los archivos y dan acceso a la ruta completa y al directorio para el módulo actual.

Ahora que tenemos una breve comprensión de los módulos en node.js, vamos a pasar al aspecto principal, donde diferenciamos los módulos CommonJS y AMD. Abordaremos los problemas de «por qué Common.js es tan lento en la carga de módulos desde el navegador» y «cómo podemos convertirlo mediante browserify para que herede ciertas características de AMD y Require.js.» .

Presentando CommonJS y AMD

 CommonJS is a great module for the server side environment, especially when you have immediate access to the filesystem. However, using the same module system in the browser may be less reliable and extremely slow. 

Por ejemplo, consideremos cómo se cargan los dos módulos en el entorno del lado del servidor:

var foo = require('./foo');var bar = require('./bar');// more code here 

Viendo el ejemplo anterior, se considera una buena práctica en el lado del servidor cuando un módulo se carga mientras el otro módulo espera a que se analice otro módulo.

En otras palabras, cuando el módulo foo está siendo cargado, el bar no será analizado o procesado hasta que el foo sea cargado completamente. Incluso el servidor podría no ser consciente del módulo bar hasta que haya terminado con el módulo foo.

Usar el mismo sistema de módulos en el navegador no se considera una buena idea porque cada sistema de módulos necesitaría lanzar una petición HTTP al servidor. Esto es mucho menos eficiente y menos fiable en el entorno del servidor. Degrada la experiencia del usuario en el lado del cliente. Este problema podría resolverse mediante la carga asíncrona de módulos.

Aquí es donde entra AMD. AMD, también conocido como definición de módulo asíncrono, se introdujo para soportar la carga asíncrona de los módulos en el navegador –
al final resuelve la lentitud de carga de los módulos en el navegador. De acuerdo con el significado de «asíncrono», los módulos se activan en diferentes momentos.

Para exportar algo en un archivo en AMD, simplemente necesitamos incluir una función callback y devolverla desde una función callback de definición. Aquí hay un ejemplo:

 define(, function () { var foo = function () { console.log ('foo was called');}; return foo; // function foo is exported});

Al igual que la sintaxis de la variable de exportación en node.JS, la función define también toma un argumento especial llamado exportaciones, que es bastante similar a la de node.JS.

define(, function (exports) {var bas = exports.log = function () {console.log ('bas.log was called'); };});

Para que sea posible cargar dos módulos en el navegador, tenemos que descargar e instalar RequireJS. Tened en cuenta que esto es sólo una opción que impide a los desarrolladores utilizar el código de node.JS en el navegador.]

¿Por qué necesitamos RequireJS para poder cargar módulos a través de la definición asíncrona del módulo?
Aquí está la razón: porque la función Define, que forma parte del código de abajo (que nos muestra cómo podemos cargar más de un módulo en el navegador a través del AMD), no es nativa del navegador. Por lo tanto, la mejor opción es acceder a ella desde una librería de terceros. RequireJS es simplemente un archivo javascript que incluyes en tu proyecto.

define(, function(foo, bar){ //more code here// more code here }); 

Cómo convertir node.js en código para el navegador:

Ahora, vamos a ver cómo podemos convertir CommonJS para que sea compatible con AMD/RequireJS a través de browserify. La conversión de CommonJS a través de browserify permite a node.js cargar módulos en el navegador de forma similar a AMD/RequireJS.

Instalemos browserify a través del siguiente código. Por favor, asegúrese de que está conectado a Internet whilse instalación. La g con guión significa simplemente global.

npm install –g browserify

Puedes crear módulos, nombrarlos como clientJS o cualquier nombre que prefieras, y eventualmente convertirlos a AMD/RequireJS usando browserify.

module.exports = function () {console.log('bas was called');}

exports.log = function () {console.log('bar.log was called');}

Ahora, para convertir el código anterior para que sea compatible con AMD, es decir, para que cargue los módulos de forma asíncrona, tenemos que hacerlo a través de los siguientes argumentos en la línea de comandos:

browserify client.js -o amdmodule.js

Puedes asignar cualquier nombre que prefieras para ser el cliente. No siempre debe ser client.js pero también es preferible client.js. Recuerda que es sólo un archivo. Además, puedes consultar más configuración sobre browserify en http://browserify.org/.

Resumiendo:

Por último, debes tener en cuenta que no todos los módulos de node.JS se pueden convertir para que funcionen eficazmente en el navegador. Los que dependen de características que están disponibles en el lado del servidor no funcionarán en absoluto en el navegador.

Acabo de introducir AMD/RequireJS como una solución que permite la carga asíncrona de módulos en el navegador, lo que se considera una buena práctica. Cargar módulos de forma asíncrona es mucho más rápido y fiable que usar CommonJS en el navegador.