Construyendo módulos: Require e Import

En Node tenemos una forma de importar módulos la cual es con el método require, el cual es la forma por defecto de importar módulos, ya sean nuestros propios módulos como los de otras personas en nuestros proyectos JS, pero suele haber mucha confusión debido al import.
Import es la forma de importar módulos en Ecmascript, el cual es un estándar de JavaScript para la web, esta forma de importar en teoría Node no la acepta oficialmente, a no ser que usemos su modo de .mjs.
Pero gracias a compiladores como Babel, nosotros podremos utilizar estas normas de Ecmascript en nuestro código para cuando se ejecute se transforme en código que sea aceptable por Node.
Se recomienda en la mayoría de veces la importación con require.

en el presente ya no es experimental me funciona bien

También podemos usar el operador de reposo para importar los modulos

// Traer modulo
const { saludar, prop } = require('./modulo');
// Ejecutar una función del modulo
saludar();
console.log(prop);

Para los que llegan a este curso a mediados de 2021 o más recientemente, los imports y exports en estándar ES6 ya están 100% soportados. A continuación les comparto un ejemplo realizado de ambos modos.
FORMATO REQUIREJS:
File: myOwnModule.js

function sayHello() {
    console.log('Hello from inside a function of myOwnModule.js');
}

const property1 = 'Property 1 String value';
const property2 = 2;

module.exports = {sayHello, property1, property2}
};

File: index.js

const myOwnModule = require('./myOwnModule');

console.log(myOwnModule.property1);
console.log('Property 2 value (number): ', myOwnModule.property2);
myOwnModule.sayHello();

FORMATO ECMASCRIPT 6:
File: myOwnES6Module.mjs

function sayHello() {
    console.log('Hello from inside a function of myOwnES6Module.mjs');
}

const property1 = 'Property 1 String value';
const property2 = 2;

export default {sayHello,property1,property2};

File: index.mjs

import myOwnES6Module from './myOwnES6ModuleES6.mjs';

console.log(myOwnES6Module.property1);
console.log('Property 2 value (number): ', myOwnES6Module.property2);
myOwnES6Module.sayHello();

También se podría utilizar el operador de desestructuración para obtener las funciones y propiedades del módulo importado directamente en variables independientes, por ejemplo utiizando el primer ejemplo:

const { sayHello, property1, property 2 } = require('./myOwnModule.js');

Espero les sirva el aporte. Happy Coding!

Construyendo módulos: Require e Import

Pueden trabajarse los módulos así:

// Traer nuestro modulo
const modulo = require('./modulo')

// Ejecutar una función del modulo
console.log(modulo)
modulo.saludar()
// modulo()

function saludar() {
    console.log(`Hola mundo!`)
}

module.exports = {
    saludar,
    prop1: 'hola k lo k es'
}

🔥 El import de ES+6 todavía no viene incluido en Node.js, solo viene de forma experimental, en 2021 ya este no es experimental

import modulo from './modulo.mjs'

modulo()

function saludar() {
    console.log(`Hola mundo!`)
}

export default saludar

Modulos

Para importar modulos propios o de terceros, debemos utilizar el require o import (import se considera experimental en versiones antiguas de node)

// Modulo

function suma(a, b) { return a + b};
function saludar(nombre) { return `Hola ${nombre}`}
const PI = 3.14159264

module.exports = { suma, saludar, PI }

//Importación

const { suma, saludar, PI } = require(...path_module)
suma(3,2)
saludar('Jesuskinto')
console.log(`Pi es un constante y su valor es: ${PI}`)

Node ya soporta los módulos de la sintáxis ES6 solo hay que agregar esta linea en el package.json
"type": “module”,
quedaria algo asi el archivo

  "name": "fundamentosnodejs",
  "version": "1.0.0",
  "description": "una descripción",
  "main": "index.js",
  "type": "module",

y con esto ya se podrá trabajar con los archivos en extencion .js en lugar de .mjs

Node ya soporta los módulos de la sintáxis ES6+ y pueden correr node index.mjs sin problemas ni warnings

