Udžbenik za Node.js za principijelnost: de cero a your primera app

Početna » Piton » Udžbenik za Node.js za principijelnost: de cero a your primera app

Ako ste prvi kontakt s 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, pasando por módulos del system, npm y el enfoque asíncrono que hace tan especial al ecosistema de Node.

Además de orientarte con prethodni zahtjevi, konfiguracija u Visual Studio Code i prvi projekti, verás cómo organizar un server 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

Necesitarás unos conocimientos básicos de JavaScript (tipos, variables, funciones, objetos) y ganas de probar cosas con la consola. Node.js je entorno de ejecución de JavaScript fuera del navegador, basado en V8, con una librería estándar potente y un modelo de ejecución dirigido por eventos y no bloqueante. Esto le permite gestionar muchas conexiones concurrentes sin crear un hilo por cada petición.

S čvorom se može konstruirati servidores web, API-ji REST, herramientas de línea de comandos, apps en tiempo real (chat, notificaciones), integraciones con bases de datos y hasta proyectos IoT. Su fortaleza está en el manejo de E/S concurrente, lo que lo hace ideal para tráfico alto y experiencias interactivas.

Preuzimanje i instalacija

Preuzmite Node.js sa službene web stranice en nodejs.org e instalirao za vaš operativni sustav. U sustavima Windows, macOS ili Linux instalirani su i novi paketi. Tras la instalación, confirma 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.

Vaš prvi kontakt: Hola Mundo s VS kodom

Ako koristite Visual Studio Code, 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 en VS Code con kod.. Stvorite pozvanu datoteku app.js e uvesti algo sencillo para arrancar: poruka putem konzole.

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

