Tutorial de Node.js per a principiants: de zero a la teva primera app

Inici » Pitó » Tutorial de Node.js per a principiants: de zero a la teva primera app

Si és la teva primera presa de contacte amb Node.js, aquí té una guia pensada per començar amb un bon pie: volem del més bàsic a un flux de treball real, amb exemples pràctics i explicacions clares. T'acompanyarà des del mític Hola Mundo fins a aixecar una aplicació web amb Express, passant pels mòduls del sistema, npm i l'enfocament aixíncrono que fa tan especial al ecosistema de Node.

A més d'orientar-te amb requisits previs, configuració en Visual Studio Code i primers projectes, veureu com organitzar un servidor HTTP, enrutar peticions, manejar controladors, treballar amb dades POST sense bloquejar el fil i entendre la filosofia event-driven. Tot amb un llenguatge proper, sense rodeos, i amb el toc necessari per a què no et pierdes.

Requisits previs i què esperar de Node.js

Necessites uns coneixements bàsics de JavaScript (tipus, variables, funcions, objectes) i ganes de provar coses amb la consola. Node.js és un entorn d'execució de JavaScript fora del navegador, basat en V8, amb una llibreria estàndard potent i un model d'execució dirigit per esdeveniments i no bloquejant. Això li permet gestionar moltes connexions concurrents sense crear un hilo per cada petició.

Amb el node pots construir servidors web, APIs REST, eines de línia de comandaments, apps en temps real (xat, notificacions), integracions amb bases de dades i fins a projectes IoT. La seva fortaleza està en el maneig d'E/S concurrent, el que fa ideal per a tràfic alt i experiències interactivas.

Descàrrega i instal·lació

Descarrega Node.js des del web oficial en nodejs.org i s'instal·la per al vostre sistema operatiu. A Windows, macOS o Linux tindràs instal·ladors i paquets adequats. Tras la instal·lació, confirmeu el terminal amb: node -v y npm -v. npm és el gestor de paquets de Node i permetrà instal·lar llibreries de tercers de forma sencilla.

El primer contacte: Hola Mundo amb VS Code

Si fas servir el codi del Visual Studio, podeu obrir la carpeta del projecte i llançar el terminal integrat amb total comoditat. Crea una carpeta de treball i entra en ella: mkdir HelloNode && cd HelloNode.

Ara obre aquesta carpeta en VS Code con codi.. Crea un arxiu anomenat app.js e introdueix algo senzill per arrancar: un missatge per consola.

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

