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 utiliza para diferentes casos de uso, es transmitir información mediante cadenas de consulta o parámetros de URL. Para obtener más información, consulte 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 la creación de Express.js servidores.
Te puede interesar:Uso de la gestión y mitigación de riesgos en el desarrollo webEnví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 HTML <form>
o una solicitud de API. Los datos pueden adoptar diferentes formas, siendo las más comunes:
application/x-www-form-urlencoded
: Los datos de esta codificación tienen el formato de una cadena de consulta que vería en una URL, con el valor-clave paris separado por&
caracteres. Por ejemplo:foo=bar&abc=123&stack=abuse
. Ésta es la codificación predeterminada.multipart/form-data
: Esta codificación se utiliza normalmente 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.text/plain
: Estos datos solo se envían como texto sin formato no estructurado y, por lo general, no se utilizan.
Una solicitud HTTP POST sin procesar con el application/x-www-form-urlencoded
la codificación podría verse así:
POST /signup HTTP/1.1
Host: example.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 53
username=scott&password=secret&website=Pharos.sh.com
Extracción de datos POST
Antes de que podamos comenzar a acceder a los datos POST de inmediato, debemos configurar correctamente nuestra aplicación Express. Esta configuración debe realizarse ya que no todos los servidores de aplicaciones web necesitan análisis corporal, y qué análisis corporal está habilitado depende de su aplicación.
Te puede interesar:Manejo de eventos en Node.js con EventEmitterPara configurar esto, usaremos el analizador corporal paquete, que puede manejar muchas formas de datos. Este paquete es un middleware que intercepta el cuerpo sin procesar y lo analiza en una forma que el código de su aplicación puede usar fácilmente.
// 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!`));
Note como llamamos app.use(...)
antes de definir nuestra ruta. El orden aquí importa. Esto asegurará que el body-parser
se ejecutará 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 el curl
utilidad en una ventana de consola diferente:
$ curl -d "username=scott&password=secret&website=Pharos.sh.com" -X POST http://localhost:8080/post-test
OK
$ node index.js
Started server at http://localhost:8080!
Got body: { username: 'scott',
password: 'secret',
website: 'Pharos.sh.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 extended
opción al llamar bodyParser.urlencoded
. Utilizando el extended
la opción dice body-parser
usar el qs
biblioteca para analizar los datos codificados en URL. Esto permite que cosas como objetos y matrices se codifiquen en el formato codificado para URL.
Y mientras urlencoded
es uno de los analizadores más utilizados que body-parser
proporciona, también puede utilizar lo siguiente:
.json()
: Analiza el texto con formato JSON para los cuerpos con unContent-Type
deapplication/json
..raw()
: Analiza el cuerpo HTTP en unBuffer
para la costumbre especificadaContent-Type
s, aunque se acepta el valor predeterminadoContent-Type
esapplication/octet-stream
..text()
: Analiza los cuerpos HTTP con unContent-Type
detext/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 que la compresión aún se puede usar de forma transparente sin ningún trabajo adicional por parte del código de su aplicación.
Lo mejor del modelo de middleware y de cómo este paquete analiza los datos es que no está obligado a utilizar 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:
// 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 tuviéramos que enviar una solicitud HTTP POST con JSON como cuerpo, se analizará en un objeto JSON normal en el req.body
propiedad:
POST /post-test HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Content-Length: 69
'{"username":"scott","password":"secret","website":"Pharos.sh.com"}'
$ node index.js
Started server at http://localhost:8080!
Got body: { username: 'scott',
password: 'secret',
website: 'Pharos.sh.com' }
Conclusión
La forma más común de enviar grandes y diversas 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 middleware, como el body-parser
paquete, 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 del body
propiedad de la req
objeto.
En este artículo explicamos un poco sobre los distintos tipos de contenido / codificaciones, cómo usar el body-parser
paquete 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.
.
Te puede interesar:Construyendo una API GraphQL con Django