Uwaga : ta odpowiedź jest dla Express 2. Zobacz tutaj dla Express 3.

Jeśli używasz connect / express, powinieneś użyć bodyParser middleware : jest to opisane w 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
});

Oto Oryginalna wersja 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;;
    });
  })
);

Zarówno querystring jak i body są przetwarzane przy użyciu rails-style(qs) zamiast biblioteki niskiego poziomu querystring . W celu analizy powtórzeń parametry z qs, parametr musi mieć nawiasy: name[]=val1&name[]=val2. Obsługuje również zagnieżdżone mapy. Oprócz analizowania przesłanych formularzy HTML, bodyParser może automatycznie analizować żądania JSON.

Edit : czytam w Expressie.js i zmodyfikowałem moją odpowiedź, aby była bardziej naturalna dla użytkowników Express.

Bezpieczeństwo przy użyciu express.bodyParser()

Podczas gdy wszystkie inne odpowiedzi obecnie zalecają użycie express.bodyParser() middleware, jest to w rzeczywistości owijka wokół express.json(), express.urlencoded(), i express.multipart() middlewares ( http://expressjs.com/api.html#bodyParser ). parsowanie ciał żądań formularza odbywa się za pomocą oprogramowania pośredniczącego express.urlencoded() i jest wszystkim, czego potrzebujesz, aby ujawnić dane formularza na obiekcie req.body.

Ze względu na troskę o bezpieczeństwo Z Jak express.multipart()/connect.multipart() tworzy pliki tymczasowe dla wszystkich przesłanych plików (i nie są zbierane śmieci), jest teraz zalecane nie używaj wrappera express.bodyParser(), ale zamiast tego używaj tylko tego, czego potrzebujesz.

Uwaga: connect.bodyParser() zostanie wkrótce zaktualizowany, aby zawierać tylko urlencoded i json po wydaniu Connect 3.0 (który rozszerza Express).

W skrócie, zamiast ...

app.use(express.bodyParser());

...należy użyć

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

I jeśli / kiedy trzeba obsłużyć formularze wieloczęściowe (przesyłanie plików), korzystaj z biblioteki lub oprogramowania pośredniczącego innych firm, takich jak multiparty, busboy, dicer itp.

To zrobi, jeśli chcesz zbudować wysłane zapytanie bez middleware:

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

});

To prześle to do przeglądarki

email=emailval&password1=pass1val&password2=pass2val

Prawdopodobnie lepiej jest użyć middleware, więc nie musisz pisać tego w kółko przy 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średniczącego (takiego jak bodyParser) nie jest już dołączona do programu Express i musi być zainstalowana osobno. Zobacz https://github.com/senchalabs/connect#middleware .

Będziesz musiał zainstalować pakiet body-parser oddzielnie z npm , a następnie użyć czegoś takiego jak poniżej (przykład zaczerpnię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();
})

Dana forma:

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

Using express

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

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

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

Wyjście:

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

app.use(express.bodyParser());

Następnie dla app.post request można uzyskać wartości post poprzez req.body.{post request variable}.

Aktualizacja dla Express 4.4.1

Oprogramowanie pośredniczące następujących elementów jest usuwane z Express.

• bodyParser
• json
• urlencoded
• multipart

Kiedy używasz oprogramowania pośredniczącego 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 tych middleware, teraz musisz wykonać npm dla każdego middleware osobno.

Ponieważ bodyParser jest oznaczony jako przestarzały, więc polecam idąc za pomocą json, urlencode i Parser multipart jak formidable, connect-multiparty. (Multipart middleware jest również przestarzałe).

Pamiętaj również, że po prostu definiując urlencode + json, dane formularza nie będą przetwarzane i req.ciało będzie nieokreślone. Musisz zdefiniować oprogramowanie pośredniczące 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);

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

Dla Express 4.1 i nowszych

Ponieważ większość odpowiedzi używa do wyrażenia, bodyParser, connect; gdzie multipart jest przestarzały. Istnieje bezpieczny sposób na łatwe wysyłanie obiektów Post multipart.

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

Aby zainstalować pakiet

$ npm install multer

Załaduj go w swojej aplikacji:

var multer = require('multer');

A następnie dodaj go do stosu middleware wraz z inną formą parsującą middleware.

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

Połącz się.json () uchwyty application / json

Połącz się.urlencoded () obsługuje application / x-www-form-urlencoded

Multipart() obsługuje multipart / form-data

Szukałam dokładnie tego problemu. Zastosowałem się do wszystkich powyższych rad, ale req.ciało wciąż zwracało pusty obiekt {}. W moim przypadku było to coś tak prostego, jak niepoprawny html.

W html formularza upewnij się, że używasz atrybutu 'name' w znacznikach wejściowych, a nie tylko 'id'. W przeciwnym razie nic nie jest analizowane.

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

Nie powinieneś używać aplikacji.użycie (wym.bodyParser ()) . BodyParser jest związkiem json + urlencoded + mulitpart. Nie powinieneś tego używać, ponieważ multipart zostanie usunięty w connect 3.0.

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

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

Its very important know that app.użycie (Ok.router) powinien być używany po JSON i urlencoded, w przeciwnym razie nie działa!

Request streaming pracował 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 poniższego kodu dla Posti GET requests.

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

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

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

Używasz ' req.zapytanie.post "z niewłaściwą metodą" req.zapytanie.post 'works with' method = get' 'method = post' działa z body-parserem.

Po prostu spróbuj, zmieniając post, 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>

I w ekspresowym kodzie użyj ' app.get '