Express.js req.body undefiniert

Ich habe dies als Konfiguration meines Express-Servers

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

Aber immer noch, wenn ich req.body.somethingauf meinen Routen danach frage, erhalte ich einen Fehler, der darauf hinweist body is undefined. Hier ist ein Beispiel für eine Route, die Folgendes verwendet req.body:

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

Ich habe gelesen, dass dieses Problem durch das Fehlen von verursacht wird, app.use(express.bodyParser());aber wie Sie sehen können, nenne ich es vor den Routen.

Irgendeine Ahnung?

Sie müssen sicherstellen, dass Sie alle Konfigurationen definieren, bevor Sie Routen definieren. In diesem Fall können Sie die Verwendung fortsetzen express.bodyParser().

Ein Beispiel ist wie folgt:

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

Die neuesten Versionen von Express (4.x) haben die Middleware vom Kernframework entbündelt. Wenn Sie einen Body Parser benötigen, müssen Sie ihn separat installieren

npm install body-parser --save

und dann tun Sie dies in Ihrem Code

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

Nein, Sie müssen app.use(express.bodyParser())vorher verwenden app.use(app.router). In der Tat app.use(app.router)sollte das letzte sein, was Sie anrufen.

Stellen Sie zunächst sicher, dass Sie das npm-Modul mit dem Namen 'body-parser' installiert haben, indem Sie Folgendes aufrufen:

npm install body-parser --save

Stellen Sie dann sicher, dass Sie die folgenden Zeilen eingefügt haben, bevor Sie Routen aufrufen

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

app.use(bodyParser.json());

Express 4 verfügt über einen integrierten Body-Parser. Es ist nicht erforderlich, einen separaten Body-Parser zu installieren. Also unten wird funktionieren:

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

Der Header "Content-Type in Request" ist sehr wichtig, insbesondere wenn Sie die Daten von Curl oder anderen Tools veröffentlichen.

Stellen Sie sicher, dass Sie etwas wie application / x-www-form-urlencoded, application / json oder andere verwenden. Dies hängt von Ihren Post-Daten ab. Lassen Sie dieses Feld leer, um Express zu verwirren.

Wie bereits unter einem Kommentar gepostet, habe ich es mit gelöst

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

anstatt

app.use(express.bodyParser());

Ich weiß immer noch nicht, warum das Einfache express.bodyParser()nicht funktioniert ...

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

Fügen Sie in Ihrem app.js

vor dem Anruf des Routers

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

Der Body-Parser wird anscheinend nicht mehr mit Express ausgeliefert. Möglicherweise müssen wir es separat installieren.

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!

Weitere Informationen und Beispiele finden Sie auf der Git-Seite https://github.com/expressjs/body-parser .

Für den Fall, dass jemand auf dasselbe Problem stößt, das ich hatte; Ich verwende ein URL-Präfix wie

http://example.com/api/

welches mit Router eingerichtet wurde

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

und dann hatte ich folgendes

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

Was mein Problem behoben hat, war das Platzieren der Bodyparser-Konfiguration oben 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 () muss mitgeteilt werden, um welche Art von Inhalt es sich handelt. Daher müssen Sie sicherstellen, dass Sie beim Ausführen einer POST-Anforderung den Header "Content-Type" einschließen. Andernfalls weiß bodyParser möglicherweise nicht, was mit dem Text Ihrer POST-Anforderung zu tun ist.

Wenn Sie curl verwenden, um eine POST-Anforderung auszuführen, die ein JSON-Objekt im Hauptteil enthält, sieht dies ungefähr so ​​aus:

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

Wenn Sie eine andere Methode verwenden, stellen Sie sicher, dass Sie dieses Headerfeld mit der entsprechenden Konvention festlegen.

Verwenden Sie app.use (bodyparser.json ()); vor dem Routing. //. app.use ("/ api", Routen);

Sie können versuchen, diese Codezeile oben hinzuzufügen (nach Ihren erforderlichen Anweisungen):

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

