Express.js req.body undefined

Tengo esto como configuración de mi servidor Express

app.use(app.router); 
app.use(express.cookieParser());
app.use(express.session({ secret: "keyboard cat" }));
app.set('view engine', 'ejs');
app.set("view options", { layout: true });
//Handles post requests
app.use(express.bodyParser());
//Handles put requests
app.use(express.methodOverride());

Pero aún así, cuando solicito req.body.somethingen mis rutas, aparece un error que lo señala body is undefined. Aquí hay un ejemplo de una ruta que usa req.body:

app.post('/admin', function(req, res){
    console.log(req.body.name);
});

Leí que este problema es causado por la falta de, app.use(express.bodyParser());pero como puede ver, lo llamo antes de las rutas.

¿Cualquier pista?

Debe asegurarse de definir todas las configuraciones ANTES de definir rutas. Si lo hace, puede continuar usándolo express.bodyParser().

Un ejemplo es el siguiente:

var express = require('express'),
    app     = express(),
    port    = parseInt(process.env.PORT, 10) || 8080;

app.configure(function(){
  app.use(express.bodyParser());
  app.use(app.router);
});

app.listen(port);

app.post("/someRoute", function(req, res) {
  console.log(req.body);
  res.send({ status: 'SUCCESS' });
});

Las últimas versiones de Express (4.x) han desagregado el middleware del framework central. Si necesita un analizador corporal, debe instalarlo por separado

npm install body-parser --save

y luego haz esto en tu código

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

// parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: false }))

// parse application/json
app.use(bodyParser.json())

No. Necesitas usar app.use(express.bodyParser())antes app.use(app.router). De hecho, app.use(app.router)debería ser lo último que llames.

Primero asegúrese de haber instalado el módulo npm llamado 'body-parser' llamando a:

npm install body-parser --save

Luego, asegúrese de haber incluido las siguientes líneas antes de llamar a las rutas

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

app.use(bodyParser.json());

Express 4, tiene un analizador de cuerpo incorporado. No es necesario instalar un analizador de cuerpo por separado. Entonces a continuación funcionará:

export const app = express();
app.use(express.json());

El tipo de contenido en el encabezado de solicitud es realmente importante, especialmente cuando publica los datos de curl o cualquier otra herramienta.

Asegúrese de estar usando algo como application / x-www-form-urlencoded, application / json u otros, depende de los datos de su publicación. Dejar este campo vacío confundirá Express.

Como ya se publicó bajo un comentario, lo resolví usando

app.use(require('connect').bodyParser());

en vez de

app.use(express.bodyParser());

Todavía no sé por qué lo simple express.bodyParser()no funciona ...

// Require body-parser (to receive post data from clients)

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

app.use(bodyParser.urlencoded({ extended: false }))

// parse application/json

app.use(bodyParser.json())

Agrega tu app.js

antes de la llamada del enrutador

const app = express();
app.use(express.json());

Parece que el analizador de cuerpo ya no se envía con express. Es posible que tengamos que instalarlo por separado.

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

// parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: false }))

// parse application/json
app.use(bodyParser.json())