Za ejecutarlo, abre la terminal integriran u VS Code (Ver > Terminal, ili koristite Ctrl+`), i lanza node app.js. Verás el clásico izlaz “Hello World” en la consola; sí, sencillo, pero confirma que todo va bien.

Glavni poslužitelj: najmanji HTTP poslužitelj

Čvor trae un módulo 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 s node server.js i posjetiti http://localhost:8888/. La magia de Node está en su modelo orientado a eventos: pasas una función y el runtime la “llama de vuelta” (povratni poziv) cuando sucede el evento (una petición entrante).

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

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

Ključno je razumjeti razliku između operaciones bloqueantes y no bloqueantes. Si predstavlja algo que ocupa la CPU durante segundos (por ejemplo, un bucle de espera), el processo entero se detiene y todas las peticiones sufren. En čvor, trabaja siempre que puedas con E/S asíncrona y povratni pozivi o promesas para evitar bloquear el hilo.

Modularni dizajn: servidor, router y manejadores

Odvojite odgovornosti te ayudará a escalar el proyecto: un módulo para el server HTTP, otro para el enrutador y otros para los controladores (rukovatelji zahtjevima). Puedes exponer funciones con exports y requerir módulos locales con require('./miModulo').

Una estructura típica podría ser: index.js kao ulazna točka, poslužitelj.js s HTTP poslužiteljem, usmjerivač.js para decidir a qué función mandar cada ruta y requestHandlers.js con la lógica de cada krajnja točka. Esta organización mantiene el código lisible y fácil de probar.

Extrayendo la ruta y enrutando

El objeto request tiene la URL solicitadaIzvorni modul url dopustiti ekstra naziv putanje y, si hace falta, la query. 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) ...
}

Ruter ga prima karta ruta i funkcija (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 existe, la ejecuta; si no, devuelve un 404.

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

Uobičajena namjera 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 ubrizgaj odgovor na objekt 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();
  }
}

Ovaj pristup omogućuje responder justo cuando la E/S asíncrona concluye, sin bloquear el proceso ni forzar a devolver datos antes de tiempo.

Express: stvorite web aplikaciju u minutima

Express je minimalistički okvir za Node.js que facilita gestionar rutas, vistas, middleware y utilidades HTTP. Con su generador puedes crear la estructura de un proyecto en segundos, con carpetas para rutas, vistas y recursos estáticos.

1. Napravite mapu za svoje projekte: mkdir ExpressProjects && cd ExpressProjects.
2. Rod una plantilla: npx express-generator HelloWorld --view=pug crea la app con motor de vistas Pug.
3. Otvori VS kod s code . i revizija strukture: kanta (aranžiranje), javni (JS/CSS/slike), destinacije (kontrolori ruta), pregleda (plantilje), app.js (konfiguracija), paket.json (skripte i ovisnosti).
4. Instaliranje ovisnosti s npm install na tepihu projekta.
5. Pokrenite aplikaciju. Por ejemplo, con depuración: npx cross-env DEBUG=HelloWorld:* npm start.
6. otvara http://localhost:3000. Prueba a cambiar la vista principalU views/index.pug, zamjenjuje naslov h1 "Hello World!" i ponovno napuniti.

Express incorpora lo necesario para upravlja GET, POST, PUT i DELETE, usar middleware, servir estáticos, renderizar vistas y estructurar una app de varias páginas con menos fricción.

npm i modulos incorporados de Node

npm es el gestor de paquetes de Node y te permite instalar librerías de terceros. Por ejemplo, para añadir Express: npm install express. Onda možete require('express') y utilizarlo en tu código. Esta flexibilidad es clave para crecer con tu proyecto.

Además, uključeni čvor izvorni moduli za općine: fs (arhiva), http/https (poslužitelji), path (rute), os (podaci sustava), url (raščlanjivanje URL-a) y muchos más. Puedes importarlos con require() ne instalirajući ništa.

Probando un módulo nativo: información del system

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

1. Opisati trokut os.platform() za saber la platforma (win32, linux, darwin…). Potvrdite aktivni SO izravno.
2. s os.arch() nabaviti arhitekturu (x64, arm64…). Koristi se za binarne datoteke ili verzije.
3. Koristiti os.cpus() para ver los núcleos disponibles. Idealno za ravnotežni teret con clusteres o processos hijos.
4. Sal del REPL s .exit ili pritisnite Ctrl+C dva puta. Brzo i bez ostataka.

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

Ekosistem npm je ogroman. Algunas utilidades populares: oštar (tratamiento de imágenes y compresión), PDFKit (generiranje PDF-a), validator.js (validacija hvatišta), imagemin y UglifyJS (smanjivanje), Spritesmith (sprajtovi), Winston (sječa drva) y commander.js (CLI). Instalirano s npm install <paquete> kada ih trebate.

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

Guarda tu código en un archivo, por ejemplo app.jsi izbacio/la sam ga node app.js na terminalu. Esto inicia tu program 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, organizar módulos y añadir scripts de npm. De esta forma podrás automatizar tareas con npm trčanje y documentar los comandos de inicio en package.json.

Manejando datos POST sin bloquear

Cuando un usuario envía un formulario, el cuerpo de la petición puede llegar en varios trozos. Na poslužitelju (povratni poziv de createServer) slušatelji añade data y end para ir acumulando el contenido y processarlo al final. Indica también la codificación, por ejemplo 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, koristite modul 'querystring' para parsear el cuerpo cuando llega como application/x-www-form-urlencoded: querystring.parse(postBody).text, na primjer.

Operaciones costosas y exec no bloqueante

Para ejecutar comandos del system sin detener el servidor, utiliza child_process.exec y responde en el back call. Puedes añadir opciones como timeout o maxBuffer para controlar comandos pesados. El patrón es siempre el mismo: ništa od blokiranja, y responder 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á respondiendo con normalidad siempre que no hagas trabajo sincrónico costoso en el hilo principal.

Subidas de ficheros: enfoque y herramientas

Para manejar uploads multiparte (slike u otros archivos) lo más práctico es recurrir a un paquete especializado. Módulos como težak olakšati analizu obrazaca multipart/form-data, acceder a los archivos temporales y moverlos a su destino. La idea es la misma: povratni pozivi/obećanja 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 koji primam obrazac, usmjerivač que dirige a la ruta de subida, y sekundant que valida, guarda y responde con el resultado (por ejemplo, mostrando la imagen).

Estructura de vistas y contenido dinámico

Optas por Express con Pug u drugi motor, 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 formulario y otro que procesa y devuelve el contenido primljeno.

Dobre organizacijske prakse

Monolitički arhivi Evita. Divide en módulos, nombra funciones con verbos que expresen acciones (por ejemplo, iniciar, pretrpjeti, izlistati), y desacopla con inyección de dependencias cuando tenga sentido (pasando funciones o mapas de rutas al server y al router). Mantener las capas ligeras te permitirá crecer sin dolores.

Što možete konstruirati s Node.js

Su model vođen događajima i neblokiran lo hace specialmente bueno para: web serveri, API-ji REST, apps en timepo real (chat, dashboards), roboti y CLIs, integraciones con bases de datos, colas de bajo, y control de hardware. La facilidad para manejar websockets y streaming lo convierte en una elección natural para experiencias interactivas.

• Web poslužitelji i web-lokacije s biljkama ili SSR-om.
• API-ji REST preparadas para alto tráfico.
• U stvarnom vremenu s utičnicama za chat, obavijesti o igrama.
• alati naredbenog retka za automatizaciju zadataka.
• Procesos con ficheros y bases de datos, kola i cjevovodi.
• IoT i hardver sa specifičnim knjižnicama.

Herramientas de aprendizaje y practica

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

Visual Studio Code: productividad sin salir del editor

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 urednik. Además, konfiguriraj launch.json te permitirá 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: povratni pozivi, modulos nativos, asincronía, enrutado y separación de responsabilidades. Hoy trabajarás con versiones actuales, más rápidas y seguras, y con un ecosistema npm aún más rico.

Descargas y recursos adicionales

Puedes ampliar estudio con documentación, PDF-ovi i tutoriales. Revisa siempre la web oficial de Node para novedades y descarga, e identifica fuentes didácticas que incluyan udarci, kvizovi i ritmovi para afianzar conocimientos a medida que avances.

Si buscas material complementario, encontrarás guías introductorias y referencias prácticas con ejemplos, así como enlaces de descarga cuando sea necesario. Održavaj fokus na praksi: leer está bien; ejecutar, romper cosas y arreglarlas, mejor.

Kompletan primjer: mini aplikacija s usmjerivačem i rukovateljima

Juntando piezasZamislite projekt s index.js koji upravlja poslužiteljem, poslužitelj.js s HTTP-om i parsiranjem POST-a, usmjerivač.js que odlučiti 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 adapter conforme aumente su complejidad.

Todo lo visto te da una base sólida: desde instalar Node y ejecutar tu primer script, passando por VS Code, HTTP izvorni poslužitelj, enrutado propio, Express, npm, izvorni moduli, 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.