Ottenere un corpo POST HTTP in Express.js

Introduzione

In questo breve articolo vedremo come estrarre informazioni da un corpo POST in Express.js. Il protocollo HTTP fornisce una serie di modi per passare informazioni da un client a un server, con i corpi POST che sono il metodo più flessibile e più comunemente usato per inviare dati via HTTP.

Un altro modo, che è tipicamente utilizzato per diversi casi d’uso, è quello di trasmettere informazioni utilizzando stringhe di query o parametri URL. Per maggiori informazioni, controlla come ottenere stringhe di query e parametri in Express.js.

Per questo articolo presumo che tu abbia un po’ di esperienza con Node.js e con la creazione di semplici server Express.js.

Inviare dati POST in HTTP

I dati possono essere inviati tramite una chiamata HTTP POST per molte ragioni, alcune delle più comuni sono tramite un HTML <form> o una richiesta API. I dati possono assumere diverse forme, le più comuni sono:

• application/x-www-form-urlencoded: I dati in questa codifica sono formattati come una stringa di query che vedresti in un URL, con i valori chiave separati da & caratteri. Per esempio: foo=bar&abc=123&stack=abuse. Questa è la codifica predefinita.
• multipart/form-data: Questa codifica è tipicamente usata per inviare file. In breve, ogni valore-chiave viene inviato nella stessa richiesta, ma in diverse “parti”, che sono separate da “confini” e includono più meta-dati.
• text/plain: Questi dati vengono semplicemente inviati come testo semplice non strutturato, e tipicamente non vengono utilizzati.

Una richiesta HTTP POST grezza con la codifica application/x-www-form-urlencoded potrebbe apparire come questa:

POST /signup HTTP/1.1Host: example.comContent-Type: application/x-www-form-urlencodedContent-Length: 53username=scott&password=secret&website=stackabuse.com

Estrazione dei dati POST

Prima di poter iniziare ad accedere ai dati POST, dobbiamo configurare correttamente la nostra app Express. Questa configurazione deve essere fatta perché non tutti i server delle web app hanno bisogno del body parsing, e quale body parsing è abilitato dipende dalla tua applicazione.

Per impostare questo, useremo il pacchetto body-parser, che può gestire molte forme di dati. Questo pacchetto è un middleware che intercetta il corpo grezzo e lo analizza in una forma che il codice dell’applicazione può facilmente utilizzare.

// index.jsconst express = require('express');const bodyParser = require('body-parser');const app = express();app.use(bodyParser.urlencoded({ extended: true }));app.post('/post-test', (req, res) => { console.log('Got body:', req.body); res.sendStatus(200);});app.listen(8080, () => console.log(`Started server at http://localhost:8080!`));

Nota come chiamiamo app.use(...) prima di definire la nostra rotta. L’ordine qui è importante. Questo farà sì che il body-parser venga eseguito prima della nostra rotta, il che assicura che la nostra rotta possa accedere al corpo HTTP POST analizzato.

Per testare questo, avvieremo prima l’app Express e poi useremo l’utility curl in un’altra finestra della console:

$ curl -d "username=scott&password=secret&website=stackabuse.com" -X POST http://localhost:8080/post-testOK

$ node index.jsStarted server at http://localhost:8080!Got body: { username: 'scott', password: 'secret', website: 'stackabuse.com' }

Qui potete vedere che i dati della query string sono stati analizzati in un oggetto JavaScript al quale possiamo facilmente accedere.

Another important thing to note is our use of the extended option when calling bodyParser.urlencoded. Using the extended option tells body-parser to use the qs library to parse the URL-encoded data. This allows for things like objects and arrays to be encoded into the URL-encoded format.

And while urlencoded is one of the most commonly used parsers that body-parser provides, you can also use the following:

• .json(): Parses JSON-formatted text for bodies with a Content-Type of application/json.
• .raw(): Parses HTTP body in to a Buffer for specified custom Content-Types, although the default accepted Content-Type is application/octet-stream.
• .text(): Analizza i corpi HTTP con un Content-Type di text/plain, che lo restituisce come una semplice stringa.

Ognuno di questi parser supporta anche l’inflazione automatica dei dati codificati con gzip o deflate, così la compressione può ancora essere usata in modo trasparente senza alcun lavoro extra da parte del codice della vostra applicazione.

La cosa grandiosa del modello middleware e di come questo pacchetto analizza i dati è che non si è costretti ad usare un solo analizzatore. Puoi abilitare uno o più analizzatori per la tua applicazione per assicurarti che tutti i tipi di dati siano processati correttamente:

// index.jsconst express = require('express');const bodyParser = require('body-parser');const app = express();app.use(bodyParser.urlencoded({ extended: true }));app.use(bodyParser.json());app.use(bodyParser.raw());// ...

Così ora se dovessimo inviare una richiesta HTTP POST con JSON come corpo, sarà analizzato in un normale oggetto JSON nella proprietà req.body:

POST /post-test HTTP/1.1Host: localhost:8080Content-Type: application/jsonContent-Length: 69'{"username":"scott","password":"secret","website":"stackabuse.com"}'

$ node index.jsStarted server at http://localhost:8080!Got body: { username: 'scott', password: 'secret', website: 'stackabuse.com' }

Conclusione

Il modo più comune per inviare diverse e grandi quantità di dati via HTTP è usare il metodo POST. Prima di poter accedere facilmente a questi dati sul lato server in Express, abbiamo bisogno di usare qualche middleware, come il pacchetto body-parser, per analizzare i dati in un formato al quale possiamo accedere facilmente. Una volta che i dati della richiesta HTTP grezza vengono analizzati, è possibile accedervi tramite la proprietà body dell’oggetto req.