Con ES6 también puedes hacerlo de la siguiente forma.

export const bye = () => {
  console.log("Soy BYE y me fui de aqui");
};

import { bye } from "./modulo.mjs";
bye();

Lo de construir módulos (y su sintaxis para llamarlos y exportarlos) me está recordando mucho como funciona React para el front. Se nota muchísimo que se basan en los mismos conceptos de JavaScript internos… me queda mucho más claro por qué en las clases del principio decían que NodeJS es un entorno de JavaScript!

Good News Devs, NodeJS a dia de hoy ya soporta los module.exports, pueden verlo aqui: Click Aqui
Tambien soportan los imports: Click Aqui

require se utiliza para consumir módulos. Nos permite incluir módulos integrados de Node.js, externos (como los importados de npm) y módulos locales.

const express = require('express');

export nos permite “exportar” sus objetos y métodos en modulos que pueden ser utilizados a lo largo de nuestro proyecto.

Cuando requerimos un modulo utilizando ./ indica que es un modulo que se encuentra local.

// modulo.js
// vamos a declarar las funciones que vamos a exportar en el modulo.
exports.por5 = numero => numero * 5;
exports.por10 = numero => numero * 10;

// multiplicador.js
// Importamos el modulo.js y llamamos las funciones
const multiplicador = require('./modulo.js');

const numero = 10;
console.log(multiplicador.por5(numero)); //  50
console.log(multiplicador.por10(numero)); // 100

A día de hoy, 17 de Septiembre de 2021.

Añadir en el fichero package.json, "type": "module"

package.json

{
    "name": "funda-node",
    "version": "1.0.0",
    "description": "Cursos de Fundamentos de Node.js",
    "main": "src/index.js",
    "type": "module",
    "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1"
    },
    ....
    "author": "Javi Felices @javifelices,
    "license": "MIT",
	...
}

modulo.js

const saludar = () => console.log('Hola mundo');

export default {
    saludar,
    prop1: 'Hola que tal',
};

index.js

import modulo from './modulo.js';

console.log(modulo.prop1);

modulo.saludar();

Un saludo y gracias.

Las versiones actuales ya permiten la importación de módulos al estilo “ES6”!!!

En la última versión de nodejs ya no es válido la forma en como el profesor está enseñando.

Para más información:
https://nodejs.org/dist/latest-v12.x/docs/api/modules.html#modules_module_exports

Los comandos de ES6 ya funcionan muy bien en este tiempo

En las nuevas versiones de node ya lo puedes utilizar directamente con node index.js

Modulos
_____________-

-------------------------------------------------------------------------------------------------------------------------_______________

Al 2021 ya se puede correr el modulo sin –experimental-modules

¿es necesario usar webpack o babel en NodeJS?

Trabajando en WSL, con ubuntu, me ha dado error en la parte de importar modulo diferente al del profesor.
Mi versión de node era la 10, en lugar de la 14. Actualicé usando el comando: ++sudo n stable ++

y ya con la versión 14 me funcionó bien la clase.

Interesante de manera informativa esta bien saber lo que estan experimentacion.

function saludar() {
    console.log('Hola mundo mundial!!!');
};

export default {
    saludar,
    propiedad1: 'Soy un modulo experimental'
};

import modulo from './modulo.mjs';

console.log(modulo.propiedad1);
modulo.saludar();

My code!!!

module.js

function saludar() { 
    return "Hola desde una función!";
}

module.exports = {
    saludar,
    prop1: 'Propiedad 1'
}```

index.js

//traer modulo
const modulo = require(’./modulo’);

//ejecutar modulo
console.log(modulo.prop1);
console.log(modulo.saludar());```

module.exports o export default
Al referirnos a estos conceptos, suele englobar en ES6. Sin embargo, desde el server-side o backend, nos referimos a su traducción de código, por Babel, como commonJS.
Cuando exportamos elementos, en ES6, nos encontramos en el contexto de los named exports donde, como palabra reservada, tenemos default.
En esencia, Babel responde con su “transpilación”:

