복붙노트

[NODEJS] 어떻게 Node.js를에서 POST 데이터를 처리하는 방법을?

NODEJS

어떻게 Node.js를에서 POST 데이터를 처리하는 방법을?

해결법

  1. 1.당신이 익스프레스 (Node.js를위한 고성능, 높은 수준의 웹 개발)를 사용하는 경우, 당신은이 작업을 수행 할 수 있습니다 :

    당신이 익스프레스 (Node.js를위한 고성능, 높은 수준의 웹 개발)를 사용하는 경우, 당신은이 작업을 수행 할 수 있습니다 :

    HTML :

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

    API 클라이언트 :

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

    Node.js를 (익스프레스 v4.16.0 이후부터)

    // Parse URL-encoded bodies (as sent by HTML forms)
app.use(express.urlencoded());

// Parse JSON bodies (as sent by API clients)
app.use(express.json());

// Access the parse results as request.body
app.post('/', function(request, response){
    console.log(request.body.user.name);
    console.log(request.body.user.email);
});

    Node.js를 (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)
});

  2. 2.당신은 쿼리 문자열 모듈을 사용할 수 있습니다 :

    당신은 쿼리 문자열 모듈을 사용할 수 있습니다 :

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

    당신은 이름 나이 입력 필드가 있다면 이제, 예를 들어, 당신은 변수 포스트를 사용하여 액세스 할 수 있습니다 :

    console.log(post.age);

  3. 3.누군가가 당신의 RAM을 홍수하려고하면 연결을 죽일 수 있는지 확인하십시오!

    누군가가 당신의 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

        });
    }
}

  4. 4.여기 답변의 많은 더 이상 좋은 관행이 아니거나 그의 왜 내가 이것을 쓰고 있어요, 그래서 아무것도 설명하지 않습니다.

    여기 답변의 많은 더 이상 좋은 관행이 아니거나 그의 왜 내가 이것을 쓰고 있어요, 그래서 아무것도 설명하지 않습니다.

    http.createServer의 콜백이 호출되면 서버가 실제로 요청에 대한 모든 헤더를받은 경우이지만, 우리는 기다릴 필요가 그래서는 데이터가 아직 접수되지 않은 가능성이 있습니다. HTTP 요청 객체 (http.IncomingMessage 인스턴스) 실제로 읽을 스트림입니다. 읽을 스트림에서 데이터의 덩어리가, 데이터 이벤트가 방출되는 도착할 때마다 (당신이 그것에 콜백을 등록 가정) 모든 덩어리가 도착 때 종료 이벤트가 방출된다. 다음은 이벤트를 수신하는 방법에 대한 예입니다 :

    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 스트림 모듈을 사용할 수 있습니다 :

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

    당신이 HTML 기본 콘텐츠 형식에없는 파일이나 나눠 jQuery를 아약스 호출을 POST 제출을 형성 수용하려고하는 경우, 콘텐츠 형식이 응용 프로그램 / UFT-8 인코딩 x-www-form-urlencoded를합니다. 당신은 역 직렬화를 액세스 속성에 쿼리 문자열 모듈을 사용할 수 있습니다 :

    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을 경우, 당신은 단순히 대신 qs.parse의 JSON.parse를 사용할 수 있습니다.

    당신이이 경우에 다음 파일을 처리 또는 멀티 콘텐츠 형식을 처리하는 경우, 당신은 그것을 처리에서 모든 고통을 제거하는 강력한 같은 것을 사용한다. 나는 다중 내용에 대한 유용한 링크 및 모듈을 게시 한 광산이 다른 답변에서보세요.

    당신은 콘텐츠를 구문 분석 오히려 덜 수있을 것 같은, 다른 곳, 예를 들어 내가 배관보다는 버퍼링 제안 파일에 데이터와 같은 다른 HTTP 요청을하거나 저장을 보내도록을 통과하지 않으려면 코드는, 핸들은 적은 메모리를 가지고 빠른 경우에 따라서 것, 더 나은 압력을 백업 할 수 있습니다.

    당신이 파일의 내용을 저장 싶다면 :

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

    다른 답변은 악의적 인 클라이언트 응용 프로그램을 중단하거나 메이크업을 보호하기 때문에 당신의 기억을 채우기 위해 당신에게 엄청난 양의 데이터를 전송할 수 있음을 마음에 두어야을 언급 한대로 확인하면 발광 데이터가 특정 한도를 통과 요청을 놓습니다. 당신이 들어오는 데이터를 처리하는 라이브러리를 사용하지 않는 경우. 내가 요청을 중단 할 수 있습니다 스트림 미터 같은 것을 사용하는 것이 좋습니다 것 도달하면 지정된 제한 :

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

    또는

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

    또는

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

    난 당신이 단순히를 들어, HTTP 요청 본문을 사용하는 방법에 위에서 설명한 동안 버퍼링 및 콘텐츠를 구문 분석, 나는 그들이 아마 더 나은 가장자리 경우를 처리하므로 오히려 자신에 구현이 모듈 중 하나를 사용하여 제안. 표현을 위해 나는 몸 파서를 사용하는 것이 좋습니다. KOA를 들어, 유사한 모듈이있다.

    당신이 프레임 워크를 사용하지 않는 경우, 몸은 아주 좋다.

  5. 5.다음은 여기에 게시 된 다른 답변과 기사를 기반으로하는 매우 간단한 노 프레임 워크 래퍼입니다 :

    다음은 여기에 게시 된 다른 답변과 기사를 기반으로하는 매우 간단한 노 프레임 워크 래퍼입니다 :

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

  6. 6.당신이 JSON으로 데이터를 인코딩하는 경우가 청소기 될 것입니다, 다음 Node.js.로 보내

    당신이 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));
        });
    }
}

  7. 7.이 서로를 풍덩 관리 웹 프레임 워크 I를 설치하지 않고이 간단한 작업을 수행하는 방법을 궁금해 사람들을위한. 단단하게 생산 준비하지만 작동하는 것 같다.

    이 서로를 풍덩 관리 웹 프레임 워크 I를 설치하지 않고이 간단한 작업을 수행하는 방법을 궁금해 사람들을위한. 단단하게 생산 준비하지만 작동하는 것 같다.

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

  8. 8.당신은 몸 파서는 Node.js를 몸 구문 분석 미들웨어를 사용할 수 있습니다.

    당신은 몸 파서는 Node.js를 몸 구문 분석 미들웨어를 사용할 수 있습니다.

    먼저 부하 몸 파서

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

    더 많은 문서는 여기에서 찾을 수 있습니다

  9. 9.참조 : https://nodejs.org/en/docs/guides/anatomy-of-an-http-transaction/

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

  10. 10.다음은 노드 강력한 사용하는 경우 당신이 그것을 할 수있는 방법입니다 :

    다음은 노드 강력한 사용하는 경우 당신이 그것을 할 수있는 방법입니다 :

    var formidable = require("formidable");

