Obtenha um corpo POST HTTP no Express.js

Introdução

Neste breve artigo vamos rever como extrair informações de um corpo POST no Express.js. O protocolo HTTP fornece uma série de maneiras de passar informações de um cliente para um servidor, com corpos POST sendo o método mais flexível e mais comumente usado para enviar dados via HTTP.

Uma outra maneira, que é tipicamente usada para diferentes casos de uso, é transmitir informações usando strings de consulta ou parâmetros URL. Para mais informações, veja como obter strings e parâmetros de consulta em Express.js.

Para este artigo eu assumo que você tem alguma experiência com Node.js e criação de servidores Express.js simples.

Enviar dados POST em HTTP

Os dados podem ser enviados via uma chamada POST HTTP por muitas razões, sendo algumas das mais comuns via HTML <form> ou uma solicitação API. Os dados podem assumir algumas formas diferentes, sendo a mais comum:

• application/x-www-form-urlencoded: Os dados nesta codificação são formatados como uma query string que você veria em uma URL, com paris de valor chave separados por caracteres &. Por exemplo: foo=bar&abc=123&stack=abuse. Esta é a codificação padrão.
• multipart/form-data: Esta codificação é tipicamente usada para o envio de arquivos. Em resumo, cada valor chave é enviado na mesma requisição, mas diferentes “partes”, que são separadas por “limites” e incluem mais meta-dados.
• text/plain: Estes dados são apenas enviados como texto simples não estruturado, e tipicamente não é usado.

Um pedido HTTP POST cru com o application/x-www-form-urlencoded a codificação pode parecer algo como isto:

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

Extraindo dados POST

Antes de podermos começar a acessar os dados POST imediatamente, precisamos configurar corretamente nosso aplicativo Express. Esta configuração precisa ser feita já que nem todos os servidores de aplicação web precisam de análise de corpo, e qual análise de corpo está habilitada depende da sua aplicação.

Para configurar isto, estaremos usando o pacote body-parser, que pode lidar com muitas formas de dados. Este pacote é um middleware que intercepta o corpo bruto e o analisa em um formulário que seu código de aplicação pode facilmente usar.

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

Notice como chamamos app.use(...) antes de definir nossa rota. A ordem aqui importa. Isto irá assegurar que o body-parser irá correr antes da nossa rota, o que assegura que a nossa rota pode então aceder ao corpo do HTTP POST analisado.

Para testar isto, vamos primeiro iniciar a aplicação Express e depois usar o utilitário curl numa janela de consola diferente:

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

Aqui pode ver que os dados da string de consulta foram analisados num objecto JavaScript ao qual podemos facilmente aceder.

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(): Parses corpos HTTP com um Content-Type de text/plain, que o retorna como uma string simples.

Cada um destes analisadores também suporta a inflação automática de dados codificados com gzip ou deflate, assim a compressão ainda pode ser utilizada de forma transparente sem qualquer trabalho extra pelo código da sua aplicação.

O ótimo do modelo middleware e como este pacote analisa os dados é que você não está preso a usar apenas um analisador. Você pode habilitar um ou mais parsers para sua aplicação para garantir que todos os tipos de dados sejam processados corretamente:

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

Então agora se nós enviarmos um pedido HTTP POST com JSON como corpo, ele será analisado para um objeto JSON regular na propriedade 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' }

Conclusion

A forma mais comum de enviar diversas e grandes quantidades de dados via HTTP é usar o método POST. Antes de podermos aceder facilmente a estes dados no lado do servidor no Express, precisamos de usar algum middleware, como o pacote body-parser, para analisar os dados num formato que possamos aceder facilmente. Uma vez que os dados do pedido HTTP bruto são analisados, eles podem então ser acessados através do pacote body propriedade do req object.