<aside> ❓ Preguntas

</aside>

Qué es un módulo?
Cómo crear módulos?
Tipos de módulos
Qué son los Módulos Built-in?
Módulo console
Módulo process
Módulo os
Módulo Timers
Módulo fs
Los métodos del módulo fs son síncronos?
Primero las tareas síncronas o asíncronas?
El setInmediate() se ejecuta de inmediato?
Qué es el Higher Order Programming

<aside> 📓 Notas

</aside>

Módulos

Un módulo es una funcionalidad organizada en uno o varios archivos JavaScript que puede ser reutilizada en una aplicación. Permite compartir código entre 2 o más archivos JavaScript.

Ventajas

Evitar repetición de código
Reutilizar código
Es más fácil encontrar y corregir “bugs”
Es más fácil modificar el código
Es más fácil agregar nuevas funcionalidades

Untitled

¿Cómo crearlos?

Para tener acceso a los elementos definidos en otro módulo debemos exportarlo desde el archivo de origen e importarlo a mi archivo actual. Exportando una vez, podemos importarlo cuantas veces querramos.

//saludos.js
function saludar(nombre) {
	return `Hola ${nombre}`
}

module.exports.saludo = saludar

//app.js
const saludo = require('./saludos.js')

console.log(saludo("freeCodeCamp"))

CommonJS vs ES Modules

NodeJS soporta por defecto el formato de módulos llamado CommonJS que necesita la función require( ) para importar elementos y module.exportspara exportarlos. Por otro lado, en el browser la ejecución de los módulos se da con el formato ECMAScript Modules, este formato es el estandar oficial para escribir JavaScript en la mayoría de browsers. Para conocer mejor sobre cuál es mejor en qué casos, podemos revisarlo aquí.

Exportando varios elementos

//saludos.js
function saludar(str) {
	return `Hola ${str}`
}

function despedir(str) {
	return `¡Vuelve pronto, ${str}!`
}

module.exports = {
	saludo: saludar,
	despdedida: despedir
}

//app.js
const { saludo, despedida } = require('./saludos.js')

console.log(saludo("Alex"))
//"Hola Alex"

console.log(despedida("te esperamos"))
//"¡Vuelve pronto, te esperamos!"

Módulos built-in / Core Modules

Módulos que puedes usar directamente al trabajar con Node.js, no necesitan instalación. Los más comunes son:

http
https
fs
os
path

Módulo console

Provee una manera consola simple para debuguear que es similar al mecanismo que usan los browsers con JavaScript.

Este módulo ejecuta las funciones .log(), .warn(), .error(), .assert() y .table().

<aside> 👁️‍🗨️ Dentro de los paréntesis podemos crear un new Error() para manejar errores

</aside>

Módulo process

Provee información sobre el proceso de NodeJS que se ejecuta, también puede tener cierto control sobre el proceso.

process.env

Nos da información específica del environment en el que se está ejecutando mi aplicación.

process.argv

Recibe los argumentos que mandamos desde la terminal.

> node app.js hola 45

NodeJS interpreta esto como un array de elementos ordenados, podemos ingresar a cada uno de los argumentos si los llamamos a partir del índice 2.

console.log(process.argv[2]) = 'hola'

Módulo os

Nos permite obtener información sobre el sistema operativo donde se ejecuta nuestra app. Este módulo no está disponible de forma global por lo que tenemos que importarlo usando require('os').

const os = require('os')

os.type() //Output: Windows_NT
os.homedir() //Output: Directorio principal C:\\Users\\Dario
os.uptime() //Tiempo que se lleva ejecutando el OS
os.userInfo() //Información sobre el usuario

Módulo Timers

Funciones que ejecutan un código luego de un cierto periodo de tiempo. Es una manera de crear procesos asíncronos.

setTimeOut()

Sirve para ejecutar un código luego de un número específico de milisegundos.setTimeOut(funcion, retraso, argumento1, argumento2);

