È possibile che questo documento non sia aggiornato poiché la documentazione è in inglese. Per gli ultimi aggiornamenti, fare riferimento alla documentazione in inglese.
✖
Compilazione del middleware per l’utilizzo nelle applicazioni Express
Panoramica
Le funzioni middleware sono funzioni con accesso all’oggetto richiesta (req), all’oggetto risposta (res) e alla successiva funzione middleware nel ciclo richiesta-risposta dell’applicazione. La successiva funzione middleware viene comunemente denotata da una variabile denominata next.
Le funzioni middleware possono eseguire le attività elencate di seguito:
Eseguire qualsiasi codice.
Apportare modifiche agli oggetti richiesta e risposta.
Terminare il ciclo richiesta-risposta.
Chiamare il successivo middleware nello stack.
Se la funzione middleware corrente non termina il ciclo richiesta-risposta, deve richiamare next() per passare il controllo alla successiva funzione middleware. Altrimenti, la richiesta verrà lasciata in sospeso.
I seguenti esempi mostrano gli elementi di una chiamata alla funzione middleware:
Metodo HTTP per cui si applica la funzione middleware.
</tbody>
Percorso (route) per cui si applica la funzione middleware.
La funzione middleware.
Argomento di callback nella funzione middleware, denominata per convenzione "next".
Argomento risposta HTTP nella funzione middleware, denominato "res" per convenzione.
Argomento richiesta HTTP nella funzione middleware, denominato "req" per convenzione.
</table>
Starting with Express 5, middleware functions that return a Promise will call `next(value)` when they reject or throw an error. `next` will be called with either the rejected value or the thrown Error.
Esempio
Ecco un esempio di una semplice applicazione Express "Hello World", per cui si definiranno due funzioni middleware:
The remainder of this article will define and add three middleware functions to the application:
one called `myLogger` that prints a simple log message, one called `requestTime` that
displays the timestamp of the HTTP request, and one called `validateCookies` that validates incoming cookies.
```js
const express = require('express')
const app = express()
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(3000)
```
Middleware function myLogger
Ecco un semplice esempio di una funzione middleware, denominata "myLogger". Questa funzione stampa semplicemente la dicitura "LOGGED" quando una richiesta all'applicazione la attraversa. La funzione middleware è assegnata ad una variabile denominata `myLogger`.
```js
const myLogger = function (req, res, next) {
console.log('LOGGED')
next()
}
```
Si noti la chiamata precedente a next(). Richiamando questa funzione si richiama la successiva funzione middleware nell’applicazione.
La funzione next() non fa parte dell’API Express o Node.js, ma è il terzo argomento trasmesso alla funzione middleware. La funzione next() potrebbe essere denominata in qualsiasi modo, ma per convenzione viene sempre denominata “next”.
Per evitare confusione, utilizzare sempre questa convenzione.
Per caricare la funzione middleware, richiamare `app.use()`, specificando la funzione middleware.
Ad esempio, il seguente codice carica la funzione middleware `myLogger` prima della route al percorso root (/).
```js
const express = require('express')
const app = express()
const myLogger = function (req, res, next) {
console.log('LOGGED')
next()
}
app.use(myLogger)
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(3000)
```
Ogni volta che un'applicazione riceve una richiesta, viene stampato il messaggio "LOGGED" sul terminale.
L'ordine di caricamento del middleware è importante: le funzioni middleware che vengono caricate per prime vengono anche eseguite per prime.
Se `myLogger` viene caricato dopo la route sul percorso root, la richiesta non lo raggiunge mai e l'applicazione non stampa "LOGGED", poiché l'handler di route del percorso root termina il ciclo richiesta-risposta.
La funzione middleware `myLogger` stampa semplicemente un messaggio, successivamente passa la richiesta alla successiva funzione middleware nello stack chiamando la funzione `next()`.
Middleware function requestTime
Nel successivo esempio viene aggiunta una proprietà denominata `requestTime` all'oggetto richiesta. Questa funzione middleware verrà denominata "requestTime".
```js
const requestTime = function (req, res, next) {
req.requestTime = Date.now()
next()
}
```
L'applicazione utilizza ora la funzione middleware `requestTime`. Inoltre, la funzione di callback della route percorso root utilizza la proprietà che la funzione middleware aggiunge a `req` (l'oggetto richiesta).
```js
const express = require('express')
const app = express()
const requestTime = function (req, res, next) {
req.requestTime = Date.now()
next()
}
app.use(requestTime)
app.get('/', (req, res) => {
let responseText = 'Hello World! '
responseText += `Requested at: ${req.requestTime}`
res.send(responseText)
})
app.listen(3000)
```
Quando si effettua una richiesta al root dell'applicazione, l'applicazione mostra la cronologia data e ora della richiesta nel browser.
Middleware function validateCookies
Finally, we'll create a middleware function that validates incoming cookies and sends a 400 response if cookies are invalid.
Here's an example function that validates cookies with an external async service.
```js
async function cookieValidator (cookies) {
try {
await externallyValidateCookie(cookies.testCookie)
} catch {
throw new Error('Invalid cookies')
}
}
```
Here, we use the [`cookie-parser`](/resources/middleware/cookie-parser.html) middleware to parse incoming cookies off the `req` object and pass them to our `cookieValidator` function. The `validateCookies` middleware returns a Promise that upon rejection will automatically trigger our error handler.
```js
const express = require('express')
const cookieParser = require('cookie-parser')
const cookieValidator = require('./cookieValidator')
const app = express()
async function validateCookies (req, res, next) {
await cookieValidator(req.cookies)
next()
}
app.use(cookieParser())
app.use(validateCookies)
// error handler
app.use((err, req, res, next) => {
res.status(400).send(err.message)
})
app.listen(3000)
```
Note how next() is called after await cookieValidator(req.cookies). This ensures that if cookieValidator resolves, the next middleware in the stack will get called. If you pass anything to the next() function (except the string 'route' or 'router'), Express regards the current request as being an error and will skip any remaining non-error handling routing and middleware functions.
Poiché si dispone dell'accesso all'oggetto richiesta, l'oggetto risposta, la successiva funzione middleware nello stack e l'API Node.js completo, le possibilità con le funzioni middleware sono infinite.
Per ulteriori informazioni sul middleware Express, consultare: [Utilizzo del middleware Express](/it/guide/using-middleware.html).
Configurable middleware
If you need your middleware to be configurable, export a function which accepts an options object or other parameters, which, then returns the middleware implementation based on the input parameters.
File: `my-middleware.js`
```js
module.exports = function (options) {
return function (req, res, next) {
// Implement the middleware function based on the options object
next()
}
}
```
The middleware can now be used as shown below.
```js
const mw = require('./my-middleware.js')
app.use(mw({ option1: '1', option2: '2' }))
```
Refer to [cookie-session](https://github.com/expressjs/cookie-session) and [compression](https://github.com/expressjs/compression) for examples of configurable middleware.
