# Introducción a Node.js
Node.js es un entorno de ejecución de JavaScript del lado del servidor construido sobre el motor V8 de Chrome. Te permite ejecutar JavaScript fuera del navegador, lo que lo hace perfecto para construir aplicaciones web escalables, APIs REST y herramientas de línea de comandos.
## ¿Qué es Node.js?
Node.js fue creado por Ryan Dahl en 2009 para abordar las limitaciones de los servidores web tradicionales. Está construido sobre estos principios clave:
### Características Principales
1. **JavaScript en Todas Partes**: Usa JavaScript tanto para desarrollo frontend como backend
2. **Orientado a Eventos**: Usa un modelo de E/S impulsado por eventos que lo hace eficiente
3. **No Bloqueante**: Las operaciones asíncronas permiten alta concurrencia
4. **Un Solo Hilo**: Usa un modelo de evento de un solo hilo con bucle de eventos
5. **Rendimiento Rápido**: Motor V8 compila JavaScript directamente a código máquina
### ¿Por Qué Usar Node.js?
```typescript
// Ejemplo: Servidor HTTP simple
import http from 'http';
const server = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('¡Hola desde Node.js!');
});
server.listen(3000, () => {
console.log('Servidor ejecutándose en http://localhost:3000');
});
```
**Beneficios:**
- ⚡ **Rápido**: Operaciones de E/S no bloqueantes
- 📦 **NPM**: Ecosistema de paquetes más grande del mundo
- 🔄 **Tiempo Real**: Excelente para aplicaciones en tiempo real
- 🎯 **Stack Unificado**: Mismo lenguaje frontend y backend
- 🚀 **Escalable**: Construido para aplicaciones de red escalables
## Instalación
### Usando NVM (Recomendado)
Node Version Manager (NVM) te permite instalar y cambiar entre múltiples versiones de Node.js:
```bash
# Instalar NVM (macOS/Linux)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
# Instalar la última versión LTS
nvm install --lts
# Instalar una versión específica
nvm install 18.17.0
# Usar una versión específica
nvm use 18.17.0
# Ver versiones instaladas
nvm list
# Establecer versión por defecto
nvm alias default 18.17.0
```
### Instalación Directa
Descarga desde [nodejs.org](https://nodejs.org/):
- **LTS (Long Term Support)**: Para producción
- **Current**: Últimas características
```bash
# Verificar instalación
node --version
# v18.17.0
npm --version
# 9.6.7
```
## Tu Primer Programa Node.js
### Archivo: hello.js
```javascript
// Módulo simple
console.log('¡Hola, Node.js!');
// Usar módulos integrados
const os = require('os');
console.log('Plataforma:', os.platform());
console.log('Arquitectura:', os.arch());
console.log('Total de memoria:', os.totalmem() / 1024 / 1024 / 1024, 'GB');
```
**Ejecutar:**
```bash
node hello.js
```
### Programa Interactivo
```javascript
// interactive.js
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
rl.question('¿Cuál es tu nombre? ', (name) => {
console.log(`¡Hola, ${name}!`);
rl.close();
});
```
## Node.js vs JavaScript del Navegador
| Característica | Node.js | Navegador |
|---|---|---|
| **Entorno** | Servidor | Cliente |
| **Objetos Globales** | `global`, `process` | `window`, `document` |
| **Sistema de Módulos** | CommonJS, ES Modules | ES Modules |
| **Sistema de Archivos** | ✅ Acceso completo | ❌ Sin acceso |
| **APIs** | APIs del OS, red | DOM, APIs Web |
| **Caso de Uso** | Backend, herramientas | Frontend, UI |
### Ejemplo: Diferencias Clave
```javascript
// En el navegador:
console.log(window); // ✅ Funciona
console.log(document.getElementById('app')); // ✅ Funciona
const fs = require('fs'); // ❌ Error
// En Node.js:
console.log(global); // ✅ Funciona
console.log(process.cwd()); // ✅ Funciona
const fs = require('fs'); // ✅ Funciona
console.log(window); // ❌ Error: window no está definido
```
## Objetos Globales de Node.js
Node.js proporciona objetos globales que están disponibles en todos los módulos:
### process
Información y control sobre el proceso actual de Node.js:
```javascript
// Información del proceso
console.log('ID del Proceso:', process.pid);
console.log('Versión de Node:', process.version);
console.log('Plataforma:', process.platform);
console.log('Directorio Actual:', process.cwd());
console.log('Tiempo de Ejecución:', process.uptime(), 'segundos');
// Variables de Entorno
console.log('NODE_ENV:', process.env.NODE_ENV);
console.log('Puerto:', process.env.PORT || 3000);
// Argumentos de Línea de Comandos
console.log('Argumentos:', process.argv);
// node app.js arg1 arg2
// ['node', '/ruta/a/app.js', 'arg1', 'arg2']
// Salir del proceso
process.exit(0); // Éxito
process.exit(1); // Error
```
### __dirname y __filename
```javascript
// Rutas del módulo actual
console.log('Directorio:', __dirname);
// /Users/usuario/proyecto
console.log('Archivo:', __filename);
// /Users/usuario/proyecto/app.js
// Casos de uso
const path = require('path');
const configPath = path.join(__dirname, 'config.json');
```
### console
```javascript
// Métodos de registro
console.log('Información');
console.error('Error');
console.warn('Advertencia');
console.info('Info');
// Medición de rendimiento
console.time('operación');
// ... algún código
console.timeEnd('operación');
// operación: 123.456ms
// Registro de tabla
console.table([
{ nombre: 'Juan', edad: 30 },
{ nombre: 'María', edad: 25 }
]);
```
### Temporizadores
```javascript
// setTimeout - Ejecutar después de retraso
setTimeout(() => {
console.log('¡Ejecutado después de 2 segundos!');
}, 2000);
// setInterval - Ejecutar repetidamente
const interval = setInterval(() => {
console.log('Cada segundo');
}, 1000);
// Limpiar interval
setTimeout(() => {
clearInterval(interval);
}, 5000);
// setImmediate - Ejecutar después del ciclo de eventos actual
setImmediate(() => {
console.log('Inmediato');
});
```
## Tu Primera Aplicación
Vamos a crear una aplicación simple de línea de comandos:
### Archivo: calculator.js
```javascript
// Calculator CLI
const args = process.argv.slice(2);
if (args.length !== 3) {
console.error('Uso: node calculator.js ');
console.error('Ejemplo: node calculator.js 5 + 3');
process.exit(1);
}
const [num1, operator, num2] = args;
const a = parseFloat(num1);
const b = parseFloat(num2);
if (isNaN(a) || isNaN(b)) {
console.error('Por favor, proporciona números válidos');
process.exit(1);
}
let result;
switch (operator) {
case '+':
result = a + b;
break;
case '-':
result = a - b;
break;
case '*':
result = a * b;
break;
case '/':
if (b === 0) {
console.error('Error: División por cero');
process.exit(1);
}
result = a / b;
break;
default:
console.error('Operador no válido. Usa: +, -, *, /');
process.exit(1);
}
console.log(`${a} ${operator} ${b} = ${result}`);
```
**Usar:**
```bash
node calculator.js 10 + 5
# 10 + 5 = 15
node calculator.js 20 / 4
# 20 / 4 = 5
```
## Próximos Pasos
Ahora que entiendes los fundamentos de Node.js, puedes explorar:
1. **Sistema de Módulos**: CommonJS y ES Modules
2. **NPM**: Gestión de paquetes y dependencias
3. **Sistema de Archivos**: Leer y escribir archivos
4. **Servidor HTTP**: Construir servidores web
5. **Programación Asíncrona**: Callbacks, Promises, Async/Await
## Recursos
- [Documentación Oficial de Node.js](https://nodejs.org/docs)
- [Guía de Node.js](https://nodejs.dev/learn)
- [NPM Documentación](https://docs.npmjs.com/)
¡Comienza a construir con Node.js hoy! 🚀
Lección 1 de 6
5 min de lectura
Node.js
Introducción a Node.js
Aprende los fundamentos de Node.js y cómo empezar