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

si vous utilisez connect/express, vous devez utiliser le bodyParser middleware : 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 originale connect-only:

// 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 Rail-style parameter handling ( qs ) plutôt que le low-level querystring library . Pour séparer les paramètres répétés avec qs , le paramètre doit avoir des parenthèses: name[]=val1&name[]=val2 . Il supporte également les cartes imbriquées. En plus d'analyser les soumissions de formulaires HTML, le bodyParser peut analyser les requêtes JSON automatiquement.

Modifier : j'ai lu sur l'express.js et a modifié mon réponse à de plus naturel pour les utilisateurs de Express.

problème de Sécurité à l'aide de l'express.bodyParser ()

alors que toutes les autres réponses recommandent actuellement d'utiliser le express.bodyParser() middleware, il s'agit en fait d'un enveloppement autour des express.json() , express.urlencoded() , et express.multipart() middlewares ( http://expressjs.com/api.html#bodyParser ). L'analyse des corps de demande de formulaire est faite par le middleware express.urlencoded() et est tout ce dont vous avez besoin pour exposer vos données de formulaire sur req.body objet.

en raison d'un problème de sécurité avec la façon dont express.multipart() / connect.multipart() crée des fichiers temporaires pour tous les fichiers téléchargés (et ne sont pas des déchets collectés), il est maintenant recommandé ne pas utiliser le express.bodyParser() enveloppeur, mais à la place utiliser seulement les middlewares dont vous avez besoin.

Note: connect.bodyParser() sera bientôt mis à jour pour inclure seulement urlencoded et json quand Connect 3.0 est libéré (ce qui S'étend Express).

bref, au lieu de ...

app.use(express.bodyParser());

...vous devez utiliser

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

et si/quand vous avez besoin de gérer les formulaires multipartis (téléchargement de fichiers), utilisez une bibliothèque ou un middleware tiers tels que multiparty, busboy, dicer, etc.

cela le fera si vous voulez construire la requête posté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);
    });

});

qui enverra ceci au navigateur

email=emailval&password1=pass1val&password2=pass2val

il est probablement préférable d'utiliser middleware bien que vous ne devez pas écrire ceci encore et encore dans chaque route.

Note pour les utilisateurs Express 4:

si vous essayez de mettre 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 middlewares (comme bodyParser) ne sont plus fournis avec Express et doivent être installés séparément. S'il vous plaît voir https://github.com/senchalabs/connect#middleware .

Vous aurez à installer le paquet body-parser séparément de npm , puis utiliser 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();
})

Donné une certaine forme:

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

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

app.use(express.bodyParser());

puis pour la requête app.post vous pouvez obtenir les valeurs post via req.body.{post request variable} .

mise à jour pour Express 4.4.1

Middleware du suivant est retiré de l'Express.

• bodyParser
• json
• urlencoded
• multipart

lorsque vous utilisez l'middleware directement comme vous l'avez fait dans 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 utiliser ces middleware, maintenant, vous devez faire mnp pour chaque middleware séparément.

puisque bodyParser est marqué comme déprécié, je recommande donc la façon suivante en utilisant JSON, urlencode et multiparseur comme formidable, connect-multiparty. (L'middleware multipartite est également déprécié).

rappelez-vous aussi, juste en définissant urlencode + json, les données de forme ne seront pas analysés et req.le corps ne sera pas défini. Vous avez besoin pour 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);

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

Frontend:

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

pour Express 4.1 et au-dessus

comme la plupart des réponses sont utilisées pour exprimer, bodyParser, connect; où multipart est déprécié. Il y a un moyen sûr d'envoyer des objets post multipart 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, l'ajouter dans le pile de middleware avec l'autre forme d'analyse de middleware.

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

connecter.json() poignées d'application/json

connecter.urlencoded() poignées d'application/x-www-form-urlencoded

multer () handles multipart /form-data

je cherchais précisément ce problème. Je suivais tous les conseils ci-dessus mais req.le corps retournait toujours un objet vide. Dans mon cas, c'était quelque chose d'aussi simple que le html est incorrect.

dans le code html de votre formulaire, assurez-vous d'utiliser l'attribut 'name' dans vos balises de saisie, pas seulement 'id' . Sinon, rien n'est analysée.

<input id='foo' type='text' value='1'/>             // req = {}
<input id='foo' type='text' name='foo' value='1' /> // req = {foo:1}

mon erreur idiote est votre avantage.

vous ne devriez pas utiliser app.utilisation(express.bodyParser ()) . BodyParser est une union de JSON + urlencoded + mulitpart. Vous ne devez pas l'utiliser car multipart sera supprimé dans connect 3.0.

Pour résoudre cela, vous pouvez faire ceci:

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

il est très important de savoir que app.utilisation(app.router) doit être utilisé après le json et urlencoded, sinon ça ne marche pas!

Demande streaming a fonctionné pour moi

req.on('end', function() {
    var paramstring = postdata.split("&");
});

var postdata = "";
req.on('data', function(postdataChunk){
    postdata += postdataChunk;
});

je pouvais trouver tous les paramètres en utilisant le code suivant pour les requêtes POST et GET .

 var express = require('express');
    var app = express();
    const util = require('util');  
    app.post('/', function (req, res) {
        console.log("Got a POST request for the homepage");
        res.send(util.inspect(req.query,false,null));
    })

Post Parameters can be retrieved as follows-

app.post('/api/v1/test',Testfunction);
http.createServer(app).listen(port, function(){
console.log("Express server listening on port " + port)
});

function Testfunction(request,response,next)
{
   console.log(request.param("val1"));

   response.send('HI');
}

use colis express-fileupload

var app = require('express')();
var http = require('http').Server(app);
const fileUpload = require('express-fileupload')

app.use(fileUpload());

app.post('/', function(req, res) {
var email = req.body.email;
res.send('<h1>Email :</h1> '+email);
});

http.listen(3000, function(){
  console.log('Running Port:3000');
});

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

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

app.get('/',function(req,res){
  res.sendfile("index.html");
});
app.post('/login',function(req,res){
  var user_name=req.body.user;
  var password=req.body.password;
  console.log("User name = "+user_name+", password is "+password);
  res.end("yes");
});
app.listen(3000,function(){
  console.log("Started on PORT 3000");
})

vous utilisez 'req.requête.post de mal avec la méthode 'req.requête.post fonctionne avec 'method=get' 'method=post' fonctionne avec body-parser.

juste essayer ceci en changeant le post pour obtenir

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

Et dans l'express code à utiliser app.get'