जवाबों:
यदि आप एक्सप्रेस (उच्च-प्रदर्शन, Node.js के लिए उच्च-स्तरीय वेब विकास) का उपयोग करते हैं, तो आप ऐसा कर सकते हैं:
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: (एक्सप्रेस 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: (एक्सप्रेस <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)
});app.use(express.bodyParser());।
आप 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नाम के साथ कोई फ़ील्ड है , तो आप ageचर का उपयोग करके इसे एक्सेस कर सकते हैं post:
console.log(post.age);var POST = qs.parse(body); // use POST केवल मेरे जैसे नोब्स के लिए: जब इनपुट टेक्स्ट फ़ील्ड का नाम "उपयोगकर्ता" है, Post.userतो उस फ़ील्ड का डेटा दिखाएगा। जैसेconsole.log(Post.user);
readableडेटा को बॉडी स्ट्रिंग में बनाने के बजाय कॉलबैक का उपयोग कर सकते हैं । एक बार जब यह निकाल दिया जाता है, तो शरीर के माध्यम से उपलब्ध होता हैrequest.read();
req.connection.destroy(); कॉलबैक को निष्पादित होने से नहीं रोकती है! उदाहरण के लिए "ऑन एंड" कॉलबैक को काटे गए शरीर के साथ निष्पादित किया जाएगा! यह वह नहीं है जो आप चाहते हैं ...
यदि कोई आपकी 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
});
}
}var POST = qs.parse(body); // use POST केवल नोब्स के लिए: जब इनपुट टेक्स्ट फ़ील्ड का नाम "उपयोगकर्ता" है, तो Post.user उस फ़ील्ड का डेटा दिखाएगा। जैसे कंसोल.लॉग (पोस्ट.यूज़र);
यहाँ बहुत सारे उत्तर अच्छे अभ्यास नहीं हैं या कुछ भी स्पष्ट नहीं करते हैं, इसलिए मैं यह लिख रहा हूं।
जब http.createServer का कॉलबैक कहा जाता है, जब सर्वर वास्तव में अनुरोध के लिए सभी हेडर प्राप्त करता है, लेकिन यह संभव है कि डेटा अभी तक प्राप्त नहीं हुआ है, इसलिए हमें इसके लिए इंतजार करना होगा। Http अनुरोध वस्तु (एक http.IncomingMessage उदाहरण) वास्तव में एक है पठनीय धारा । पठनीय धाराओं में जब भी डेटा का एक हिस्सा आता है, तो एक घटना उत्सर्जित हो जाती है (यह मानते हुए कि आपने इसे कॉलबैक दर्ज कर लिया है) और जब सभी खंड आए हैं तो एक घटना उत्सर्जित होती है। यहाँ एक उदाहरण है कि आप घटनाओं को कैसे सुनते हैं:data 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)यदि आप यह कोशिश करते हैं तो आप देखेंगे कि चूजे बफ़र हैं । यदि आप द्विआधारी डेटा के साथ काम नहीं कर रहे हैं और इसके बजाय स्ट्रिंग्स के साथ काम करने की आवश्यकता है, तो मेरा सुझाव है कि 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)यहां बफ़र.कॉनटैट का उपयोग किया जाता है, जो बस सभी बफ़र्स को समेटता है और एक बड़ा बफर वापस करता है। आप कॉनकैट-स्ट्रीम मॉड्यूल का भी उपयोग कर सकते हैं जो समान है:
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 के अजाक्स कॉल को सौंपना है , तो सामग्री प्रकार एन्कोडिंग के application/x-www-form-urlencodedसाथ है uft-8। आप इसे डी-सीरियल करने और गुणों तक पहुंचने के लिए क्वेरिस्ट्रिंग मॉड्यूल का उपयोग कर सकते हैं :
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 ।
यदि आप फ़ाइलों के साथ काम कर रहे हैं या मल्टीपार्ट सामग्री प्रकार को संभाल रहे हैं, तो उस स्थिति में, आपको कुछ ऐसा उपयोग करना चाहिए, जो दुर्जेय हो। मेरे इस अन्य उत्तर पर एक नज़र डालें जहां मैंने मल्टीपार्ट सामग्री के लिए सहायक लिंक और मॉड्यूल पोस्ट किए हैं।
यदि आप सामग्री को पार्स नहीं करना चाहते हैं, बल्कि इसे कहीं और पास करना चाहते हैं, उदाहरण के लिए इसे डेटा के रूप में किसी अन्य http अनुरोध पर भेजें या इसे किसी फ़ाइल में सहेजें मैं इसे बफ़र करने के बजाय इसे पाइप करने का सुझाव देता हूं , क्योंकि यह कम होगा कोड, पीठ के दबाव को बेहतर ढंग से संभालता है, यह कम मेमोरी और कुछ मामलों में तेजी से लेगा।
इसलिए यदि आप किसी फ़ाइल में सामग्री को सहेजना चाहते हैं:
http.createServer((request, response) => {
request.pipe(fs.createWriteStream('./request'));
}).listen(8080)जैसा कि अन्य जवाबों ने मेरे ध्यान में रखा है कि दुर्भावनापूर्ण ग्राहक आपके एप्लिकेशन को क्रैश करने के लिए या आपकी मेमोरी को भरने के लिए एक बड़ी मात्रा में डेटा भेज सकते हैं ताकि यह सुनिश्चित करने के लिए कि आप अनुरोधों को छोड़ दें जो डेटा को फेंकना एक निश्चित सीमा को पार करते हैं। यदि आप आने वाले डेटा को संभालने के लिए लाइब्रेरी का उपयोग नहीं करते हैं। मैं स्ट्रीम-मीटर जैसी किसी चीज़ का उपयोग करने का सुझाव दूंगा जो निर्दिष्ट सीमा तक पहुंचने पर अनुरोध को रद्द कर सकती है:
limitedStream = request.pipe(meter(1e7));
limitedStream.on('data', ...);
limitedStream.on('end', ...);या
request.pipe(meter(1e7)).pipe(createWriteStream(...));या
concat(request.pipe(meter(1e7)), ...);जब मैंने ऊपर वर्णित किया कि आप HTTP अनुरोध बॉडी का उपयोग कैसे कर सकते हैं, तो बस सामग्री को बफरिंग और पार्स करने के लिए, मैं सुझाव देता हूं कि इनमें से किसी एक मॉड्यूल का उपयोग करके आप अपने आप को लागू कर सकते हैं क्योंकि वे शायद किनारे के मामलों को बेहतर तरीके से संभालेंगे। एक्सप्रेस के लिए मैं बॉडी-पार्सर का उपयोग करने का सुझाव देता हूं । कोआ के लिए, एक समान मॉड्यूल है ।
यदि आप एक रूपरेखा का उपयोग नहीं करते हैं, तो शरीर काफी अच्छा है।
requestका फिर से उपयोग किया जाए और request.on('end')कई बार मिला हो? मैं इससे कैसे बच सकता हूं?
request.on('end', ...)बुलाया जाएगा।
यहाँ पोस्ट किए गए अन्य उत्तरों और लेखों के आधार पर एक बहुत ही सरल नो-फ्रेमवर्क आवरण है:
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);response.postअधिक तार्किक होना चाहिए request.post। मैंने पोस्ट अपडेट की।
यह क्लीनर होगा यदि आप अपने डेटा को 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));
});
}
}qs.parse(), JSON.parse()शरीर को प्रयोग करने योग्य वस्तु में बदल दिया। उदाहरण: var post = JSON.parse(body);इसके बाद डेटा तक पहुंचें post.fieldname। (कहानी का नैतिक, अगर आप जो देख रहे हैं उसके बारे में उलझन में हैं, तो मत भूलना typeof!)
request.setEncodingइस काम को सही तरीके से करने के लिए उपयोग करना चाहिए अन्यथा यह गैर-एएससीआई पात्रों को ठीक से संभाल नहीं सकता है।
बिना किसी वेब फ्रेमवर्क को स्थापित किए यह काम कैसे करना है, यह सोचकर, मैं इसे एक साथ रखने में कामयाब रहा। मुश्किल से उत्पादन तैयार है लेकिन यह काम करने लगता है।
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);
})
}
}आप उपयोग कर सकते हैं 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);
})संदर्भ: https://nodejs.org/en/docs/guides/anatomy-of-an-http-nransrans//
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
});यदि आप नोड-दुर्जेय का उपयोग करते हैं तो आप इसे कैसे कर सकते हैं :
var formidable = require("formidable");
var form = new formidable.IncomingForm();
form.parse(request, function (err, fields) {
console.log(fields.parameter1);
console.log(fields.parameter2);
// ...
});यदि आप शुद्ध 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}`);
});1) 'body-parser'npm से स्थापित करें ।
2) फिर अपने app.ts में
var bodyParser = require('body-parser');3) फिर आपको लिखने की आवश्यकता है
app.use(bodyParser.json())में app.ts मॉड्यूल
4) ध्यान रखें कि आप शामिल हैं
app.use(bodyParser.json())शीर्ष या किसी भी मॉड्यूल घोषणा से पहले।
उदाहरण के लिए:
app.use(bodyParser.json())
app.use('/user',user);5) फिर उपयोग करें
var postdata = req.body;यदि आप 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
});यह दृष्टिकोण आने वाले अनुरोध को संशोधित करता है, लेकिन जैसे ही आप अपनी प्रतिक्रिया समाप्त करते हैं, अनुरोध कचरा एकत्र हो जाएगा, ताकि कोई समस्या न हो।
यदि आप विशाल निकायों से डरते हैं, तो शरीर के आकार की जांच करने के लिए एक उन्नत तरीका होगा।
requestएक सामान्य नोड.जेएस स्ट्रीम है, इसलिए आप request.headersशरीर की लंबाई की जांच कर सकते हैं और यदि आवश्यक हो तो अनुरोध को रद्द कर सकते हैं।
इसे करने के कई तरीके हैं। हालाँकि, मुझे पता है कि बॉडी-पार्सर के साथ Express.js लाइब्रेरी का उपयोग करने का सबसे तेज़ तरीका है।
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);यह स्ट्रिंग्स के लिए काम कर सकता है, लेकिन मैं bodyParser.urlencoded को bodyParser.json में बदल दूंगा, अगर इसके बजाय POST डेटा में JSON सरणी है।
अधिक जानकारी: http://www.kompulsa.com/how-to-accept-and-parse-post-requests-in-node-js/
आपको 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)आपको संकेतित स्थिति में आकार सीमा जोड़ने पर विचार करना चाहिए जैसा कि सुझाव दिया गया है ।
setTimeoutउस निश्चित अवधि के बाद कनेक्शन समाप्त होने से रोका जा सकता है , अगर उस विंडो के भीतर पूर्ण अनुरोध प्राप्त नहीं हुआ है।
यदि आप एक्सप्रेस .js का उपयोग कर रहे हैं , इससे पहले कि आप req.body तक पहुँच सकें, आपको मिडलवेयर बॉडीपेयर जोड़ना होगा:
app.use(express.bodyParser());तो आप के लिए पूछ सकते हैं
req.body.userऔर यदि आप एक्सप्रेस की तरह पूरे ढांचे का उपयोग नहीं करना चाहते हैं, लेकिन आपको अपलोड सहित विभिन्न प्रकार के प्रपत्रों की आवश्यकता है, तो औपचारिक रूप से एक अच्छा विकल्प हो सकता है।
यह Node.js मॉड्यूल में सूचीबद्ध है
मुझे एक वीडियो मिला जिसमें बताया गया है कि इसे कैसे प्राप्त किया जा सकता है: https://www.youtube.com/watch?v=nuw48-u3Yrg
यह डिफॉल्ट "http" मॉड्यूल का उपयोग "क्वेरिस्ट्रिंग" और "स्ट्रिंगबिल्डर" मॉड्यूल के साथ करता है। आवेदन एक वेब पेज से दो नंबर (दो टेक्स्टबॉक्स का उपयोग करके) लेता है और सबमिट करने पर, उन दोनों का रिटर्न (टेक्स्टबॉक्स में मूल्यों को बनाए रखने के साथ) देता है। यह सबसे अच्छा उदाहरण है जो मुझे कहीं और मिल सकता है।
संबंधित स्रोत कोड:
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);ओवरहेड एन्कोडिंग के बिना कच्चे बाइनरी 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!");
});
});आप एक्सप्रेस मिडलवेयर का उपयोग कर सकते हैं , जिसमें अब बॉडी-पार्सर बनाया गया है। इसका मतलब यह है कि आपको बस इतना करना चाहिए:
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)
})यह कोड उदाहरण ES6 एक्सप्रेस 4.16.x के साथ है
आप एक्सप्रेस का उपयोग किए बिना पोस्ट पैरामीटर निकाल सकते हैं।
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>मुझे उम्मीद है कि यह आपके लिए काम करेगा। धन्यवाद।
सीमा POST आकार अपने नोड एप्लिकेशन बाढ़ से बचें। एक महान कच्चा-शरीर मॉड्यूल है, जो एक्सप्रेस और कनेक्ट दोनों के लिए उपयुक्त है, जो आकार और लंबाई के अनुसार अनुरोध को सीमित करने में आपकी सहायता कर सकता है।
इन जैसे फार्म फील्ड पर
<input type="text" name="user[name]" value="MyName">
<input type="text" name="user[email]" value="myemail@somewherefarfar.com">उपरोक्त कुछ उत्तर विफल हो जाएंगे क्योंकि वे केवल फ्लैट डेटा का समर्थन करते हैं।
अब मैं केसी चू जवाब उपयोग कर रहा हूँ के लिए लेकिन साथ "qs" के बदले "क्वेरी स्ट्रिंग" मॉड्यूल। यह मॉड्यूल "बॉडी-पार्सर" भी उपयोग करता है। इसलिए यदि आप नेस्टेड डेटा चाहते हैं तो आपको 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.
});
}
}आप "अनुरोध - सरलीकृत HTTP क्लाइंट" और जावास्क्रिप्ट प्रॉमिस का उपयोग करके 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);
}
});
});
}यदि आप चाहते हैं कि फॉर्म डेटा req.body में उपलब्ध हो तो आपको बॉडीपेयर () का उपयोग करना होगा। body-parser आपके अनुरोध को पार्स करता है और इसे एक ऐसे प्रारूप में परिवर्तित करता है जिससे आप आसानी से प्रासंगिक जानकारी निकाल सकते हैं जिसकी आपको आवश्यकता हो सकती है।
उदाहरण के लिए, मान लें कि आपके सामने दृश्यपटल पर एक साइन-अप फ़ॉर्म है। आप इसे भर रहे हैं, और सर्वर से अनुरोध कर रहे हैं कि वह विवरणों को बचाए।
यदि आप बॉडी-पार्सर का उपयोग करते हैं तो आपके अनुरोध से उपयोगकर्ता नाम और पासवर्ड निकालना उतना ही सरल है।
............................................................।
var loginDetails = {
username : request.body.username,
password : request.body.password
};MIDDLEWARE के बिना एक लाइनर
यदि आप निम्नलिखित डेटा पोस्ट करते हैं, 'name':'ABC'
तो आप निम्नलिखित एक लाइनर का उपयोग करके इसे पार्स कर सकते हैं,
require('url').parse(req.url, true).query.name