// parse application/vnd.api+json as json
app.use(bodyParser.json({ type: 'application/vnd.api+json' }))
app.use(function (req, res, next) {
console.log(req.body) // populated!

Consulte la página de git https://github.com/expressjs/body-parser para obtener más información y ejemplos.

En caso de que alguien se encuentre con el mismo problema que estaba teniendo; Estoy usando un prefijo de URL como

http://example.com/api/

que se configuró con el enrutador

app.use('/api', router); 

y luego tuve lo siguiente

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

Lo que solucionó mi problema fue colocar la configuración del bodyparser arriba app.use('/api', router);

Final

// setup bodyparser
    app.use(bodyParser.json());
    app.use(bodyParser.urlencoded({ extended: true }));

//this is a fix for the prefix of example.com/api/ so we dont need to code the prefix in every route
    app.use('/api', router); 

express.bodyParser () necesita que se le diga qué tipo de contenido es el que está analizando. Por lo tanto, debe asegurarse de que cuando ejecute una solicitud POST, incluya el encabezado "Tipo de contenido". De lo contrario, bodyParser podría no saber qué hacer con el cuerpo de su solicitud POST.

Si está utilizando curl para ejecutar una solicitud POST que contiene algún objeto JSON en el cuerpo, se vería así:

curl -X POST -H "Content-Type: application/json" -d @your_json_file http://localhost:xxxx/someRoute

Si usa otro método, solo asegúrese de establecer ese campo de encabezado usando la convención apropiada.

Use app.use (bodyparser.json ()); antes de enrutar. //. app.use ("/ api", rutas);

Puede intentar agregar esta línea de código en la parte superior (después de sus declaraciones de requerimiento):

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

En cuanto a las razones de por qué funciona, consulte los documentos: https://www.npmjs.com/package/body-parser#bodyparserurlencodedoptions

La mayoría de las veces, req.body no está definido debido a que falta el analizador JSON

const express = require('express');
app.use(express.json());

podría faltar para el analizador de cuerpo

const bodyParser  = require('body-parser');
app.use(bodyParser.urlencoded({extended: true}));

y a veces no está definido debido al origen de los cros, así que agrégalos

const cors = require('cors');
app.use(cors())

Esto me ocurrió hoy. Ninguna de las soluciones anteriores funciona para mí. Pero un poco de google me ayudó a resolver este problema. Estoy codificando para el servidor de terceros wechat.

Las cosas se vuelven un poco más complicadas cuando su aplicación node.js requiere leer datos POST de transmisión, como una solicitud de un cliente REST. En este caso, la propiedad de la solicitud "legible" se establecerá en verdadera y los datos POST deben leerse en fragmentos para recopilar todo el contenido.

http://www.primaryobjects.com/CMS/Article144

Perdido mucho tiempo:

Dependiendo del tipo de contenido en la solicitud de su cliente,
el servidor debe tener una aplicación diferente, a continuación, use.) ():

app.use(bodyParser.text({ type: 'text/html' }))
app.use(bodyParser.text({ type: 'text/xml' }))
app.use(bodyParser.raw({ type: 'application/vnd.custom-type' }))
app.use(bodyParser.json({ type: 'application/*+json' }))

Fuente: https://www.npmjs.com/package/body-parser#bodyparsertextoptions

Ejemplo:

Para mí, en el lado del cliente, tenía debajo del encabezado:

Content-Type: "text/xml"

Entonces, en el lado del servidor, usé:

app.use(bodyParser.text({type: 'text/xml'}));

Entonces, req.body funcionó bien.

en Express 4, es realmente simple

const app = express()
const p = process.env.PORT || 8082

app.use(express.json()) 

Para trabajar, necesita app.use (app.router) después de app.use (express.bodyParser ()) , así:

app.use(express.bodyParser())
   .use(express.methodOverride())
   .use(app.router);

var bodyParser = require('body-parser');
app.use(bodyParser.json());

Esto me salvó el día.

Este problema puede deberse a que no ha utilizado body-parser ( enlace )

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

var app = express();
app.use(bodyParser.json());

Lo resolví con:

app.post('/', bodyParser.json(), (req, res) => {//we have req.body JSON
});

Esta también es una posibilidad : asegúrese de escribir este código antes de la ruta en su archivo app.js (o index.js).

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

Puede usar el analizador corporal exprés.

var express = require('express');
var app = express();
var bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({ extended: true }));

La última versión de Express ya tiene incorporado el analizador de cuerpo. Entonces puedes usar:

const express = require('express);
... 
app.use(express.urlencoded({ extended: false }))
.use(express.json());

En caso de que publique un mensaje SOAP, debe usar un analizador de cuerpo sin procesar:

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

app.use(bodyParser.raw({ type: 'text/xml' }));

Basándose en @ kevin-xue, dijo, el tipo de contenido debe ser declarado. En mi caso, esto solo ocurría con IE9 porque XDomainRequest no establece un tipo de contenido , por lo que bodyparser y expressjs ignoraban el cuerpo de la solicitud.

Lo solucioné estableciendo el tipo de contenido explícitamente antes de pasar la solicitud al analizador de cuerpo, de esta manera:

app.use(function(req, res, next) {
    // IE9 doesn't set headers for cross-domain ajax requests
    if(typeof(req.headers['content-type']) === 'undefined'){
        req.headers['content-type'] = "application/json; charset=UTF-8";
    }
    next();
})
.use(bodyParser.json());

Gracias a @spikeyang por la excelente respuesta (proporcionada a continuación). Después de leer el artículo sugerido adjunto a la publicación, decidí compartir mi solución.

¿Cuándo usar?

La solución requería que usaras el enrutador rápido para disfrutarlo ... así que: si has intentado usar la respuesta aceptada sin suerte, solo usa copiar y pegar esta función:

function bodyParse(req, ready, fail) 
{
    var length = req.header('Content-Length');

    if (!req.readable) return fail('failed to read request');

    if (!length) return fail('request must include a valid `Content-Length` header');

    if (length > 1000) return fail('this request is too big'); // you can replace 1000 with any other value as desired

    var body = ''; // for large payloads - please use an array buffer (see note below)

    req.on('data', function (data) 
    {
        body += data; 
    });

    req.on('end', function () 
    {
        ready(body);
    });
}

y lo llaman así:

bodyParse(req, function success(body)
{

}, function error(message)
{

});

NOTA: Para cargas grandes, utilice un búfer de matriz ( más @ MDN )

Si está utilizando alguna herramienta externa para realizar la solicitud, asegúrese de agregar el encabezado:

Content-Type: application/json

Para cualquiera que no haya trabajado ninguna de las respuestas anteriores, tuve que habilitar los cors entre mi front-end y express.

Puedes hacer esto ya sea por:

1. Descargar y activar una extensión CORS para su navegador, como:

   https://chrome.google.com/webstore/detail/allow-control-allow-origi/nlfbmbojpeacfghkpbjhddihlkkiljbi?hl=en

   para Chrome,

o por

2. Agregar las líneas

   var cors=require('cors');
   
   app.use(cors());

a tu app.jspágina express . (Después npm install cors)