Routing

Routing si riferisce a come gli endpoint di un’applicazione (URI) rispondono alle richieste del client. Per un’introduzione al routing, vedere Instradamento di base.

Definisci il routing usando metodi dell’oggetto app Express che corrispondono ai metodi HTTP; per esempio, app. et() per gestire le richieste GET e app.post per gestire le richieste POST. Per una lista completa, vedi app.METHOD. Puoi anche usare app.all() per gestire tutti i metodi HTTP e app. se() to specify middleware as the callback function (Vedi Using middleware for details).

Questi metodi di routing specificano una funzione di callback (a volte chiamata “funzioni di handler”) chiamata quando l’applicazione riceve una richiesta al percorso specificato (endpoint) e il metodo HTTP. In altre parole, l’applicazione “ascolta” per le richieste che corrispondono ai percorsi e ai metodi specificati, e quando rileva una corrispondenza, chiama la funzione di callback specificata.

Infatti, i metodi di routing possono avere più di una funzione di callback come argomenti. Con funzioni di callback multiple, è importante fornire next come argomento alla funzione di callback e poi chiamare next() all’interno del corpo della funzione per consegnare il controllo al prossimo callback.

Il seguente codice è un esempio di un percorso molto basilare.

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

// respond with "hello world" when a GET request is made to the homepage
app.get('/', (req, res) => {
  res.send('hello world');
});

Metodi percorso

Un metodo di percorso è derivato da uno dei metodi HTTP ed è collegato ad un’istanza della classe express.

Il seguente codice è un esempio di percorsi definiti per il GET e i metodi POST nella root dell’app.

// GET method route
app.get('/', (req, res) => {
  res.send('GET request to the homepage');
});

// POST method route
app.post('/', (req, res) => {
  res.send('POST request to the homepage');
});

Express supporta metodi che corrispondono a tutti i metodi di richiesta HTTP: get, post, e così via. Per un elenco completo, vedere app.METHOD.

C’è un metodo di routing speciale, app.all(), utilizzato per caricare le funzioni middleware in un percorso per tutti i metodi di richiesta HTTP. Ad esempio, il seguente gestore viene eseguito per le richieste al percorso "/secret" se si utilizza GET, POST, PUT, DELETE, o qualsiasi altro metodo di richiesta HTTP supportato nel modulo http.

app.all('/secret', (req, res, next) => {
  console.log('Accessing the secret section ...');
  next(); // pass control to the next handler
});

Percorsi di rotta

Percorsi di percorso, in combinazione con un metodo di richiesta, definire gli endpoint in cui le richieste possono essere fatte. I tracciati del percorso possono essere stringhe, motivi di stringa o espressioni regolari.

Percorsi di percorso basati su stringhe

Questo percorso corrisponderà alle richieste del percorso root, /.

app.get('/', (req, res) => {
  res.send('root');
});

Questo percorso corrisponderà alle richieste di /about.

app.get('/about', (req, res) => {
  res.send('about');
});

Questo percorso corrisponderà alle richieste a /random.text.

app.get('/random.text', (req, res) => {
  res.send('random.text');
});

Percorsi del percorso in base ai motivi delle stringhe

Questo percorso corrisponde a acd e abcd.

app.get('/ab?cd', (req, res) => {
  res.send('ab?cd');
});

Questo percorso corrisponderà a abcd, abbcd, abbbcd, e così via.

app.get('/ab+cd', (req, res) => {
  res.send('ab+cd');
});

Questo percorso corrisponde a abcd, abxcd, abRANDOMcd, ab123cd, e così via.

app.get('/ab*cd', (req, res) => {
  res.send('ab*cd');
});

Questo percorso corrisponde a /abe e /abcde.

app.get('/ab(cd)?e', (req, res) => {
  res.send('ab(cd)?e');
});

Percorsi di percorso basati su espressioni regolari

Questo percorso corrisponderà a qualsiasi cosa con una “a” in esso.

app.get(/a/, (req, res) => {
  res.send('/a/');
});

Questo percorso corrisponde a butterfly e dragonfly, ma non a butterflyman, dragonflyman, e così via.

app.get(/.*fly$/, (req, res) => {
  res.send('/.*fly$/');
});

Parametri percorso

I parametri del percorso sono denominati segmenti di URL che vengono utilizzati per catturare i valori specificati nella loro posizione nell’URL. I valori catturati sono popolati nell’oggetto req.params, con il nome del parametro route specificato nel percorso come loro rispettive chiavi.

Route path: /users/:userId/books/:bookId
Request URL: http://localhost:3000/users/34/books/8989
req.params: { "userId": "34", "bookId": "8989" }

Per definire i percorsi con i parametri del percorso, è sufficiente specificare i parametri del percorso nel percorso come mostrato di seguito.

app.get('/users/:userId/books/:bookId', (req, res) => {
  res.send(req.params);
});

Poiché il trattino (-) e il punto (.) sono interpretati letteralmente, possono essere utilizzati insieme ai parametri del percorso per scopi utili.