function mostrarTema(tema) {
	console.log(`Estoy aprendiendo &{tema}`)
}
// Espera 5 segundos
setTimeOut(mostrarTema, 1000, 'Node.js')

// mostrarTema('Node.js')

<aside> 👁️‍🗨️ Higher-Order Programming: Pasar una función como argumento de otra.

</aside>

setImmediate()

Ejecuta código asíncrono en la próxima iteración del ciclo de enventos (lo más pronto posible), es decir, se ejecuta después del código síncrono. setImmediate(funcion, argumento1, argumento2);

function mostrarTema(tema) {
	console.log(`Estoy aprendiendo ${tema}`)
}
setTimeOut(console.log('mensaje escrito antes del setImmediate'), 1000) //Segunda ejecución asíncrona
setImmediate(mostrarTema, 'Node.js') //Primera ejecución asíncrona
console.log('Primera ejecución') //Primera ejecución síncrona

setInterval()

Se usa para ejecutar código un número infinito de veces con un retraso específico de milisegundos. setInterval(funcion, intervalo, arg1, arg2);

function mostrarTema(tema) {
	console.log(`Estoy aprendiendo ${tema}`)
}

setInterval(mostrarTema, 1500, 'Node.js')

Módulo fs

Módulo que contiene funcionalidad muy útil para trabajar con el sistema de archivos. Podremos leer, modificar contenido, copiar, eliminar y cambiar el nombre de los archivos.

Async Mode: Todos los métodos de este módulo son asíncronos por defecto, no bloquean la ejecución del programa mientras se ejecutan. fs.rename()

Sync Mode: Se puede escoger versiones síncronas agregando Sync a sus nombres. fs.renameSync()

<!--Archivo original index.html-->
<!DOCTYPE html>
<html lang='es'>
	<head>
		<title>Node.js</title>
	</head>
	<body>
		<h1>freeCodeCamp</h1>
		<p> Estoy aprendiendo Node.js</p>
	</body>
</html>

// 2. Cambiar nombre del archivo
const fs = require('fs')

fs.rename('index.html', 'main.html', (err) => {
	if (err) {
		throw err
	}
	console.log('Nombre actualizado')
});

// 4. Reemplazar todo el contenido del archivo
const fs = require('fs')

fs.writeFile('index.html', 'Contenido Nuevo', (err) => {
	if (err) {
		throw err
	}
	console.log('Contenido reemplazado')
});

// 1. Leer archivo
const fs = require('fs')

fs.readFile('./index.html', 'utf-8', (err, contenido) => {
	if (err) {
		throw err
	} else {
		console.log(contenido)
	}
});

// 3. Agregar contenido al final del archivo
const fs = require('fs')

fs.appendFile('index.html', '<p>Hola</p>', (err) => {
	if (err) {
		throw err
	}
	console.log('Contenido agregado')
});

// 5. Eliminar archivo 
const fs = require('fs')

fs.unlink('index.html', (err) => {
	if (err) {
		throw err
	}
	console.log('Archivo eliminado exitosamente')
});

<aside> 🚨 Si queremos que sea síncrono tenemos que agregar Sync al final

</aside>

<aside> 💭 Resumen

</aside>

Los módulos son súmamente importantes en NodeJS porque nos permiten reutilizar funcionalidades en varias partes de nuestra aplicación, también nos sirve para encontrar y corregir bugs de manera eficiente. Hay dos maneras de usar los módulos que son con CommonJS (nativo en NodeJS) y ECMAScript Modules (nativo en browsers).

NodeJS nos brinda algunos módulos nativos como el console, process, Timers, os, fs, http, y muchos más. Estos módulos nos dan acceso al sistema operativo donde podremos crear, modificar y elminar archivos ó conocer el entorno de ejecución. Aquí es donde entra un nuevo concepto que son los eventos asíncronos, eventos que siempre se ejecutarán después de los síncronos.