Node.js'deform[method="post"] HTTP POSTyönteminden gönderilen form verilerini ( ) ve dosya yüklemelerini nasıl ayıklayabilirsiniz ?

Belgeleri okudum, araştırdım ve hiçbir şey bulamadım.

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

Bir kütüphane veya kesmek var mı?

Eğer kullanırsanız Express'i (node.js için yüksek performanslı, yüksek sınıf web geliştirme), bunu yapabilirsiniz:

HTML:

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

API istemcisi:

fetch('/', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        user: {
            name: "John",
            email: "john@example.com"
        }
    })
});

Node.js: (Express v4.16.0'dan beri)

// 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 için)

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

querystringModülü kullanabilirsiniz :

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

Şimdi, örneğin, inputadında bir alanınız agevarsa, değişkenini kullanarak bu alana erişebilirsiniz post:

console.log(post.age);

Birisi RAM'inizi taşmaya çalışırsa bağlantıyı öldürdüğünüzden emin olun!

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

        });
    }
}

Buradaki birçok cevap artık iyi uygulamalar değil ya da hiçbir şeyi açıklamıyor, bu yüzden bunu yazıyorum.

temeller

Http.createServer'ın geri çağrılması çağrıldığında, sunucunun istek için tüm üstbilgileri gerçekten almasıdır, ancak verilerin henüz alınmamış olması mümkündür, bu yüzden beklememiz gerekir. Http isteği nesneler (http.IncomingMessage örneği) aslında bir olan okunabilir akışı . Bir yığın veri geldiğinde okunabilir akışlarda bir olay yayınlanır (buna geri arama kaydettiğiniz varsayılarak) ve tüm parçalar geldiğinde bir olay gönderilir. Olayları nasıl dinlediğinize ilişkin bir örnek: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)

Tamponları Dizelere Dönüştürme

Bunu denerseniz, parçaların tamponlar olduğunu . İkili verilerle uğraşmıyorsanız ve bunun yerine dizelerle çalışmanız gerekiyorsa , akışın verilen kodlamayla yorumlanan ve çok baytlı karakterleri doğru şekilde işlediği akışa neden olan request.setEncoding yöntemini kullanmanızı öneririz .

Tamponlama Topakları

Şimdi muhtemelen her bir parçaya kendi başına ilgi duymuyorsunuz, bu durumda muhtemelen bu şekilde tamponlamak istiyorsunuz:

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)

Burada , tüm arabellekleri birleştiren ve bir büyük arabellek döndüren Buffer.concat kullanılır. Concat-stream modülünü de kullanabilirsinizAynı şeyi yapan :

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

İçeriği Ayrıştırma

HTML hiçbir dosya veya teslim olan POST gönderimi oluşturur kabul etmeye çalışıyorsanız jQuery ajax varsayılan içerik türüyle aramaların ardından içerik türüdür application/x-www-form-urlencodedile uft-8kodlama. Sorgulamayı kaldırmak ve özelliklerine erişmek için querystring modülünü kullanabilirsiniz :

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)

İçerik türünüz bunun yerine JSON ise , qs.parse yerine JSON.parse komutunu kullanabilirsiniz . .

Dosyalarla uğraşıyorsanız veya çok parçalı içerik türünü işliyorsanız, bu durumda, tüm acıyı onunla uğraşmaktan uzaklaştıran müthiş bir şey kullanmalısınız. Bu diğer cevaba bir göz atınÇok parçalı içerikler için yararlı bağlantılar ve modüller yayınladığım .

borular

İçeriği ayrıştırmak istemiyorsanız, başka bir yere iletmek istiyorsanız, örneğin veri olarak başka bir http isteğine gönderin veya önerdiğim bir dosyaya kaydedin bunu boru daha az olacak şekilde yerine, onu ara belleğe kod, geri basıncı daha iyi idare eder, daha az bellek ve bazı durumlarda daha hızlı sürer.

İçeriği bir dosyaya kaydetmek istiyorsanız:

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

Veri Miktarını Sınırlama

Diğer yanıtların belirttiği gibi, kötü niyetli müşterilerin uygulamanızı çökertmek veya belleğinizi doldurmak için size büyük miktarda veri gönderebileceğini aklınızda bulundurun, böylece verileri yayan istekleri belirli bir sınırı aştığınızdan emin olun. Gelen verileri işlemek için bir kütüphane kullanmıyorsanız. Belirtilen sınıra ulaştığında isteği iptal edebilen akış ölçer gibi bir şey kullanmanızı öneririm :

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

veya

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

veya

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

NPM Modülleri

Yukarıda HTTP istek gövdesini nasıl kullanabileceğinizi açıklarken, içeriği sadece arabelleğe almak ve ayrıştırmak için, büyük olasılıkla uç durumları daha iyi ele alacağı için bu modüllerden birini kendi başınıza uygulamak yerine kullanmanızı öneririm. Ekspres için vücut ayrıştırıcı kullanmanızı öneririm . Koa için benzer bir modül var .

Bir çerçeve kullanmazsanız, vücut oldukça iyidir.

Burada yayınlanan diğer cevaplara ve makalelere dayanan çok basit bir çerçeve olmayan sarmalayıcı:

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

Kullanım örneği:

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

Eğer eğer temiz olacak verilerinizi kodlamak JSON ardından Node.js. gönderin

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

Bir web çerçevesi yüklemeden bu önemsiz görevin nasıl yapılacağını merak eden herkes için bunu bir araya getirmeyi başardım. Üretime neredeyse hiç hazır değil ama işe yarıyor gibi görünüyor.

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

Kullanabilirsiniz body-parser , node.js vücut ayrıştırma ortakatmanı.

İlk yük body-parser

$ npm install body-parser --save

