Node.js:n opetusohjelma periaatteessa: de cero a tu primera app

Etusivu » Python » Node.js:n opetusohjelma periaatteessa: de cero a tu primera app

Si es tu primera toma de contacto Continental 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 eemplos prácticos y explicaciones claras. Te acompañaré desde el mítico Hola Mundo hasta levantar una app web con Express, pasando por modulos del system, npm y el enfoque asíncrono que hace tan especial al ecosistema de Node.

Oriental-harrastukset requisitos previos, configuración fi Visual Studio Code y primeros proyectos, veras 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

Necesitarás unos conocimientos básicos de JavaScript (tipos, muuttujat, 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 permite gestionar muchas conexiones concurrentes sin crear un hilo por cada petición.

Solmu voi rakentaa servidores web, APIs REST, herramientas de línea de comandos, apps en tiempo real (chat, notificaciones), integraciones con bases de datas y hasta proyectos IoT. Su fortaleza está en el manejo de E/S concurrente, lo que lo hace ideal para trafico alto y experiencias interactiveas.

Lataa ja asenna

Lataa Node.js virallisesta webistä en nodejs.org e instálalo para tu system operativo. Windows-, macOS- tai Linux-käyttöjärjestelmissä asennetaan ja paquetes adecuados. Tras la instalación, vahvista terminaaliin: node -v y npm -v. npm es el gestor de paquetes de Node y te permitirá instalar librerías de terceros de forma sencilla.

Pohjustuskontakti: Hola Mundo con VS Code

Si usa Visual Studio -koodi, 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 koodi.. Luo nimetty tiedosto app.js Esittele algo sencillo para arrancar: viesti konsolille.

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

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

De cero a servidor: un HTTP-palvelin minimo

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 vierailla 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" (takaisinsoitto) 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 muuttujat. 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 ratkaisevan tärkeää ymmärtää ero ns. operaciones bloqueantes y no bloqueantes. Si esittelee algo que ocupa la CPU durante segundos (por eemplo, 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 takaisinsoittoja o promesas para evitar bloquear el hilo.

Diseño modulaarinen: servidor, reititin ja manejadores

Erilliset vastuut te ayudará a escalar el proyecto: un modulo para el servidor HTTP, otro para el enrutador y otros para los controladores (pyyntökäsittelijät). Puedes exponer funciones con exports y requerir modulos locales con require('./miModulo').

Una estructura típica podría ser: index.js kuten sisäänkäynti, server.js HTTP-palvelimella, reititin.js para decidir a qué función mandar cada ruta y requestHandlers.js con la lógica de cada -päätepiste. Esta organzación mantiene el código readible y fácil de probar.

Extrayendo la ruta y enrutando

El objeto pyyntö tiene la URL solicitadaAlkuperäinen moduuli url sallia ylimääräinen el polku y, si hace falta, la kysely. 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) ...
}

Reitittimen vastaanotto toimintojen reittikartta (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 olemassa, la ejecuta; ei, devuelve un 404.

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

Tavanomainen harjoittelu 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 ruiskuttaa esineen vastauksen 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();
  }
}

Tämä lähestymistapa mahdollistaa vastaaja justo cuando la E/S asíncrona concluye, sin bloquear el proceso ni forzar a devolver datos antes de tiempo.

Express: luo sovellus web minuutilla

Express on minimalista kehys Node.js:lle helpottaa käyttöä, näkymiä, väliohjelmistoa ja HTTP:n käyttöä. Con su generador puedes crear la estructura de un proyecto en segundos, con carpetas para rutas, vistas y recursos estáticos.

1. Luo kansio projekteillesi: mkdir ExpressProjects && cd ExpressProjects.
2. Suku una plantilla: npx express-generator HelloWorld --view=pug luo sovellus mopsiin.
3. Avaa VS-koodissa kanssa code . ja tarkista rakenne: astia (arranque) julkinen (JS/CSS/kuvat), reitit (tienpitäjät), näkymät (kasvit) app.js (kokoonpano), package.json (skriptit ja riippuvuudet).
4. Asenna riippuvuudet kanssa npm install projektin matolla.
5. Käynnistä sovellus. Esimerkiksi, con depuración: npx cross-env DEBUG=HelloWorld:* npm start.
6. avautuu http://localhost:3000. Prueba a cambiar la vista principal: in views/index.pug, korvaa otsikon h1 "Hello World!" ja lataa uudelleen.

Express incorpora lo necesario para käyttöliittymä GET, POST, PUT ja DELETE, usar middleware, servir estáticos, renderizar vistas y estructurar una app de varias paginas con menos fricción.

npm y modulos incorporados de Node

npm es el gestor de paquetes de Node y te allowe instalar libreriaas de terceros. Esimerkiksi Expressillä: npm install express. Sitten voit require('express') y utilizarlo en tu código. Esta flexibilidad es clave para crecer con tu proyecto.

