Question Comment récupérer les paramètres de requête POST?


Voici ma forme simple:

<form id="loginformA" action="userlogin" method="post">
    <div>
        <label for="email">Email: </label>
        <input type="text" id="email" name="email"></input>
    </div>
<input type="submit" value="Submit"></input>
</form>

Voici mon Express.js/Node.js code:

app.post('/userlogin', function(sReq, sRes){    
    var email = sReq.query.email.;   
}

j'ai essayé sReq.query.email ou sReq.query['email'] ou sReq.params['email'], etc. Aucun d'eux ne fonctionne. Ils reviennent tous undefined.

Quand je change pour un appel Get, ça marche, donc ... une idée?


632
2018-04-19 00:38


origine


Réponses:


Les choses ont modifié encore une fois à partir Express 4.16.0, vous pouvez maintenant utiliser express.json() et express.urlencoded() juste comme dans Express 3.0.

C'était différent départ Express 4.0 à 4.15:

$ npm install --save body-parser

et alors:

var bodyParser = require('body-parser')
app.use( bodyParser.json() );       // to support JSON-encoded bodies
app.use(bodyParser.urlencoded({     // to support URL-encoded bodies
  extended: true
})); 

Le reste est comme dans Express 3.0:

Tout d'abord, vous devez ajouter un middleware pour analyser les données de poste du corps.

Ajoutez une ou les deux lignes de code suivantes:

app.use(express.json());       // to support JSON-encoded bodies
app.use(express.urlencoded()); // to support URL-encoded bodies

Ensuite, dans votre gestionnaire, utilisez le req.body objet:

// assuming POST: name=foo&color=red            <-- URL encoding
//
// or       POST: {"name":"foo","color":"red"}  <-- JSON encoding

app.post('/test-page', function(req, res) {
    var name = req.body.name,
        color = req.body.color;
    // ...
});

Notez que l'utilisation de express.bodyParser() n'est pas recommandé.

app.use(express.bodyParser());

...est équivalent à:

app.use(express.json());
app.use(express.urlencoded());
app.use(express.multipart());

Des problèmes de sécurité existent avec express.multipart(), et il est donc préférable d'ajouter explicitement le support pour le (s) type (s) d'encodage spécifique (s) dont vous avez besoin. Si vous avez besoin d'un codage en plusieurs parties (pour prendre en charge le téléchargement de fichiers par exemple), vous devriez lis ça.


1042
2017-08-17 15:30



Remarque: cette réponse est pour Express 2. Voir ici pour Express 3.

Si vous utilisez connect / express, vous devez utiliser le middleware bodyParser: Il est décrit dans le Expressjs guide.

// example using express.js:
var express = require('express')
  , app = express.createServer();
app.use(express.bodyParser());
app.post('/', function(req, res){
  var email = req.param('email', null);  // second parameter is default
});

Voici la version d'origine de connexion uniquement:

// example using just connect
var connect = require('connect');
var url = require('url');
var qs = require('qs');
var server = connect(
  connect.bodyParser(),
  connect.router(function(app) {
    app.post('/userlogin', function(req, res) {
      // the bodyParser puts the parsed request in req.body.
      var parsedUrl = qs.parse(url.parse(req.url).query);
      var email = parsedUrl.email || req.body.email;;
    });
  })
);

Les deux Querystring et le corps sont analysés en utilisant Gestion des paramètres de type Rails (qs) plûtot que le niveau faible querystring bibliothèque. Afin d'analyser les paramètres répétés avec qs, le paramètre doit avoir des crochets: name[]=val1&name[]=val2. Il prend également en charge les cartes imbriquées. En plus d'analyser les soumissions de formulaires HTML, bodyParser peut analyser automatiquement les requêtes JSON.

modifier: J'ai lu sur express.js et modifié ma réponse pour être plus naturel pour les utilisateurs d'Express.


75
2018-04-19 02:21



Préoccupation de sécurité en utilisant express.bodyParser ()

Alors que toutes les autres réponses recommandent actuellement d'utiliser le express.bodyParser() middleware, c'est en fait un emballage autour de la express.json(), express.urlencoded(), et express.multipart() middlewares (http://expressjs.com/api.html#bodyParser). L'analyse des corps de requête de formulaire est effectuée par le express.urlencoded() middleware et est tout ce que vous avez besoin d'exposer vos données de formulaire sur req.body objet.

À cause de préoccupation de sécurité avec comment express.multipart()/connect.multipart() crée des fichiers temporaires pour tous les fichiers téléchargés (et ne sont pas collectés), il est maintenant conseillé ne pas utiliser le express.bodyParser() wrapper mais utilisez uniquement les middlewares dont vous avez besoin.

Remarque: connect.bodyParser() sera bientôt mis à jour pour inclure seulement urlencoded et json lorsque Connect 3.0 est libéré (extension Express).


Donc, en bref, au lieu de ...

app.use(express.bodyParser());

...Tu devrais utiliser

app.use(express.urlencoded());
app.use(express.json());      // if needed

et si / quand vous avez besoin de gérer des formulaires en plusieurs parties (upload de fichiers), utilisez une bibliothèque tierce ou un middleware tel que multiparty, busboy, dicer, etc.


73
2017-11-21 22:00



Cela le fera si vous voulez construire la requête publiée sans middleware:

app.post("/register/",function(req,res){
    var bodyStr = '';
    req.on("data",function(chunk){
        bodyStr += chunk.toString();
    });
    req.on("end",function(){
        res.send(bodyStr);
    });

});

Cela enverra ceci au navigateur

email=emailval&password1=pass1val&password2=pass2val

Il est probablement préférable d'utiliser le middleware, vous n'avez donc pas besoin de l'écrire encore et encore sur chaque route.


27
2017-07-22 02:19



Note pour les utilisateurs d'Express 4:

Si vous essayez et mettez app.use(express.bodyParser()); dans votre application, vous obtiendrez l'erreur suivante lorsque vous essayez de démarrer votre serveur Express:

Erreur: La plupart des middleware (comme bodyParser) ne sont plus fournis avec Express et doivent être installés séparément. S'il te plait regarde https://github.com/senchalabs/connect#middleware.

Vous devrez installer le paquet body-parser séparément à partir de npm, puis utilisez quelque chose comme ce qui suit (exemple tiré de la page GitHub):

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

var app = express();

app.use(bodyParser());

app.use(function (req, res, next) {
  console.log(req.body) // populated!
  next();
})

22
2018-05-10 20:52



Donné une forme:

<form action='/somepath' method='post'>
   <input type='text' name='name'></input>
</form>

En utilisant express

app.post('/somepath', function(req, res) {

    console.log(JSON.stringify(req.body));

    console.log('req.body.name', req.body['name']);
});

Sortie:

{"name":"x","description":"x"}
req.param.name x

18
2018-01-20 11:12



app.use(express.bodyParser());

Puis pour app.post demande que vous pouvez obtenir des valeurs de poste via req.body.{post request variable}.


14
2018-04-09 19:18



Mise à jour pour Express 4.4.1

L'intergiciel de ce qui suit est supprimé d'Express.

  • bodyParser
  • json
  • urlencodé
  • en plusieurs parties

Lorsque vous utilisez le middleware directement comme vous l'avez fait en express 3.0. Vous obtiendrez l'erreur suivante:

Error: Most middleware (like urlencoded) is no longer bundled with Express and 
must be installed separately.


Afin d'utiliser ces logiciels, maintenant vous devez faire NPM pour chaque middleware séparément.

Comme bodyParser est marqué comme obsolète, je recommande l'utilisation suivante de json, urlencode et parser multipart comme formidable, connect-multiparty. (Le middleware Multipart est également déconseillé).

Souvenez-vous également, en définissant simplement urlencode + json, les données du formulaire ne seront pas analysées et req.body sera indéfini. Vous devez définir un middleware gérer la requête multipart.

var urlencode = require('urlencode');
var json = require('json-middleware');
var multipart = require('connect-multiparty');
var multipartMiddleware = multipart();

app.use(json);
app.use(urlencode);
app.use('/url/that/accepts/form-data', multipartMiddleware);

13
2018-06-12 04:13



Backend:

import express from 'express';
import bodyParser from 'body-parser';

const app = express();
app.use(bodyParser.json()); // add a middleware (so that express can parse request.body's json)

app.post('/api/courses', (request, response) => {
  response.json(request.body);
});

L'extrémité avant:

fetch("/api/courses", {
  method: 'POST',
  body: JSON.stringify({ hi: 'hello' }), // stringify JSON
  headers: new Headers({ "Content-Type": "application/json" }); // add headers
});

10
2017-08-05 18:05



Pour Express 4.1 et supérieur

Comme la plupart des réponses utilisent Express, bodyParser, connect; où multipart est obsolète. Il existe un moyen sécurisé d'envoyer des objets multi-parties facilement.

Multer peut être utilisé en remplacement de connect.multipart ().

Pour installer le paquet

$ npm install multer

Chargez le dans votre application:

var multer = require('multer');

Et puis, ajoutez-le dans la pile middleware avec l'autre middleware d'analyse de formulaire.

app.use(express.json());
app.use(express.urlencoded());
app.use(multer({ dest: './uploads/' }));

connect.json () gère l'application / json

connect.urlencoded () gère l'application / x-www-form-urlencoded

multer () gère multipart / form-data


7
2017-08-30 10:37