Możesz użyć querystring moduł:

var qs = require('querystring');

function (request, response) {
    if (request.method == 'POST') {
        var body = '';

        request.on('data', function (data) {
            body += data;

            // Too much POST data, kill the connection!
            // 1e6 === 1 * Math.pow(10, 6) === 1 * 1000000 ~~~ 1MB
            if (body.length > 1e6)
                request.connection.destroy();
        });

        request.on('end', function () {
            var post = qs.parse(body);
            // use post['blah'], etc.
        });
    }
}

Teraz, na przykład, jeśli masz pole input o nazwie age, możesz uzyskać do niego dostęp za pomocą zmiennej post:

console.log(post.age);

Upewnij się, aby zabić połączenie, jeśli ktoś próbuje zalać PAMIĘĆ RAM!

var qs = require('querystring');

function (request, response) {
    if (request.method == 'POST') {
        var body = '';
        request.on('data', function (data) {
            body += data;
            // 1e6 === 1 * Math.pow(10, 6) === 1 * 1000000 ~~~ 1MB
            if (body.length > 1e6) { 
                // FLOOD ATTACK OR FAULTY CLIENT, NUKE REQUEST
                request.connection.destroy();
            }
        });
        request.on('end', function () {

            var POST = qs.parse(body);
            // use POST

        });
    }
}

Wiele odpowiedzi tutaj nie są już dobrymi praktykami lub niczego nie wyjaśniają, więc dlatego piszę to.

Podstawy

Gdy wywołanie zwrotne http.createServer jest wywoływany, kiedy serwer rzeczywiście otrzymał wszystkie nagłówki żądania, ale jest możliwe, że dane nie zostały jeszcze odebrane, więc musimy na nie czekać. Obiekt HTTP request (a http.Incomingmessage instance) jest w rzeczywistości czytelny stream . W odczytywalnych strumieni, gdy przybywa porcja danych, a data zdarzenie jest emitowane(zakładając, że zarejestrowałeś callback do niego) i gdy wszystkie kawałki przybyły end wydarzenie jest emitowane. Oto przykład, jak słuchasz wydarzeń:

http.createServer((request, response) => {
  console.log('Now we have a http message with headers but no data yet.');
  request.on('data', chunk => {
    console.log('A chunk of data has arrived: ', chunk);
  });
  request.on('end', () => {
    console.log('No more data');
  })
}).listen(8080)

Konwersja buforów na łańcuchy

Jeśli spróbujesz tego, zauważysz, że kawałki są buforami. Jeśli nie masz do czynienia z danymi binarnymi i potrzebujesz pracować z ciągami znaków, sugeruję użycie Prośba.setEncoding metoda, która powoduje, że strumień emituje ciągi znaków zinterpretowanych z podanym kodowaniem i prawidłowo obsługuje znaki wielobajtowe.

Części Buforujące

Teraz prawdopodobnie nie jesteś zainteresowany każdym kawałkiem przez to własne, więc w tym przypadku prawdopodobnie chcesz go buforować w ten sposób:

http.createServer((request, response) => {
  const chunks = [];
  request.on('data', chunk => chunks.push(chunk));
  request.on('end', () => {
    const data = Buffer.concat(chunks);
    console.log('Data: ', data);
  })
}).listen(8080)

Tutaj Bufor.używany jest concat , który po prostu łączy wszystkie bufory i zwraca jeden duży bufor. Możesz również użyć modułu concat-stream co robi to samo:

const http = require('http');
const concat = require('concat-stream');
http.createServer((request, response) => {
  concat(request, data => {
    console.log('Data: ', data);
  });
}).listen(8080)

Parsowanie Zawartości

Jeśli próbujesz zaakceptować wysyłanie formularzy HTML bez plików lub przekazywanie jQuery ajax wywołań z domyślnym typem zawartości, to typem zawartości jest application/x-www-form-urlencoded z kodowaniem uft-8. Możesz użyć modułu querystring , aby usunąć serializację i uzyskać dostęp do właściwości:

const http = require('http');
const concat = require('concat-stream');
const qs = require('querystring');
http.createServer((request, response) => {
  concat(request, buffer => {
    const data = qs.parse(buffer.toString());
    console.log('Data: ', data);
  });
}).listen(8080)

Jeśli twoim typem zawartości jest JSON, możesz po prostu użyć JSON.parse zamiast qs.parse .

