HTTP POST Body ophalen in Express.js

Inleiding

In dit korte artikel gaan we in op hoe je informatie uit een POST body kunt halen in Express.js. Het HTTP protocol biedt een aantal manieren om informatie van een client naar een server te sturen, waarbij POST bodies de meest flexibele en meest gebruikte methode is om data via HTTP te versturen.

Een andere manier, die typisch wordt gebruikt voor verschillende use-cases, is om informatie over te brengen met behulp van query strings of URL parameters. Voor meer informatie, zie hoe query strings en parameters in Express.js te krijgen.

Voor dit artikel ga ik ervan uit dat je enige ervaring hebt met Node.js en het maken van eenvoudige Express.js servers.

Versturen van POST data in HTTP

Data kan worden verzonden via een HTTP POST call om vele redenen, met enkele van de meest voorkomende zijn via een HTML <form> of een API verzoek. De gegevens kunnen verschillende vormen aannemen, waarvan de meest voorkomende zijn:

• application/x-www-form-urlencoded: Gegevens in deze codering zijn geformatteerd als een querystring die je in een URL zou zien, waarbij key-value paris worden gescheiden door &-tekens. Bijvoorbeeld: foo=bar&abc=123&stack=abuse. Dit is de standaard encoding.
• multipart/form-data: Deze encoding wordt typisch gebruikt voor het verzenden van bestanden. Kort gezegd wordt elke key-value in hetzelfde request verzonden, maar in verschillende “delen”, die worden gescheiden door “grenzen” en meer metagegevens bevatten.
• text/plain: Deze gegevens worden gewoon als ongestructureerde platte tekst verzonden, en worden doorgaans niet gebruikt.

Een ruw HTTP POST verzoek met de application/x-www-form-urlencoded codering zou er ongeveer zo uit kunnen zien:

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

Extractie van POST data

Voordat we direct aan de slag kunnen met POST data, moeten we onze Express app goed configureren. Deze configuratie is nodig omdat niet alle web app servers body parsing nodig hebben, en welke body parsing is ingeschakeld hangt af van uw applicatie.

Om dit op te zetten, gebruiken we het body-parser pakket, dat vele vormen van data kan verwerken. Dit pakket is een middleware die de ruwe body onderschept en parseert in een vorm die uw applicatie code gemakkelijk kan gebruiken.

// 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!`));

Merk op hoe we app.use(...) aanroepen voordat we onze route definiëren. De volgorde is hier belangrijk. Dit zorgt ervoor dat de body-parser vóór onze route wordt uitgevoerd, wat ervoor zorgt dat onze route vervolgens toegang krijgt tot de geparsede HTTP POST body.

Om dit te testen, starten we eerst de Express app en gebruiken dan de curl utility in een ander console venster:

$ 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' }

Hier kunt u zien dat de query string data is geparseerd in een JavaScript object dat we gemakkelijk kunnen benaderen.

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(): Parseert HTTP-bodies met een Content-Type of text/plain, die het retourneert als een platte string.

Elke van deze parsers ondersteunt ook het automatisch opblazen van gegevens die zijn gecodeerd met gzip of deflate, zodat compressie nog steeds transparant kan worden gebruikt zonder extra werk door uw applicatiecode.

Het mooie van het middleware-model en de manier waarop dit pakket gegevens parseert, is dat u niet gebonden bent aan het gebruik van slechts één parser. U kunt een of meer parsers voor uw app inschakelen om ervoor te zorgen dat alle gegevenstypen correct worden verwerkt:

// 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());// ...

Dus als we nu een HTTP POST-verzoek met JSON als body zouden verzenden, wordt dit in een gewoon JSON-object in de req.body property geparseerd:

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' }

Conclusie

De meest gebruikelijke manier om diverse en grote hoeveelheden gegevens via HTTP te verzenden is door gebruik te maken van de POST methode. Voordat we deze gegevens gemakkelijk kunnen benaderen aan de server kant in Express, moeten we middleware gebruiken, zoals het body-parser pakket, om de gegevens te ontleden in een formaat dat we gemakkelijk kunnen benaderen. Zodra de data van het ruwe HTTP verzoek is geparsed, kan het worden benaderd via de body property van het req object.