Bagaimana Anda mengekstrak data formulir ( form[method="post"]) dan unggahan file yang dikirim dari POSTmetode HTTP di Node.js ?

Saya sudah membaca dokumentasinya, googled dan tidak menemukan apa pun.

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

Apakah ada perpustakaan atau retasan?

Jika Anda menggunakan Express (kinerja tinggi, pengembangan web kelas tinggi untuk Node.js), Anda dapat melakukan ini:

HTML:

<form method="post" action="/">
    <input type="text" name="user[name]">
    <input type="text" name="user[email]">
    <input type="submit" value="Submit">
</form>

Klien API:

fetch('/', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        user: {
            name: "John",
            email: "[email protected]"
        }
    })
});

Node.js: (sejak 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: (untuk 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)
});

Anda dapat menggunakan querystringmodul:

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

Sekarang, misalnya, jika Anda memiliki inputbidang dengan nama age, Anda bisa mengaksesnya menggunakan variabel post:

console.log(post.age);

Pastikan untuk mematikan koneksi jika seseorang mencoba membanjiri RAM Anda!

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

        });
    }
}

Banyak jawaban di sini bukan praktik yang baik lagi atau tidak menjelaskan apa pun, jadi itu sebabnya saya menulis ini.

Dasar-dasar

Ketika panggilan balik dari http.createServer dipanggil, adalah ketika server benar-benar menerima semua tajuk untuk permintaan tersebut, tetapi ada kemungkinan bahwa data belum diterima, jadi kami harus menunggu untuk itu. The request http objek (contoh http.IncomingMessage) sebenarnya dapat dibaca aliran . Dalam aliran yang dapat dibaca setiap kali sepotong data tiba, suatu peristiwa dipancarkan (dengan asumsi Anda telah mendaftarkan panggilan balik ke sana) dan ketika semua potongan telah tiba suatu peristiwa dipancarkan. Berikut ini contoh cara Anda mendengarkan acara: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)

Konversi Buffer ke String

Jika Anda mencoba ini, Anda akan melihat potongan buffer . Jika Anda tidak berurusan dengan data biner dan perlu bekerja dengan string, saya sarankan menggunakan metode request.setEncoding yang menyebabkan stream memancarkan string yang ditafsirkan dengan pengkodean yang diberikan dan menangani karakter multi-byte dengan benar.

Buffering Chunks

Sekarang Anda mungkin tidak tertarik pada masing-masing bidak sendiri, jadi dalam hal ini mungkin Anda ingin melakukan penyangga seperti ini:

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)

Di sini Buffer.concat digunakan, yang hanya menggabungkan semua buffer dan mengembalikan satu buffer besar. Anda juga dapat menggunakan modul concat-stream yang melakukan hal yang sama:

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

Mengurai Konten

Jika Anda mencoba menerima formulir HTML, pengiriman POST tanpa file atau menyerahkan panggilan jQuery ajax dengan tipe konten default, maka tipe kontennya adalah application/x-www-form-urlencodeddengan uft-8encoding. Anda dapat menggunakan modul querystring untuk menghapus serialisasi dan mengakses properti:

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)

Jika tipe konten Anda adalah JSON, Anda cukup menggunakan JSON.parse dan bukan qs.parse .

Jika Anda berurusan dengan file atau menangani tipe konten multi-bagian, maka dalam hal ini, Anda harus menggunakan sesuatu seperti tangguh yang menghilangkan semua rasa sakit karena berurusan dengan itu. Lihat jawaban saya yang lain ini di mana saya telah memposting tautan dan modul bermanfaat untuk konten multi bagian.

Perpipaan

Jika Anda tidak ingin mem-parsing konten tetapi meneruskannya ke tempat lain, misalnya mengirimnya ke permintaan http lain sebagai data atau menyimpannya ke file, saya sarankan untuk memipipkannya daripada buffering, karena akan kurang kode, menangani tekanan balik lebih baik, itu akan mengambil lebih sedikit memori dan dalam beberapa kasus lebih cepat.

Jadi jika Anda ingin menyimpan konten ke file:

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

Membatasi Jumlah Data

Seperti jawaban lain telah dicatat, ingatlah bahwa klien jahat dapat mengirimkan Anda sejumlah besar data untuk membuat crash aplikasi Anda atau mengisi memori Anda sehingga untuk melindungi itu pastikan Anda menjatuhkan permintaan yang memancarkan data yang melewati batas tertentu. Jika Anda tidak menggunakan perpustakaan untuk menangani data yang masuk. Saya menyarankan menggunakan sesuatu seperti stream-meter yang dapat membatalkan permintaan jika mencapai batas yang ditentukan:

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

atau

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

atau

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

Modul NPM

Meskipun saya jelaskan di atas tentang bagaimana Anda dapat menggunakan badan permintaan HTTP, hanya untuk buffering dan parsing konten, saya sarankan menggunakan salah satu modul ini daripada menerapkannya sendiri karena mereka mungkin akan menangani kasus tepi yang lebih baik. Untuk ekspres saya sarankan menggunakan body-parser . Untuk koa, ada modul serupa .

Jika Anda tidak menggunakan kerangka kerja, tubuh cukup bagus.

Berikut ini adalah pembungkus tanpa kerangka kerja yang sangat sederhana berdasarkan pada jawaban dan artikel lain yang diposting di sini:

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

Contoh penggunaan:

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

Akan lebih bersih jika Anda menyandikan data Anda ke JSON , kemudian mengirimkannya ke 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));
        });
    }
}

Bagi siapa pun yang bertanya-tanya bagaimana melakukan tugas sepele ini tanpa menginstal kerangka kerja web, saya berhasil melakukan ini bersama-sama. Produksi hampir tidak siap tetapi tampaknya berhasil.

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