Jeśli masz do czynienia z plikami lub obsługą wieloczęściowego typu treści, to w takim przypadku powinieneś użyć czegoś takiego jak formidable, który usuwa cały ból z radzenia sobie z nim. Spójrz na ta inna odpowiedź mojej, w której umieściłem pomocne linki i moduły dla treści wieloczęściowych.

Orurowanie

Jeśli nie chcesz analizować zawartości, ale raczej przekazać ją do innego miejsca, na przykład wyślij ją do innego żądania http jako dane lub zapisać go do pliku proponuję Orurowanie go zamiast buforowania go, ponieważ będzie mniej kodu, lepiej radzi sobie z przeciwciśnieniem, zajmie mniej pamięci, a w niektórych przypadkach szybciej.

Więc jeśli chcesz zapisać zawartość do pliku:

 http.createServer((request, response) => {
   request.pipe(fs.createWriteStream('./request'));
 }).listen(8080)

Ograniczenie ilości danych

Jak zauważyły inne odpowiedzi, pamiętaj, że złośliwi klienci mogą wysłać Ci ogromną ilość danych, aby zawiesić aplikację lub wypełnić pamięć, aby chronić, że nie wysyłasz żądań które emitują dane przechodzą określony limit. Jeśli nie używasz biblioteki do obsługi przychodzących danych. Sugerowałbym użycie czegoś w rodzaju stream-meter, który może przerwać żądanie, jeśli osiągnie określony limit:

limitedStream = request.pipe(meter(1e7));
limitedStream.on('data', ...);
limitedStream.on('end', ...);

Lub

request.pipe(meter(1e7)).pipe(createWriteStream(...));

Lub

concat(request.pipe(meter(1e7)), ...);

Moduły NPM

Podczas gdy opisałem powyżej, jak można używać HTTP request body, po prostu buforowanie i parsowanie treści, sugeruję użycie jednego z tych modułów, a raczej implementowanie samodzielnie jako prawdopodobnie będą lepiej obsługiwać sprawy krawędziowe. W przypadku express proponuję użyć body-parser. Dla koa istnieje podobny moduł.

Jeśli nie używasz frameworka, ciało jest całkiem dobre.

Oto bardzo prosty wrapper no-framework oparty na innych odpowiedziach i artykułach zamieszczonych tutaj:

var http = require('http');
var querystring = require('querystring');

function processPost(request, response, callback) {
    var queryData = "";
    if(typeof callback !== 'function') return null;

    if(request.method == 'POST') {
        request.on('data', function(data) {
            queryData += data;
            if(queryData.length > 1e6) {
                queryData = "";
                response.writeHead(413, {'Content-Type': 'text/plain'}).end();
                request.connection.destroy();
            }
        });

        request.on('end', function() {
            request.post = querystring.parse(queryData);
            callback();
        });

    } else {
        response.writeHead(405, {'Content-Type': 'text/plain'});
        response.end();
    }
}

Przykład użycia:

http.createServer(function(request, response) {
    if(request.method == 'POST') {
        processPost(request, response, function() {
            console.log(request.post);
            // Use request.post here

            response.writeHead(200, "OK", {'Content-Type': 'text/plain'});
            response.end();
        });
    } else {
        response.writeHead(200, "OK", {'Content-Type': 'text/plain'});
        response.end();
    }

}).listen(8000);

Będzie czystsze, jeśli zakodujesz swoje dane do JSON, następnie wyślij go do węzła.js.

function (req, res) {
    if (req.method == 'POST') {
        var jsonString = '';

        req.on('data', function (data) {
            jsonString += data;
        });

        req.on('end', function () {
            console.log(JSON.parse(jsonString));
        });
    }
}

Dla wszystkich, którzy zastanawiają się, jak zrobić to banalne zadanie bez instalowania frameworka internetowego, udało mi się to zrobić razem. Mało gotowy do produkcji, ale wydaje się, że działa.

function handler(req, res) {
    var POST = {};
    if (req.method == 'POST') {
        req.on('data', function(data) {
            data = data.toString();
            data = data.split('&');
            for (var i = 0; i < data.length; i++) {
                var _data = data[i].split("=");
                POST[_data[0]] = _data[1];
            }
            console.log(POST);
        })
    }
}

Możesz użyć body-parser, węzła.js body parsing middleware.

Pierwszy załadunek body-parser

$ npm install body-parser --save

Jakiś przykładowy kod

var express = require('express')
var bodyParser = require('body-parser')

var app = express()

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


app.use(function (req, res) {
  var post_data = req.body;
  console.log(post_data);
})

Więcej dokumentacji można znaleźć tutaj

