Nota : esta respuesta es para Express 2. Ver aquí para Express 3.

Si está utilizando connect/express, debe usar el middleware bodyParser: Se describe en la guía Expressjs.

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

Aquí está la versión original de solo conexión:

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

Tanto el querystring como el body se analizan usando el manejo de parámetros de estilo Rails(qs) en lugar de la biblioteca de bajo nivel querystring . Con el fin de analizar repetido parámetros con qs, el parámetro necesita tener corchetes: name[]=val1&name[]=val2. También soporta mapas anidados. Además de analizar los envíos de formularios HTML, el bodyParser puede analizar automáticamente las solicitudes JSON.

Edit : He leído en express.js y modifiqué mi respuesta para que fuera más natural para los usuarios de Express.

Problema de seguridad usando express.bodyParser()

Mientras que todas las otras respuestas actualmente recomiendan usar el middleware express.bodyParser(), esto es en realidad un envoltorio alrededor del express.json(), express.urlencoded(), y express.multipart() middlewares ( http://expressjs.com/api.html#bodyParser ). El análisis de los cuerpos de solicitud de formulario se realiza mediante el middleware express.urlencoded() y es todo lo que necesita para exponer los datos de su formulario en el objeto req.body.

Debido a un problema de seguridad con cómo express.multipart()/connect.multipart() crea archivos temporales para todos los archivos cargados (y no se recogen basura), ahora es recomendado no usar el wrapper express.bodyParser() sino usar solo los middlewares que necesita.

Nota: connect.bodyParser() pronto se actualizará para incluir solo urlencoded y json cuando se lance Connect 3.0 (que Express extiende).

Así que en resumen, en lugar de ...

app.use(express.bodyParser());

...debe usar

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

Y si / cuando necesita manejar formularios multiparte (cargas de archivos), utilice una biblioteca o middleware de terceros como multiparty, busboy, dicer, etc.

Esto lo hará si desea compilar la consulta publicada sin middleware:

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

});

Que enviará esto al navegador

email=emailval&password1=pass1val&password2=pass2val

Probablemente sea mejor usar middleware para no tener que escribir esto una y otra vez en cada ruta.

Nota para los usuarios de Express 4:

Si intenta poner app.use(express.bodyParser()); en su aplicación, obtendrá el siguiente error cuando intente iniciar su servidor Express:

Error: La mayoría del middleware (como bodyParser) ya no está incluido con Express y debe instalarse por separado. Véase https://github.com/senchalabs/connect#middleware .

Tendrá que instalar el paquete body-parser por separado de npm , luego use algo como lo siguiente (ejemplo tomado de la página de 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();
})

Dada alguna forma:

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

Usando express

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

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

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

Salida:

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

app.use(express.bodyParser());

Luego para la solicitud app.post puede obtener valores post a través de req.body.{post request variable}.

Actualización para Express 4.4.1

Middleware de lo siguiente se elimina de Express.

• bodyParser
• json
• urlencoded
• multiparte

Cuando usa el middleware directamente como lo hizo en express 3.0. Obtendrá el siguiente error:

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

Para utilizar esos middleware, ahora necesita hacer npm para cada middleware por separado.

Dado que bodyParser está marcado como obsoleto, por lo que recomiendo el siguiendo el camino usando json, urlencode y multipart parser como formidable, connect-multiparty. (El middleware Multipart también está obsoleto).

También recuerde, simplemente definiendo urlencode + json, los datos del formulario no serán analizados y req.el cuerpo será indefinido. Debe definir un controlador de middleware para la solicitud de varias partes.

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

Motor:

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

Interfaz:

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

Para Express 4.1 y superiores

Como la mayoría de las respuestas están usando para Expresar, bodyParser, conectar; donde multiparte está en desuso. Hay una forma segura de enviar objetos post multiparte fácilmente.

Multer se puede usar como reemplazo para connect.multipart ().

Para instalar el paquete

$ npm install multer

Cárgalo en tu app:

var multer = require('multer');

Y luego, agréguelo en la pila de middleware junto con el otro formulario que analiza el middleware.

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

Conectar.json () maneja application / json

Conectar.urlencoded () maneja application / x-www-form-urlencoded

Multer () maneja datos de múltiples partes/formularios

Estaba buscando este problema exacto. Estaba siguiendo todos los consejos anteriores, pero req.body seguía devolviendo un objeto vacío {}. En mi caso, era algo tan simple como que el html fuera incorrecto.

En el html de tu formulario, asegúrate de usar el atributo 'name' en tus etiquetas de entrada, no solo 'id'. De lo contrario, nada se analiza.

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

Mi error idiota es tu beneficio.

No deberías usar la aplicación .use (express.bodyParser ()) . bodyParser es una unión de json + urlencoded + mulitpart. No debería usar esto porque multipart se eliminará en connect 3.0.

Para resolver eso, puedes hacer esto:

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

Es muy importante saber que aplicación.use (app.router) se debe utilizar después del json y urlencoded, de lo contrario no funciona!

La transmisión de solicitudes funcionó para mí

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

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

Podría encontrar todos los parámetros usando el siguiente código para las solicitudes POST y 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 el paquete 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");
})

Está utilizando 'req.consulta.post 'con método incorrecto' req.consulta.post' trabaja con "method=get' 'method = post' funciona con body-parser.

Solo prueba esto cambiando post para obtener

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

Y en express code use ' app.get '