var form = new formidable.IncomingForm();
form.parse(request, function (err, fields) {
    console.log(fields.parameter1);
    console.log(fields.parameter2);
    // ...
});

  11. 11.이 아래 그림처럼 당신은 다음 POST 데이터를 추출 할 수 순수 Node.js를 사용을 선호하는 경우 :

    이 아래 그림처럼 당신은 다음 POST 데이터를 추출 할 수 순수 Node.js를 사용을 선호하는 경우 :

    // 종속성 CONST StringDecoder는 = ( 'string_decoder')를 요구 StringDecoder한다.; CONST HTTP =이 필요합니다 ( 'HTTP'); // 인스턴스화 HTTP 서버. CONST HTTP 서버 http.createServer = ((요청, 응답) => { // 페이로드 (있는 경우)를 가져옵니다. 디코더 = CONST 새로운 StringDecoder ( "UTF-8"); 페이로드 = ''하자; request.on ( '데이터'(데이터) => { 페이로드 + = decoder.write (데이터); }); request.on ( '말단'() => { 페이로드 + = decoder.end (); // 객체에 대한 구문 분석 페이로드. 페이로드 = JSON.parse (페이로드); // 음주 페이로드와 smoething .... }); }; // 시작 HTTP 서버. CONST 포트 = 3000; httpServer.listen (포트 () => { CONSOLE.LOG는 (`서버는 포트 $ {포트}`에서 수신 대기) });

  12. 12.1) NPM에서 시신 파서 '을 설치한다.

    1) NPM에서 시신 파서 '을 설치한다.

    2) 그런 다음 app.ts에서

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

    3) 당신은 쓸 필요가

    app.use(bodyParser.json())

    app.ts 모듈

    4) 당신이 포함 것을 명심

    app.use(bodyParser.json())

    상단 또는 모든 모듈 선언 전에.

    전의:

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

    5) 다음에 사용

    var postdata = req.body;

  13. 13.당신이 청크하지 않으려면 데이터와 함께 당신의 데이터는 항상 이런 식으로 읽을 수있는 콜백을 사용할 수 있습니다 콜백 :

    당신이 청크하지 않으려면 데이터와 함께 당신의 데이터는 항상 이런 식으로 읽을 수있는 콜백을 사용할 수 있습니다 콜백 :

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

    이러한 접근 방식은 수정 들어오는 요청을하지만, 바로 그게 문제가되지 않습니다 때문에 요청이 쓰레기가 수집됩니다 응답을 완료한다.

    고급 접근 방식은 거대한 몸 두려워하는 경우, 먼저 몸의 크기를 확인하는 것입니다.

  14. 14.그것을 할 수있는 여러 가지 방법이 있습니다. 그러나 내가 아는 가장 빠른 방법은 몸 파서와 Express.js 라이브러리를 사용하는 것입니다.

    그것을 할 수있는 여러 가지 방법이 있습니다. 그러나 내가 아는 가장 빠른 방법은 몸 파서와 Express.js 라이브러리를 사용하는 것입니다.

    var express = require("express");
