Vodič za Node.js za principijete: de cero a tu primera app

Početna stranica » Python » Vodič za Node.js za principijete: de cero a tu primera app

Si es tu primera toma de contacto sa 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 je pokrenut u web-aplikaciji Express, pasando por módulos del sistema, npm y el enfoque asíncrono que hace tan especial al ecosistema de Node.

Además de orientarte con requisitos previos, configuración en Visual Studio Code y primeros proyectos , verás cómo organizar un HTTP server, enrutar peticiones, manejar controladores, trabajar con datos POST sin bloquear el hilo y entendería event- 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 basicos de JavaScript (tipovi, varijable, funkcije, objekti) i 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 i un model de ejecución dirigido por eventos y no bloqueante . Esto le permite gestionar muchas conexiones concurrentes sin crear un hilo por cada petición.

U čvoru su izgrađeni web servisi, API-ji REST, herramientas de línea de comandos, aplikacije i tiempo real (chat, notificaciones) , integracije s bazama podataka i 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 web oficial en nodejs.org e instaliran za operativni sistem. Pod Windows, macOS ili Linux instalirani su i paquetes adecuados. Tras la instalación, potvrdite i terminal sa: node -v y npm -v. npm es el gestor de paquetes de Node y te permitirá instalar librerías de terceros de forma sencila.

Tu temeljni kontakt: Hola Mundo sa 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 .. Kreirajte datoteku koja se zove app.js e uvesti algo sencillo za arrancar: poruka putem konzole.

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

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

De cero a servidor: un HTTP server mínimo

Č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 con 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 peticion entrante).

Entendiendo povratni pozivi, asincronía y flujo de ejecución

En JavaScript las funciones son ciudadanos de primera : se pueden pasar como argumentos, devolver y almacenar en varijabli. Ovo je patrón encaja con el bucle de eventos de node: tu šifru registra funkcija koje se ejecutan cuando ocurren sucesos (na primjer, llega una petición HTTP).

Es crucial entender la diferencia entre operaciones bloqueantes y no bloqueantes . Si uvodi algo que ocupa la CPU durante segundos (por ejemplo, un bucle de espera), el processo entero se detiene y todas las peticiones sufren. En Node, trabaja siempre que puedas con E/S asíncrona y callbacks ili promesas para evitar bloquear el hilo.

Diseño modular: servidor, router y manejadores

Odvojite odgovornosti te escalar el project: un modulo para el servidor HTTP, otro para el enrutador y otros para los controladores (upravljači zahtjeva). Puedes exponer funciones con exports y zatražiti modulos locales con require('./miModulo').

Una estructura típica podría ser: index.js kao punto de entrada, server.js sa HTTP serverom, router.js za odlučivanje o funkciji mandar cada ruta y requestHandlers.js sa logičkom lokacijom krajnje točke. Esta organización mantiene el código čitljiv y fácil de probar.

Extrayendo la ruta y enrutando

Zahtjev za objelodanjivanje za traženi URLIzvorni modul url dozvolite 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) ...
}

El router recibe el mapa de rutas a funciones (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; ne, devuelve un 404.

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

Una tentación habitual 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 (kao leer de disco ili ejecutar un comando). Efektivno rješenje je inyectar el objeto response hasta el handler y que el propio handler escriba la respuesta cuando la tenga (primjerno, 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();
  }
}

Ovo je dozvoljeno da odgovori samo na E/S asíncrona concluye , sin bloquear el processo ni forzar a devolver datos antes de tiempo.

Express: kreirajte web aplikaciju u nekoliko minuta

Express je minimalistički okvir za Node.js koji omogućava korištenje ruta, vista, međuvera i HTTP-a. Con su generador puedes crear la estructura de un proyecto en segundos, con carpetas para rutas, vistas y recursos estáticos.

1. Kreirajte folder za svoje projekte: mkdir ExpressProjects && cd ExpressProjects.
2. Rodovi jedne biljke: npx express-generator HelloWorld --view=pug crea la app con motor de vistas Pug.
3. Otvori VS kod con code . i revizija strukture: am (aranžiranje), javnost (JS/CSS/slike), rute (kontrolori ruta), views (biljke), app.js (konfiguracija), package.json (skripte i zavisnosti).
4. Instaliranje zavisnosti con npm install na tepihu projekta.
5. Pokrenite aplikaciju. Por ejemplo, con depuración: npx cross-env DEBUG=HelloWorld:* npm start.
6. Otvori http://localhost:3000. Prueba a cambiar la vista principal: en views/index.pug, zamjenjuje naslov h1 "Hello World!" i napunite se.

Express incorpora lo necessario para gestionar GET, POST, PUT y DELETE , koristite srednji softver, server estáticos, renderizar vistas i 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 permite instalar librerías de terceros. Na primjer, para añadir Express: npm install expressNakon što require('express') y utilizarlo en tu código. Esta flexibilidad es clave para crecer con tu proyecto.