Per executar-lo, obre la terminal integrada en VS Code (Ver > Terminal, o atajo Ctrl+`), i llança node app.js. Veuràs la sortida del clàssic “Hello World” en la consola; sí, senzill, però confirma que tot va bé.

De cap a un servidor: un servidor HTTP mínim

El node inclou un mòdul natiu anomenat 'http' amb el que pots crear un servidor en poques línies. El cor és http.createServer, que rep una funció de devolució de trucada que s'executa cada vegada que arriba una petició.

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 amb node server.js i visita http://localhost:8888/. La magia de Node està en el seu model orientat a esdeveniments: passa una funció i el runtime la “llama de vuelta” (callback) quan succeeix l'esdeveniment (una petició entrante).

Entenent les devolucions de trucada, asincronia i flux d'execució

En JavaScript les funcions son ciudadanos de primera: es poden passar com a arguments, devolver i emmagatzemar en variables. Aquest patró encaixa amb el bucle d'esdeveniments de Node: el vostre codi de registre de funcions que s'executa quan succeeixin successos (per exemple, arriba una petició HTTP).

És crucial entendre la diferència entre operacions bloquejants i no bloquejants. Si introduces algo que ocupa la CPU durante segundos (per exemple, un bucle d'espera), el procés entero es detiene i totes les peticions sufren. En Node, trabaja siempre que puedas con E/S asíncrona i callbacks o promesas per evitar bloquejar el hilo.

Disseny modular: servidor, router i manejadors

Separar responsabilitats t'ajudarà a escalar el projecte: un mòdul per al servidor HTTP, un altre per a l'enrutador i altres per als controladors (request handlers). Pots exponer funcions amb exports i requerir mòduls locals amb require('./miModulo').

Una estructura típica podria ser: index.js com a punt d'entrada, server.js amb el servidor HTTP, router.js per decidir a quina funció mandar cada ruta y requestHandlers.js amb la lògica de cada endpoint. Esta organització manté el codi legible i fàcil de provar.

Extrayendo la ruta y enrutando

L'objecte sol·licitat té l'URL sol·licitatEl mòdul natiu url permetre extreure'l nom de ruta y, si fa falta, la query. Amb això, el router podrà decidir quin controlador executar.

var url = require('url');

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

El router el rep mapa de rutes amb funcions (un objecte on cada clau és una ruta, i el valor, el handler), junt amb el pathname, i comprueba si hi ha una funció associada. Si existeix, la executa; si no, torna un 404.

Haciendo que el handler responda (el patró correcte)

Una temptació habitual és fer que el controlador retorni una cadena i que el servidor lo escriba. Però això falla quan el handler necessita fer algo aixíncrono (com a llegir de disc o executar un comandament). La solució efectiva és injectar la resposta de l'objecte fins al handler i que el propi handler escriba la resposta quan la tingui (per exemple, dins del callback d'una funció 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();
  }
}

Aquest enfocament permet respondre justo quan la E/S asíncrona concluye, sense bloquejar el procés ni forçar a devolver dades abans del temps.

Express: crea una aplicació web en minuts

Express és un framework minimalista per a Node.js que facilita gestionar rutes, vistes, middleware i utilitats HTTP. Amb el seu generador podeu crear l'estructura d'un projecte en segons, amb carpetes per a rutes, vistes i recursos estàtics.

1. Crea una carpeta pels teus projectes: mkdir ExpressProjects && cd ExpressProjects.
2. Gènere una plantilla: npx express-generator HelloWorld --view=pug crea l'aplicació amb motor de vistes Pug.
3. Obreix el codi VS amb code . i revisa l'estructura: paperera (arrancar), públic (JS/CSS/imatges), rutes (controladors de rutes), vistes (plantilles), app.js (configuració), paquet.json (scripts i dependències).
4. Instal·la dependències amb npm install a la carpeta del projecte.
5. Inicia l'app. Per exemple, amb depuració: npx cross-env DEBUG=HelloWorld:* npm start.
6. Obre http://localhost:3000. Prueba a canviar la vista principal: En views/index.pug, substitueix el títol per h1 "Hello World!" i recàrrega.

Express incorpora el necessari para gestionar GET, POST, PUT i DELETE, utilitzar middleware, servir estàtics, renderitzar vistes i estructurar una aplicació de diverses pàgines amb menys fricció.

npm i mòduls incorporats de Node

npm és el gestor de paquets de Node i et permet instal·lar llibreries de tercers. Per exemple, per afegir Express: npm install expressDesprés podràs require('express') i utilitzar-lo en el teu codi. Aquesta flexibilitat és clau per créixer amb el vostre projecte.

A més, el node inclou mòduls nadius per a tasques comunes: fs (arxius), http/https (servents), path (rutes), os (dades del sistema), url (anàlisi d'URL) i molts més. Podeu importar-los amb require() sense instal·lar res.

Proba un mòdul natiu: informació del sistema

El mòdul 'os' ofereix dades del sistema operatiu. Obre la consola y entra en el REPL de Node con node per provar funcions ràpidament sense crear arxius.

1. Escriu os.platform() per saber la plataforma (win32, linux, darwin…). Confirmaràs l'SO actiu de forma directa.
2. Amb os.arch() obtendrás la arquitectura (x64, arm64…). Útil per a binaris o compilacions.
3. EUA os.cpus() per veure els nuclis disponibles. Ideal per equilibrar la càrrega amb clústers o processos hijos.
4. Sal del REPL amb .exit o prement Ctrl+C dues vegades. Ràpid i sense residus.

Biblioteca de tercers útils en el dia a dia

L'ecosistema npm és enorme. Algunes utilitats populars: forta (tractament d'imatges i compressió), PDFKit (generació de PDF), validator.js (validació de cadenes), imatgemin y UglifyJS (minificació), spritesmith (sprites), winston (registre) i comandant.js (CLI). Instal·la-les amb npm install <paquete> quan les necessitis.

Com executar el codi Node.js des de l'arxiu

Guarda el teu codi en un arxiu, per exemple app.js, i executa-ho amb node app.js en la terminal. Això inicieu el vostre programa i veureu els resultats en consola o, si aixequeu un servidor, al vostre navegador.

Del REPL a l'aplicació real: flux complet

Probar en el REPL és perfecte per a funcions petites, però en quant al teu codi creix, et convé passar a arxius, organitzar mòduls i afegir scripts de npm. D'aquesta forma podràs automatitzar tareas amb npm run i documentar els comandaments d'inici en package.json.

Manejant dades POST sense bloquejar

Quan un usuari envía un formulari, el cuerpo de la petición puede llegar en varios trozos. En el servidor (callback de createServer) oients afegits data y end per acumular el contingut i processar-lo al final. Indica també la codificació, per exemple UTF-8, per manipular correctament.

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

Si necessites més camps individuals, utilitza el mòdul 'querystring' per analitzar el cos quan arriba com a application/x-www-form-urlencoded: querystring.parse(postBody).text, Per exemple.

Operacions costoses i exec no bloquejant

Per executar ordres del sistema sin detener el servidor, utilitzar child_process.exec i respondre en el callback. Podeu afegir opcions com timeout o maxBuffer per controlar comandaments pesats. El patró és sempre el mateix: res de bloquejar, i respondre quan hagi dades.

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 canvia l'ordre per algo més exigent, el resto de rutes seguirà responent amb normalitat sempre que no hagas trabajo sincrónico costoso en el hilo principal.

Subides de fitxes: enfocament i eines

Para manejar puja multiparte (imatges u altres arxius) el més pràctic és recurrir a un paquet especialitzat. Mòduls com meravellós faciliten l'anàlisi de formularis multipart/form-data, accediu als fitxers temporals i moveu-vos al seu destí. La idea és la mateixa: retrorevocacions/promeses i treballar de forma segura amb streams.

Encara que la implementació completa escapa als primers passos, l'important és que integres la càrrega al teu flux: servidor que rep el formulari, enrutador que dirigeix ​​a la ruta de subida, y manipulador que valida, guarda i respon amb el resultat (per exemple, mostrant la imatge).

Estructura de vistes i contingut dinàmic

Si optas per Express amb Pug i un altre motor, el controlador passa dades a la vista i aquesta els renderitza. Per a un formulari senzill amb una zona de text enviada per POST i una ruta que mostra la mostra, bastant amb dos handlers: un que serveix el formulari i un altre que processa i torna el contingut rebut.

Bones pràctiques d'organització

Evita els arxius monolítics. Divide en mòduls, nombra funcions amb verbos que expressen accions (per exemple, iniciar, pujar, llistar), i desacobla amb injecció de dependències quan tingui sentit (passant funcions o mapes de rutes al servidor i al router). Mantener las capas ligeras et permetrà créixer sense dolors.

Què pots construir amb Node.js

El seu model basat en esdeveniments i sense bloqueig ho fa especialment bé per a: servidors web, APIs REST, apps en temps real (chat, dashboards), bots i CLI, integracions amb bases de dades, coles de treball i control de hardware. La facilitat per manejar websockets i streaming es converteix en una elecció natural per a experiències interactivas.

• Servidors i llocs web amb plantilles o SSR.
• APOS REST preparades per a alt tràfic.
• temps real amb sockets per a xat, notificacions o jocs.
• Eines de línia d'ordres per automatitzar tasques.
• Processos amb fitxes i bases de dades, cues i canonades.
• IoT i maquinari amb llibreries específiques.

Herramientas d'aprenentatge i pràctica

Existeixen entorns interactius que mostren codi i sortida lado a lado, ideals per entendre exemples ràpids. Aun així, podràs progressar sense crear comptes: documentar, copiar exemples i executar en local amb el teu terminal és més que suficient al principi.

Visual Studio Code: productivitat sense sortir de l'editor

El terminal integrat, el depurador i les extensions de VS Code fan que treballar amb Node sea molt còmode. Des de “Ver > Terminal” podeu obrir shells, canviar el predeterminat i executar node o npm run sin abandonar el editor. A més, configurar launch.json et permetrà depurar pas a pas.

Apuntes de versió i estabilitat

Moltes guies clàssiques es van provar amb versions antigues de Node, però els conceptes es mantenen vigents: callbacks, mòduls natius, asincronía, enrutat i separació de responsabilitats. Hoy treballaràs amb versions actuals, més ràpides i segures, i amb un ecosistema npm encara més rico.

Descàrregues i recursos addicionals

Pots ampliar l'estudi amb documentació, PDFs i tutorials. Revisa sempre la web oficial de Node per a novetats i descàrregues, i identifica les fonts didàctiques que inclouen exercicis, qüestionaris i reptes per a afianzar coneixements a mesura que avances.

Si busqueu material complementari, trobareu guies introductòries i referències pràctiques amb exemples, així com enllaços de descàrrega quan sigui necessari. Mantingueu el vostre enfocament en la pràctica: leer està bé; executar, romper coses i arreglar, millor.

Exemple complet: mini aplicació amb encaminador i controladors

Juntant pecesImagina't un projecte amb index.js que arrenca el servidor, server.js amb HTTP i anàlisi de POST, router.js que decideix quina funció executar i requestHandlers.js amb dos rutes: una que mostra un formulari i una altra que ensenya el text enviat.

// 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;

Amb aquest esqueleto mínim ja tens un servidor funcional i no bloquejant, amb rutes i controladors separats, preparats per créixer cap a vistes, càrregues o integració amb bases de dades.

La clau de Node està en pensar en “accions”: passar funcions, inyectar dependències quan es convoqui i mantenir petits els blocs de responsabilitat. Així, la teva aplicació serà més fàcil de mantenir i adaptar-se a la seva complexitat.

Tot ho veieu amb una base sòlida: des d'instal·lar Node i executar el vostre primer script, passant per VS Code, un servidor HTTP natiu, enrutat propi, Express, npm, mòduls natius, REPL, asincronía sense blocs i maneig de formularis POST. Amb pràctica i petites iteracions, podreu construir projectes cada vegada més complets sense perdre claritat en el codi.