var bodyParser = require("body-parser");
var app = express();

app.use(bodyParser.urlencoded({extended : true}));

app.post("/pathpostdataissentto", function(request, response) {
  console.log(request.body);
  //Or
  console.log(request.body.fieldName);
});

app.listen(8080);

    POST 데이터가 JSON 배열을 포함하는 대신 경우 문자열에 대한 그 캔 작업은,하지만 난 bodyParser.json에 bodyParser.urlencoded을 변경합니다.

    추가 정보 : http://www.kompulsa.com/how-to-accept-and-parse-post-requests-in-node-js/

  15. 15.당신은 request.on 사용하여 덩어리에서 POST 데이터를 수신 할 필요가 ( '데이터', 기능 (덩어리) {...})

    당신은 request.on 사용하여 덩어리에서 POST 데이터를 수신 할 필요가 ( '데이터', 기능 (덩어리) {...})

    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 제안대로 지정된 위치에 크기 제한을 추가하는 것을 고려한다.

  16. 16.익스프레스 vch.17.0

    익스프레스 vch.17.0

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

  17. 17.당신이 req.body에 액세스 할 수 있습니다 전에, Express.js를 사용하는 경우, 당신은 미들웨어 bodyParser를 추가해야합니다 :

    당신이 req.body에 액세스 할 수 있습니다 전에, Express.js를 사용하는 경우, 당신은 미들웨어 bodyParser를 추가해야합니다 :

    app.use(express.bodyParser());

    그럼 당신은 요청할 수 있습니다

    req.body.user

  18. 18.당신이 익스프레스와 같은 전체 프레임 워크를 사용하지 않지만, 당신은 또한 업로드를 포함하는 형태의 다른 종류를해야하는 경우, 다음 포르말린은 좋은 선택이 될 수 있습니다.

    당신이 익스프레스와 같은 전체 프레임 워크를 사용하지 않지만, 당신은 또한 업로드를 포함하는 형태의 다른 종류를해야하는 경우, 다음 포르말린은 좋은 선택이 될 수 있습니다.

    그것은 Node.js를 모듈에 나열되어 있습니다

  19. 19.당신이 표현을 사용하지 않고 포스트 매개 변수를 추출 할 수 있습니다.

    당신이 표현을 사용하지 않고 포스트 매개 변수를 추출 할 수 있습니다.

    1 : NPM 멀티 파티를 설치

    2 : 수입 다자간. var에 다자간로 = ( '다당제')을 필요로;

    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>

    나는 이것이 당신을 위해 작동 바랍니다. 감사.

  20. 20.나는 이것을 달성하는 방법을 설명하는 동영상을 발견 : https://www.youtube.com/watch?v=nuw48-u3Yrg

    나는 이것을 달성하는 방법을 설명하는 동영상을 발견 : https://www.youtube.com/watch?v=nuw48-u3Yrg

    그것은 "쿼리 문자열"과 "StringBuilder의"모듈과 함께 기본 "HTTP"모듈을 사용합니다. 응용 프로그램 (글 상자의 값을 지속와 함께) 두의 반환 합 제출 웹 페이지에서와시 (두 개의 텍스트 상자 사용) 두 숫자를합니다. 이것은 내가 다른 곳에서는 찾을 수있는 가장 좋은 예입니다.

    관련 소스 코드 :

    var http = require("http");
var qs = require("querystring");
var StringBuilder = require("stringbuilder");

var port = 9000;

