Obtenga el cuerpo HTTP POST en Express.js

En este breve artículo, exploraremos cómo extraer información de un cuerpo de solicitud POST en Express.js y Node.js

Introducción

En este breve artículo, veremos cómo extraer información de un cuerpo POST en Express.js. El protocolo HTTP proporciona varias formas de pasar información de un cliente a un servidor, siendo los cuerpos POST el método más flexible y más utilizado para enviar datos a través de HTTP.

Otra forma, que normalmente se usa para diferentes casos de uso, es transmitir información mediante cadenas de consulta o parámetros de URL. Para obtener más información, consulta cómo obtener cadenas de consulta y parámetros en Express.js.

Para este artículo, supongo que tiene algo de experiencia con Node.js y con la creación de servidores Express.js simples.

Envío de datos POST en HTTP

Los datos se pueden enviar a través de una llamada HTTP POST por muchas razones, siendo algunas de las más comunes a través de un HTML <form> o una solicitud de API. Los datos pueden tomar algunas formas diferentes, siendo las más comunes:

  • application/x-www-form-urlencoded: los datos en esta codificación tienen el formato de una cadena de consulta que vería en una URL, con paris clave-valor separados por caracteres &. Por ejemplo: foo=bar&abc=123&stack=abuse. Esta es la codificación predeterminada.
  • multipart/form-data: esta codificación se suele utilizar para enviar archivos. En resumen, cada clave-valor se envía en la misma solicitud, pero diferentes "partes", que están separadas por "límites" e incluyen más metadatos.
  • texto/sin formato: estos datos se envían simplemente como texto sin estructura y, por lo general, no se utilizan.

Una solicitud HTTP POST sin procesar con la codificación application/x-www-form-urlencoded podría verse así:

1
2
3
4
5
6
POST /signup HTTP/1.1
Host: example.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 53

username=scott&password=secret&website=wikihtp.com

Extracción de datos POST {#extracción de datos posteriores}

Antes de que podamos comenzar a acceder a los datos POST de inmediato, debemos configurar correctamente nuestra aplicación Express. Es necesario realizar esta configuración, ya que no todos los servidores de aplicaciones web necesitan análisis de cuerpo, y el análisis de cuerpo que está habilitado depende de su aplicación.

Para configurar esto, usaremos el paquete analizador de cuerpo, que puede manejar muchas formas de datos. Este paquete es un software intermedio que intercepta el cuerpo sin procesar y lo analiza en una forma que el código de su aplicación puede usar fácilmente.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
// index.js
const 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!`));

Observe cómo llamamos a app.use(...) antes de definir nuestra ruta. El orden aquí importa. Esto garantizará que body-parser se ejecute antes que nuestra ruta, lo que garantiza que nuestra ruta pueda acceder al cuerpo HTTP POST analizado.

Para probar esto, primero iniciaremos la aplicación Express y luego usaremos la utilidad curl en una ventana de consola diferente:

1
2
$ curl -d "username=scott&password=secret&website=wikihtp.com" -X POST http://localhost:8080/post-test
OK
1
2
3
4
5
$ node index.js
Started server at http://localhost:8080!
Got body: { username: 'scott',
  password: 'secret',
  website: 'wikihtp.com' }

Aquí puede ver que los datos de la cadena de consulta se analizaron en un objeto JavaScript al que podemos acceder fácilmente.

Otra cosa importante a tener en cuenta es nuestro uso de la opción extendida al llamar a bodyParser.urlencoded. El uso de la opción extendida le dice a body-parser que use la biblioteca qs para analizar los datos codificados en URL. Esto permite que cosas como objetos y matrices se codifiquen en el formato codificado de URL.

Y aunque urlencoded es uno de los analizadores más utilizados que proporciona body-parser, también puede usar lo siguiente:

  • .json(): Analiza texto con formato JSON para cuerpos con un Content-Type de application/json.
  • .raw(): Analiza el cuerpo HTTP en un Buffer para los Content-Type personalizados especificados, aunque el Content-Type predeterminado aceptado es application/octet-stream.
  • .text(): Analiza cuerpos HTTP con un Content-Type de text/plain, que lo devuelve como una cadena simple.

Cada uno de estos analizadores también admite la inflación automática de datos codificados con gzip o desinflar, por lo tanto, la compresión aún se puede usar de manera transparente sin ningún trabajo adicional por parte del código de su aplicación.

Lo bueno del modelo de middleware y de cómo este paquete analiza los datos es que no está obligado a usar un solo analizador. Puede habilitar uno o más analizadores para su aplicación para asegurarse de que todos los tipos de datos se procesen correctamente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
// index.js
const 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());

// ...

Entonces, si enviáramos una solicitud HTTP POST con JSON como cuerpo, se analizará en un objeto JSON normal en la propiedad req.body:

1
2
3
4
5
6
POST /post-test HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Content-Length: 69

'{"username":"scott","password":"secret","website":"wikihtp.com"}'
1
2
3
4
5
$ node index.js
Started server at http://localhost:8080!
Got body: { username: 'scott',
  password: 'secret',
  website: 'wikihtp.com' }

Conclusión

La forma más común de enviar diversas y grandes cantidades de datos a través de HTTP es utilizar el método POST. Antes de que podamos acceder fácilmente a estos datos en el lado del servidor en Express, necesitamos usar algún software intermedio, como el paquete body-parser, para analizar los datos en un formato al que podamos acceder fácilmente. Una vez que se analizan los datos de la solicitud HTTP sin procesar, se puede acceder a ellos a través de la propiedad body del objeto req.

En este artículo, explicamos un poco sobre los diversos tipos/codificación de contenido, cómo usar el paquete body-parser y sus diversas opciones, y cómo acceder a los datos analizados. Si ve algún problema o tiene sugerencias, no dude en dejar un comentario a continuación.