คุณดึงข้อมูลในแบบฟอร์ม ( form[method="post"]) และอัพโหลดไฟล์ที่ส่งจากPOSTวิธีHTTP ในNode.js อย่างไรอย่างไร

ฉันอ่านเอกสารแล้ว googled และไม่พบอะไรเลย

function (request, response) {
    //request.post????
}

มีห้องสมุดหรือแฮ็คหรือไม่?

ถ้าคุณใช้Express (การพัฒนาเว็บประสิทธิภาพสูงสำหรับ 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: (ตั้งแต่ 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 <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)
});

คุณสามารถใช้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);

ตรวจสอบให้แน่ใจว่าได้ฆ่าการเชื่อมต่อหากมีคนพยายาม 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

        });
    }
}

คำตอบมากมายที่นี่ไม่ใช่วิธีปฏิบัติที่ดีอีกต่อไปหรือไม่อธิบายอะไรเลยดังนั้นฉันจึงเขียนสิ่งนี้

ข้อมูลพื้นฐานเกี่ยวกับ

เมื่อมีการเรียกการเรียกกลับของ 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)

ที่นี่ คือการใช้Buffer.concatซึ่งจะเชื่อมต่อบัฟเฟอร์ทั้งหมดและคืนหนึ่งบัฟเฟอร์ใหญ่ คุณยังสามารถใช้โมดูล concat-streamซึ่งทำสิ่งเดียวกัน:

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

แยกเนื้อหา

หากคุณกำลังพยายามที่จะยอมรับการส่งแบบฟอร์ม POST แบบ HTML โดยไม่มีไฟล์หรือส่งjQuery ajax การโทรด้วยประเภทเนื้อหาเริ่มต้นแล้วประเภทเนื้อหาจะอยู่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)), ...);

โมดูล NPM

ขณะที่ฉันอธิบายข้างต้นเกี่ยวกับวิธีที่คุณสามารถใช้เนื้อหาคำขอ HTTP สำหรับการบัฟเฟอร์และการแยกวิเคราะห์เนื้อหาฉันขอแนะนำให้ใช้หนึ่งในโมดูลเหล่านี้แทนที่จะใช้งานด้วยตัวคุณเองเนื่องจากพวกเขาอาจจัดการกับกรณีขอบได้ดีขึ้น สำหรับการแสดงผมขอแนะนำให้ใช้ตัวแยกวิเคราะห์ สำหรับไม้สัก, มีโมดูลที่คล้ายกัน

ถ้าคุณไม่ใช้เฟรมเวิร์กร่างกายก็ค่อนข้างดี

นี่คือ wrapper ไม่มีกรอบที่ง่ายมากตามคำตอบอื่น ๆ และบทความที่โพสต์ที่นี่:

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

มันจะสะอาดขึ้นถ้าคุณเข้ารหัสข้อมูลของคุณไปยัง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));
        });
    }
}

สำหรับทุกคนที่สงสัยว่าจะทำสิ่งเล็ก ๆ น้อย ๆ นี้ได้อย่างไรโดยไม่ต้องติดตั้งเฟรมเวิร์กเว็บ การผลิตแทบจะไม่พร้อม แต่ดูเหมือนว่าจะใช้งานได้

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

นี่คือวิธีที่คุณสามารถทำได้ถ้าคุณใช้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);
    // ...
});

หากคุณต้องการใช้ pure 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())

ในด้านบนหรือก่อนการประกาศโมดูลใด ๆ

Ex:

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

วิธีการนี้จะปรับเปลี่ยนคำขอที่เข้ามา แต่ทันทีที่คุณตอบสนองคำขอของคุณจะถูกรวบรวมอย่างสมบูรณ์ดังนั้นจึงไม่ควรมีปัญหา

วิธีการขั้นสูงคือการตรวจสอบขนาดร่างกายก่อนถ้าคุณกลัวร่างใหญ่

มีหลายวิธีที่จะทำ อย่างไรก็ตามวิธีที่เร็วที่สุดที่ฉันรู้คือใช้ไลบรารี 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);