Informationen zu den Gründen für die Funktionsweise finden Sie in den Dokumenten: https://www.npmjs.com/package/body-parser#bodyparserurlencodedoptions

Meistens ist req.body aufgrund des fehlenden JSON-Parsers undefiniert

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

könnte für den Body-Parser fehlen

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

und manchmal ist es aufgrund des Cros-Ursprungs undefiniert, also füge sie hinzu

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

Das ist mir heute passiert. Keine der oben genannten Lösungen funktioniert für mich. Aber ein bisschen googeln hat mir geholfen, dieses Problem zu lösen. Ich codiere für Wechat-Server von Drittanbietern.

Etwas komplizierter wird es, wenn für Ihre Anwendung node.js Streaming-POST-Daten gelesen werden müssen, z. B. eine Anforderung von einem REST-Client. In diesem Fall wird die Eigenschaft "lesbar" der Anforderung auf "true" gesetzt und die POST-Daten müssen in Blöcken gelesen werden, um den gesamten Inhalt zu erfassen.

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

Viel Zeit verschwendet:

Abhängig vom Inhaltstyp in Ihrer Client- Anfrage sollte
der Server eine andere haben, eine der folgenden 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' }))

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

Beispiel:

Auf der Client-Seite hatte ich unter der Überschrift:

Content-Type: "text/xml"

Auf der Serverseite habe ich also Folgendes verwendet:

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

Dann hat req.body gut funktioniert.

In Express 4 ist das ganz einfach

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

app.use(express.json()) 

Um zu arbeiten, müssen Sie app.use (app.router) nach app.use (express.bodyParser ()) wie folgt ausführen :

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

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

Das hat mir den Tag gerettet.

Dieses Problem kann daran liegen, dass Sie keinen Body-Parser verwendet haben ( Link )

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

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

Ich habe es gelöst mit:

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

Dies ist auch eine Möglichkeit : Stellen Sie sicher, dass Sie diesen Code vor der Route in Ihre Datei app.js (oder index.js) schreiben.

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

Sie können den Express-Body-Parser verwenden.

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

In der neuesten Version von Express ist bereits ein Body-Parser integriert. So können Sie verwenden:

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

Wenn Sie eine SOAP-Nachricht veröffentlichen, müssen Sie den Raw-Body-Parser verwenden:

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

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

Aufbauend auf @ kevin-xue muss der Inhaltstyp deklariert werden. In meinem Fall trat dies nur bei IE9 auf, da XDomainRequest keinen Inhaltstyp festlegt, sodass bodyparser und expressjs den Hauptteil der Anforderung ignorierten.

Ich habe dies umgangen, indem ich den Inhaltstyp explizit festgelegt habe, bevor ich die Anforderung an den Body-Parser weitergeleitet habe:

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

Dank an @spikeyang für die großartige Antwort ( siehe unten). Nachdem ich den vorgeschlagenen Artikel gelesen hatte, der dem Beitrag beigefügt war, beschloss ich, meine Lösung zu teilen.

Wann verwenden?

Für die Lösung mussten Sie den Express-Router verwenden, um ihn genießen zu können. Wenn Sie also versucht haben, die akzeptierte Antwort ohne Erfolg zu verwenden, verwenden Sie einfach diese Funktion zum Kopieren und Einfügen:

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

und nenne es wie:

bodyParse(req, function success(body)
{

}, function error(message)
{

});

HINWEIS: Für große Nutzdaten verwenden Sie bitte einen Array-Puffer ( mehr @ MDN ).

Wenn Sie ein externes Tool verwenden, um die Anforderung zu stellen, müssen Sie den Header hinzufügen:

Content-Type: application/json

Für jeden, für den keine der oben genannten Antworten funktioniert hat, musste ich Cors zwischen Front-End und Express aktivieren.

Sie können dies entweder tun durch:

1. Herunterladen und Aktivieren einer CORS-Erweiterung für Ihren Browser, z.

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

   für Chrome

oder von

2. Zeilen hinzufügen

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

zu Ihrer Express- app.jsSeite. (Nachher npm install cors)