如何从Node.js中的HTTP form[method="post"]方法中提取表单数据（POST）和文件上传？
我已阅读文档，谷歌搜索，一无所获。
function (request, response) {
//request.post????
}
有图书馆还是黑客？
答案 0 :(得分：671)
您可以使用querystring模块：
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.
});
}
}
现在，例如，如果您有一个名为input的{{1}}字段，则可以使用变量age访问它：
post答案 1 :(得分：489)
如果您使用Express（针对Node.js的高性能，高级Web开发），您可以这样做：
<强> HTML：
<form method="post" action="/">
<input type="text" name="user[name]">
<input type="text" name="user[email]">
<input type="submit" value="Submit">
</form>
API客户端：
fetch('/', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
user: {
name: "John",
email: "john@example.com"
}
})
});
Node.js：（自Express v4.16.0起）
// Parse URL-encoded bodies (as sent by HTML forms)
app.use(express.urlencoded());
// Parse JSON bodies (as sent by API clients)
app.use(express.json());
// Access the parse results as request.body
app.post('/', function(request, response){
console.log(request.body.user.name);
console.log(request.body.user.email);
});
Node.js：（适用于Express＆lt; 4.16.0）
const bodyParser = require("body-parser");
/** bodyParser.urlencoded(options)
* Parses the text as URL encoded data (which is how browsers tend to send form data from regular forms set to POST)
* and exposes the resulting object (containing the keys and values) on req.body
*/
app.use(bodyParser.urlencoded({
extended: true
}));
/**bodyParser.json(options)
* Parses the text as JSON and exposes the resulting object on req.body.
*/
app.use(bodyParser.json());
app.post("/", function (req, res) {
console.log(req.body.user.name)
});
答案 2 :(得分：142)
如果有人试图淹没你的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
});
}
}
答案 3 :(得分：93)
这是一个非常简单的无框架包装器，基于其他答案和文章发布在这里：
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();
}
}
用法示例：
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);
答案 4 :(得分：79)
这里的很多答案不再是好的做法，也不能解释任何事情，这就是我写这篇文章的原因。
当调用http.createServer的回调时，是当服务器实际收到请求的所有标题时，但是可能还没有收到数据，所以我们必须等待它。 http request object(a http.IncomingMessage instance)实际上是readable stream。在大量数据到达时的可读流中，data event is emitted（假设您已向其注册回调）并且当所有块都已到达时，将发出end事件。以下是您如何收听事件的示例：
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)
如果你试试这个，你会注意到这些块是buffers。如果您不处理二进制数据并且需要使用字符串，我建议使用request.setEncoding方法，这会导致流发出使用给定编码解释的字符串并正确处理多字节字符。
现在你可能对它自己的每个块都不感兴趣，所以在这种情况下你可能想要像这样缓冲它：
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)
这里使用Buffer.concat，它简单地连接所有缓冲区并返回一个大缓冲区。您也可以使用同样的concat-stream module：
const http = require('http');
const concat = require('concat-stream');
http.createServer((request, response) => {
concat(request, data => {
console.log('Data: ', data);
});
}).listen(8080)
如果您尝试接受没有文件的HTML表单POST提交或使用默认内容类型处理jQuery ajax个调用，则内容类型为application/x-www-form-urlencoded且编码为uft-8。您可以使用querystring module对其进行反序列化并访问属性：
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)
如果您的内容类型是JSON，则只需使用JSON.parse代替qs.parse。
如果您正在处理文件或处理多部分内容类型，那么在这种情况下，您应该使用类似强大的东西来消除处理它的所有痛苦。看看我的this other answer，我已经发布了多部分内容的有用链接和模块。
如果您不想解析内容，而是将其传递到其他地方，例如将其作为数据发送到另一个http请求，或将其保存到我建议piping it而不是缓冲的文件中它，因为它会减少代码，更好地处理背压，它会减少内存，在某些情况下会更快。
因此，如果您想将内容保存到文件中：
http.createServer((request, response) => {
request.pipe(fs.createWriteStream('./request'));
}).listen(8080)
正如其他答案所指出的那样，请记住，恶意客户端可能会向您发送大量数据以使您的应用程序崩溃或填满您的内存，以便保护您确保丢弃发出数据的请求超过某个限制。如果您不使用库来处理传入的数据。我建议使用类似stream-meter的东西，如果达到指定的限制，可以中止请求：
limitedStream = request.pipe(meter(1e7));
limitedStream.on('data', ...);
limitedStream.on('end', ...);
或
request.pipe(meter(1e7)).pipe(createWriteStream(...));
或
concat(request.pipe(meter(1e7)), ...);
还尝试使用npm模块而不是自己实现，因为它们可能会更好地处理边缘情况。对于表达，我建议使用body-parser。对于koa，有similar module。
如果您不使用框架，body非常好。
答案 5 :(得分：76)
如果您将数据编码为 JSON ，然后将其发送到Node.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));
});
}
}
答案 6 :(得分：34)
对于任何想知道如何在不安装Web框架的情况下完成这项琐碎任务的人，我设法将它们放在一起。几乎没有生产准备但它似乎有效。
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);
})
}
}
答案 7 :(得分：11)
您可以使用body-parser，Node.js正文解析中间件。
首先加载body-parser
$ npm install body-parser --save
一些示例代码
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);
})
可以找到更多文档here
答案 8 :(得分：9)
参考：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
});
答案 9 :(得分：7)
如果您使用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);
// ...
});
答案 10 :(得分：5)
1）从npm安装'body-parser'。
2）然后在 app.ts
中var bodyParser = require('body-parser');
3）然后你需要写
app.use(bodyParser.json())
4）请记住，你包括
app.use(bodyParser.json())
在顶部或任何模块声明之前。
前：
app.use(bodyParser.json())
app.use('/user',user);
5）然后使用
var postdata = req.body;
答案 11 :(得分：4)
如果您不想将数据与data回调一起分块，您可以随时使用readable回调：
// 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
});
此方法修改传入的请求，但是一旦您完成响应，请求将被垃圾收集，因此这不应该是一个问题。
如果你害怕巨大的身体，一种先进的方法是首先检查身体大小。
答案 12 :(得分：4)
如果您更喜欢使用纯Node.js，则可以提取POST数据，如下所示：
// 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}`);
});
答案 13 :(得分：4)
有多种方法可以做到这一点。但是，我知道最快的方法是将Express.js库与body-parser一起使用。
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);
这可以用于字符串，但如果POST数据包含JSON数组，我会将bodyParser.urlencoded更改为bodyParser.json。
更多信息：http://www.kompulsa.com/how-to-accept-and-parse-post-requests-in-node-js/
答案 14 :(得分：4)
您需要使用POST
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)
您应该考虑在指定位置添加尺寸限制为thejh suggested。
答案 15 :(得分：3)
如果您使用Express.js，则在访问req.body之前，必须添加中间件bodyParser：
app.use(express.bodyParser());
然后你可以要求
req.body.user
答案 16 :(得分：2)
Express v4.17.0
app.use(express.urlencoded( {extended: true} ))
答案 17 :(得分：2)
如果您不想使用像Express这样的整个框架，但是您还需要不同类型的表单，包括上传，那么formaline可能是一个不错的选择。
中答案 18 :(得分：1)
您可以使用express中间件，该中间件现在内置了主体解析器。这意味着您需要做的是以下事情：
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)
})
该代码示例是带有Express 4.16.x的ES6
答案 19 :(得分：1)
对于那些使用原始二进制POST上传而没有编码开销的用户，可以使用：
<强>客户端：
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);
服务器
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!");
});
});
答案 20 :(得分：1)
我找到了一个视频，解释了如何实现这个目标： https://www.youtube.com/watch?v=nuw48-u3Yrg
它使用默认＆＃34; http＆＃34;模块和＆＃34; querystring＆＃34;和＆＃34; stringbuilder＆＃34;模块。应用程序从网页中获取两个数字（使用两个文本框），并在提交时返回这两个数字的总和（以及保留文本框中的值）。这是我在其他地方找到的最好的例子。
相关源代码：
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);
答案 21 :(得分：0)
如果希望表单数据在req.body中可用，则需要使用bodyParser（）。 body-parser解析您的请求并将其转换为一种格式，您可以从中轻松提取您可能需要的相关信息。
例如，假设您在前端有一个注册表格。您正在填充它，并请求服务器将详细信息保存在某处。
如果使用body-parser，从请求中提取用户名和密码非常简单。
………………………………………………。
var loginDetails = {
username : request.body.username,
password : request.body.password
};
答案 22 :(得分：0)
一个没有MIDDLEWARE的班轮
如果发布以下数据，
'name':'ABC'
然后，您可以使用以下一种衬纸
require('url').parse(req.url, true).query.name
答案 23 :(得分：0)
如果您从 POST 以 JSON 格式接收数据。 :
import http from 'http';
const hostname = '127.0.0.1';
const port = 3000;
const httpServer: http.Server = http.createServer((req: http.IncomingMessage, res:
http.ServerResponse) => {
if(req.method === 'POST') {
let body: string = '';
req.on('data',(chunck) => {
body += chunck;
});
req.on('end', () => {
const body = JSON.parse(body);
res.statusCode = 200;
res.end('OK post');
});
}
});
httpServer.listen(port, hostname, () => {
console.info(`Server started at port ${port}`);
})
答案 24 :(得分：0)
通过使用“请求-简化的HTTP客户端”和Javascript Promise，您可以轻松发送并获取POST请求的响应。
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);
}
});
});
}
答案 25 :(得分：0)
在这些表单字段
上 <input type="text" name="user[name]" value="MyName">
<input type="text" name="user[email]" value="myemail@somewherefarfar.com">
上述一些答案会失败，因为它们只支持平面数据。
目前我正在使用Casey Chu的答案，但使用的是"qs"而不是“querystring”模块。这也是"body-parser"模块使用的模块。因此，如果您想要嵌套数据，则必须安装qs。
npm install qs --save
然后替换第一行，如：
//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.
});
}
}
答案 26 :(得分：0)
如果涉及文件上传，浏览器通常会将其作为"multipart/form-data"内容类型发送。
你可以在这种情况下使用它
var multipart = require('multipart');
multipart.parse(req)
答案 27 :(得分：0)
限制POST大小，避免泛滥节点应用。 有一个很棒的raw-body模块，适用于快速和连接，可以帮助您按大小和长度限制请求。
答案 28 :(得分：0)
你可以不使用快递提取post参数。
1：nmp install multiparty
2：导入多方。作为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：和HTML FORM IS。
<form method=POST enctype=multipart/form-data>
<input type=text name=userfile1><br>
<input type=submit>
</form>
我希望这对你有用。感谢。