// input
export const foo = 42;
export default 21;

// output
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var foo = exports.foo = 42;
exports.default = 21;

Donde las “propiedades” son anexadas a export . (Cabe mencionar que foo , un placeholder de un valor que puede cambiar dependiendo de las condiciones o la información en sí).

import from vs const require

Tal cual en capas, son similares de hecho:

Sin embargo, cabe aclarar que poseen notables diferencias:

1. Para require, no puedes cargar piezas de la petición, donde para import se pueden hacerlo.
2. Para require, la carga es synchronous, donde para import puede ser asynchronous mejorando un poco el rendimiento que su contra parte.

también pueden exportar directamente la función e importarla de forma nombrada. O con el nombre literal que tiene la función

export function saludar() {
  console.log('Hola mundo')
}

y así lo importan

import { saludar } from './modulo.mjs'

saludar()

Para la Version:
% node --version
v16.0.0
Se puede realizar para el modulo.mjs

//Modulo
const saludar = () => {
  console.log("Hola mundo");
};

export { saludar };

Y para el index.mjs

import { saludar } from "./modulo.mjs";

console.log(saludar);
saludar();

El día de hoy con node v14.16.0 funciona correctamente parece que la opción de import ya no es experimental

Apenas se publico un nuevo curso sobre ECMASCRIPT 6+ se encuentra en la carrera de javaScript

El soporte para import/export modules viene ya a partir de la version 14.10 de Node

Por fin después de meses comprendo como funcionan los export, los cuales usaba, pero no comprendía muy bien

¿Qué es transpilar?

Si van al shell y hacen: node --help van a poder observar una lista bastante amplia de modos experimentales, en version actual de node(v12.18.4) salen:

  --experimental-import-meta-resolve
                              experimental ES Module
                              import.meta.resolve() support
  --experimental-json-modules experimental JSON interop support for
                              the ES Module loader
  --loader, --experimental-loader=...
                              use the specified module as a custom
                              loader
  --experimental-policy=...   use the specified file as a security
                              policy
  --experimental-repl-await   experimental await keyword support in
                              REPL
  --experimental-specifier-resolution=...
                              Select extension resolution algorithm
                              for es modules; either 'explicit'
                              (default) or 'node'
  --experimental-vm-modules   experimental ES Module support in vm
                              module
  --experimental-wasi-unstable-preview1
                              experimental WASI support
  --experimental-wasm-modules experimental ES Module support for

Eso de import y export default se usa un monton de VueJS, ahora entiendo porque, en VueJS sirve para importar/exportar componentes, pero en realidad lo que se hace es exportar un modulo 😮

Módulos

Para exportar módulos en node.js hay dos formas:

1. El método “default”, haciendo uso de require (recomendada):

modulo.js:

//la función a exportar
function saludar(){
    console.log('Hola como andas');
}

//exportación
module.exports = saludar;

index.js:

//Traer nuestro modulo
const modulo = require('./modulo');

//ejecutar la función exportada
modulo();

1. Método con ES6, la cual es experimental_:

Se ejecuta en consola con:

node --experimental-modules index.mjs js

modulo.mjs:

// exportación
export function saludar(){
    console.log('Hola como andas');
}

index.mjs:

// importacion
import {saludar} from './modulo.mjs';

// ejecución de la función exportada
saludar()

Construyendo módulos: Require e Import

Cuando tengamos un proyecto robusto es posible que tengamos que trabajar con módulos creados por nosotros mismos.

Cuando hablamos de construir módulos es de modularizar nuestro código mediante el siguiente ejemplo:

Tenemos un archivo que al ser llamado puede saludarnos según la hora del día.

// El arachivo se llama 'modulo-requerido.js'
function saludar(nombre) {
  console.log(`Hola ${nombre}`);
  
  function despedida() {
    setTimeout(() => {
      console.log(`Chao ${nombre}`)
    }, 1000);
  }
  return despedida();
}

module.exports = {
  saludar,
  dia: 'Buenos Días',
  tarde: 'Buenas Tardes',
  noche: 'Buenas Noches',
};