Bazı örnek kodlar

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

Daha fazla dokümantasyon burada bulunabilir

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

Düğüm-müthiş kullanırsanız, bunu nasıl yapabileceğiniz aşağıda açıklanmıştır :

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 kullanmayı tercih ediyorsanız, POST verilerini aşağıda gösterildiği gibi çıkarabilirsiniz:

// 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'den yükleyin .

2) Sonra uygulamanızda. T

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

3) o zaman yazmanız gerekir

app.use(bodyParser.json())

içinde app.ts modül

4) eklediğinizi unutmayın

app.use(bodyParser.json())

üstte veya herhangi bir modül bildiriminden önce.

Ör:

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

5) Sonra kullanın

var postdata = req.body;

Verilerinizi datageri arama ile birlikte yığınlamak istemiyorsanız geri aramayı her zaman şu şekilde kullanabilirsiniz 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
});

Bu yaklaşım, gelen isteği değiştirir, ancak yanıtınızı tamamlar tamamlamaz istek çöp toplanır, bu nedenle bir sorun olmamalıdır.

Gelişmiş bir yaklaşım, büyük bedenlerden korkuyorsanız, önce vücut büyüklüğünü kontrol etmek olacaktır.

Bunu yapmanın birden fazla yolu var. Ancak, bildiğim en hızlı yol Express.js kitaplığını gövde ayrıştırıcı ile kullanmaktır.

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

Bu dizeleri için çalışabilir, ancak POST verileri bir JSON dizisi içeriyorsa bodyParser.urlencoded için bodyParser.json değiştirmek istiyorum.

Daha fazla bilgi: http://www.kompulsa.com/how-to-accept-and-parse-post-requests-in-node-js/

POSTVerileri parçalar halinde almanız gerekirrequest.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)

Belirtilen konuma, önerilen şekilde bir boyut sınırı eklemeyi düşünmelisiniz .

Express v4.17.0

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

Express.js kullanıyorsanız , req.body'ye erişebilmeniz için, middleware body'yi eklemeniz gerekir.

app.use(express.bodyParser());

Sonra isteyebilirsiniz

req.body.user

Express gibi tüm çerçeveyi kullanmak istemiyorsanız, ancak yüklemeler de dahil olmak üzere farklı formlara ihtiyacınız varsa, o zaman formalin iyi bir seçim olabilir.

Node.js modüllerinde listelenir

Bunu nasıl başaracağınızı açıklayan bir video buldum: https://www.youtube.com/watch?v=nuw48-u3Yrg

Varsayılan "http" modülünü "querystring" ve "stringbuilder" modülleriyle birlikte kullanır. Uygulama, bir web sayfasından iki sayı alır (iki metin kutusu kullanarak) ve gönderildikten sonra, bu ikisinin toplamını döndürür (metin kutularındaki değerlerin kalıcılığıyla birlikte). Bu, başka bir yerde bulabileceğim en iyi örnek.

İlgili kaynak kodu:

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

Ham ikili POST yüklemesi kullananlar için kullanabilirsiniz havai kodlama olmadan:

müşteri:

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

sunucu:

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

İçinde gövde ayrıştırıcısı bulunan hızlı ara katman yazılımını kullanabilirsiniz . Bu, tek yapmanız gereken aşağıdakiler olduğu anlamına gelir:

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

Bu kod örneği Express 4.16.x içeren ES6'dır

ekspres kullanmadan post parametresini ayıklayabilirsiniz.

1: nmp install multiparty

2: çok parçalı içe aktarma. gibivar 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: ve HTML FORM IS.

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

Umarım bu senin için işe yarar. Teşekkürler.

POST boyutunu sınırlayın, düğüm uygulamanızın taşmasını önleyin. İsteği boyut ve uzunluğa göre sınırlamanıza yardımcı olabilecek hem ekspres hem de bağlantı için uygun harika bir ham gövde modülü vardır.

Bir dosya yüklemeyi içeriyorsa, tarayıcı genellikle "multipart/form-data"içerik türü olarak gönderir . Bu gibi durumlarda kullanabilirsiniz

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

Referans 1

Referans 2

Bunun gibi form alanlarında

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

Yukarıdaki yanıtlardan bazıları başarısız olur çünkü yalnızca düz verileri desteklerler.

Şimdilik Casey Chu yanıtını kullanıyorum ama "sorgu dizesi" modülü yerine "qs" kullanıyorum. Bu da "body-parser" modülünün kullandığı modüldür . Eğer iç içe veri istiyorsanız qs yüklemeniz gerekir.

npm install qs --save

Sonra ilk satırı aşağıdaki gibi değiştirin:

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

"İstek - Basitleştirilmiş HTTP istemcisi" ve Javascript Promise kullanarak POST isteğini kolayca gönderebilir ve yanıt alabilirsiniz.

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

Form verilerinin req.body'de kullanılabilir olmasını istiyorsanız bodyParser () yöntemini kullanmanız gerekir. body-parser, isteğinizi ayrıştırır ve gereksinim duyabileceğiniz alakalı bilgileri kolayca ayıklayabileceğiniz bir biçime dönüştürür.

Örneğin, ön ucunuzda bir kayıt formunuz olduğunu varsayalım. Dolduruyorsunuz ve sunucudan ayrıntıları bir yere kaydetmesini istiyorsunuz.

Gövde ayrıştırıcı kullanıyorsanız, isteğinizden kullanıcı adı ve parola çıkarmak aşağıdaki kadar basittir.

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

var loginDetails = {

username : request.body.username,

password : request.body.password

};

MIDDLEWARE olmadan BİR LINER
Aşağıdaki verileri gönderirseniz
'name':'ABC'
, aşağıdaki bir astarı kullanarak ayrıştırabilirsiniz,

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