ที่สามารถทำงานกับสตริง แต่ฉันจะเปลี่ยน 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)

คุณควรพิจารณาการเพิ่มขีด จำกัด ของขนาดที่ตำแหน่งที่ระบุเป็นthejh ปัญหา

Express v4.17.0

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

หากคุณใช้Express.jsก่อนที่คุณจะสามารถเข้าถึง req.body คุณต้องเพิ่มมิดเดิลแวร์ bodyParser:

app.use(express.bodyParser());

จากนั้นคุณสามารถขอ

req.body.user

และถ้าคุณไม่ต้องการใช้กรอบทั้งหมดเช่น Express แต่คุณต้องการรูปแบบต่าง ๆ รวมถึงการอัปโหลดฟอร์มาลินอาจเป็นตัวเลือกที่ดี

มันอยู่ในโมดูล Node.js

ฉันพบวิดีโอที่อธิบายเกี่ยวกับวิธีการทำให้สำเร็จ: https://www.youtube.com/watch?v=nuw48-u3Yrg

มันใช้โมดูล "http" เริ่มต้นพร้อมกับโมดูล "querystring" และ "stringbuilder" แอปพลิเคชันใช้ตัวเลขสองตัว (โดยใช้สองช่องข้อความ) จากหน้าเว็บและเมื่อส่งจะส่งคืนผลรวมของทั้งสองนั้น (รวมถึงการยืนยันค่าในกล่องข้อความ) นี่คือตัวอย่างที่ดีที่สุดที่ฉันสามารถหาได้จากที่อื่น

รหัสแหล่งที่เกี่ยวข้อง:

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 ที่มี Express 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 method=POST enctype=multipart/form-data>
<input type=text name=userfile1><br>
<input type=submit>
</form>

ฉันหวังว่าสิ่งนี้จะได้ผลสำหรับคุณ ขอบคุณ

ขนาด จำกัด POST หลีกเลี่ยงการทำให้แอปโหนดของคุณท่วม มีโมดูลตัวถังขนาดใหญ่ที่เหมาะสำหรับทั้งการเชื่อมต่อและด่วนที่สามารถช่วยคุณ จำกัด การร้องขอตามขนาดและความยาว

หากเกี่ยวข้องกับการอัปโหลดไฟล์เบราว์เซอร์มักจะส่งเป็นประเภท"multipart/form-data"เนื้อหา คุณสามารถใช้สิ่งนี้ในกรณีดังกล่าว

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

การอ้างอิง 1

การอ้างอิง 2

ในเขตข้อมูลแบบฟอร์มเช่นนี้

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

คุณสามารถส่งและรับคำขอ POST ได้ง่าย ๆ โดยใช้ "คำขอ - ไคลเอนต์ HTTP แบบง่าย" และสัญญา Javascript

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

คุณจำเป็นต้องใช้ bodyParser () ถ้าคุณต้องการให้ข้อมูลในแบบฟอร์มสามารถใช้ได้ใน req.body body-parser แยกวิเคราะห์คำขอของคุณและแปลงเป็นรูปแบบที่คุณสามารถดึงข้อมูลที่เกี่ยวข้องที่คุณอาจต้องการได้อย่างง่ายดาย

ตัวอย่างเช่นสมมติว่าคุณมีแบบฟอร์มลงทะเบียนที่ส่วนหน้าของคุณ คุณกำลังกรอกข้อมูลและขอให้เซิร์ฟเวอร์บันทึกรายละเอียดที่อื่น

การแยกชื่อผู้ใช้และรหัสผ่านออกจากคำขอของคุณนั้นง่ายมากหากคุณใช้ body-parser

............................................................

var loginDetails = {

username : request.body.username,

password : request.body.password

};

ซับในเดียวที่ไม่มี MIDDLEWARE
หากคุณโพสต์ข้อมูลต่อไปนี้
'name':'ABC'
คุณสามารถแยกวิเคราะห์ได้โดยใช้ซับต่อไปนี้

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