Express.js req.body undefined

Je l'ai comme configuration de mon serveur 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());

Mais quand je demande req.body.somethingdans mes itinéraires, je reçois une erreur en le signalant body is undefined. Voici un exemple de route qui utilise req.body:

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

J'ai lu que ce problème est causé par le manque de app.use(express.bodyParser());mais comme vous pouvez le voir je l'appelle avant les itinéraires.

Un indice?

Vous devez vous assurer que vous définissez toutes les configurations AVANT de définir des itinéraires. Si vous le faites, vous pouvez continuer à utiliser express.bodyParser().

Un exemple est le suivant:

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

Les dernières versions d'Express (4.x) ont dégroupé le middleware du framework principal. Si vous avez besoin d'un analyseur de corps, vous devez l'installer séparément

npm install body-parser --save

puis faites-le dans votre 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())

Non, vous devez utiliser app.use(express.bodyParser())avant app.use(app.router). En fait, ce app.use(app.router)devrait être la dernière chose que vous appelez.

Assurez-vous d'abord que vous avez installé le module npm nommé 'body-parser' en appelant:

npm install body-parser --save

Assurez-vous ensuite d'avoir inclus les lignes suivantes avant d'appeler des itinéraires

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

app.use(bodyParser.json());

Express 4, possède un analyseur de corps intégré. Pas besoin d'installer un analyseur de corps séparé. Donc ci-dessous fonctionnera:

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

Le type de contenu dans l'en-tête de demande est vraiment important, surtout lorsque vous publiez les données de curl ou de tout autre outil.

Assurez-vous que vous utilisez quelque chose comme application / x-www-form-urlencoded, application / json ou autres, cela dépend de vos données de publication. Laisser ce champ vide confondra Express.

Comme déjà posté sous un commentaire, je l'ai résolu en utilisant

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

au lieu de

app.use(express.bodyParser());

Je ne sais toujours pas pourquoi le simple express.bodyParser()ne fonctionne pas ...

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

Ajoutez votre app.js

avant l'appel du routeur

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

Il semble que l'analyseur de corps ne soit plus expédié avec express. Nous devrons peut-être l'installer séparément.

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!

Reportez-vous à la page git https://github.com/expressjs/body-parser pour plus d'informations et d'exemples.

Au cas où quelqu'un rencontrerait le même problème que je rencontrais; J'utilise un préfixe d'URL comme

http://example.com/api/

qui a été configuré avec un routeur

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

puis j'ai eu ce qui suit

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

Ce qui a résolu mon problème était de placer la configuration du bodyparser au-dessus 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 () doit être informé du type de contenu qu'il s'agit d'analyser. Par conséquent, vous devez vous assurer que lorsque vous exécutez une demande POST, vous incluez l'en-tête "Content-Type". Sinon, bodyParser peut ne pas savoir quoi faire avec le corps de votre demande POST.

Si vous utilisez curl pour exécuter une requête POST contenant un objet JSON dans le corps, cela ressemblerait à ceci:

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

Si vous utilisez une autre méthode, assurez-vous simplement de définir ce champ d'en-tête en utilisant la convention appropriée.

Utilisez app.use (bodyparser.json ()); avant le routage. //. app.use ("/ api", routes);

Vous pouvez essayer d'ajouter cette ligne de code en haut, (après vos instructions require):

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

Quant aux raisons pour lesquelles cela fonctionne, consultez les documents: https://www.npmjs.com/package/body-parser#bodyparserurlencodedoptions

La plupart du temps, req.body n'est pas défini en raison de l'analyseur JSON manquant

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

pourrait être manquant pour l'analyseur corporel

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

et parfois, il n'est pas défini en raison de l'origine des cros, alors ajoutez-les

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

Cela m'est arrivé aujourd'hui. Aucune des solutions ci-dessus ne fonctionne pour moi. Mais un peu de recherche sur Google m'a aidé à résoudre ce problème. Je code pour un serveur tiers wechat.

Les choses deviennent un peu plus compliquées lorsque votre application node.js nécessite la lecture de données POST en streaming, comme une demande d'un client REST. Dans ce cas, la propriété de la requête "lisible" sera définie sur true et les données POST doivent être lues par blocs afin de collecter tout le contenu.

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

Perdu beaucoup de temps:

Selon le type de contenu dans votre demande client,
le serveur doit avoir un autre, l'un des app.use () ci-dessous:

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

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

Exemple:

Pour moi, côté client, j'avais en-dessous:

Content-Type: "text/xml"

Donc, côté serveur, j'ai utilisé:

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

Ensuite, tout le monde a bien fonctionné.

dans Express 4, c'est vraiment simple

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

app.use(express.json()) 

Pour travailler, vous devez app.use (app.router) après app.use (express.bodyParser ()) , comme ceci:

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

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

Cela m'a sauvé la journée.

Ce problème peut être dû au fait que vous n'avez pas utilisé l'analyseur de corps ( lien )

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

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

Je l'ai résolu avec:

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

C'est également une possibilité : assurez-vous que vous devez écrire ce code avant l'itinéraire dans votre fichier app.js (ou index.js).

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

Vous pouvez utiliser l'analyseur corporel express.

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

La dernière version d'Express a déjà intégré l'analyseur de corps. Vous pouvez donc utiliser:

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

Si vous postez un message SOAP, vous devez utiliser un analyseur de corps brut:

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

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

En s'appuyant sur @ kevin-xue, le type de contenu doit être déclaré. Dans mon cas, cela ne se produisait qu'avec IE9 parce que XDomainRequest ne définit pas de type de contenu , donc bodyparser et expressjs ignoraient le corps de la demande.

J'ai contourné cela en définissant explicitement le type de contenu avant de passer la demande à l'analyseur de corps, comme ceci:

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

Crédit à @spikeyang pour la grande réponse (ci - dessous). Après avoir lu l'article suggéré en pièce jointe, j'ai décidé de partager ma solution.

Quand utiliser?

La solution vous obligeait à utiliser le routeur express pour en profiter .. donc: Si vous avez essayé d'utiliser la réponse acceptée sans succès, utilisez simplement le copier-coller de cette fonction:

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

et appelez-le comme:

bodyParse(req, function success(body)
{

}, function error(message)
{

});

REMARQUE: pour les grandes charges utiles - veuillez utiliser un tampon de tableau ( plus @ MDN )

Si vous utilisez un outil externe pour effectuer la demande, assurez-vous d'ajouter l'en-tête:

Content-Type: application/json

Pour toute personne pour laquelle aucune des réponses ci-dessus n'a fonctionné, j'ai dû activer les cors entre mon front-end et express.

Vous pouvez le faire soit par:

1. Téléchargement et activation d'une extension CORS pour votre navigateur, telle que:

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

   pour Chrome,

ou par

2. Ajout des lignes

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

à votre app.jspage express . (Après npm install cors)