Il framework di Express

Express è un framework per applicazioni web basato su Node.js, progettato per essere minimale e flessibile. È il framework più diffuso nell’ecosistema Node.js, alla base di molti progetti. Con Express puoi:

Installazione di Express

Come ogni framework, anche Express deve essere installato nella cartella del nostro progetto Node.js. Per farlo, basta entrare nella cartella ed eseguire l'installazione tramite terminale: 

cd /Users/Admin/Desktop/progetto
npm install express

Una volta che è installato, ricordiamoci di aggiungere il modulo Express in tutti i nostri file Node.js:

const express = require('express');

Utilizzare Express

Il framework di Express non è complicato. Per prima cosa, creiamo un semplice file che permette di aprire un server che restituisca una pagina "Hello World!" quando ci si reca all'indirizzo http://localhost:3000.

const express = require("express");
const app = express();

app.get("/", (req, res) => {
  res.send("Hello World!");
});

app.listen(3000);

La prima istruzione dopo l'aggiunta del modulo di Express è sempre app = express(). Questa istruzione crea un oggetto che contiene dei metodi da utilizzare per gestire il server.

Poi, utilizziamo app.get(), un metodo che si attiva quando un utente visita una pagina (nel nostro caso, quando si trova nella home del nostro sito web). All'interno:

Con res.send() si invia al browser una risposta testuale e viene chiusa la connessione.

Infine, usando app.listen() si avvia il server, che inizia ad ascoltare le connessioni quando un utente apre la pagina, utilizzando la porta specificata (di solito 3000).

I metodi dell'oggetto app

Ecco riassunti i metodi più importanti da utilizzare con Express:

Possiamo, ad esempio, creare un file users.js per gestire soltanto gli utenti che si trovano alla pagina /users. A questo scopo, Express offre il costrutto express.Router() per suddividere le varie pagine in moduli diversi. Ad esempio, proviamo a guardare questo esempio di codice in users.js:

const express = require("express");
const router = express.Router();

// Pagina /users/
router.get("/", (req, res) => {
  res.send("Elenco utenti");
});

// Pagina /users/:id
router.get("/:id", (req, res) => {
  res.send("Utente " + req.params.id);
});

module.exports = router;

Nel file users.js, abbiamo creato un router indipendente, ovvero un modulo che gestisce autonomamente una singola cartella del server (ovvero localhost:3000/users).

Abbiamo definito una pagina principale (quando si accede a /users) che restituisce all'utente la lista delle persone iscritte al sito web.

Se, invece, la pagina è /users/1, possiamo scrivere :id per indicare che tutto quello che è successivo a /users/ è un parametro che si chiama id, che poi leggiamo con req.params.

Infine, con module.exports = router esportiamo il router per utilizzarlo nell'app principale. Avevamo già visto questa istruzione per i moduli personalizzati.

Ora, costruiamo il nostro index.js:

const express = require("express");
const usersRouter = require("./users");
const app = express();

app.use("/users", usersRouter);
app.listen(3000);

Attraverso app.use(), specifichiamo a Node.js di utilizzare il modulo usersRouter quando l'utente si trova alla pagina /users.

Facciamo partire il server (ricordati di recarti alla pagina localhost:3000/users e localhost:3000/users/2 per provare le istruzioni che abbiamo scritto):

node index.js

I metodi di req

Vediamo quali sono i metodi più importanti da utilizzare con req, ovvero l'oggetto contenente la richiesta (dall'inglese, request).

Vediamo i principali in dettaglio.

Il metodo req.body

Il metodo req.body contiene i dati inviati nel corpo della richiesta, tipicamente con JSON o form HTML.

Per prima cosa, dobbiamo utilizzare una o entrambe queste istruzioni, in base al caso:

Supponiamo di avere un form che invia un nome e un cognome. Creiamo prima il form HTML index.html: 

<form action="/submit" method="POST">
  <input type="text" placeholder="Nome" name="nome">
  <input type="text" placeholder="Cognome" name="cognome">
  <input type="submit" value="Invia">
</form>