Dodatno, čvor uključen izvorni moduli za općine: fs (arhiva), http/https (servidori), path (rute), os (sistemski podaci), url (parsing URL) y muchos más. Puedes importarlos con require() bez instaliranja bilo čega.

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

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

1. pisati os.platform() para saber la plataforma (win32, linux, darwin…). Potvrdi SO aktivno direktno.
2. con os.arch() obtendrás la arquitectura (x64, arm64…). Koristi se za binarne datoteke ili verzije.
3. SAD os.cpus() para ver los núcleos disponibles. Idealno za ravnotežno opterećenje con clústeres o procesos hijos.
4. Sal del REPL sa .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 imagenes y compresión), PDFKit (generisanje PDF-a), validator.js (validacija hvatišta), imagemin y UglifyJS (minimizacija), Spritesmith (sprajtovi), Vinston (sječa drva) y commander.js (CLI). Instalirano sa npm install <paquete> kada vam zatrebaju.

Cómo ejecutar codigo Node.js desde archivo

Čuvajte kod i arhivu, na primjer app.jsi izbacio/la sam ga node app.js en la terminal. 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 run 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. En el servidor (povratni poziv de createServer) slušaoci añade data y end para ir acumulando el contenido y procesarlo al final. Indica también la codificación, por primjer 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 sistema sin detener el servidor, utiliza child_process.exec y responde en el callback. Puedes añadir opciones como timeout o maxBuffer para controlar comandos pesados. El patrón es siempre el mismo: ništa od blokiranja, y odgovorni 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 zapanjujuće olakšano analiziranje formulara 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: servidor que recibe el formulario, router que dirige a la ruta de subida, y handler que valida, guarda y responde con eledejemplodado (porrandojemploded image).

Estructura de vistas y contenido dinámico

Si optas por Express con Pug u otro 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 recibido.

Dobre organizacijske prakse

Evita archivos monolíticos . Divide en módulos, nombra funciones con verbos que expresen acciones (por ejemplo, iniciar , subir , listar ), y desacopla con inyección dependencias cuando tenga sentido (pasando funciones ili mapas de rutas al servidor y al router). Mantener las capas ligeras te permitirá crecer sin dolores.

Qué puedes construir con Node.js

Na modelu vođen događajima y neblokirajućim, ima posebne pogodnosti za: web servise, API-je REST, realne aplikacije (čet, kontrolne table), botove y CLI-ove, integracije sa bazama podataka, kontrolne trake, kontrolu hardvera. La facilidad para manejar websockets y streaming lo convierte en una elección natural para experiencias interactivas.

• Web serveri i web stranice sa biljkama ili SSR-om.
• REST API-ji preparadas para alto tráfico.
• Realno vreme con sockets para chat, notificaciones o juegos.
• alati komandne linije automatizirati zadatke.
• Procesos con ficheros y bases de datos, kola i cjevovodi.
• IoT i hardver sa specifičnim bibliotekama.

Herramientas de aprendizaje y práctica

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 comodo. Desde “Ver > Terminal” puedes abrir shells, cambiar el predeterminado y ejecutar node o npm run sin abandonar el editor. Además, konfigurisati launch.json te permitirá depurar paso a paso.

Apuntes de version y estabilidad

Muchas guías clásicas se probaron con versiones antiguas de Node, pero los conceptos se mantienen vigentes : callbacks, módulos nativos, asincronía, enrutado y separación de responsabilidades. Hoy trabajarás con versiones currentes, 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, PDFs y tutoriales . Revisa siempre la web oficial de Node para novedades y descarga, e identifica fuentes didácticas que incluyan ejercicios, quizzes y retos para afianzar conocimientos a medida que avances.

Si buscas material compplementario, encontrarás guías introductorias y referencias prácticas con ejemplos, así como enlaces de descarga cuando sea necesario. Mantén tu foco en practicar : leer está bien; ejecutar, romper cosas y arreglarlas, mejor.

Kompletan primjer: mini aplikacija sa ruterom i rukovaocima

Juntando piezas . Imagina un proyecto con index.js que arranca el servidor, server.js con HTTP y parsing de POST, router.js que odluči qué función ejecutar y requestHandlers.js con dos rutas: una que muestra un formulario y otra que textoña envia

// 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 ili integración con base 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 da una base sólida: desde instalar Node y izbaciti u skriptu za početnike, upotrijebiti VS Code, un servidor HTTP nativo, enrutado propio, Express, npm, módulos nativos, REPL, asincronía sin bloqueos i manejo za POST. Con práctica y pequeñas iteraciones, podrás construir proyectos cada vez más completos sin perder claridad en el código.