Oto moja prosta forma:

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

Oto mój kod Express.js /Node.js:

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

Próbowałem sReq.query.emaillub sReq.query['email']lub sReq.params['email']itp żaden z nich pracy. Wszyscy wracają undefined.

Po zmianie na połączenie Get działa, więc .. masz jakiś pomysł?

Wszystko się zmieniło od uruchomienia Express 4.16.0 , możesz teraz używać express.json()i express.urlencoded()tak jak w Express 3.0 .

To było inne, począwszy od Express 4.0 do 4.15 :

$ npm install --save body-parser

i wtedy:

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

Reszta jest jak w Express 3.0 :

Najpierw musisz dodać oprogramowanie pośrednie, aby przeanalizować dane postu treści.

Dodaj jeden lub oba z następujących wierszy kodu:

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

Następnie w swoim module obsługi użyj req.bodyobiektu:

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

Pamiętaj, że użycie express.bodyParser()nie jest zalecane.

app.use(express.bodyParser());

...jest równa:

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

Istnieją obawy dotyczące bezpieczeństwa express.multipart(), dlatego lepiej jest jawnie dodać obsługę określonych typów kodowania, których potrzebujesz. Jeśli potrzebujesz kodowania wieloczęściowego (na przykład w celu obsługi przesyłania plików), powinieneś to przeczytać .

Kwestia bezpieczeństwa przy użyciu express.bodyParser ()

Podczas gdy wszystkie inne odpowiedzi obecnie zalecane przy użyciu express.bodyParser()oprogramowania pośredniczącego, to faktycznie owinięcie wokół express.json(), express.urlencoded()i express.multipart()middleware ( http://expressjs.com/api.html#bodyParser ). Parsowanie treści żądań formularzy odbywa się przez express.urlencoded()oprogramowanie pośrednie i jest to wszystko, czego potrzebujesz do ujawnienia danych formularza na req.bodyobiekcie.

Ze względu na obawy dotyczące bezpieczeństwa związane z tym, w jaki sposób express.multipart()/ connect.multipart()tworzy pliki tymczasowe dla wszystkich przesyłanych plików (i nie są usuwane), zaleca się teraz, aby nie używać express.bodyParser()opakowania, ale zamiast tego używać tylko potrzebnych plików pośrednich.

Uwaga: connect.bodyParser()wkrótce zostanie zaktualizowany, aby obejmował tylko urlencodedi jsonwydanie Connect 3.0 (które rozszerza Express).

Krótko mówiąc, zamiast ...

app.use(express.bodyParser());

...powinieneś użyć

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

a jeśli / kiedy musisz obsługiwać formularze wieloczęściowe (przesyłanie plików), użyj biblioteki innej firmy lub oprogramowania pośredniego, takiego jak multiparty, busboy, dicer itp.

Uwaga : ta odpowiedź dotyczy Express 2. Zobacz tutaj Express 3.

Jeśli używasz Connect / Express, powinieneś użyć oprogramowania pośredniego bodyParser : Jest to opisane w przewodniku 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
});

Oto oryginalna wersja tylko do połączenia:

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

Zarówno kwerenda, jak i treść są analizowane przy użyciu obsługi parametrów w stylu Rails ( qs), a nie biblioteki niskiego poziomuquerystring . W celu analizowania parametrów z powtarzających się qs, parametr musi mieć wsporniki: name[]=val1&name[]=val2. Obsługuje również mapy zagnieżdżone. Oprócz analizowania przesłanych formularzy HTML bodyParser może automatycznie analizować żądania JSON.

Edycja : Przeczytałem na express.js i zmodyfikowałem moją odpowiedź, aby była bardziej naturalna dla użytkowników Express.

To zrobi, jeśli chcesz zbudować wysłane zapytanie bez oprogramowania pośredniego:

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

});

To wyśle ​​to do przeglądarki

email=emailval&password1=pass1val&password2=pass2val

Prawdopodobnie lepiej jest jednak użyć oprogramowania pośredniego, więc nie musisz zapisywać tego w kółko na każdej trasie.

Uwaga dla użytkowników Express 4:

Jeśli spróbujesz umieścić app.use(express.bodyParser());w swojej aplikacji, podczas próby uruchomienia serwera Express pojawi się następujący błąd:

Błąd: większość oprogramowania pośredniego (takiego jak bodyParser) nie jest już dostarczana w pakiecie z Express i musi być instalowana osobno. Zobacz https://github.com/senchalabs/connect#middleware .

Będziesz musiał zainstalować pakiet body-parserosobno od npm , a następnie użyj czegoś takiego: (przykład wzięty ze strony 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();
})

Biorąc pod uwagę jakąś formę:

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

Korzystanie z ekspresu

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

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

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

Wynik:

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

Frontend:

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

Następnie na app.postżądanie można uzyskać wartości postów za pośrednictwem req.body.{post request variable}.

Aktualizacja dla Express 4.4.1

Poniższe oprogramowanie pośrednie zostało usunięte z programu Express.

• bodyParser
• json
• urlencoded
• wieloczęściowy

Gdy używasz oprogramowania pośredniego bezpośrednio tak, jak w Express 3.0. Otrzymasz następujący błąd:

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

Aby korzystać z oprogramowania pośredniego, musisz teraz zrobić npm dla każdego oprogramowania pośredniego osobno.

Ponieważ bodyParser jest oznaczony jako przestarzały, dlatego polecam następujący sposób, używając json, urlencode i parsera wieloczęściowego, np. Formidable, connect-multiparty. (Oprogramowanie pośrednie Multipart jest również przestarzałe).

Pamiętaj również, że po zdefiniowaniu urlencode + json dane formularza nie zostaną przeanalizowane, a żądanie będzie niezdefiniowane. Musisz zdefiniować oprogramowanie pośrednie obsługujące żądanie wieloczęściowe.

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

Dla Express 4.1 i nowszych

Ponieważ większość odpowiedzi używa Express, bodyParser, connect; gdzie multipart jest przestarzałe. Istnieje bezpieczny sposób łatwego wysyłania obiektów wieloczęściowych.

Multer może być używany jako zamiennik metody connect.multipart ().

Aby zainstalować pakiet

$ npm install multer

Załaduj go do swojej aplikacji:

var multer = require('multer');

Następnie dodaj go do stosu oprogramowania pośredniego wraz z innym narzędziem do analizowania oprogramowania pośredniego.

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

connect.json () obsługuje aplikację / json

connect.urlencoded () obsługuje aplikację / x-www-form-urlencoded

multer () obsługuje dane wieloczęściowe / formularze

Dokładnie szukałem tego problemu. Postępowałem zgodnie ze wszystkimi powyższymi wskazówkami, ale wymaganie: wciąż zwracałem pusty obiekt {}. W moim przypadku było to tak proste, jak niepoprawny HTML.

W formularzu HTML upewnij się, że używasz 'name'atrybutu w tagach wejściowych, nie tylko 'id'. W przeciwnym razie nic nie zostanie przeanalizowane.

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

Mój błąd idioto jest twoją korzyścią.

Nie powinieneś używać app.use (express.bodyParser ()) . BodyParser to połączenie json + urlencoded + mulitpart. Nie powinieneś tego używać, ponieważ multipart zostanie usunięty w Connect 3.0.

Aby rozwiązać ten problem, możesz to zrobić:

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

Bardzo ważne jest, aby wiedzieć, że app.use (app.router) powinien być używany po jsonie i urlencodowany, w przeciwnym razie nie zadziała!

Żądanie przesyłania strumieniowego działało dla mnie

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

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

Mogłem znaleźć wszystkie parametry, używając następującego kodu dla żądań POST i 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));
})

Napisane w wersji Express 4.16

Wewnątrz funkcji routera można użyć req.bodywłaściwości, aby uzyskać dostęp do zmiennej post. Na przykład, jeśli była to POSTtrasa twojego formularza, odesłałbyś to, co wpisałeś:

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

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

PS dla tych, którzy znają PHP: Aby uzyskać dostęp do $_GETzmiennej PHP, której używamy, req.queryi aby uzyskać dostęp do $_POSTzmiennej PHP używamy req.bodyw 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");
})

Parametry posta można pobrać w następujący sposób:

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

Używasz req.query.postmetodą niewłaściwych req.query.postprac z method=get, method=postprac z ciała parsera .

Spróbuj tego, zmieniając wpis, aby uzyskać :

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

W kodzie ekspresowym użyj „app.get”

Użyj pakietu 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');
});