Odniesienie: https://nodejs.org/en/docs/guides/anatomy-of-an-http-transaction /

let body = [];
request.on('data', (chunk) => {
  body.push(chunk);
}).on('end', () => {
  body = Buffer.concat(body).toString();
  // at this point, `body` has the entire request body stored in it as a string
});

Oto jak możesz to zrobić, jeśli użyjesz node-formidable :

var formidable = require("formidable");

var form = new formidable.IncomingForm();
form.parse(request, function (err, fields) {
    console.log(fields.parameter1);
    console.log(fields.parameter2);
    // ...
});

Jeśli wolisz używać pure Node.js następnie możesz wyodrębnić dane postu, jak pokazano poniżej:

// Dependencies
const StringDecoder = require('string_decoder').StringDecoder;
const http = require('http');

// Instantiate the HTTP server.
const httpServer = http.createServer((request, response) => {
  // Get the payload, if any.
  const decoder = new StringDecoder('utf-8');
  let payload = '';

  request.on('data', (data) => {
    payload += decoder.write(data);
  });

  request.on('end', () => {
    payload += decoder.end();

    // Parse payload to object.
    payload = JSON.parse(payload);

    // Do smoething with the payload....
  });
};

// Start the HTTP server.
const port = 3000;
httpServer.listen(port, () => {
  console.log(`The server is listening on port ${port}`);
});

1) Zainstaluj 'body-parser' z npm.

2) Następnie w aplikacji .ts

var bodyParser = require('body-parser');

3) Następnie musisz napisać

app.use(bodyParser.json())

W app.ts Moduł

4) pamiętaj, że dołączasz

app.use(bodyParser.json())

Na górze lub przed dowolną deklaracją modułu.

Ex:

app.use(bodyParser.json())
app.use('/user',user);

5) Następnie użyj

var postdata = req.body;

Jeśli nie chcesz dzielić danych razem z wywołaniem zwrotnym data, zawsze możesz użyć wywołania zwrotnego readable w następujący sposób:

// Read Body when Available
request.on("readable", function(){
  request.body = '';
  while (null !== (request.body += request.read())){}
});

// Do something with it
request.on("end", function(){
  request.body //-> POST Parameters as String
});

To podejście modyfikuje przychodzące żądanie, ale jak tylko skończysz odpowiedź, żądanie zostanie pobrane śmieci, więc nie powinno to być problemem.

Zaawansowanym podejściem byłoby sprawdzenie najpierw rozmiaru ciała, jeśli boisz się wielkich ciał.

Można to zrobić na wiele sposobów. Jednak najszybszym sposobem, jaki znam, jest użycie ekspresu.biblioteka js z body-parserem.

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

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

app.post("/pathpostdataissentto", function(request, response) {
  console.log(request.body);
  //Or
  console.log(request.body.fieldName);
});

app.listen(8080);

To może działać na struny, ale zmieniłbym bodyParser.urlencoded to bodyParser.json zamiast tego, jeśli dane POST zawierają tablicę JSON.

Więcej informacji: http://www.kompulsa.com/how-to-accept-and-parse-post-requests-in-node-js/

Musisz otrzymać POST Dane w kawałkach za pomocą request.on('data', function(chunk) {...})

const http = require('http');

http.createServer((req, res) => {
    if (req.method == 'POST') {
        whole = ''
        req.on('data', (chunk) => {
            # consider adding size limit here
            whole += chunk.toString()
        })

        req.on('end', () => {
            console.log(whole)
            res.writeHead(200, 'OK', {'Content-Type': 'text/html'})
            res.end('Data received.')
        })
    }
}).listen(8080)

Należy rozważyć dodanie limitu wielkości we wskazanej pozycji jako thejh sugerowane .

Express v4.17.0

app.use(express.urlencoded( {extended: true} ))

console.log(req.body) // object

Formularz Demo

Kolejna Odpowiedź Związana

Jeśli używasz Express.js , zanim uzyskasz dostęp do req.body, musisz dodać middleware bodyParser:

app.use(express.bodyParser());

Wtedy możesz poprosić o

req.body.user

I jeśli nie chcesz używać całego frameworka jak Express, ale potrzebujesz również różnego rodzaju formularzy, w tym uploadów, to formaline może być dobrym wyborem.

Jest wymieniony w Node.Moduły js

Możesz wyodrębnić parametr post bez użycia express.

1: nmp install multiparty

2: Importuj wielopartyjny . as var multiparty = require('multiparty');