Podemos requerir este archivo de la siguiente manera:

//traer modulo
const modulo = require('./modulo-requerido');
//ejecutar una funcion del modulo
modulo.saludar('Manuel');
console.log(modulo.dia);
console.log(modulo.tarde);
console.log(modulo.noche);

Para ECMAScript 6 la forma de exportar y requerir módulos ha cambiado pero es una forma experimental, quiere decir que para node aun no es nativo y requiere de una condiciones especiales para su ejecución:

archivo del modulo y el archivo donde se ejecuta el modulo deben tener extensión .mjs

// El archivo se llama 'modulo-requerido.mjs'
function saludar(nombre) {
  console.log(`Hola ${nombre}`);

  function despedida() {
    setTimeout(() => {
      console.log(`Chao ${nombre}`);
    }, 1000);
  }
  return despedida();
}
export default {
  saludar,
  dia: "Buenos Días",
  tarde: "Buenas Tardes",
  noche: "Buenas Noches",
};

index.mjs es donde se importa el modulo anterior

//AHORA segun ECMAScript 6
import modulo from './modulo-requerido.mjs'
//ejecutar una funcion del modulo
modulo.saludar('Manuel');
console.log(modulo.dia);
console.log(modulo.tarde);
console.log(modulo.noche);

Para exportar un módulo:

function myModulo(){
	//haz algo
}
module.exports = myModulo

Crear módulos facilita la tarea de segmentar codigo. Permite crear código que corresponda a areas específicas.

Pues yo intente el node index.mjs y si corrió, al parecer ya esta soportado.

Estoy utilizando Node v13.14.0 y no es necesario pasar ningún parámetro a la hora de correr el archivo index.mjs

A fecha de hoy con la versión LTS Node 16, los mjs ya son soportados sin ser experimental ✌

Me encanto esta clase, de verdad estaba un poco confundido con en esto es6 y la anterior forma de importar módulos, adicional a ellos no tenia idea que en nodejs no se podía usar tal cual como se hace con ES6.

Hoy en dia los ES modules se pueden configurar en el package.json.
Se suele ubicar justo abajo de name:

"type": "module",

si mal no recuerdo…

Recuerden que se puede usar la desestructuración de objetos, para llamar una función específica, o ambas con diferentes nombres:

const { saludar, nombre } = require('./modulo');

En la última version de Node. No se necesita de “–experimental-modules” para correr. Con ES6 , solo es necesario crear el módulo con la extensió .mjs

mymodulo.js

index.mjs

Hoy en día todo esto no es experimental.
Aún así se puede comprobar todo en la documentación, en la versión 17.x es este enlace:
https://nodejs.org/dist/latest-v17.x/docs/api/esm.html

Que excelente clase

De acuerdo a la documentación, si se utiliza ES para los módulos, no se tendrá acceso a las variables __dirname y __pathname.

Fuente: Documentación de NodeJS

Construyendo módulos: Require e Import

Cómo trabajar con módulos propios

Lo primero que se debe hacer es crear un archivo en el que va a estar el módulo. Y dentro de este se debe poner la función que va a ejecutar:

const saludar = () => {
  console.log('Hello World')
}

Además, se debe exportar para que pueda ser utilizado en distintos lugares de mi proyecto:

const saludar = () => {
  console.log('Hello World')
}

module.exports = saludar

module es el nombre del archivo en este caso

Si quiero tener ese módulo en un archivo de mi proyecto, debo “importarlo” de la siguiente forma:

// Traer el módulo
const ext_module = require('./module')

Y para utilizarlo:

// Ejecutar función del módulo
ext_module()

/* 
	output:
	Hello World
*/

También se pueden exportar estructuras de datos más robustas, como un objeto:

const saludar = () => {
  console.log('Hello World')
}

module.exports = {
  saludar,
  saludar_esp: 'Hola Mundo en Español',
}

