Node.js õpetus põhiprintsiipide kohta: de cero a tu primera app

Esileht » Python » Node.js õpetus põhiprintsiipide kohta: de cero a tu primera app

Si es tu primera toma de contacto con Node.js, aquí tienes una guía pensada para empezar con buen pie: iremos de lo más básico a un flujo de trabajo real, con ejemplos prácticos y explicaciones claras. Te acompañaré desde el mítico Hola Mundo hasta levantar una app web con Express, passando por modulos del system, npm y el enfoque asíncrono que hace tan especial al ecosistema de Node.

Orientatsiooni además requisitos previos, configuración et Visual Studio Code y primeros proyectos, verás cómo organzar un servidor HTTP, enrutar peticiones, manejar controladores, trabajar con datos POST sin bloquear el hilo y entender la filosofía event-driven. Todo con un lenguaje cercano, sin rodeos, y con el toque necesario para que no te pierdas.

Requisitos previos y qué esperar de Node.js

Vajalik JavaScripti põhiteadmised (tipos, muutujad, funciones, objetos) y ganas de probar cosas con la consola. Node.js es un entorno de ejecución de JavaScript fuera del navegador, basado en V8, con una libreria estándar potente y un modelo de ejecución dirigido por eventos y no bloqueante. Esto le lubae gestionar muchas conexiones concurrentes sin crear un hilo por cada petición.

Con Node saab ehitada servidores web, APIs REST, herramientas de línea de comandos, apps en tiempo real (vestlus, teavitused), integraciones con bases de datos y hasta proyectos IoT. Su fortaleza está en el manejo de E/S concurrente, lo que lo hace ideaal para trafico alto y experiencias interactiveas.

Laadige alla ja installige

Laadige alla Node.js ametlikult veebist et nodejs.org ja installitud süsteemi operatiivsüsteem. Et Windows, macOS või Linux on installitud ja adecuados. Tras la instalación, checka en terminal con: node -v y npm -v. npm es el gestor de paquetes de Node y te permitirá instalar librerías de terceros de forma sencilla.

Primer kontakt: Hola Mundo koos VS Code'iga

Si usa Visual Studio kood, puedes abrir la carpeta del proyecto y lanzar el terminal integrado con total comodidad. Crea una carpeta de trabajo y entra en ella: mkdir HelloNode && cd HelloNode.

Ahora abre esa carpeta et VS Code con kood .. Loo fail nimega app.js e tutvustada algo sencillo para arrancar: lohutuse sõnum.

var msg = 'Hello World';
console.log(msg);