3: `

if(req.method ==='POST'){
   var form = new multiparty.Form();
   form.parse(req, function(err, fields, files) {
      console.log(fields['userfile1'][0]);
    });
    }

4: A formularz HTML jest .

<form method=POST enctype=multipart/form-data>
<input type=text name=userfile1><br>
<input type=submit>
</form>

Znalazłem film, który wyjaśnia, jak to osiągnąć: https://www.youtube.com/watch?v=nuw48-u3Yrg

Używa domyślnego modułu " http "wraz z modułami" querystring "i" stringbuilder". Aplikacja pobiera dwie liczby (używając dwóch pól tekstowych) ze strony internetowej i po przesłaniu zwraca ich sumę (wraz z utrzymaniem wartości w polach tekstowych). To najlepszy przykład, jaki mogłem znaleźć nigdzie indziej.

Powiązany kod źródłowy:

var http = require("http");
var qs = require("querystring");
var StringBuilder = require("stringbuilder");

var port = 9000;

function getCalcHtml(req, resp, data) {
    var sb = new StringBuilder({ newline: "\r\n" });
    sb.appendLine("<html>");
    sb.appendLine(" <body>");
    sb.appendLine("     <form method='post'>");
    sb.appendLine("         <table>");
    sb.appendLine("             <tr>");
    sb.appendLine("                 <td>Enter First No: </td>");

    if (data && data.txtFirstNo) {
        sb.appendLine("                 <td><input type='text' id='txtFirstNo' name='txtFirstNo' value='{0}'/></td>", data.txtFirstNo);
    }
    else {
        sb.appendLine("                 <td><input type='text' id='txtFirstNo' name='txtFirstNo' /></td>");
    }

    sb.appendLine("             </tr>");
    sb.appendLine("             <tr>");
    sb.appendLine("                 <td>Enter Second No: </td>");

    if (data && data.txtSecondNo) {
        sb.appendLine("                 <td><input type='text' id='txtSecondNo' name='txtSecondNo' value='{0}'/></td>", data.txtSecondNo);
    }
    else {
        sb.appendLine("                 <td><input type='text' id='txtSecondNo' name='txtSecondNo' /></td>");
    }

    sb.appendLine("             </tr>");
    sb.appendLine("             <tr>");
    sb.appendLine("                 <td><input type='submit' value='Calculate' /></td>");
    sb.appendLine("             </tr>");

    if (data && data.txtFirstNo && data.txtSecondNo) {
        var sum = parseInt(data.txtFirstNo) + parseInt(data.txtSecondNo);
        sb.appendLine("             <tr>");
        sb.appendLine("                 <td>Sum: {0}</td>", sum);
        sb.appendLine("             </tr>");
    }

    sb.appendLine("         </table>");
    sb.appendLine("     </form>")
    sb.appendLine(" </body>");
    sb.appendLine("</html>");
    sb.build(function (err, result) {
        resp.write(result);
        resp.end();
    });
}

function getCalcForm(req, resp, data) {
    resp.writeHead(200, { "Content-Type": "text/html" });
    getCalcHtml(req, resp, data);
}

function getHome(req, resp) {
    resp.writeHead(200, { "Content-Type": "text/html" });
    resp.write("<html><html><head><title>Home</title></head><body>Want to some calculation? Click <a href='/calc'>here</a></body></html>");
    resp.end();
}

function get404(req, resp) {
    resp.writeHead(404, "Resource Not Found", { "Content-Type": "text/html" });
    resp.write("<html><html><head><title>404</title></head><body>404: Resource not found. Go to <a href='/'>Home</a></body></html>");
    resp.end();
}

function get405(req, resp) {
    resp.writeHead(405, "Method not supported", { "Content-Type": "text/html" });
    resp.write("<html><html><head><title>405</title></head><body>405: Method not supported</body></html>");
    resp.end();
}

http.createServer(function (req, resp) {
    switch (req.method) {
        case "GET":
            if (req.url === "/") {
                getHome(req, resp);
            }
            else if (req.url === "/calc") {
                getCalcForm(req, resp);
            }
            else {
                get404(req, resp);
            }
            break;
        case "POST":
            if (req.url === "/calc") {
                var reqBody = '';
                req.on('data', function (data) {
                    reqBody += data;
                    if (reqBody.length > 1e7) { //10MB
                        resp.writeHead(413, 'Request Entity Too Large', { 'Content-Type': 'text/html' });
                        resp.end('<!doctype html><html><head><title>413</title></head><body>413: Request Entity Too Large</body></html>');
                    }
                });
                req.on('end', function () {
                    var formData = qs.parse(reqBody);
                    getCalcForm(req, resp, formData);
                });
            }
            else {
                get404(req, resp);
            }
            break;
        default:
            get405(req, resp);
            break;
    }
}).listen(port);

Dla osób używających raw binary POST upload bez kodowania możesz użyć:

Klient:

var xhr = new XMLHttpRequest();
xhr.open("POST", "/api/upload", true);
var blob = new Uint8Array([65,72,79,74]); // or e.g. recorder.getBlob()
xhr.send(blob);

Serwer:

var express = require('express');
var router = express.Router();
var fs = require('fs');

router.use (function(req, res, next) {
  var data='';
  req.setEncoding('binary');
  req.on('data', function(chunk) {
    data += chunk;
  });

  req.on('end', function() {
    req.body = data;
    next();
  });
});

router.post('/api/upload', function(req, res, next) {
  fs.writeFile("binaryFile.png", req.body, 'binary', function(err) {
    res.send("Binary POST successful!");
  });
});

Możesz użyć express middleware, który teraz ma wbudowany body-parser. Oznacza to, że wszystko, co musisz zrobić, to:

import express from 'express'

const app = express()

app.use(express.json())

app.post('/thing', (req, res) => {
  console.log(req.body) // <-- this will access the body of the post
  res.sendStatus(200)
})

Ten przykład kodu to ES6 z Expressem 4.16.x

Ogranicz rozmiar postu unikaj zalewania aplikacji węzła. Istnieje świetny moduł raw-body , odpowiedni zarówno dla express, jak i connect, który może pomóc w ograniczeniu żądania według rozmiaru i długości.

Jeśli wymaga przesłania pliku, przeglądarka zazwyczaj wysyła go jako typ zawartości "multipart/form-data". Możesz tego użyć w takich przypadkach

var multipart = require('multipart');
multipart.parse(req)

Odniesienie 1

Odniesienie 2

Na takich polach formularzy

   <input type="text" name="user[name]" value="MyName">
   <input type="text" name="user[email]" value="[email protected]">

Niektóre z powyższych odpowiedzi zawiodą, ponieważ obsługują tylko dane płaskie.

Na razie używam odpowiedzi Casey Chu, ale z " qs " zamiast modułu "querystring". Jest to również moduł "body-parser". Więc jeśli chcesz zagnieżdżone dane, musisz zainstalować qs.

npm install qs --save

Następnie zastąp pierwszą linię jak:

//var qs = require('querystring');
var qs = require('qs'); 

function (request, response) {
    if (request.method == 'POST') {
        var body = '';

        request.on('data', function (data) {
            body += data;

            // Too much POST data, kill the connection!
            // 1e6 === 1 * Math.pow(10, 6) === 1 * 1000000 ~~~ 1MB
            if (body.length > 1e6)
                request.connection.destroy();
        });

        request.on('end', function () {
            var post = qs.parse(body);
            console.log(post.user.name); // should work
            // use post['blah'], etc.
        });
    }
}

Możesz łatwo wysłać i uzyskać odpowiedź żądania POST za pomocą "Request-Simplified HTTP client" i JavaScript Promise.

var request = require('request');

function getData() {
    var options = {
        url: 'https://example.com',
        headers: {
            'Content-Type': 'application/json'
        }
    };

    return new Promise(function (resolve, reject) {
        var responseData;
        var req = request.post(options, (err, res, body) => {
            if (err) {
                console.log(err);
                reject(err);
            } else {
                console.log("Responce Data", JSON.parse(body));
                responseData = body;
                resolve(responseData);
            }
        });
    });
}

Musisz użyć bodyParser (), jeśli chcesz, aby dane formularza były dostępne w req.ciało. body-parser przetwarza żądanie i konwertuje je do formatu, z którego można łatwo wyodrębnić istotne informacje, które mogą być potrzebne.

Na przykład, załóżmy, że masz formularz rejestracji w interfejsie użytkownika. Wypełniasz go i prosisz serwer o zapisanie danych gdzieś.

Wyodrębnienie nazwy użytkownika i hasła z twojego żądania jest tak proste, jak poniżej, jeśli używasz body-parser.

…………………………………………………….

var loginDetails = {

username : request.body.username,

password : request.body.password

};

Jedna wkładka bez warstwy pośredniej
Jeśli zamieścisz następujące dane,
'name':'ABC'
Następnie możesz go przeanalizować używając następującej linijki

require('url').parse(req.url, true).query.name