function getCalcHtml(req, resp, data) {
    var sb = new StringBuilder({ newline: "\r\n" });
    sb.appendLine("<html>");
    sb.appendLine(" <body>");
    sb.appendLine("     <form method='post'>");
    sb.appendLine("         <table>");
    sb.appendLine("             <tr>");
    sb.appendLine("                 <td>Enter First No: </td>");

    if (data && data.txtFirstNo) {
        sb.appendLine("                 <td><input type='text' id='txtFirstNo' name='txtFirstNo' value='{0}'/></td>", data.txtFirstNo);
    }
    else {
        sb.appendLine("                 <td><input type='text' id='txtFirstNo' name='txtFirstNo' /></td>");
    }

    sb.appendLine("             </tr>");
    sb.appendLine("             <tr>");
    sb.appendLine("                 <td>Enter Second No: </td>");

    if (data && data.txtSecondNo) {
        sb.appendLine("                 <td><input type='text' id='txtSecondNo' name='txtSecondNo' value='{0}'/></td>", data.txtSecondNo);
    }
    else {
        sb.appendLine("                 <td><input type='text' id='txtSecondNo' name='txtSecondNo' /></td>");
    }

    sb.appendLine("             </tr>");
    sb.appendLine("             <tr>");
    sb.appendLine("                 <td><input type='submit' value='Calculate' /></td>");
    sb.appendLine("             </tr>");

    if (data && data.txtFirstNo && data.txtSecondNo) {
        var sum = parseInt(data.txtFirstNo) + parseInt(data.txtSecondNo);
        sb.appendLine("             <tr>");
        sb.appendLine("                 <td>Sum: {0}</td>", sum);
        sb.appendLine("             </tr>");
    }

    sb.appendLine("         </table>");
    sb.appendLine("     </form>")
    sb.appendLine(" </body>");
    sb.appendLine("</html>");
    sb.build(function (err, result) {
        resp.write(result);
        resp.end();
    });
}

function getCalcForm(req, resp, data) {
    resp.writeHead(200, { "Content-Type": "text/html" });
    getCalcHtml(req, resp, data);
}

function getHome(req, resp) {
    resp.writeHead(200, { "Content-Type": "text/html" });
    resp.write("<html><html><head><title>Home</title></head><body>Want to some calculation? Click <a href='/calc'>here</a></body></html>");
    resp.end();
}

function get404(req, resp) {
    resp.writeHead(404, "Resource Not Found", { "Content-Type": "text/html" });
    resp.write("<html><html><head><title>404</title></head><body>404: Resource not found. Go to <a href='/'>Home</a></body></html>");
    resp.end();
}

function get405(req, resp) {
    resp.writeHead(405, "Method not supported", { "Content-Type": "text/html" });
    resp.write("<html><html><head><title>405</title></head><body>405: Method not supported</body></html>");
    resp.end();
}

http.createServer(function (req, resp) {
    switch (req.method) {
        case "GET":
            if (req.url === "/") {
                getHome(req, resp);
            }
            else if (req.url === "/calc") {
                getCalcForm(req, resp);
            }
            else {
                get404(req, resp);
            }
            break;
        case "POST":
            if (req.url === "/calc") {
                var reqBody = '';
                req.on('data', function (data) {
                    reqBody += data;
                    if (reqBody.length > 1e7) { //10MB
                        resp.writeHead(413, 'Request Entity Too Large', { 'Content-Type': 'text/html' });
                        resp.end('<!doctype html><html><head><title>413</title></head><body>413: Request Entity Too Large</body></html>');
                    }
                });
                req.on('end', function () {
                    var formData = qs.parse(reqBody);
                    getCalcForm(req, resp, formData);
                });
            }
            else {
                get404(req, resp);
            }
            break;
        default:
            get405(req, resp);
            break;
    }
}).listen(port);

  21. 21.당신이 사용할 수있는 오버 헤드 인코딩없이 원시 이진 POST 업로드를 사용하는 경우 :

    당신이 사용할 수있는 오버 헤드 인코딩없이 원시 이진 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!");
  });
});

  22. 22.당신은 지금에 내장 된 몸 파서가 명시 미들웨어를 사용할 수 있습니다. 이 방법 당신이 할 필요가 다음입니다 :

    당신은 지금에 내장 된 몸 파서가 명시 미들웨어를 사용할 수 있습니다. 이 방법 당신이 할 필요가 다음입니다 :

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

    즉, 코드 예제 익스프레스 4.16.x와 ES6입니다

  23. 23.제한 POST 크기 피하기는 노드 응용 프로그램을 홍수. 당신은 크기와 길이의 요청을 제한 할 수 있습니다 모두 명시하고 연결에 적합한 좋은 원료 몸 모듈은있다.

    제한 POST 크기 피하기는 노드 응용 프로그램을 홍수. 당신은 크기와 길이의 요청을 제한 할 수 있습니다 모두 명시하고 연결에 적합한 좋은 원료 몸 모듈은있다.

  24. 24.이 파일 업로드를 포함하면 브라우저는 일반적으로 "다중 / 폼 데이터"콘텐츠 형식으로 보낼 수 있습니다. 당신은 이러한 경우에 이것을 사용할 수 있습니다

    이 파일 업로드를 포함하면 브라우저는 일반적으로 "다중 / 폼 데이터"콘텐츠 형식으로 보낼 수 있습니다. 당신은 이러한 경우에 이것을 사용할 수 있습니다

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

    참고 1

    참조 2

  25. 25.이와 같은 양식 필드에

    이와 같은 양식 필드에

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

    그들은 단지 플랫 데이터를 지원하기 때문에 위의 답변 중 일부는 실패합니다.

    지금은 케이시 추 응답을 사용하고 들어 있지만, "QS"대신 "쿼리 문자열"모듈. 이뿐만 아니라 모듈 "몸 파서"용도입니다. 중첩 된 데이터를 원하는 경우 그래서 당신은 QS를 설치해야합니다.

    npm install qs --save

    다음과 같은 첫 번째 라인을 교체 :

    //var qs = require('querystring');