Ora creiamo il file lato server che recupera le informazioni e le stampi nella pagina:

const express = require("express");
const app = express();

// Leggere i dati JSON e dei form
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.get("/", (req, res) => {
    res.sendFile(__dirname + "/index.html");
});

app.post("/submit", (req, res) => {
  const { nome, cognome } = req.body;
  res.send(`Dati ricevuti: Nome: ${nome}, Cognome: ${cognome}`);
});

app.listen(3000);

Nell'esempio:

Il metodo req.hostname

Il metodo req.hostname restituisce il nome del dominio della richiesta. È utile per controllare da quale host proviene la richiesta, ad esempio localhost o example.com.

Nell'esempio, vogliamo mostrare il nome dell'host per ogni richiesta.

const express = require("express");
const app = express();

app.get("/", (req, res) => {
  const host = req.hostname;
  res.send(`Richiesta ricevuta da: ${host}`);
});

app.listen(3000);

Il metodo req.ip

Il metodo req.ip restituisce l'indirizzo IP del client che ha fatto la richiesta. È utile per la geolocalizzazione, la sicurezza o per limitare le richieste da un certo IP.

Nell'esempio, vogliamo mostrare all'utente il suo indirizzo IP.

const express = require("express");
const app = express();

app.get("/", (req, res) => {
  const clientIp = req.ip;
  res.send(`Il tuo indirizzo IP è: ${clientIp}`);
});


app.listen(3000);

Nota: l'IP viene mostrato soltanto su un dominio reale. Se si accede tramite localhost, allora si vedrà ::1 o 127.0.0.1.

Il metodo req.params

Il metodo req.params è un oggetto che contiene i parametri dinamici definiti nell'URL. Ad esempio, in un percorso come /users/:id, il valore di :id sarà disponibile in req.params.id.

Ad esempio, vogliamo visualizzare il profilo di un utente specifico.

const express = require("express");
const app = express();

app.get("/users/:id", (req, res) => {
  const userId = req.params.id;
  res.send(`Richiesta del profilo utente con ID: ${userId}`);
});



app.listen(3000);

Il metodo req.path

Il metodo req.path restituisce il percorso dell'URL della richiesta, escludendo la query string. Ad esempio, per la URL https://example.com/products/view?category=books, req.path sarà /products/view.

Nell'esempio, vogliamo sapere il percorso della pagina visitata dall'utente.

const express = require("express");
const app = express();

app.get("/blog/post", (req, res) => {
  const path = req.path;
  res.send(`Stai visitando il percorso: ${path}`);
});




app.listen(3000);

Per vedere il risultato dell'esempio, devi recarti in localhost:3000/blog/post.

I metodi di res

