Express.js req.body non definito

Ho questo come configurazione del mio server 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());

Ma ancora quando chiedo req.body.somethingnei miei percorsi mi viene segnalato un errore body is undefined. Ecco un esempio di un percorso che utilizza req.body:

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

Ho letto che questo problema è causato dalla mancanza di app.use(express.bodyParser());ma, come puoi vedere, lo chiamo prima delle rotte.

Qualche idea?

È necessario assicurarsi di aver definito tutte le configurazioni PRIMA di definire i percorsi. In tal caso, è possibile continuare a utilizzare express.bodyParser().

Un esempio è il seguente:

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' });
});

Le ultime versioni di Express (4.x) hanno separato il middleware dal framework principale. Se è necessario il parser per il corpo, è necessario installarlo separatamente

npm install body-parser --save

e quindi fai questo nel tuo codice

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. È necessario utilizzare app.use(express.bodyParser())prima app.use(app.router). In effetti, app.use(app.router)dovrebbe essere l'ultima cosa che chiami.

Innanzitutto assicurati di aver installato il modulo npm chiamato 'body-parser' chiamando:

npm install body-parser --save

Quindi assicurati di aver incluso le seguenti linee prima di chiamare le rotte

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

app.use(bodyParser.json());

Express 4, ha un parser per il corpo integrato. Non è necessario installare body parser separato. Quindi di seguito funzionerà:

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

Il tipo di contenuto nell'intestazione della richiesta è molto importante, soprattutto quando si pubblicano i dati da ricci o altri strumenti.

Assicurati di utilizzare qualcosa come application / x-www-form-urlencoded, application / json o altri, dipende dai dati dei tuoi post. Lascia questo campo vuoto confonderà Express.

Come già pubblicato sotto un commento, l'ho risolto usando

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

invece di

app.use(express.bodyParser());

Non so ancora perché il semplice express.bodyParser()non funzioni ...

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

Aggiungi nel tuo app.js

prima della chiamata del router

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

Sembra che il body-parser non sia più spedito con express. Potrebbe essere necessario installarlo separatamente.

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!

Fare riferimento alla pagina git https://github.com/expressjs/body-parser per maggiori informazioni ed esempi.

Nel caso qualcuno incontri lo stesso problema che stavo riscontrando; Sto usando un prefisso URL come

http://example.com/api/

che è stato installato con il router

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

e poi ho avuto il seguente

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

Ciò che ha risolto il mio problema è stato posizionare la configurazione bodyparser sopra app.use('/api', router);

Finale

// 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 () deve essere informato sul tipo di contenuto che sta analizzando. Pertanto, è necessario assicurarsi che quando si esegue una richiesta POST, si includa l'intestazione "Content-Type". Altrimenti, bodyParser potrebbe non sapere cosa fare con il corpo della tua richiesta POST.

Se stai usando curl per eseguire una richiesta POST contenente qualche oggetto JSON nel corpo, sarebbe simile a questo:

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

Se si utilizza un altro metodo, accertarsi di impostare quel campo di intestazione utilizzando qualsiasi convenzione sia appropriata.

Usa app.use (bodyparser.json ()); prima del routing. //. app.use ("/ api", route);

Puoi provare ad aggiungere questa riga di codice in alto, (dopo le istruzioni richieste):

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

Per quanto riguarda i motivi per cui funziona, consulta i documenti: https://www.npmjs.com/package/body-parser#bodyparserurlencodedoptions

Il più delle volte req.body non è definito a causa della mancanza del parser JSON

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

potrebbe mancare per il parser del corpo

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

e a volte non è definito a causa dell'origine cros, quindi aggiungili

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

Questo mi è successo oggi. Nessuna delle soluzioni precedenti funziona per me. Ma un po 'googling mi ha aiutato a risolvere questo problema. Sto codificando per quel server di terze parti.

Le cose diventano leggermente più complicate quando l'applicazione node.js richiede la lettura di dati POST in streaming, come una richiesta da un client REST. In questo caso, la proprietà della richiesta "leggibile" verrà impostata su true e i dati POST devono essere letti in blocchi per raccogliere tutto il contenuto.

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

Ha perso molto tempo:

A seconda del tipo di contenuto nella richiesta del client,
il server dovrebbe avere una delle seguenti app.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' }))

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

Esempio:

Per me, sul lato client, avevo sotto l'intestazione:

Content-Type: "text/xml"

Quindi, sul lato server, ho usato:

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

Quindi, req.body ha funzionato bene.

in Express 4, è davvero semplice

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

app.use(express.json()) 

Per funzionare, devi app.use (app.router) dopo app.use (express.bodyParser ()) , in questo modo:

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

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

Questo mi ha salvato la giornata.

Questo problema potrebbe essere dovuto al fatto che non hai utilizzato body-parser ( link )

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

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

L'ho risolto con:

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

Anche questa è una possibilità : assicurati di scrivere questo codice prima del percorso nel tuo file app.js (o index.js).

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

È possibile utilizzare il parser per il corpo espresso.

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

L'ultima versione di Express ha già incorporato body-parser. Quindi puoi usare:

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

Nel caso in cui pubblichi un messaggio SOAP è necessario utilizzare il parser del corpo grezzo:

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

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

Basandosi su @ kevin-xue, il tipo di contenuto deve essere dichiarato. Nel mio caso, ciò si è verificato solo con IE9 perché XDomainRequest non imposta un tipo di contenuto , quindi bodyparser ed expressjs ignoravano il corpo della richiesta.

Ho risolto il problema impostando esplicitamente il tipo di contenuto prima di passare la richiesta al parser del corpo, in questo modo:

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

Ringraziamo @spikeyang per l'ottima risposta (fornita di seguito). Dopo aver letto l'articolo suggerito allegato al post, ho deciso di condividere la mia soluzione.

Quando usare?

La soluzione ti ha richiesto di utilizzare il router espresso per godertelo .. quindi: se hai tentato di utilizzare la risposta accettata senza fortuna, usa semplicemente copia e incolla questa funzione:

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);
    });
}

e chiamalo come:

bodyParse(req, function success(body)
{

}, function error(message)
{

});

NOTA: per payload di grandi dimensioni, utilizzare un buffer di array ( altro @ MDN )

Se stai utilizzando uno strumento esterno per effettuare la richiesta, assicurati di aggiungere l'intestazione:

Content-Type: application/json

Per chiunque per cui nessuna delle risposte sopra ha funzionato, ho dovuto abilitare cors tra il mio front-end ed express.

Puoi farlo sia:

1. Download e attivazione di un'estensione CORS per il browser, ad esempio:

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

   per Chrome,

o da

2. Aggiungere le linee

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

alla tua app.jspagina espressa . (Dopo npm install cors)