En este caso estamos exportando un objeto que llama a la función saludar y tiene una propiedad llamada saludar_esp , ahora para utilizar esto en el archivo que estamos importando el módulo debemos hacer lo siguiente:

const ext_module = require('./module')

// Ejecutar función del módulo
ext_module.saludar()
console.log(ext_module.saludar_esp)

Estamos utilizando sintaxis de programación orientada a objetos, porque lo que se exporta es un objeto.

Importar y exportar módulos con ES6

Para utilizar la notación de ES6 es necesario utilizar la extensión de archivo .mjs , así Node.js va a reconocer que se esta utilizando esta sintaxis. Para exportar un módulo se debe hacer de la siguiente forma:

//module.mjs
const saludar = () => {
  console.log('Hello World')
}

export default saludar

La palabra clave es export default para hacer el exporte de la función saludar .

Y para importar este módulo en otro archivo del proyecto, se debe hacer lo siguiente:

//index.mjs

import ext_module from './module.mjs'

ext_module()

las palabras clave en este caso van a ser import y from para nombrar el módulo dentro del archivo y para especificar la ruta del mismo. De igual forma que la otra sintaxis de importación y exportación de módulos, también se puede exportar tipos de datos más robustos como objetos.

// module.mjs
const saludar = () => {
  console.log('Hello World')
}

export default {
  saludar,
  property1: 'Esta es otra propiedad del objeto',
}

Aquí se está exportando un objeto que contiene la función saludar y una propiedad.

//index.mjs
import ext_package from './module.mjs'

ext_package.saludar()
console.log(ext_package.property1)

Se hace el importe del módulo.

Otra forma de importar un módulo que solo exporta una función es la siguiente:

const saludar = () => {
  console.log('Hello World')
}

export { saludar }

En este caso se exporta como un objeto des-estructurado

import { saludar } from './module.mjs'

saludar()

De esta forma no es necesario nombrar el módulo en el archivo que se va a importar porque esta funcionando como un objeto des-estructurado.

Tengo la sensación de que debo actualizar vscode

La forma nativa para exportar módulos en node es con Require()

Para acceder a un modulo custom lo podemos hacer desde su ruta:

const moduloCustom = require("./ruta/modulo")

Sobre el tema de los módulos ES6 comparto un artículo interesante de Manz.

[Módulos ECMAScript (https://lenguajejs.com/javascript/caracteristicas/modulos-es6/)

Un saludo.

require(“nombre_modulo”): para node js

import from: para ecma script 6

IMPORTANTE
Utiliza la forma de require js hasta que los experimental sean oficiales. Si usas los experimntlaes trasnpilarlos con babel o webpack!

me siento del futuro, porque en el curso de react trabajamos exportando e importando de está manera, y aparte si me dejó correr lo experimental xDD

module.exports = saludar();

Exporta la función directamente al index, Solo basta con requerir el module.js, no requiere llamarla.

Parece ser que actualmente Node ya soporta módulos ES6.
Aquí la documentación de esto.
https://nodejs.org/api/esm.html#esm_modules_ecmascript_modules

¿Cuál sería la diferencia entre usar require e import?

Acaba de salir la versión 14 inestable de node y el feature de import ya no es experimental

Perfecto!

Para aprender de ECMAScript: https://platzi.com/clases/ecmascript-6/

Y como dijo el profesor para utilizar algunas de esas funcionalidades se necesita usar herramientas como Webpack (Curso en la sección de enlaces) o Babel (Vídeo ejemplo: https://www.youtube.com/watch?v=FZBbX9f6b78&ab_channel=Fazt)

Es mejor ahorrarnos problemas con los módulos de Es6 y utilizar los módulos de Node… El fin es el mismo

Jeje ahora veo la magia de Babel

Excelente clase

export module

Tengo una duda respecto a cómo es la arquitectura de una aplicación web completa. Es así?
Cliente(website) -> Api -> Servidor -> Base de Datos

a la fecha de hoy, el import de es6 funciona . todavia el archivo tien eque ser ,mjs

import modulo from './modulo.mjs'

console.log(modulo.prop1)

modulo.saludar();