Además, solmu mukaan lukien natiivimoduulit kuntia varten: fs (arkisto) http/https (palvelijat), path (rutit), os (järjestelmän tiedot), url (URL-osoitteen jäsentäminen) y muchos lisää. Puedes importarlos con require() asentamatta mitään.

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 arkistot.

1. Escribe os.platform() para saber la plataforma (win32, linux, darwin…). Vahvista SO-aktivointi suoraan.
2. kanssa os.arch() obtendrás la arquitectura (x64, arm64…). Binaarien tai rakennusten suunnittelu.
3. Yhdysvallat os.cpus() para ver los núcleos disponibles. Ideaalinen tasapainoiseen kuormaukseen con clusteres o procesos hijos.
4. Sal del REPL con .exit tai paina Ctrl+C kahdesti. Nopea ja jäännökset puuttuvat.

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

NPM-ekosysteemi on valtava. Algunas utilidades populares: terävä (tratamiento de imágenes y compresión), PDFKit (PDF-sukupolvi) validator.js (kahdensien validointi), imagemin y UglifyJS (minifikaatio) spritesmith (spritit), winston (metsästys) y komentaja.js (CLI). Asennukset npm install <paquete> kun tarvitset niitä.

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

Guarda tu código en un archivo, esimerkiksi app.js, ja ejekútalo kanssa node app.js terminaalissa. 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 dokumentti 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 (takaisinsoitto de createServer) añade-kuuntelijat 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, käytä moduulia 'kyselymerkkijono' parsear el cuerpo cuando llega como application/x-www-form-urlencoded: querystring.parse(postBody).text, Esimerkiksi.

Operaciones costosas y exec no bloqueante

Para ejecutar comandos del system sin detener el servidor, usea child_process.exec vastaa takaisinsoittoon. Puedes añadir opciones como timeout o maxBuffer para controlar comandos pesados. El patrón es siempre el mismo: nada de bloquear, y vastaaja 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 lataa moniosaisia (kuvat u otro arkiston) lo más práctico es recurrir a un paquete especializado. Módulos como ihana helpottaa jäsentämistä multipart/form-data, acceder a los archivos temporales y moverlos a su destino. Idea es la misma: takaisinkutsuja/promesoja 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: palvelin joka sai reseptin, reititin que dirige a la ruta de subida, y käsittelijä que valid, guarda y responsee con el resultado (por eemplo, mostrando la imagen).

Estructura de vistas y contenido dinamico

Käytä Express- ja Mopsi-moottoria, 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 Process y devuelve el contenido sai.

Hyvät organisaatiokäytännöt

Monolyyttiset Evita-arkistot. Divide en modulos, nombra funciones con verbos que expresen acciones (por ejemplo, Iniciar, Subir, lista), y desacopla con inyección de dependencias cuando tenga sentido (pasando funciones o mapas de rutas al servidor y al router). Mantener las capas ligeras te sallii crecer sin dolores.

Qué puedes construir construir con Node.js

Malli on tapahtumaohjattu ja estävä lo hace especialmente bueno for: palvelevat verkkoa, API:t REST, sovellukset ja todelliset sovellukset (chat, kojelaudat), botit ja CLI:t, integraatiot tietopohjan kanssa, kola de trabajo ja laitteiston hallinta. La facilidad para manjar websockets y streaming lo convierte en una elección natural para experiencias interactiveas.

• Verkkosivustot ja -palvelut SSR-kasvien kanssa.
• REST-sovellusliittymät preparadas para alto trafico.
• Reaaliaikainen con sockets para chat, notificaciones tai juegos.
• komentorivityökalut automatisoida tehtäviä.
• Procesos con ficheros y bases de datas, kola- ja putkistot.
• IoT ja laitteisto erityisten kirjastojen avulla.

Herramientas de aprendizaje y práctica

Existen entornos interactiveos que muestran 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 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 syn abandonar el editor. Además, konfiguroi launch.json te atļaujirá depurar paso a paso.

Apuntes de versión y estabilidad

Muchas guías clásicas se probaron con versiones antiguas de Node, mutta los conceptos se mantienen vigentes: takaisinsoitto, 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.

Lataa y recursos adicionales

Puedes ampliar estudio ja dokumentaatio, PDF-tiedostot ja opetusohjelmat. Revisa siempre la web oficial de Node para novedades y descarga, e identifica fuentes didácticas que incluyan siemensyöksyt, tietokilpailut ja harjoitukset 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. Pidä keskittymisenne harjoittelussa: leer está bien; ejecutar, romper cosas y arreglarlas, mejor.

Esim. täydellinen: minisovellus reitittimellä ja käsittelijillä

Juntando-piezasKuvittele projekti index.js mitä palvelija järjestää, server.js HTTP:n ja POST-jäsennyksen avulla reititin.js que Decision qué función ejecutar y requestHandlers.js con dos rutas: una que muestra un formulaario 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 primer 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.