Ecco la mia forma semplice:

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

Ecco il mio codice Express.js /Node.js:

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

Ho provato sReq.query.emailo sReq.query['email']o sReq.params['email'], ecc. Nessuno di loro funziona. Tutti ritornano undefined.

Quando cambio a una chiamata, funziona, quindi ... qualche idea?

Le cose sono cambiate ancora una volta a partire da Express 4.16.0 , ora puoi usare express.json()e express.urlencoded()proprio come in Express 3.0 .

È stato diverso a partire da Express 4.0 a 4.15 :

$ npm install --save body-parser

e poi:

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

Il resto è come in Express 3.0 :

Innanzitutto è necessario aggiungere un middleware per analizzare i dati di post del corpo.

Aggiungi una o entrambe le seguenti righe di codice:

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

Quindi, nel gestore, utilizzare l' req.bodyoggetto:

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

Si noti che l'uso di express.bodyParser()non è raccomandato.

app.use(express.bodyParser());

...è equivalente a:

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

Esistono problemi di sicurezza express.multipart(), quindi è meglio aggiungere esplicitamente il supporto per i tipi di codifica specifici richiesti. Se hai bisogno della codifica multipart (ad esempio per supportare il caricamento di file), dovresti leggere questo .

Problemi di sicurezza con express.bodyParser ()

Mentre tutte le altre risposte attualmente consiglia di utilizzare il express.bodyParser()middleware, questo è in realtà un wrapper express.json(), express.urlencoded()e express.multipart()middleware ( http://expressjs.com/api.html#bodyParser ). L'analisi dei corpi di richiesta del modulo viene eseguita dal express.urlencoded()middleware ed è tutto ciò che serve per esporre i dati del modulo req.bodysull'oggetto.

A causa di un problema di sicurezza relativo a come express.multipart()/ connect.multipart()crea file temporanei per tutti i file caricati (e non vengono raccolti in modo inutile), ora si consiglia di non utilizzare il express.bodyParser()wrapper ma di utilizzare solo i middleware necessari.

Nota: connect.bodyParser()verrà presto aggiornato per includere solo urlencodede jsonquando verrà rilasciato Connect 3.0 (che Express estende).

Quindi in breve, invece di ...

app.use(express.bodyParser());

...dovresti usare

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

e se / quando è necessario gestire moduli multipart (upload di file), utilizzare una libreria o un middleware di terze parti come multiparty, busboy, dicer, ecc.

Nota : questa risposta è per Express 2. Vedi qui per Express 3.

Se stai usando connect / express, dovresti usare il middleware bodyParser : è descritto nella guida di 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
});

Ecco la versione originale di sola connessione:

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

Sia la querystring che il body vengono analizzati utilizzando la gestione dei parametri in stile Rails ( qs) anziché la libreria di basso livelloquerystring . Al fine di analizzare i parametri ripetuti con qs, il parametro deve avere staffe: name[]=val1&name[]=val2. Supporta anche mappe nidificate. Oltre all'analisi degli invii di moduli HTML, bodyParser può analizzare automaticamente le richieste JSON.

Modifica : ho letto su express.js e modificato la mia risposta per essere più naturale per gli utenti di Express.

Questo lo farà se si desidera creare la query pubblicata senza middleware:

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

});

Questo invierà questo al browser

email=emailval&password1=pass1val&password2=pass2val

Probabilmente è meglio usare il middleware, quindi non è necessario scriverlo più e più volte in ogni percorso.

Nota per gli utenti di Express 4:

Se si tenta di inserire app.use(express.bodyParser());l'app, si verificherà il seguente errore quando si tenta di avviare il server Express:

Errore: la maggior parte dei middleware (come bodyParser) non è più inclusa in Express e deve essere installata separatamente. Si prega di consultare https://github.com/senchalabs/connect#middleware .

Dovrai installare il pacchetto body-parserseparatamente da npm , quindi utilizzare qualcosa di simile al seguente (esempio preso dalla pagina 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();
})

Dato un modulo:

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

Produzione:

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

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

Fine frontale:

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

app.use(express.bodyParser());

Quindi per la app.postrichiesta è possibile ottenere i valori dei post tramite req.body.{post request variable}.

Aggiornamento per Express 4.4.1

Il middleware di quanto segue viene rimosso da Express.

• bodyParser
• jSON
• urlencoded
• multipart

Quando si utilizza il middleware direttamente come in Express 3.0. Verrà visualizzato il seguente errore:

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

Per utilizzare questi middleware, ora devi fare npm per ciascun middleware separatamente.

Poiché bodyParser è contrassegnato come obsoleto, quindi ti consiglio di utilizzare Json, urlencode e il parser multipart come formidabile, connect-multiparty. (Anche il middleware multipart è obsoleto).

Ricorda anche che, semplicemente definendo urlencode + json, i dati del modulo non verranno analizzati e req.body non sarà definito. È necessario definire un middleware per gestire la richiesta 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);

Per Express 4.1 e versioni successive

Poiché la maggior parte delle risposte utilizza Express, bodyParser, connect; dove multipart è deprecato. C'è un modo sicuro per inviare facilmente oggetti multipart post.

Il multer può essere usato in sostituzione di connect.multipart ().

Per installare il pacchetto

$ npm install multer

Caricalo nella tua app:

var multer = require('multer');

Quindi, aggiungilo nello stack del middleware insieme all'altro middleware di analisi del modulo.

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

connect.json () gestisce application / json

connect.urlencoded () gestisce application / x-www-form-urlencoded

multer () gestisce multipart / form-data

Stavo cercando questo esatto problema. Stavo seguendo tutti i consigli sopra ma req.body stava ancora restituendo un oggetto vuoto {}. Nel mio caso, era qualcosa di semplice come l'html che non era corretto.

Nell'html del modulo, assicurati di utilizzare l' 'name'attributo nei tag di input, non solo 'id'. Altrimenti, nulla viene analizzato.

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

Il mio errore idiota è il tuo vantaggio.

Non dovresti usare app.use (express.bodyParser ()) . BodyParser è un'unione di json + urlencoded + mulitpart. Non dovresti usarlo perché multipart verrà rimosso in connect 3.0.

Per risolverlo, puoi farlo:

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

È molto importante sapere che app.use (app.router) dovrebbe essere usato dopo il codice json e codificato, altrimenti non funziona!

Lo streaming delle richieste ha funzionato per me

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

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

Ho trovato tutti i parametri utilizzando il seguente codice per entrambe le richieste POST e 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));
})

Scritto in Express versione 4.16

All'interno della funzione router è possibile utilizzare la req.bodyproprietà per accedere alla variabile post. Ad esempio, se questo fosse il POSTpercorso del modulo, restituirebbe ciò che hai inserito:

function(req,res){
      res.send(req.body);

      //req.body.email would correspond with the HTML <input name="email"/>
}

PS per coloro che hanno familiarità con PHP: per accedere alla $_GETvariabile PHP che utilizziamo req.querye per accedere alla $_POSTvariabile PHP usiamo req.bodyin Node.js.

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

I parametri postali possono essere recuperati come segue:

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

Stai usando req.query.postcon il metodo sbagliato req.query.postfunziona method=get, method=postfunziona con body-parser .

Prova questo cambiando post per ottenere :

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

E nel codice espresso usa 'app.get'

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