Bagaimana cara memproses data POST di Node.js?


637

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?

Jawaban:


552

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: "john@example.com"
        }
    })
});

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

45
Fungsionalitas sebenarnya ada dalam modul BodyParser yang terhubung, jika Anda ingin menggunakan titik entri level yang lebih rendah.
Julian Birch

14
Saya bingung. Bagaimana nama = "pengguna [email]" sesuai dengan request.body.email?
sbose

36
Tuhan!! Saya menjadi marah karena harus membaca 3 dokumen pada waktu yang sama untuk kerangka kerja yang sama: / nodejs.org/api/http.html , senchalabs.org/connect & expressjs.com/guide.html
Salman von Abbas

15
Ini tidak bekerja untuk saya sampai saya menambahkan app.use(express.bodyParser());.
Pettys

13
Express adalah untuk simpul apa jQuery adalah untuk sisi klien JS. Setiap kali saya membantu google untuk simpul saya mendapatkan lumpuh ini "gunakan express!" jawaban. Apakah benar-benar sangat sulit untuk mem-parsing data posting yang membenarkan menginstal seluruh kerangka web?
Shawn Whinnery

710

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

8
@ejh Hm, itu poin yang bagus. Seharusnya tidak sulit untuk menambahkan itu, jadi saya akan mengabaikannya untuk membuat hal-hal sederhana.
Casey Chu

72
Pengembangan server web node.js diganggu dengan middlewarez yang mengharuskan Anda untuk mempelajarinya berjam-jam untuk menghemat coding. Apalagi sedikit dokumentasi yang hampir semuanya menawarkan. Dan aplikasi Anda pada akhirnya bergantung pada kriteria orang lain, bukan milik Anda. Ditambah sejumlah masalah kinerja.
Juan Lanus

4
var POST = qs.parse(body); // use POST hanya untuk noobs seperti saya: ketika nama bidang teks input adalah "pengguna", Post.userakan menampilkan data bidang itu. misconsole.log(Post.user);
Michael Moeller

5
Anda juga bisa menggunakan readablecallback alih-alih membangun data menjadi string tubuh. Setelah dipecat, tubuh tersedia melaluirequest.read();
Thomas Fankhauser

4
Pemberitahuan yang req.connection.destroy(); tidak mencegah callback dieksekusi! Misalnya panggilan balik "on end" akan dieksekusi dengan tubuh terpotong! Ini mungkin bukan yang Anda inginkan ...
collimarco

149

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

        });
    }
}

53
Anda juga dapat mengembalikan Kode Kesalahan HTTP 413 (Permintaan Entitas Terlalu Besar)
neoascetic

1
@ SSSHi ini: Tidak, ini 1 * 10 ^ 6 = 10.000
thejh

@ tq: dalam hal ini, POST [nama] (mis. POST ["foo"]).
thejh

2
var POST = qs.parse(body); // use POST hanya untuk noobs: ketika nama bidang teks input adalah "pengguna", pengguna Post.user akan menampilkan data bidang itu. misalnya console.log (Post.user);
Michael Moeller

2
Adakah yang bisa membantu, jika saya memposting {'Name': 'Joe'} Saya mendapatkan {{'Name': 'Joe'}: ''} setelah qs.Parse (POST) ...
Matt Canty

118

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.


Terima kasih, saya menggunakan kode Anda dan saya mendapat pesan duplikat misterius. Mungkinkah variabel requestdigunakan kembali dan request.on('end')mendapat dipanggil beberapa kali? Bagaimana saya bisa menghindarinya?
Yan King Yin

Saya tidak tahu mengapa tanpa melihat kode Anda. Perhatikan bahwa untuk setiap permintaan, request.on('end', ...)akan dipanggil.
Farid Nouri Neshat

Ini mungkin tidak terkait dengan kode Anda, saya sedang melakukan acara yang dikirim ke server dan mungkin telah mengacaukannya ... kode Anda berfungsi dengan baik, terima kasih pula :)
Yan King Yin

Bagaimana ini mempengaruhi kinerja bila dibandingkan dengan memproses permintaan GET tanpa penangan 'akhir', yaitu tanpa potongan buffering?
JSON

1
Ini di sini adalah jawaban terbaik untuk pertanyaan itu. 🧐
montrealis

103

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

Seharusnya cek ini tidak dipindahkan ke middleware terpisah sehingga dapat memeriksa permintaan terlalu besar pada semua permintaan post / put
Pavel Nikolov

@PavelNikolov ini dimaksudkan terutama untuk pekerjaan yang cepat dan kotor, jika tidak, orang mungkin lebih baik menggunakan Express seperti yang diterima di sini (yang mungkin menangani juga mengelola permintaan besar). Jangan ragu untuk memodifikasi dan "garpu" sesuai dengan keinginan Anda.
Mahn