Anda dapat menggunakan body-parser, middleware parsing Node.js body.

Beban pertama body-parser

$ npm install body-parser --save

Beberapa contoh kode

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

Dokumentasi lebih lanjut dapat ditemukan di sini

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

Inilah cara Anda dapat melakukannya jika Anda menggunakan 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);
    // ...
});

Jika Anda lebih suka menggunakan Node.js murni maka Anda dapat mengekstrak data POST seperti ditunjukkan di bawah ini:

// 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) Instal 'body-parser'dari npm.

2) Kemudian di app.ts Anda

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

3) maka Anda perlu menulis

app.use(bodyParser.json())

dalam modul app.ts

4) perlu diingat bahwa Anda termasuk

app.use(bodyParser.json())

di bagian atas atau sebelum deklarasi modul.

Ex:

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

5) Kemudian gunakan

var postdata = req.body;

Jika Anda tidak ingin memotong data bersama dengan datapanggilan baliknya, Anda selalu dapat menggunakan readablepanggilan balik seperti ini:

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

Pendekatan ini mengubah permintaan yang masuk, tetapi segera setelah Anda menyelesaikan respons Anda, permintaan tersebut akan menjadi sampah yang dikumpulkan, sehingga seharusnya tidak menjadi masalah.

Pendekatan lanjutan akan memeriksa ukuran tubuh terlebih dahulu, jika Anda takut tubuh besar.

Ada banyak cara untuk melakukannya. Namun, cara tercepat yang saya tahu adalah menggunakan perpustakaan Express.js dengan 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);

Itu bisa berfungsi untuk string, tapi saya akan mengubah bodyParser.urlencoded menjadi bodyParser.json sebagai gantinya jika data POST berisi array JSON.

Info lebih lanjut: http://www.kompulsa.com/how-to-accept-and-parse-post-requests-in-node-js/

Anda perlu menerima POSTdata dalam potongan menggunakanrequest.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)

Anda harus mempertimbangkan menambahkan batas ukuran pada posisi yang ditunjukkan seperti yang disarankan jh .

Express v4.17.0

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

Jika Anda menggunakan Express.js , sebelum Anda dapat mengakses req.body, Anda harus menambahkan bodyParser middleware:

app.use(express.bodyParser());

Maka Anda bisa meminta

req.body.user

Dan jika Anda tidak ingin menggunakan seluruh kerangka kerja seperti Express, tetapi Anda juga membutuhkan berbagai jenis bentuk, termasuk unggahan, maka formaline mungkin merupakan pilihan yang baik.

Tercantum dalam modul Node.js

Saya menemukan video yang menjelaskan cara mencapai ini: https://www.youtube.com/watch?v=nuw48-u3Yrg

Ini menggunakan modul "http" bersama dengan modul "querystring" dan "stringbuilder". Aplikasi mengambil dua angka (menggunakan dua kotak teks) dari halaman web dan setelah mengirimkan, mengembalikan jumlah dari dua (bersama dengan mempertahankan nilai-nilai dalam kotak teks). Ini adalah contoh terbaik yang bisa saya temukan di tempat lain.

Kode sumber terkait:

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

Bagi mereka yang menggunakan unggahan POST biner mentah tanpa pengkodean overhead Anda dapat menggunakan:

klien:

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

server:

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

Anda dapat menggunakan middleware ekspres , yang sekarang memiliki body-parser di dalamnya. Ini berarti yang perlu Anda lakukan adalah sebagai berikut:

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

Contoh kode itu adalah ES6 dengan Express 4.16.x

Anda dapat mengekstrak parameter posting tanpa menggunakan express.

1: nmp install multiparty

2: impor banyak pihak. sebagaivar 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: dan FORMULIR HTML IS.

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

Saya harap ini akan berhasil untuk Anda. Terima kasih.

Batasi ukuran POST agar tidak membanjiri aplikasi simpul Anda. Ada modul badan mentah yang bagus , cocok untuk mengekspresikan dan menghubungkan, yang dapat membantu Anda membatasi permintaan berdasarkan ukuran dan panjangnya.

Jika ini melibatkan pengunggahan file, browser biasanya mengirimkannya sebagai tipe "multipart/form-data"konten. Anda dapat menggunakan ini dalam kasus seperti itu

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

Referensi 1

Referensi 2

Pada bidang formulir seperti ini

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

beberapa jawaban di atas akan gagal karena hanya mendukung data datar.

Untuk saat ini saya menggunakan jawaban Casey Chu tetapi dengan "qs" bukan modul "querystring". Ini juga menggunakan modul "body-parser" . Jadi jika Anda ingin data bersarang Anda harus menginstal qs.

npm install qs --save

Kemudian ganti baris pertama seperti:

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

Anda dapat dengan mudah mengirim dan mendapatkan respons permintaan POST dengan menggunakan "Permintaan - klien HTTP Sederhana" dan 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);
            }
        });
    });
}

Anda perlu menggunakan bodyParser () jika Anda ingin data formulir tersedia di req.body. body-parser mem-parsing permintaan Anda dan mengubahnya menjadi format yang dengannya Anda dapat dengan mudah mengekstrak informasi relevan yang mungkin Anda butuhkan.

Misalnya, katakanlah Anda memiliki formulir pendaftaran di frontend Anda. Anda mengisinya, dan meminta server untuk menyimpan detailnya di suatu tempat.

Mengekstrak nama pengguna dan kata sandi dari permintaan Anda sesederhana seperti di bawah ini jika Anda menggunakan body-parser.

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

var loginDetails = {

username : request.body.username,

password : request.body.password

};

ONE LINER tanpa MIDDLEWARE
Jika Anda memposting data berikut,
'name':'ABC'
Maka Anda dapat menguraikannya menggunakan liner berikut,

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