Express.js req.body undefined
J'ai ceci 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 toujours req.body.something dans mes routes, je reçois une erreur en soulignant que body is undefined. Voici un exemple d'itinéraire utilisant 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 routes.
Un indice?
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 la simple express.bodyParser() ne fonctionne pas ...
Vous devez vous assurer que vous définissez toutes les configurations AVANT de définir les itinéraires. Si vous le faites, vous pouvez continuer à utiliser express.bodyParser().
Un exemple est comme suit:
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 dissocié le middleware du cadre principal. Si vous avez besoin d’un analyseur de corps, vous devez l’installer séparément.
npm install body-parser --save
et ensuite le faire 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, app.use(app.router) devrait être la dernière chose que vous appelez.
D'abord, assurez-vous d'avoir installé le module npm nommé 'analyseur de corps' 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());
L'en-tête de demande Content-Type in est très important, en particulier lorsque vous publiez les données à partir de curl ou de tout autre outil.
Assurez-vous que vous utilisez quelque chose comme application/x-www-form-urlencoded, application/json ou autre, cela dépend de vos données de publication. Laissez ce champ vide va confondre Express.
// 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())
Express 4, possède un analyseur de corps intégré. Pas besoin d'installer un analyseur de corps séparé. Donc ci-dessous travaillera:
export const app = express();
app.use(express.json());
On dirait que l'analyseur de corps n'est plus livré 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.
express.bodyParser () doit savoir quel type de contenu 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". Dans le cas contraire, bodyParser pourrait 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.
Au cas où quelqu'un aurait le même problème que moi; J'utilise un préfixe d'URL comme
http://example.com/api/
qui a été configuré avec un routeur
app.use('/api', router);
et puis j'ai eu le suivant
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
Ce qui a résolu mon problème, c’était de placer la configuration de bodyparser au-dessus de 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);
Vous pouvez essayer d’ajouter cette ligne de code en haut (après vos instructions require):
app.use(bodyParser.urlencoded({extended: true}));
Pour savoir pourquoi cela fonctionne, consultez la documentation: https://www.npmjs.com/package/body-parser#bodyparserurlencodedoptions
Utilisez app.use (bodyparser.json ()); avant le routage. // . app.use ("/ api", routes);
Cela m'est arrivé aujourd'hui. Aucune des solutions ci-dessus ne fonctionne pour moi. Mais une petite recherche sur Google m'a aidé à résoudre ce problème. Je code pour le serveur tiers wechat.
Les choses se compliquent un peu lorsque votre application node.js nécessite la lecture de données en continu POST, telles qu'une requête d'un client REST. Dans ce cas, la propriété "readable" de la requête sera définie sur true et les données POST doivent être lues par morceaux afin de collecter tout le contenu.
Perdu beaucoup de temps:
En fonction du type de contenu dans votre demande client
le serveur doit avoir différentes, l'une 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, .__ Du côté client, j'avais en-tête ci-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é.
var bodyParser = require('body-parser');
app.use(bodyParser.json());
Cela a sauvé ma journée.
Pour fonctionner, vous devez app.use (app.router) after app.use (express.bodyParser ()) , comme ceci:
app.use(express.bodyParser())
.use(express.methodOverride())
.use(app.router);
Ce problème peut être dû au fait que vous n'avez pas utilisé body-parser ( link )
var express = require('express');
var bodyParser = require('body-parser');
var app = express();
app.use(bodyParser.json());
Vous pouvez utiliser l'analyseur de corps 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 intègre déjà un analyseur de corps. Pour que vous puissiez utiliser:
const express = require('express);
...
app.use(express.urlencoded({ extended: false }))
.use(express.json());
Nous remercions @spikeyang pour l'excellente réponse fournie 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 pouvoir en profiter .. donc: Si vous avez déjà essayé d'utiliser la réponse acceptée sans succès, utilisez simplement un 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 comme ça:
bodyParse(req, function success(body)
{
}, function error(message)
{
});
NOTE: Pour les grandes charges utiles - veuillez utiliser un tampon de tableau ( more @ MDN )
C’est aussi une possibilité : Assurez-vous d’écrire ce code avant la route dans votre fichier app.js (ou index.js).
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.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 car le XDomainRequest ne définit pas de type de contenu , donc Bododarser et expressjs ignoraient le corps de la demande.
J'ai contourné cela en définissant explicitement le type de contenu avant de transmettre 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());
Pour tous ceux pour lesquels aucune des réponses ci-dessus n’avaient fonctionné, je devais activer les cors entre mon interface utilisateur et mon adresse express.
Vous pouvez le faire soit par:
Télécharger et activer une extension CORS pour votre navigateur, telle que:
pour Chrome,
ou par
Ajout des lignes
var cors=require('cors'); app.use(cors());
sur votre page express app.js. (Après npm install cors)
Un autre moyen possible d'obtenir request.body vide lorsque vous oubliez l'attribut name de l'élément input ...
<input type="text" /> /* give back empty request.body -> {}*/
<input type="text" name="username" /> /* give back request.body -> {"username": "your-input"} */
Ajoutez dans votre app.js.
avant l'appel du routeur
const app = express ();
app.use (express.json ());
Si vous utilisez un outil externe pour effectuer la demande, veillez à ajouter l'en-tête:
Content-Type: application/json
Je l'ai résolu avec:
app.post('/', bodyParser.json(), (req, res) => {//we have req.body JSON
});