Express.js wymaga.body undefined

Mam to jako konfigurację mojego serwera 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());

Ale wciąż, gdy pytam o to req.body.somethingna moich trasach, pojawia się błąd, który to wskazuje body is undefined. Oto przykład trasy, która wykorzystuje req.body:

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

Czytam, że ten problem jest spowodowany brakiem, app.use(express.bodyParser());ale jak widać nazywam go przed trasami.

Jakieś wskazówki?

Musisz upewnić się, że zdefiniowałeś wszystkie konfiguracje PRZED zdefiniowaniem tras. Jeśli to zrobisz, możesz nadal korzystać express.bodyParser().

Przykład jest następujący:

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

Najnowsze wersje Express (4.x) uwolniły oprogramowanie pośrednie od podstawowej struktury. Jeśli potrzebujesz parsera treści, musisz zainstalować go osobno

npm install body-parser --save

a następnie zrób to w swoim kodzie

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

Nie. Musisz użyć app.use(express.bodyParser())wcześniej app.use(app.router). W rzeczywistości app.use(app.router)powinna to być ostatnia rzecz, do której dzwonisz.

Najpierw upewnij się, że zainstalowałeś moduł npm o nazwie „body-parser”, wywołując:

npm install body-parser --save

Następnie upewnij się, że podałeś następujące linie, zanim zadzwonisz na trasy

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

app.use(bodyParser.json());

Express 4, ma wbudowany parser treści. Nie trzeba instalować osobnego parsera treści. Więc poniżej będzie działać:

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

Nagłówek Content-Type w żądaniu jest naprawdę ważny, szczególnie gdy publikujesz dane z curl lub innych narzędzi.

Upewnij się, że używasz czegoś takiego jak application / x-www-form-urlencoded, application / json lub innych, to zależy od twoich danych postu. Pozostaw to pole puste, pomyli Express.

Jak już napisano pod jednym komentarzem, rozwiązałem go za pomocą

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

zamiast

app.use(express.bodyParser());

Nadal nie wiem, dlaczego to proste express.bodyParser()nie działa ...

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

Dodaj w swoim app.js

przed wywołaniem routera

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

Wygląda na to, że parser body nie jest już wysyłany ekspresowo. Może być konieczne zainstalowanie go osobno.

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!

Więcej informacji i przykładów można znaleźć na stronie git https://github.com/expressjs/body-parser .

Na wypadek, gdyby ktoś napotkał ten sam problem, który miałem; Używam przedrostka adresu URL jak

http://example.com/api/

który został skonfigurowany z routerem

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

a potem miałem następujące

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

Tym, co naprawiło mój problem, było umieszczenie konfiguracji bodyparsera powyżej app.use('/api', router);

Finał

// 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 () musi zostać poinformowany, jaki typ treści jest analizowany. Dlatego musisz upewnić się, że wykonując żądanie POST, dołączasz nagłówek „Content-Type”. W przeciwnym razie bodyParser może nie wiedzieć, co zrobić z treścią żądania POST.

Jeśli używasz curl do wykonania żądania POST zawierającego jakiś obiekt JSON w ciele, wyglądałoby to mniej więcej tak:

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

Jeśli używasz innej metody, pamiętaj, aby ustawić to pole nagłówka za pomocą odpowiedniej konwencji.

Użyj app.use (bodyparser.json ()); przed routingiem. //. app.use („/ api”, trasy);

Możesz spróbować dodać ten wiersz kodu u góry (po żądaniu instrukcji):

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

Jeśli chodzi o powody, dla których to działa, sprawdź dokumenty: https://www.npmjs.com/package/body-parser#bodyparserurlencodedoptions

Przez większość czasu wymaganie body jest niezdefiniowane z powodu braku parsera JSON

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

może brakować parsera ciała

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

a czasem jest niezdefiniowany ze względu na pochodzenie krzyżowe, więc dodaj je

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

To zdarzyło mi się dzisiaj. Żadne z powyższych rozwiązań nie działa dla mnie. Ale trochę googlowania pomogło mi rozwiązać ten problem. Koduję do serwera zewnętrznego firmy Wechat.

Sprawy stają się nieco bardziej skomplikowane, gdy aplikacja node.js wymaga odczytu strumieniowych danych POST, takich jak żądanie klienta REST. W takim przypadku właściwość żądania „czytelny” zostanie ustawiona na wartość true, a dane POST muszą zostać odczytane we fragmentach, aby zebrać całą zawartość.

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

Zmarnowałem dużo czasu:

W zależności od Content-Type w Twoim kliencie życzenie serwer powinien mieć różne, jedną z poniżej 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' }))

Źródło: https://www.npmjs.com/package/body-parser#bodyparsertextoptions

Przykład:

Dla mnie po stronie klienta miałem poniższy nagłówek:

Content-Type: "text/xml"

Po stronie serwera użyłem:

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

Następnie wymagane jest, aby ktoś działał dobrze.

w Express 4 jest to naprawdę proste

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

app.use(express.json()) 

Aby pracować, musisz app.use (app.router) po app.use (express.bodyParser ()) w następujący sposób :

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

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

To uratowało mi dzień.

Przyczyną tego problemu może być to, że nie użyłeś parsera ciała ( link )

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

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

Rozwiązałem to za pomocą:

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

Jest to również jedna możliwość : upewnij się, że powinieneś napisać ten kod przed trasą w pliku app.js (lub index.js).

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

Możesz użyć ekspresowego parsera treści.

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

Najnowsza wersja Express ma już wbudowany parser treści. Możesz więc użyć:

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

W przypadku opublikowania komunikatu SOAP należy użyć analizatora składni treści:

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

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

Opierając się na @ kevin-xue powiedział, typ zawartości musi zostać zadeklarowany. W moim przypadku miało to miejsce tylko w IE9, ponieważ XDomainRequest nie ustawia typu zawartości , więc bodyparser i expressjs ignorowały treść żądania.

Obejrzałem to, ustawiając jawnie typ zawartości przed przekazaniem żądania do parsera treści, w następujący sposób:

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

Kredyt dla @spikeyang za wielki odpowiedzi (podane poniżej). Po przeczytaniu sugerowanego artykułu dołączonego do postu postanowiłem podzielić się moim rozwiązaniem.

Kiedy użyć?

Rozwiązanie wymagało użycia routera ekspresowego, aby cieszyć się nim. Więc: Jeśli próbujesz użyć zaakceptowanej odpowiedzi bez powodzenia, po prostu użyj tej funkcji kopiuj i wklej:

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

i nazwij to tak:

bodyParse(req, function success(body)
{

}, function error(message)
{

});

UWAGA: W przypadku dużych ładunków - użyj bufora macierzy ( więcej @ MDN )

Jeśli używasz jakiegoś zewnętrznego narzędzia do wysłania żądania, pamiętaj o dodaniu nagłówka:

Content-Type: application/json

Dla każdego, kto nie udzielił żadnej z powyższych odpowiedzi, musiałem włączyć cors między moim front-endem a ekspresowym.

Możesz to zrobić albo:

1. Pobieranie i włączanie rozszerzenia CORS dla przeglądarki, takie jak:

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

   dla Chrome

lub przez

2. Dodawanie linii

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

do Twojej app.jsstrony ekspresowej . (Po npm install cors)