Vediamo quali sono i metodi più importanti di res, ovvero l'oggetto contenente la risposta da dare all'utente (dall'inglese, response).

Vediamo i principali in dettaglio.

Il metodo res.send()

Il metodo res.send() è uno dei più usati in Express per inviare una risposta HTTP al client.

Quando passi una stringa a res.send(), Express la considera automaticamente codice HTML. Questo è utile per inviare semplici messaggi di testo o porzioni di pagina.

app.get("/", (req, res) => {
  res.send("<h1>Hello, world!</h1>");
});

Se passi un oggetto o un array, Express riconosce la struttura e la struttura in JSON. Questo può essere utile per creare delle API.

app.get("/api", (req, res) => {
  const user = { name: "Mario Rossi", age: 30 };
  res.send(user);
});

Se passi un numero intero, Express lo interpreterà come uno stato HTTP e terminerà la risposta senza inviare dati.

app.get("/", (req, res) => {
  res.send(404); // Errore 404: Pagina non trovata
});

Il metodo res.json()

Il metodo res.json() invia una risposta in formato JSON. A differenza di res.send(), che cerca di indovinare il tipo di contenuto, res.json() converte automaticamente il body (che può essere un oggetto, un array o un valore) in una stringa JSON.

Ad esempio, vogliamo restituire un oggetto con il prezzo di due elementi di uno store:

app.get("/api/products", (req, res) => {
  const products = [
    { id: 1, name: "Laptop", price: 1200 },
    { id: 2, name: "Mouse", price: 25 },
  ];
  res.json(products);
});

Il metodo res.end()

Il metodo res.end() termina la richiesta senza inviare alcun dato nel corpo della risposta. È utile quando non c'è bisogno di rispondere con un contenuto o un messaggio, ad esempio per terminare la connessione. Serve comunque mandare uno stato HTTP di risposta, usando res.status().

app.head("/end", (req, res) => {
  res.status(200).end();
});

Il metodo res.sendFile()

Il metodo res.sendFile() permette di inviare un file come risposta all'utente. Per funzionare bisogna specificare il percorso del file, che può essere in formati come HTML, CSS o JavaScript.

app.get("/", (req, res) => {
  res.sendFile("C:/Users/admin/Desktop/progetto/index.html");
});

Se il file è nella stessa cartella dello script, si può usare __dirname, è una variabile globale nativa contenente il percorso della directory dove si trova lo script in esecuzione. Per unire questo percorso al nome del file, usiamo la funzione path.join(). Questa funzione fa parte del modulo path di Node.js, che deve essere importato per poter essere utilizzato.

const express = require("express");
const path = require("path");
const app = express();

app.get("/", (req, res) => {
  const filePath = path.join(__dirname, "index.html");
  res.sendFile(filePath);
});

app.listen(3000);

Nell'esempio utilizziamo path.join() per unire il percorso (__dirname) al nome del file (index.html).

Il metodo res.status()

Il metodo res.status() imposta lo stato HTTP per la risposta. È un metodo che deve essere concatenato con un altro metodo che invia i dati, come res.send() o res.json(). È cruciale per comunicare al client se la richiesta è andata a buon fine, se ci sono stati errori, o se è necessario un reindirizzamento.

app.post("/nuovo-articolo", (req, res) => {
  const postData = req.body;
  if (!postData || !postData.title) {
    // Imposta lo stato a 400 Bad Request e invia un messaggio
    return res.status(400).json({ error: "Il titolo manca" });
  }

  // Se la richiesta è andata a buon fine, imposta lo stato a 201 Created
  res.status(201).json({ message: "Articolo creato!" });
});

Nell'esempio, se esiste la variabile postData e postData.title, allora viene restituito uno stato 201, altrimenti una risposta 400.

Il metodo res.set()

Il metodo res.set() imposta l'intestazione HTTP della risposta. Puoi usarlo per impostare un'intestazione singola con un valore, o per impostare più intestazioni passando un oggetto.

app.get("/", (req, res) => {
  res.set("Content-Type", "text/plain");
  res.send("Questa è una risposta di solo testo.");
});

Il metodo res.cookie()

Il metodo res.cookie() imposta un cookie nel browser del client. I cookie sono piccole stringhe di testo usate per memorizzare dati sul browser dell'utente, come le sessioni, le preferenze o i token di autenticazione.

Ad esempio, creiamo un cookie chiamato sessionId che scade dopo 15 minuti.

app.get("/login", (req, res) => {
  // Imposta un cookie che scade dopo 900000 millisecondi (15 minuti)
  res.cookie("sessionId", "user12345", { maxAge: 900000, httpOnly: true });
  res.send("Cookie di sessione impostato.");
});

Il metodo res.clearCookie()

Il metodo res.clearCookie() cancella un cookie precedentemente impostato dal browser del client. È essenziale per gestire il logout degli utenti o per rimuovere dati temporanei.

Ad esempio, cancelliamo il cookie di sessione dell'utente.

app.get("/logout", (req, res) => {
  res.clearCookie("sessionId");
  res.send("Logout avvenuto. Il cookie di sessione è stato cancellato.");
});

Il metodo res.redirect()

Il metodo res.redirect() reindirizza il client a un URL diverso. Quando il browser riceve una risposta di reindirizzamento, esegue una nuova richiesta all'URL specificato.

Ad esempio, reindirizziamo l'utente dalla pagina /login a una pagina /home.

app.get("/login", (req, res) => {
  res.redirect("/home");
});