Bagaimana dengan metode .read ()? Apakah itu tidak didukung oleh modul http? Misalnya. response.read ()
BT

Hei, hanya ingin tahu - mengapa Anda menempatkan muatan ke objek respons (response.post) daripada meminta objek?
Jotham

@Jotham pertanyaan yang bagus ... Saya tidak tahu mengapa saya tidak menyadarinya sebelumnya, tetapi tidak ada alasan mengapa itu seharusnya response.postlebih masuk akal request.post. Saya memperbarui pos.
Mahn

83

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

1
Inilah yang bekerja untuk saya. Ternyata solusi lain mengembalikan string yang tampak seperti JSON tetapi tidak diuraikan. Alih-alih qs.parse(), JSON.parse()mengubah tubuh menjadi sesuatu yang bisa digunakan. Contoh:, var post = JSON.parse(body);lalu akses data dengan post.fieldname. (Moral dari cerita ini, jika Anda bingung tentang apa yang Anda lihat, jangan lupakan typeof!)
wmassingham

12
Perlu diketahui bahwa Anda harus mencoba-menangkap fungsi JSON.parse karena jika saya ingin crash aplikasi Anda sakit hanya mengirim tubuh dengan teks mentah.
ecarrizo

Anda harus menggunakannya request.setEncodinguntuk membuat ini berfungsi dengan baik karena mungkin tidak menangani karakter non ascii dengan benar.
Farid Nouri Neshat

37

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

Akhirnya solusi KERJA LENGKAP untuk masalah aneh ini..juga jawaban sebelumnya banyak membantu untuk memahami mengapa tidak ada data di dalam permintaan ketika panggilan balik dimulai .. Terima kasih banyak!
luis-br

3
1) Jawaban ini mengasumsikan data berupa string. Asumsi buruk, dalam kasus umum. 2) Jawaban ini mengasumsikan bahwa data tiba dalam satu potongan. Jika tidak, pemisahan dengan '=' akan memberikan hasil yang tidak terduga. Asumsi buruk, dalam kasus umum.
Konstantin

@Konstantin Sebenarnya jawaban ini menganggap data adalah Penyangga. Lihat ini. stackoverflow.com/questions/14551194/... Juga ini. millermedeiros.github.io/mdoc/examples/node_api/doc/…
Shawn Whinnery

16

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



9

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

Saya mengalami masalah dengan path, ketika saya mencoba menggunakan path atau path + name untuk mengakses file dengan lwip.open (path atau path + name, saya mendapatkan kesalahan sebagai gambar yang tidak
diketahui

7

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


6

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;

5

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.


Cara mudah untuk melakukannya, tetapi bagaimana Anda "memeriksa ukuran tubuh terlebih dahulu" dengan cara yang tidak bisa dibodohi oleh permintaan jahat?
doug65536

requestadalah aliran node.js yang normal, sehingga Anda dapat memeriksa request.headerspanjang tubuh dan membatalkan permintaan jika perlu.
Thomas Fankhauser

1
@ThomasFankhauser Panjang tubuh di header mungkin bukan nilai yang benar atau bahkan ada. Cara yang tepat untuk melakukannya, adalah ketika tubuh tiba dan Anda buffering, Anda memeriksa ukuran untuk memastikan itu tidak melewati batas.
Farid Nouri Neshat

4

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/


4

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 .


Apakah ini, lebih, rentan terhadap serangan kukang?

Nodejs kurang rentan terhadap lambat-kukang daripada, misalnya, php - karena tidak membangun objek sesi besar di sekitar setiap koneksi http. Namun, tampaknya kode ini masih bisa memperkenalkan kerentanan kukang. Ini dapat dicegah dengan setTimeoutkoneksi yang mengakhiri setelah jangka waktu tertentu, jika permintaan penuh tidak diterima dalam jendela itu.
Gershom

4

Express v4.17.0

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

3

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

Kebanyakan middleware (seperti bodyParser) tidak lagi dibundel dengan Express dan harus diinstal secara terpisah. Lihat jawaban dari @ nikodean2 di atas untuk jawaban yang lebih baru
Jeff Collier

app.use (bodyParser ()); berfungsi tetapi memberi saya penghentian pesan kesalahan merah
Chris Allinson

2

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


1

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

1

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

1

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


0

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.


0

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.


0

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


0

Pada bidang formulir seperti ini

   <input type="text" name="user[name]" value="MyName">
   <input type="text" name="user[email]" value="myemail@somewherefarfar.com">

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

0

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

0

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

};

0

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
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.