Para ejecutarlo, abre la terminal integrada et VS Code (Ver > Terminal, o atajo Ctrl+`), y lanza node app.js. Verás el clásico väljund “Tere maailm” en la consola; sí, sencillo, pero kinnitada que todo va bien.

De cero on servidor: minimaalne HTTP-server

Node trae un modulo nativo llamado 'http' con el que puedes crear un servidor en pocas líneas. El corazón es http.createServer, que recibe una función callback que se ejecuta cada vez que llega una petición.

var http = require('http');

http.createServer(function (request, response) {
  response.writeHead(200, {'Content-Type': 'text/html'});
  response.write('Hola Mundo');
  response.end();
}).listen(8888);

Arráncalo con node server.js ja külastada http://localhost:8888/. La magia de Node está en su modelo orientado ja eventos: pasas una función y el runtime la “lama de vuelta” (tagasihelistamine) cuando sucede el evento (una petición entrante).

Entendiendo tagasihelistamised, asincronía y flujo de ejecución

Et JavaScript las funciones son ciudadanos de primera: se pueden pasar como argumentos, devolver y almacenar en muutujad. Este patrón encaja con el bucle de eventos de Node: tu código registra funciones que se ejecutan cuando ocurren sucesos (por ejemplo, llega una petición HTTP).

On oluline mõista erinevust operaciones bloqueantes y no bloqueantes. Si tutvustab algo que ocupa la CPU durante segundos (por ejemplo, un bucle de espera), el proceso entero se detiene y todas las peticiones sufren. En Node, trabaja siempre que puedas con E/S asíncrona y tagasihelistamised o promesas para evitar bloquear el hilo.

Diseño modulaarne: servidor, ruuter ja manejadores

Eraldi vastutusalad te ayudará a escalar el proyecto: un modulo para el servidor HTTP, otro para el enrutador y otros para los controladores (päringute töötlejad). Puedes exponer funciones con exports y requerir modulos locales con require('./miModulo').

Una estructura típica podría ser: index.js nagu sissepääsupunkt, server.js HTTP-serveriga, ruuter.js para decidir a qué función mandar cada ruta y requestHandlers.js con la lógica de cada lõpp-punkti. Esta organización mantiene el código readible y fácil de probar.

Extrayendo la ruta y enrutando

Taotlege URL-i taotlustNatiivne moodul url lubada lisateavet teekonnanimi y, si hace falta, la päring. Con eso, el router podrá decidir qué controlador ejecutar.

var url = require('url');

function onRequest(request, response) {
  var pathname = url.parse(request.url).pathname;
  // route(pathname) ...
}

Ruuter võtab vastu elektri funktsioonide marsruutide kaart (un objeto donde cada clave es una ruta, y el valor, el handler), junto con el pathname, y comprueba si hay una función asociada. Si eksisteerib, la ejecuta; ei, devuelve un 404.

Haciendo que el handler responsea (el patrón correcto)

Harjumuspärane tentación es hacer que el controlador retorne un string y que el servidor lo escriba. Pero esto falla cuando el handler necesita hacer algo asíncrono (como leer de disco o ejecutar un comando). La solución efectiva es Objekti vastuse süstimine hasta el handler y que el propio handler escriba la respuesta cuando la tenga (por ejemplo, dentro del callback de una función asíncrona).

// router.js
function route(handle, pathname, response) {
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response);
  } else {
    response.writeHead(404, {'Content-Type': 'text/html'});
    response.write('404 No Encontrado');
    response.end();
  }
}

See lähenemisviis võimaldab vastaja justo cuando la E/S asíncrona concluye, sin bloquear el procesori ni forzar a devolver datos antes de tiempo.

Express: looge rakendus veebis ja minutis

Express on minimalistlik raamistik Node.js jaoks mis hõlbustab geessionaalseid ruute, vaateid, vahevara ja HTTP kasutamist. Con su generador puedes crear la estructura de un proyecto en segundos, con carpetas para rutas, vistas y recursos estáticos.

1. Looge oma projektide jaoks kaust: mkdir ExpressProjects && cd ExpressProjects.
2. Perekond una plantilla: npx express-generator HelloWorld --view=pug loo rakendus Mopsi mootoritele.
3. Ava VS-koodis koos code . ja struktuuri muutmine: konteiner (arranque) avalik (JS/CSS/pildid), liinidel (marsruudijuhid), vaated (plantillad) app.js (konfiguratsioon), pakett.json (skriptid ja sõltuvused).
4. Sõltuvuste installimine koos npm install projekti vaibal.
5. Käivitage rakendus. Por eemplo, con depuración: npx cross-env DEBUG=HelloWorld:* npm start.
6. Avatud http://localhost:3000. Prueba a cambiar la vista prints: In views/index.pug, asendab pealkirja h1 "Hello World!" ja laadige uuesti.

Express incorpora lo necesario para käsklus GET, POST, PUT ja DELETE, usar vahevara, estáticos, renderizar vistas y estructurar una app de varias páginas con menos fricción.

npm y modulos incorporados de Node

npm es el gestor de paquetes de Node y te lubae install libreriaas de terceros. Näiteks Expressi jaoks: npm install expressPärast . require('express') y utilizarlo en tu código. Esta flexibilidad es clave para crecer con tu proyecto.

Además, Node include natiivsed moodulid omavalitsusüksuste jaoks: fs (arhiivid), http/https (teenijad), path (rutas) os (süsteemi andmed), url (URL-i sõelumine) y muchos más. Puedes importarlos con require() midagi installimata.

Probando un modulo nativo: información del system

El modulo 'os' ofrece datos del sistema operativo. Abre la consola y entra en el REPL de Node con node para probar funciones rápidamente sin crear archivos.

1. kirjutama os.platform() para saber la plataforma (win32, linux, darwin…). Kinnitas SO aktiivsuse otse.
2. koos os.arch() obtendrás la arquitectura (x64, arm64…). Binaarsete või ehitiste jaoks.
3. USA os.cpus() para ver los núcleos disponibles. Ideaalne tasakaalustatud koormuse jaoks con clusteres o procesos hijos.
4. Sal del REPL con .exit või vajutage kaks korda Ctrl+C. Kiire ja ilma jääkideta.

Biblioteca de terceros útil en el día a día

Ökosüsteem npm on tohutu. Algunas utilidades populares: terav (tratamiento de imágenes y compresión), PDFKit (PDF-i põlvkond), validator.js (kateenade valideerimine), imagemin y UglifyJS (vähendamine) спрайтем (spraidid), Winston (metsaraie) y komandör.js (CLI). Paigaldamine koos npm install <paquete> kui sa neid vajad.

Cómo ejecutar código Node.js desde archivo

Guarda tu código en un archivo, näiteks app.js, ja ejektuaal koos node app.js terminalis. Esto inicia tu programa y verás los resultados en consola o, si levantas un servidor, en tu navegador.

Del REPL a la aplicación real: flujo completo

Probar en el REPL es perfecto para funciones pequeñas, pero en cuanto tu código crece, te conviene pasar a archivos, organzar modulos y añadir scripts de npm. De esta forma podrás automatizar tareas con npm run y dokumentaalfilm los comandos de inicio en package.json.

Manejando datos POST sin bloquear

Cuando un usuario envía un formulaario, el cuerpo de la petición puede llegar en varios trozos. En el servidor (tagasihelistamine de createServer) añade kuulajad data y end para ir acumulando el contenido y processarlo al final. Indica también la codificación, por emplo UTF-8, para manipularlo correctamente.

request.setEncoding('utf8');
var postBody = '';
request.addListener('data', function(chunk) {
  postBody += chunk;
});
request.addListener('end', function() {
  // route(handle, pathname, response, postBody)
});

Si necesitas extraer campos individuales, kasuta moodulit 'querystring' para parsear el cuerpo cuando llega como application/x-www-form-urlencoded: querystring.parse(postBody).text, Näiteks.

Operaciones costosas y exec no bloqueante

Para ejecutar comandos del sistema sin detener el servidor, utiliza child_process.exec vastake tagasihelistamisele. Puedes añadir opciones como timeout o maxBuffer para controlar comandos pesados. El patrón es siempre el mismo: nada de bloquear, y vastaja cuando haya datos.

var exec = require('child_process').exec;

function handler(response) {
  exec('ls -lah', function(error, stdout, stderr) {
    response.writeHead(200, {'Content-Type': 'text/plain'});
    response.write(stdout);
    response.end();
  });
}

Si cambias el comando por algo más exigente, el resto de rutas seguirá responseiendo con normalidad siempre que no hagas trabajo sincrónico costoso en el hilo principal.

Subidas de ficheros: enfoque y herramientas

Para manejar laadib üles mitmeosalised (pildid u otros arhiivid) lo más práctico es recurrir a un paquete especializado. Módulos como imeline hõlbustab valemite analüüsimist multipart/form-data, acceder a los archivos temporales y moverlos a su destino. Idee es la misma: tagasihelistamised/promesad y trabajar de forma segura con streams.

Aunque la implementación completa escapa a los primeros pasos, lo importante es que integres el upload en tu flujo: server kes sai valemi, ruuter que dirige a la ruta de subida, y käitleja que valid, guarda y responsee con el resultado (por eemplo, mostrando la imagen).

Estructura de vistas y contenido dinamico

See on varustatud Expressi ja mopsi mootoriga, el controlador pasa datos a la vista y esta los renderiza. Para un formulario sencillo con un textarea enviado por POST y una ruta que lo muestra, basta con dos handlers: uno que sirve el formulaario y otro que protsess y devuelve el contenido saanud.

Head organisatsioonilised tavad

Evita monolüütilised arhiivid. Divide en módulos, nombra funciones con verbos que expresen acciones (por ejemplo, algus, üles, loetlema), y desacopla con inyección de dependencias cuando tenga sentido (pasando funciones o mapas de rutas al servidor y al ruuter). Mantener las capas ligeras te permitirá crecer sin dolores.

Qué puedes construir con Node.js

Kui mudel on sündmustepõhine ja mitteblokeeriv Siin on eriline bueno: veebiserverid, API-liidesed REST, reaalsed rakendused (vestlus, armatuurlauad), robotid ja CLI-d, andmete integratsioonid, trabajood ja riistvara juhtimine. La facilidad para manjar websockets y streaming lo convierte en una elección natural para experiencias interactiveas.

• Veebiserverid ja veebisaidid SSR-i taimedega.
• REST API-d preparadas para alto tráfico.
• Reaalajas con sockets para chat, notificaciones o juegos.
• käsurea tööriistad ülesannete automatiseerimiseks.
• Procesos con ficheros y bases de datos, kola ja torujuhtmed.
• Asjade internet ja riistvara spetsiaalsete raamatukogudega.

Herramientas de aprendizaje y práctica

Existen entornos interactiveos que müestran código y salida lado a lado, ideales para entender ejemplos rápidos. Aun así, podrás progressar sin crear cuentas: documentarte, copiar ejemplos y ejecutar en local con tu terminal es más que suficiente al principio.

Visual Studio kood: redigeerija produktiivsus

El terminal integrado, el depurador y las extensiones de VS Code hacen que trabajar con Node sea muy cómodo. Desde “Ver > Terminal” puedes abrir shells, cambiar el predeterminado y ejecutar node o npm run sin abandonar el toimetaja. Además, seadista käivitamine.json te lubairá depurar paso a paso.

Apuntes de versión y estabilidad

Muchas guías clásicas se probaron con versiones antiguas de Node, pero los conceptos se mantienen vigentes: tagasihelistamised, modulos nativos, asincronía, enrutado y separación de responsabilidades. Hoy trabajarás con versiones aktuales, más rápidas y seguras, y con un ecosistema npm aún más rico.

Laadige alla ja recursos adicionales

Puedes ampliar estudio koos dokumentatsiooni, PDF-ide ja õpetustega. Revisa siempre la web oficial de Node para novedades y descarga, e identifica fuentes didácticas que incluyan ejakulatsioonid, viktoriinid ja harjutused para afianzar conocimientos a medida que avances.

Si buscas material Complementario, encontrarás guías introductorias y referencias prácticas con eemplos, así como enlaces de descarga cuando sea necesario. Hoia oma keskendumist praktikas: leer está bien; ejecutar, romper cosas y arreglarlas, mejor.

Täielik näide: minirakendus ruuteri ja käitlejatega

Juntando piezasKujutage ette projekti koos index.js kes teenija paigutab, server.js HTTP ja POST-i parsimisega ruuter.js que Decision qué función ejecutar y requestHandlers.js con dos rutas: una que muestra un formulario y otra que enseña el texto enviado.

// index.js
var server = require('./server');
var router = require('./router');
var handlers = require('./requestHandlers');

var handle = {};
handle['/'] = handlers.iniciar;
handle['/iniciar'] = handlers.iniciar;
handle['/subir'] = handlers.subir;

server.iniciar(router.route, handle);

// server.js
var http = require('http');
var url = require('url');

function iniciar(route, handle) {
  function onRequest(request, response) {
    var postData = '';
    var pathname = url.parse(request.url).pathname;

    request.setEncoding('utf8');
    request.addListener('data', function(chunk) { postData += chunk; });
    request.addListener('end', function() {
      route(handle, pathname, response, postData);
    });
  }

  http.createServer(onRequest).listen(8888);
}

exports.iniciar = iniciar;

// router.js
function route(handle, pathname, response, postData) {
  if (typeof handle[pathname] === 'function') {
    handle[pathname](response, postData);
  } else {
    response.writeHead(404, {'Content-Type': 'text/html'});
    response.end('404 No Encontrado');
  }
}

exports.route = route;

// requestHandlers.js
var querystring = require('querystring');

function iniciar(response) {
  var body = '<html>'+
    '<head><meta charset=\'UTF-8\' /></head>'+
    '<body>'+
    '<form action=\'/subir\' method=\'post\'>'+
    '<textarea name=\'text\' rows=\'10\' cols=\'40\'></textarea>'+
    '<input type=\'submit\' value=\'Enviar\' />'+
    '</form>'+
    '</body></html>';

  response.writeHead(200, {'Content-Type': 'text/html'});
  response.end(body);
}

function subir(response, postData) {
  var text = querystring.parse(postData).text || '';
  response.writeHead(200, {'Content-Type': 'text/html'});
  response.end('Tu enviaste: ' + text);
}

exports.iniciar = iniciar;
exports.subir = subir;

Con este esqueleto mínimo ya tienes un servidor funcional y no bloqueante, con rutas y controladores separados, preparado para crecer hacia vistas, uploads o integración con bases de datos.

La clave de Node está en pensar en “acciones”: pasar funciones, inyectar dependencias cuando convenga y mantener pequeños los bloques de responsabilidad. Así, tu aplicación será más fácil de mantener y adaptar conforme aumente su complejidad.

Todo lo visto te da una base solida: desde instalar Node y ejecutar tu praimeri script, passando por VS Code, un servidor HTTP nativo, enrutado propio, Express, npm, modulos nativos, REPL, asincronía sin bloqueos y manejo de formularios POST. Con práctica y pequeñas iteraciones, podrás construir proyectos cada vez más completos sin perder claridad en el código.