Búsqueda de sitios web

javascript - Cómo acceder a los campos del formulario POST en Express

Aquí está mi formulario sencillo:

<form id="loginformA" action="userlogin" method="post">
    <div>
        <label for="email">Email: </label>
        <input type="text" id="email" name="email"></input>
    </div>
<input type="submit" value="Submit"></input>
</form>

Aquí está mi código de Express.js/Node.js:

app.post('/userlogin', function(sReq, sRes){    
    var email = sReq.query.email.;   
}

Intenté sReq.query.email o sReq.query['email'] o sReq.params['email'], etc. Ninguno funciona. Todos devuelven undefined.

Cuando cambio a una llamada Get, funciona, así que... ¿alguna idea?

Respuesta #1

Las cosas han cambiado una vez más a partir de Express 4.16.0, ahora puedes usar express.json() y express.urlencoded() tal como en Express 3.0.

Esto fue diferente a partir de Express 4.0 a 4.15:

npm install --save body-parser

y luego:

var bodyParser = require('body-parser')
app.use( bodyParser.json() );       // to support JSON-encoded bodies
app.use(bodyParser.urlencoded({     // to support URL-encoded bodies
  extended: true
}));

El resto es como en Express 3.0:

Primero necesitas agregar algún middleware para analizar los datos del post del cuerpo.

Agrega una o ambas de las siguientes líneas de código:

app.use(express.json());       // to support JSON-encoded bodies
app.use(express.urlencoded()); // to support URL-encoded bodies

Luego, en tu manejador, usa el objeto req.body:

// assuming POST: name=foo&color=red            <-- URL encoding
//
// or       POST: {"name":"foo","color":"red"}  <-- JSON encoding

app.post('/test-page', function(req, res) {
    var name = req.body.name,
        color = req.body.color;
    // ...
});

Tenga en cuenta que no se recomienda el uso de express.bodyParser().

app.use(express.bodyParser());

...es equivalente a:

app.use(express.json());
app.use(express.urlencoded());
app.use(express.multipart());

Existen preocupaciones de seguridad con express.multipart(), por lo que es mejor agregar explícitamente soporte para el tipo de codificación específico que necesites. Si realmente necesitas codificación multipart (por ejemplo, para soportar la subida de archivos), entonces deberías leer esto.

Respuesta #2

Preocupación de seguridad al usar express.bodyParser()

Mientras que todas las demás respuestas actualmente recomiendan usar el middleware express.bodyParser(), en realidad este es un envoltorio alrededor de los middlewares express.json(), express.urlencoded() y express.multipart() (http://expressjs.com/api.html#bodyParser). El análisis de los cuerpos de las solicitudes de formulario se realiza mediante el middleware express.urlencoded() y es todo lo que necesita para exponer los datos de su formulario en el objeto req.body.

Debido a una preocupación de seguridad con la forma en que express.multipart()/connect.multipart() crea archivos temporales para todos los archivos subidos (y no son recolectados por el sistema de basura), ahora se recomienda no usar el envoltorio express.bodyParser(), sino usar únicamente los middlewares que necesites.

Nota: connect.bodyParser() pronto se actualizará para incluir solo urlencoded y json cuando se lance Connect 3.0 (que Express extiende).

Así que, en resumen, en lugar de ...

app.use(express.bodyParser());

...deberías usar

app.use(express.urlencoded());
app.use(express.json());      // if needed

y si/cuando necesites manejar formularios multipartes (cargas de archivos), utiliza una biblioteca de terceros o un middleware como multiparty, busboy, dicer, etc.

Respuesta #3

Nota: esta respuesta es para Express 2. Vea aquí para Express 3.

Si estás usando connect/express, deberías usar el middleware bodyParser: Está descrito en la guía de Expressjs.

// example using express.js:
var express = require('express')
  , app = express.createServer();
app.use(express.bodyParser());
app.post('/', function(req, res){
  var email = req.param('email', null);  // second parameter is default
});

Aquí está la versión original solo de conexión:

// example using just connect
var connect = require('connect');
var url = require('url');
var qs = require('qs');
var server = connect(
  connect.bodyParser(),
  connect.router(function(app) {
    app.post('/userlogin', function(req, res) {
      // the bodyParser puts the parsed request in req.body.
      var parsedUrl = qs.parse(url.parse(req.url).query);
      var email = parsedUrl.email || req.body.email;;
    });
  })
);

Tanto la cadena de consulta como el cuerpo se analizan utilizando el manejo de parámetros al estilo Rails (qs) en lugar de la biblioteca de bajo nivel querystring. Para analizar parámetros repetidos con qs, el parámetro necesita tener corchetes: name[]=val1&name[]=val2. También admite mapas anidados. Además de analizar envíos de formularios HTML, el bodyParser puede analizar solicitudes JSON automáticamente.

Editar: Leí sobre express.js y modifiqué mi respuesta para que sea más natural para los usuarios de Express.

Respuesta #4

Esto servirá si quieres construir la consulta publicada sin middleware:

app.post("/register/",function(req,res){
    var bodyStr = '';
    req.on("data",function(chunk){
        bodyStr += chunk.toString();
    });
    req.on("end",function(){
        res.send(bodyStr);
    });

});

Eso enviará esto al navegador

email=emailval&password1=pass1val&password2=pass2val

Probablemente sea mejor usar middleware, aunque, para que no tengas que escribir esto una y otra vez en cada ruta.

Respuesta #5

Nota para los usuarios de Express 4:

Si intentas poner app.use(express.bodyParser()); en tu aplicación, obtendrás el siguiente error cuando intentes iniciar tu servidor Express:

Error: La mayoría de los middleware (como bodyParser) ya no se incluyen con Express y deben instalarse por separado. Por favor, consulte https://github.com/senchalabs/connect#middleware.

Tendrás que instalar el paquete body-parser por separado desde npm, luego usar algo como lo siguiente (ejemplo tomado de la página de GitHub):

var express    = require('express');
var bodyParser = require('body-parser');

var app = express();

app.use(bodyParser());

app.use(function (req, res, next) {
  console.log(req.body) // populated!
  next();
})

Respuesta #6

Dada alguna forma:

<form action='/somepath' method='post'>
   <input type='text' name='name'></input>
</form>

Usando express

app.post('/somepath', function(req, res) {

    console.log(JSON.stringify(req.body));

    console.log('req.body.name', req.body['name']);
});

Salida :

{"name":"x","description":"x"}
req.param.name x

Respuesta #7

Backend :

import express from 'express';
import bodyParser from 'body-parser';

const app = express();
app.use(bodyParser.json()); // add a middleware (so that express can parse request.body's json)

app.post('/api/courses', (request, response) => {
  response.json(request.body);
});

Frontend:

fetch("/api/courses", {
  method: 'POST',
  body: JSON.stringify({ hi: 'hello' }), // convert Js object to a string
  headers: new Headers({ "Content-Type": "application/json" }) // add headers
});

Respuesta #8

app.use(express.bodyParser());

Entonces, para la solicitud app.post, puedes obtener los valores del post a través de req.body.{variable de la solicitud post}.

Respuesta #9

Actualización para Express 4.4.1

Se elimina el middleware de lo siguiente en Express.

  • analizadorDeCuerpo
  • json
  • codificado en URL
  • multitud

Cuando usas el middleware directamente como lo hiciste en Express 3.0, obtendrás el siguiente error:

Error: Most middleware (like urlencoded) is no longer bundled with Express and 
must be installed separately.

Para utilizar esos middleware, ahora necesitas hacer npm para cada middleware por separado.

Dado que bodyParser está marcado como obsoleto, recomiendo la siguiente forma usando json, urlencode y un parser multipart como formidable, connect-multiparty. (El middleware Multipart también está obsoleto).

También recuerda, solo definir urlencode + json, los datos del formulario no serán analizados y req.body será indefinido. Necesitas definir un middleware para manejar la solicitud multipart.

var urlencode = require('urlencode');
var json = require('json-middleware');
var multipart = require('connect-multiparty');
var multipartMiddleware = multipart();

app.use(json);
app.use(urlencode);
app.use('/url/that/accepts/form-data', multipartMiddleware);

Respuesta #10

Actualizar

A partir de Express versión 4.16+, su propia implementación de body-parser ahora está incluida en el paquete predeterminado de Express, por lo que no es necesario que descargues otra dependencia.

Es posible que hayas añadido una línea a tu código que se vea como la siguiente:

app.use(bodyparser.json()); //utilizes the body-parser package

Si estás usando Express 4.16+ ahora puedes reemplazar esa línea con:

app.use(express.json()); //Used to parse JSON bodies

Esto no debería introducir ningún cambio que rompa tus aplicaciones ya que el código en express.json() se basa en bodyparser.json().

Si también tienes el siguiente código en tu entorno:

app.use(bodyParser.urlencoded({extended: true}));

Puedes reemplazar eso con:

app.use(express.urlencoded()); //Parse URL-encoded bodies

Una nota final de precaución: todavía existen algunos casos muy específicos en los que body-parser podría ser necesario, pero en su mayoría la implementación de body-parser de Express es todo lo que necesitarás para la mayoría de los casos de uso.

(Vea la documentación en expressjs/bodyparser para más detalles).

Artículos relacionados