Route path: /flights/:from-:to
Request URL: http://localhost:3000/flights/LAX-SFO
req.params: { "from": "LAX", "to": "SFO" }

Route path: /plantae/:genus.:species
Request URL: http://localhost:3000/plantae/Prunus.persica
req.params: { "genus": "Prunus", "species": "persica" }

Per avere più controllo sulla stringa esatta che può essere abbinata a un parametro del percorso, puoi aggiungere un’espressione regolare tra parentesi (()):

Route path: /user/:userId(\d+)
Request URL: http://localhost:3000/user/42
req.params: {"userId": "42"}

Gestori del percorso

È possibile fornire più funzioni di callback che si comportano come middleware per gestire una richiesta. L’unica eccezione è che questi callback potrebbero invocare next('route') per bypassare i rimanenti callback del percorso. È possibile utilizzare questo meccanismo per imporre condizioni preliminari su un percorso, poi passare il controllo ai percorsi successivi se non c’è motivo di procedere con il percorso corrente.

app.get('/user/:id', (req, res, next) => {
  if (req.params.id === '0') {
    return next('route');
  }
  res.send(`User ${req.params.id}`);
});

app.get('/user/:id', (req, res) => {
  res.send('Special handler for user ID 0');
});

In questo esempio:

• GET /user/5 → gestito dal primo percorso → invia “User 5”
• GET /user/0 → prima rotta chiama next('route'), saltando al prossimo percorso corrispondente /user/:id

I gestori del percorso possono essere nella forma di una funzione, una serie di funzioni, o combinazioni di entrambi, come mostrato negli esempi seguenti.

Una singola funzione di callback può gestire un percorso. Per esempio:

app.get('/example/a', (req, res) => {
  res.send('Hello from A!');
});

Più di una funzione di callback può gestire un percorso (assicurati di specificare l’oggetto next). Per esempio:

app.get(
  '/example/b',
  (req, res, next) => {
    console.log('the response will be sent by the next function ...');
    next();
  },
  (req, res) => {
    res.send('Hello from B!');
  }
);

Un array di funzioni di callback può gestire un percorso. Per esempio:

const cb0 = function (req, res, next) {
  console.log('CB0');
  next();
};

const cb1 = function (req, res, next) {
  console.log('CB1');
  next();
};

const cb2 = function (req, res) {
  res.send('Hello from C!');
};

app.get('/example/c', [cb0, cb1, cb2]);

Una combinazione di funzioni indipendenti e matrici di funzioni può gestire un percorso. Per esempio:

const cb0 = function (req, res, next) {
  console.log('CB0');
  next();
};

const cb1 = function (req, res, next) {
  console.log('CB1');
  next();
};

app.get(
  '/example/d',
  [cb0, cb1],
  (req, res, next) => {
    console.log('the response will be sent by the next function ...');
    next();
  },
  (req, res) => {
    res.send('Hello from D!');
  }
);

Metodi di risposta

I metodi sull’oggetto di risposta (res) nella tabella seguente possono inviare una risposta al client e terminare il ciclo di richiesta-risposta. Se nessuno di questi metodi è chiamato da un gestore del percorso, la richiesta del cliente sarà sospesa.

app.route()

È possibile creare i gestori di rotte per un percorso utilizzando app.route(). Poiché il percorso è specificato in una singola posizione, è utile creare percorsi modulari, così come ridurre la ridondanza e pneumatici. Per ulteriori informazioni sulle rotte, si veda: Router() documentation.

Ecco un esempio di router incatenati che sono definiti utilizzando app.route().

app
  .route('/book')
  .get((req, res) => {
    res.send('Get a random book');
  })
  .post((req, res) => {
    res.send('Add a book');
  })
  .put((req, res) => {
    res.send('Update the book');
  });

express.Router

Usa la classe express.Router per creare i gestori modulari e montabili. Un’istanza Router è un sistema di routing e middleware completo; per questo motivo è spesso chiamata “mini-app”.

L’esempio seguente crea un router come modulo, carica una funzione middleware in esso, definisce alcuni percorsi e monta il modulo del router su un percorso nell’app principale.

Crea un file router chiamato birds.js nella directory delle app, con il seguente contenuto:

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

// middleware that is specific to this router
const timeLog = (req, res, next) => {
  console.log('Time: ', Date.now());
  next();
};
router.use(timeLog);

// define the home page route
router.get('/', (req, res) => {
  res.send('Birds home page');
});
// define the about route
router.get('/about', (req, res) => {
  res.send('About birds');
});

module.exports = router;

Quindi, caricare il modulo router nell’app:

const birds = require('./birds');

// ...

app.use('/birds', birds);

L’app sarà ora in grado di gestire le richieste di /birds e /birds/about, oltre a chiamare la funzione middleware timeLog che è specifica per il percorso.

Ma se il percorso principale /birds ha parametri di percorso, non sarà accessibile per impostazione predefinita dai sotto-percorsi. Per renderlo accessibile, dovrai passare l’opzione mergeParams al costruttore Router reference.

const router = express.Router({ mergeParams: true });