var qs = require('qs'); 

function (request, response) {
    if (request.method == 'POST') {
        var body = '';

        request.on('data', function (data) {
            body += data;

            // Too much POST data, kill the connection!
            // 1e6 === 1 * Math.pow(10, 6) === 1 * 1000000 ~~~ 1MB
            if (body.length > 1e6)
                request.connection.destroy();
        });

        request.on('end', function () {
            var post = qs.parse(body);
            console.log(post.user.name); // should work
            // use post['blah'], etc.
        });
    }
}

  26. 26.당신은 쉽게 전송 및 사용하여 POST 요청의 응답을 얻을 수있다 "요청 - 단순화 된 HTTP 클라이언트를"자바 스크립트 약속.

    당신은 쉽게 전송 및 사용하여 POST 요청의 응답을 얻을 수있다 "요청 - 단순화 된 HTTP 클라이언트를"자바 스크립트 약속.

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

  27. 27.당신은 양식 데이터를 req.body에서 사용할 수 있도록하려면 bodyParser ()를 사용합니다. 몸 파서는 귀하의 요청을 구문 분석하고 당신은 쉽게 당신이해야 할 수도 관련 정보를 추출 할 수있는 형식으로 변환합니다.

    당신은 양식 데이터를 req.body에서 사용할 수 있도록하려면 bodyParser ()를 사용합니다. 몸 파서는 귀하의 요청을 구문 분석하고 당신은 쉽게 당신이해야 할 수도 관련 정보를 추출 할 수있는 형식으로 변환합니다.

    예를 들어, 당신이 당신의 프론트 엔드에 가입 양식을 가정 해 봅시다. 당신은 그것을 작성하고, 어딘가에 세부 정보를 저장하는 서버를 요청하고 있습니다.

    귀하의 요청에서 추출 사용자 이름과 암호는 몸 파서를 사용하는 경우 아래와 같이 간단하게 간다.

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

    var loginDetails = {

username : request.body.username,

password : request.body.password

};

  28. 28.미들웨어없이 ONE 라이너 데이터를 다음 게시 할 경우, '이름': 'ABC' 그런 다음 한 라이너를 사용하여 구문 분석 할 수있는,

    미들웨어없이 ONE 라이너 데이터를 다음 게시 할 경우, '이름': 'ABC' 그런 다음 한 라이너를 사용하여 구문 분석 할 수있는,

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

    29. from https://stackoverflow.com/questions/4295782/how-to-process-post-data-in-node-js by cc-by-sa and MIT license

'NODEJS' 카테고리의 다른 글

[NODEJS] Node.js를 파일을 작성  (0) 2020.09.15
[NODEJS] 노드에서 클라이언트 : catch되지 않은 ReferenceError가 : 정의되지 않은 필요  (0) 2020.09.15
[NODEJS] 이 생성자 함수는 약속을 반환해야하는 나쁜 관행인가?  (0) 2020.09.15
[NODEJS] NPM은 sudo를하지 않고 오류가 발생합니다  (0) 2020.09.15
[NODEJS] 무엇 Node.js를의 module.exports의 목적은 당신이 어떻게 사용합니까?  (0) 2020.09.15
,

티스토리툴바