어떻게 HTTP POST 요청은 Node.js를 이루어집니다?

해결법

1.여기에 구글 컴파일러 API에 POST 요청을하려면 Node.js를를 사용하는 예는 다음과 같습니다

여기에 구글 컴파일러 API에 POST 요청을하려면 Node.js를를 사용하는 예는 다음과 같습니다

// We need this to build our post string
var querystring = require('querystring');
var http = require('http');
var fs = require('fs');

function PostCode(codestring) {
  // Build the post string from an object
  var post_data = querystring.stringify({
      'compilation_level' : 'ADVANCED_OPTIMIZATIONS',
      'output_format': 'json',
      'output_info': 'compiled_code',
        'warning_level' : 'QUIET',
        'js_code' : codestring
  });

  // An object of options to indicate where to post to
  var post_options = {
      host: 'closure-compiler.appspot.com',
      port: '80',
      path: '/compile',
      method: 'POST',
      headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'Content-Length': Buffer.byteLength(post_data)
      }
  };

  // Set up the request
  var post_req = http.request(post_options, function(res) {
      res.setEncoding('utf8');
      res.on('data', function (chunk) {
          console.log('Response: ' + chunk);
      });
  });

  // post the data
  post_req.write(post_data);
  post_req.end();

}

// This is an async file read
fs.readFile('LinkedList.js', 'utf-8', function (err, data) {
  if (err) {
    // If this were just a small part of the application, you would
    // want to handle this differently, maybe throwing an exception
    // for the caller to handle. Since the file is absolutely essential
    // to the program's functionality, we're going to exit with a fatal
    // error instead.
    console.log("FATAL An error occurred trying to read in the file: " + err);
    process.exit(-2);
  }
  // Make sure there's data before we post it
  if(data) {
    PostCode(data);
  }
  else {
    console.log("No data to post");
    process.exit(-1);
  }
});

내가 대신 하드 코딩 된 문자열, 파일에서 데이터를 게시하는 방법을 보여주기 위해 코드를 업데이트했습니다. 그것은 성공적인 읽기 후 실제 코드를 게시,이를 달성하기 위해 비동기 fs.readFile 명령을 사용합니다. 오류가있는 경우가 발생하고, 데이터가 존재하지 않는 경우는 음의 값으로 프로세스가 종료 실패를 나타냅니다.

2.당신이 요청 라이브러리를 사용하는 경우이 쉽게 많이 얻을 수 있습니다.

당신이 요청 라이브러리를 사용하는 경우이 쉽게 많이 얻을 수 있습니다.
```
var request = require('request');

request.post(
    'http://www.yoursite.com/formpage',
    { json: { key: 'value' } },
    function (error, response, body) {
        if (!error && response.statusCode == 200) {
            console.log(body);
        }
    }
);
```
이외에도 멋진 구문을 제공에서 그것은 JSON 요청 쉬운 핸들 (등, 트위터)에 서명하여 OAuth, 여러 부분으로 양식을 할 수있다 (예를 들어, 업로드 파일) 및 스트리밍을합니다.

설치 요청을 NPM 요청 use 명령을 설치하려면

3.당신은 요청 라이브러리를 사용할 수 있습니다. https://www.npmjs.com/package/request

당신은 요청 라이브러리를 사용할 수 있습니다. https://www.npmjs.com/package/request

var request = require('request');

JSON 데이터를 게시하려면 :

var myJSONObject = { ... };
request({
    url: "http://josiahchoi.com/myjson",
    method: "POST",
    json: true,   // <--Very important!!!
    body: myJSONObject
}, function (error, response, body){
    console.log(response);
});

포스트 CML 타타 :

var myXMLText = '<xml>...........</xml>'
request({
    url: "http://josiahchoi.com/myjson",
    method: "POST",
    headers: {
        "content-type": "application/xml",  // <--Very important!!!
    },
    body: myXMLText
}, function (error, response, body){
    console.log(response);
});

4.나는 생산을 위해 Restler와 바늘을 사용합니다. 그들은 둘 다 훨씬 더 강력한 기본 HttpRequest를보다. 그것은 기본 인증, 특수 헤더 항목 또는 업로드 / 다운로드 파일과 요청에 가능하다.

나는 생산을 위해 Restler와 바늘을 사용합니다. 그들은 둘 다 훨씬 더 강력한 기본 HttpRequest를보다. 그것은 기본 인증, 특수 헤더 항목 또는 업로드 / 다운로드 파일과 요청에 가능하다.

게시물에 대한 AS / 작업을 얻을, 그들은 또한 HttpRequest를를 사용하여 원시 아약스 통화보다 사용하기 훨씬 간단하다.
```
needle.post('https://my.app.com/endpoint', {foo:'bar'}, 
    function(err, resp, body){
        console.log(body);
});
```

5.간단하고 의존성이없는. 당신은 결과를 기다리는 수 있도록 약속을 사용합니다. 그것은 응답 본문을 반환하고 응답 상태 코드를 확인하지 않습니다.

간단하고 의존성이없는. 당신은 결과를 기다리는 수 있도록 약속을 사용합니다. 그것은 응답 본문을 반환하고 응답 상태 코드를 확인하지 않습니다.

const https = require('https');

function httpsPost({body, ...options}) {
    return new Promise((resolve,reject) => {
        const req = https.request({
            method: 'POST',
            ...options,
        }, res => {
            const chunks = [];
            res.on('data', data => chunks.push(data))
            res.on('end', () => {
                let body = Buffer.concat(chunks);
                switch(res.headers['content-type']) {
                    case 'application/json':
                        body = JSON.parse(body);
                        break;
                }
                resolve(body)
            })
        })
        req.on('error',reject);
        if(body) {
            req.write(body);
        }
        req.end();
    })
}

용법:

const res = await httpsPost({
    hostname: 'sentry.io',
    path: `/api/0/organizations/org/releases/${changesetId}/deploys/`,
    headers: {
        'Authorization': `Bearer ${process.env.SENTRY_AUTH_TOKEN}`,
        'Content-Type': 'application/json',
    },
    body: JSON.stringify({
        environment: isLive ? 'production' : 'demo',
    })
})

6.당신이 노드에 HTTP POST 요청을 만들기 위해 사용할 수있는 오픈 소스 라이브러리 수십 있습니다.

당신이 노드에 HTTP POST 요청을 만들기 위해 사용할 수있는 오픈 소스 라이브러리 수십 있습니다.

const axios = require('axios');

const data = {
    name: 'John Doe',
    job: 'Content Writer'
};

axios.post('https://reqres.in/api/users', data)
    .then((res) => {
        console.log(`Status: ${res.status}`);
        console.log('Body: ', res.data);
    }).catch((err) => {
        console.error(err);
    });

const needle = require('needle');

const data = {
    name: 'John Doe',
    job: 'Content Writer'
};

needle('post', 'https://reqres.in/api/users', data, {json: true})
    .then((res) => {
        console.log(`Status: ${res.statusCode}`);
        console.log('Body: ', res.body);
    }).catch((err) => {
        console.error(err);
    });

const request = require('request');

const options = {
    url: 'https://reqres.in/api/users',
    json: true,
    body: {
        name: 'John Doe',
        job: 'Content Writer'
    }
};

request.post(options, (err, res, body) => {
    if (err) {
        return console.log(err);
    }
    console.log(`Status: ${res.statusCode}`);
    console.log(body);
});

const https = require('https');

const data = JSON.stringify({
    name: 'John Doe',
    job: 'Content Writer'
});

const options = {
    hostname: 'reqres.in',
    path: '/api/users',
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'Content-Length': data.length
    }
};


const req = https.request(options, (res) => {
    let data = '';

    console.log('Status Code:', res.statusCode);

    res.on('data', (chunk) => {
        data += chunk;
    });

    res.on('end', () => {
        console.log('Body: ', JSON.parse(data));
    });

}).on("error", (err) => {
    console.log("Error: ", err.message);
});

req.write(data);
req.end();

자세한 내용은이 문서를 확인하십시오.

7.또한 Requestify, 내가 nodeJS을 위해 쓴 정말 멋진 간단한 HTTP 클라이언트를 사용할 수 있습니다 +는 캐싱을 지원합니다.

또한 Requestify, 내가 nodeJS을 위해 쓴 정말 멋진 간단한 HTTP 클라이언트를 사용할 수 있습니다 +는 캐싱을 지원합니다.

그냥 다음을 수행 :
```
    var requestify = require('requestify');

    requestify.post('http://example.com', {
        hello: 'world'
    })
    .then(function(response) {
        // Get the response body (JSON parsed or jQuery object for XMLs)
        response.getBody();
    });
```
8.업데이트 2020 :

업데이트 2020 :

정말 망막 기억을 즐기고 있었어요 - 울트라 경량 Node.js를 HTTP 클라이언트를

그것은 두 가지 방법으로 사용할 수 있습니다. 약속 (비동기 / 기다리고 있습니다)와 전통적인 콜백 스타일 다른 한 가지.

고도와 망막 기억 :를 통해 설치

스트레이트 await를 가진 그것의 README에서 :
```
const p = require('phin')

await p({
    url: 'https://ethanent.me',
    method: 'POST',
    data: {
        hey: 'hi'
    }
})
```
Unpromisifed (콜백) 스타일 :
```
const p = require('phin').unpromisified

p('https://ethanent.me', (err, res) => {
    if (!err) console.log(res.body)
})
```
2015 최소 코딩이 수행 할 수있는 다른 라이브러리의 다양한 해주기있다. 나는 많이 당신이 절대적으로 낮은 수준의 HTTP 물건을 제어 할 필요가 요청하지 않는 한 HTTP 우아한 경량 라이브러리를 선호합니다.

하나는 이러한 라이브러리는 Unirest입니다

설치하려면 NPM을 사용합니다. $ NPM은 unirest 설치

그리고 안녕하세요, 세계 위에! 모두가 익숙한 것을 예.
```
var unirest = require('unirest');

unirest.post('http://example.com/helloworld')
.header('Accept', 'application/json')
.send({ "Hello": "World!" })
.end(function (response) {
  console.log(response.body);
});
```
특별한: 많은 사람들은 요청의 사용을 제안하는 [2]

이 장면 뒤에 Unirest 요청 라이브러리를 사용 협조 할 수 있어야합니다.

Unirest 직접 요청 객체에 액세스하기위한 방법을 제공한다.

예:
```
var Request = unirest.get('http://mockbin.com/request');
```

9.

var https = require('https');


/**
 * HOW TO Make an HTTP Call - POST
 */
// do a POST request
// create the JSON object
jsonObject = JSON.stringify({
    "message" : "The web of things is approaching, let do some tests to be ready!",
    "name" : "Test message posted with node.js",
    "caption" : "Some tests with node.js",
    "link" : "http://www.youscada.com",
    "description" : "this is a description",
    "picture" : "http://youscada.com/wp-content/uploads/2012/05/logo2.png",
    "actions" : [ {
        "name" : "youSCADA",
        "link" : "http://www.youscada.com"
    } ]
});

// prepare the header
var postheaders = {
    'Content-Type' : 'application/json',
    'Content-Length' : Buffer.byteLength(jsonObject, 'utf8')
};

// the post options
var optionspost = {
    host : 'graph.facebook.com',
    port : 443,
    path : '/youscada/feed?access_token=your_api_key',
    method : 'POST',
    headers : postheaders
};

console.info('Options prepared:');
console.info(optionspost);
console.info('Do the POST call');

// do the POST call
var reqPost = https.request(optionspost, function(res) {
    console.log("statusCode: ", res.statusCode);
    // uncomment it for header details
//  console.log("headers: ", res.headers);

    res.on('data', function(d) {
        console.info('POST result:\n');
        process.stdout.write(d);
        console.info('\n\nPOST completed');
    });
});

// write the json data
reqPost.write(jsonObject);
reqPost.end();
reqPost.on('error', function(e) {
    console.error(e);
});

10.모듈을 '요구'를 사용 : 이것은 내가 메이크업 요청에 사용하는 간단한 방법입니다.

모듈을 '요구'를 사용 : 이것은 내가 메이크업 요청에 사용하는 간단한 방법입니다.

명령 '요청'모듈을 설치합니다 :

$ npm install request

예제 코드 :

var request = require('request')

var options = {
  method: 'post',
  body: postData, // Javascript object
  json: true, // Use,If you are sending JSON data
  url: url,
  headers: {
    // Specify headers, If any
  }
}

request(options, function (err, res, body) {
  if (err) {
    console.log('Error :', err)
    return
  }
  console.log(' Body :', body)

});

당신은 또한 요청을하려면 Node.js를 내장 된 'HTTP'모듈을 사용할 수 있습니다.

11.나는 슈퍼 에이전트 (https://github.com/visionmedia/superagent)의 단순함을 좋아한다. 노드와 브라우저 모두에서 동일한 API.

나는 슈퍼 에이전트 (https://github.com/visionmedia/superagent)의 단순함을 좋아한다. 노드와 브라우저 모두에서 동일한 API.
```
;(async function() {
  var response = await superagent.post('http://127.0.0.1:8125/', {age: 2})
  console.log(response)
})
```
경기가 브라우저에서 가져올 수 있다는 API를 가지고 노드 페치가 (https://www.npmjs.com/package/node-fetch)도있다 - 그러나이 자동으로 콘텐츠 형식을 처리하지 않습니다, 수동 쿼리 문자열 인코딩이 필요합니다, 정도 어떤 다른 일 슈퍼 에이전트의 않습니다.

12.당신이 약속을 기반으로 HTTP 요청을 찾고 있다면, Axios의 멋지게의 작업을 수행합니다.

당신이 약속을 기반으로 HTTP 요청을 찾고 있다면, Axios의 멋지게의 작업을 수행합니다.

  const axios = require('axios');

  axios.post('/user', {firstName: 'Fred',lastName: 'Flintstone'})
      .then((response) => console.log(response))
      .catch((error) => console.log(error));

또는

await axios.post('/user', {firstName: 'Fred',lastName: 'Flintstone'})

13.에 게시 나머지 / JSON 요청 우리는 단순히 요청 패키지를 사용하여 우리는 JSON 변수에 보내야하는 값을 저장할 수 있습니다.

에 게시 나머지 / JSON 요청 우리는 단순히 요청 패키지를 사용하여 우리는 JSON 변수에 보내야하는 값을 저장할 수 있습니다.

먼저하여 콘솔에서 패키지를 필요로 설치 NPM 요청 --save 설치

var request = require('request');

    var options={
                'key':'28',
                'key1':'value',
                'key2':'value'
                }

    request({
             url:"http://dev.api.ean.com/ean-services/rs/hotel/v3/ping?                      
                 minorRev="+options.key+
                 "&cid="+options.key1+
                 "&apiKey="+options.key2,
             method:"POST",
             json:true},function(error,response,body){
                     console.log(body)
               }
    );

14.나는 이것을 달성하는 방법을 설명하는 비디오를 발견 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);

15.POST와 GET에 대한이 내 솔루션입니다.

POST와 GET에 대한이 내 솔루션입니다.

포스트 방법에 관하여 :

몸은 JSON 객체 인 경우, 그것은 중요 그래서 JSON.stringify와 직렬화 가능성이 따라 내용 - 아이폰에 헤더를 설정합니다 :

      var bodyString=JSON.stringify(body)
      var _headers = {
        'Content-Length': Buffer.byteLength(bodyString)
      };

요청에 쓰기 전에 :

request.write( bodyString );

모두 가져 오기 및 게시 방법 소개 :

제한 시간은 소켓 분리로 발생할 수 있습니다, 그래서 당신은 핸들러 등을 등록해야합니다 :

request.on('socket', function (socket) {
        socket.setTimeout( self.timeout );
        socket.on('timeout', function() {
            request.abort();
            if(timeout) return timeout( new Error('request timed out') );
        });
    });

요청 핸들러 반면

       request.on('timeout', function () {
          // Timeout happend. Server received request, but not handled it
          // (i.e. doesn't send any response or it took to long).
          // You don't know what happend.
          // It will emit 'error' message as well (with ECONNRESET code).
          req.abort();
          if(timeout) return timeout( new Error('request timed out') );
        });

난 강력하게 모두 핸들러를 등록하는 것이 좋습니다.

당신은 데이터 핸들러에서 청크를 CONCAT해야하므로 응답 본문은 청크 :

      var body = '';
      response.on('data', function(d) {
          body += d;
      });

끝에서 몸 전체 응답 본문을 포함합니다 :

      response.on('end', function() {
        try {
            var jsonResponse=JSON.parse(body);
            if(success) return success( jsonResponse );
        } catch(ex) { // bad json
          if(error) return error(ex.toString());
        }
      });

확실 실제로 잘 포맷 된 JSON이며 요청을 할 때 반드시 그것을 할 수있는 방법이 없다는 것을 할 수 없기 때문에이 시도 ... catchtheJSON.parse`로 포장하는 것이 안전합니다.

모듈 : 개의 SimpleAPI를

/**
 * Simple POST and GET
 * @author Loreto Parisi (loretoparisi at gmail dot com)
*/
(function() {

  var SimpleAPI;

  SimpleAPI = (function() {

    var qs = require('querystring');

    /**
     * API Object model
     * @author Loreto Parisi (loretoparisi at gmail dot com)
     */
    function SimpleAPI(host,port,timeout,ssl,debug,json) {

      this.host=host;
      this.port=port;
      this.timeout=timeout;
      /** true to use ssl - defaults to true */
      this.ssl=ssl || true;
      /** true to console log */
      this.debug=debug;
      /** true to parse response as json - defaults to true */
      this.json= (typeof(json)!='undefined')?json:true;
      this.requestUrl='';
      if(ssl) { // use ssl
          this.http = require('https');
      } else { // go unsafe, debug only please
          this.http = require('http');
      }
    }

    /**
     * HTTP GET
     * @author Loreto Parisi (loretoparisi at gmail dot com)
     */
    SimpleAPI.prototype.Get = function(path, headers, params, success, error, timeout) {

      var self=this;
      if(params) {
        var queryString=qs.stringify(params);
        if( queryString ) {
          path+="?"+queryString;
        }
      }
      var options = {
        headers : headers,
        hostname: this.host,
        path: path,
        method: 'GET'
      };
      if(this.port && this.port!='80') { // port only if ! 80
        options['port']=this.port;
      }
      if(self.debug) {
        console.log( "SimpleAPI.Get", headers, params, options );
      }
      var request=this.http.get(options, function(response) {

          if(self.debug) { // debug
            console.log( JSON.stringify(response.headers) );
          }

          // Continuously update stream with data
          var body = '';
          response.on('data', function(d) {
              body += d;
          });
          response.on('end', function() {
            try {
              if(self.json) {
                var jsonResponse=JSON.parse(body);
                if(success) return success( jsonResponse );
              }
              else {
                if(success) return success( body );
              }
            } catch(ex) { // bad json
              if(error) return error( ex.toString() );
            }
          });
        });
        request.on('socket', function (socket) {
            socket.setTimeout( self.timeout );
            socket.on('timeout', function() {
                request.abort();
                if(timeout) return timeout( new Error('request timed out') );
            });
        });
        request.on('error', function (e) {
          // General error, i.e.
          //  - ECONNRESET - server closed the socket unexpectedly
          //  - ECONNREFUSED - server did not listen
          //  - HPE_INVALID_VERSION
          //  - HPE_INVALID_STATUS
          //  - ... (other HPE_* codes) - server returned garbage
          console.log(e);
          if(error) return error(e);
        });
        request.on('timeout', function () {
          // Timeout happend. Server received request, but not handled it
          // (i.e. doesn't send any response or it took to long).
          // You don't know what happend.
          // It will emit 'error' message as well (with ECONNRESET code).
          req.abort();
          if(timeout) return timeout( new Error('request timed out') );
        });

        self.requestUrl = (this.ssl?'https':'http') + '://' + request._headers['host'] + request.path;
        if(self.debug) {
          console.log("SimpleAPI.Post",self.requestUrl);
        }
        request.end();
    } //RequestGet

    /**
     * HTTP POST
     * @author Loreto Parisi (loretoparisi at gmail dot com)
     */
    SimpleAPI.prototype.Post = function(path, headers, params, body, success, error, timeout) {
      var self=this;

      if(params) {
        var queryString=qs.stringify(params);
        if( queryString ) {
          path+="?"+queryString;
        }
      }
      var bodyString=JSON.stringify(body)
      var _headers = {
        'Content-Length': Buffer.byteLength(bodyString)
      };
      for (var attrname in headers) { _headers[attrname] = headers[attrname]; }

      var options = {
        headers : _headers,
        hostname: this.host,
        path: path,
        method: 'POST',
        qs : qs.stringify(params)
      };
      if(this.port && this.port!='80') { // port only if ! 80
        options['port']=this.port;
      }
      if(self.debug) {
        console.log( "SimpleAPI.Post\n%s\n%s", JSON.stringify(_headers,null,2), JSON.stringify(options,null,2) );
      }
      if(self.debug) {
        console.log("SimpleAPI.Post body\n%s", JSON.stringify(body,null,2) );
      }
      var request=this.http.request(options, function(response) {

          if(self.debug) { // debug
            console.log( JSON.stringify(response.headers) );
          }

          // Continuously update stream with data
          var body = '';
          response.on('data', function(d) {
              body += d;
          });
          response.on('end', function() {
            try {
                console.log("END", body);
                var jsonResponse=JSON.parse(body);
                if(success) return success( jsonResponse );
            } catch(ex) { // bad json
              if(error) return error(ex.toString());
            }
          });

        });

        request.on('socket', function (socket) {
            socket.setTimeout( self.timeout );
            socket.on('timeout', function() {
                request.abort();
                if(timeout) return timeout( new Error('request timed out') );
            });
        });
        request.on('error', function (e) {
          // General error, i.e.
          //  - ECONNRESET - server closed the socket unexpectedly
          //  - ECONNREFUSED - server did not listen
          //  - HPE_INVALID_VERSION
          //  - HPE_INVALID_STATUS
          //  - ... (other HPE_* codes) - server returned garbage
          console.log(e);
          if(error) return error(e);
        });
        request.on('timeout', function () {
          // Timeout happend. Server received request, but not handled it
          // (i.e. doesn't send any response or it took to long).
          // You don't know what happend.
          // It will emit 'error' message as well (with ECONNRESET code).
          req.abort();
          if(timeout) return timeout( new Error('request timed out') );
        });

        self.requestUrl = (this.ssl?'https':'http') + '://' + request._headers['host'] + request.path;
        if(self.debug) {
          console.log("SimpleAPI.Post",self.requestUrl);
        }

        request.write( bodyString );
        request.end();

    } //RequestPost

    return SimpleAPI;

  })();

  module.exports = SimpleAPI

}).call(this);

용법:

// Parameters
// domain: example.com
// ssl:true, port:80
// timeout: 30 secs
// debug: true
// json response:true
var api = new SimpleAPI('posttestserver.com', 80, 1000 * 10, true, true, true); 

var headers = {
    'Content-Type' : 'application/json',
    'Accept' : 'application/json' 
};
var params = {
  "dir" : "post-test"
};
var method = 'post.php';

api.Post(method, headers, params, body
    , function(response) { // success
       console.log( response );
    }
    , function(error) { // error
      console.log( error.toString() );
    }
    , function(error) { // timeout
       console.log( new Error('timeout error') );
    });

16.게시물을 처리하고 내 프로젝트에 대한 요청을받을 수있는 낮은 수준의 유틸리티를 작성하는 동안 많은 어려움을 겪고 후, 나는 여기 내 노력을 게시하기로 결정했다. 대부분 허용 대답의 라인, 여기에 JSON 데이터를 전송하기 위해 HTTP 및 HTTPS POST 요청을 만들기위한 코드 조각입니다.

게시물을 처리하고 내 프로젝트에 대한 요청을받을 수있는 낮은 수준의 유틸리티를 작성하는 동안 많은 어려움을 겪고 후, 나는 여기 내 노력을 게시하기로 결정했다. 대부분 허용 대답의 라인, 여기에 JSON 데이터를 전송하기 위해 HTTP 및 HTTPS POST 요청을 만들기위한 코드 조각입니다.

const http = require("http")
const https = require("https")

// Request handler function
let postJSON = (options, postData, callback) => {

    // Serializing JSON
    post_data = JSON.stringify(postData)

    let port = options.port == 443 ? https : http

    // Callback function for the request
    let req = port.request(options, (res) => {
        let output = ''
        res.setEncoding('utf8')

        // Listener to receive data
        res.on('data', (chunk) => {
            output += chunk
        });

        // Listener for intializing callback after receiving complete response
        res.on('end', () => {
            let obj = JSON.parse(output)
            callback(res.statusCode, obj)
        });
    });

   // Handle any errors occurred while making request
    req.on('error', (err) => {
        //res.send('error: ' + err.message)
    });

    // Request is made here, with data as string or buffer
    req.write(post_data)
    // Ending the request
    req.end()
};

let callPost = () => {

    let data = {
        'name': 'Jon',
        'message': 'hello, world'
    }

    let options = {
        host: 'domain.name',       // Your domain name
        port: 443,                 // 443 for https and 80 for http
        path: '/path/to/resource', // Path for the request
        method: 'POST',            
        headers: {
            'Content-Type': 'application/json',
            'Content-Length': Buffer.byteLength(data)
        }
    }

    postJSON(options, data, (statusCode, result) => {
        // Handle response
        // Process the received data
    });

}

17.

let request = require('request');
let jsonObj = {};
request({
    url: "https://myapii.com/sendJsonData",
    method: "POST",
    json: true,
    body: jsonObj
    }, function (error, resp, body){
       console.log(resp);
});

또는 당신은이 라이브러리를 사용할 수 있습니다 :

let axios = require("axios");
let jsonObj = {};

const myJsonAPI = axios.create({
   baseURL: 'https://myapii.com',
   timeout: 120*1000
});

let response = await myJsonAPI.post("sendJsonData",jsonobj).catch(e=>{
    res.json(e);
});
console.log(response);

18.Axios의 브라우저와 Node.js.에 대한 약속 기반의 HTTP 클라이언트입니다 Axios의 쉽게 REST 엔드 포인트에 비동기 HTTP 요청을 보내고 CRUD 작업을 수행 할 수 있습니다. 그것은 일반 자바 스크립트 또는 뷰이나 반작용 라이브러리 등을 사용할 수 있습니다.

Axios의 브라우저와 Node.js.에 대한 약속 기반의 HTTP 클라이언트입니다 Axios의 쉽게 REST 엔드 포인트에 비동기 HTTP 요청을 보내고 CRUD 작업을 수행 할 수 있습니다. 그것은 일반 자바 스크립트 또는 뷰이나 반작용 라이브러리 등을 사용할 수 있습니다.
```
const axios = require('axios');

        var dataToPost = {
          email: "your email",
          password: "your password"
        };

        let axiosConfiguration = {
          headers: {
              'Content-Type': 'application/json;charset=UTF-8',
              "Access-Control-Allow-Origin": "*",
          }
        };

        axios.post('endpoint or url', dataToPost, axiosConfiguration)
        .then((res) => {
          console.log("Response: ", res);
        })
        .catch((err) => {
          console.log("error: ", err);
        })
```
19.추가 구성 옵션 및 사용자 정의 헤더를 사용하는 axios.post 요청의 또 다른 Axios의 예를 게시.

추가 구성 옵션 및 사용자 정의 헤더를 사용하는 axios.post 요청의 또 다른 Axios의 예를 게시.

VAR postData를 = { 이메일 : "test@test.com" 비밀번호 : "비밀번호" }; axiosConfig = {하자 헤더 : { '콘텐츠 유형': '응용 프로그램 / JSON; 문자셋 = UTF-8', "액세스 제어 - 허용 - 원산지": "*", } }; axios.post ( 'HTTP : // <호스트> : <포트> / <경로>', postData를, axiosConfig) 그 때는 ((해상도) => { CONSOLE.LOG는 ( "응답을받은 :"고해상도를); }) .catch ((ERR) => { 을 console.log ( "Axios의 오류 :"ERR); })

20.요청 종속성을 이용하여.

요청 종속성을 이용하여.

간단한 해결책 :

 import request from 'request'
 var data = {
        "host":"127.1.1.1",
        "port":9008
    }

request.post( baseUrl + '/peers/connect',
        {
            json: data,  // your payload data placed here
            headers: {
                'X-Api-Key': 'dajzmj6gfuzmbfnhamsbuxivc', // if authentication needed
                'Content-Type': 'application/json' 
            }
        }, function (error, response, body) {
            if (error) {
                callback(error, null)
            } else {
                callback(error, response.body)
            }
        });

21.요청 - 약속은 약속 기반의 응답을 제공합니다. 가 2xx 이외의 HTTP 응답 코드는 약속이 거부 될 것입니다. 이 설정 options.simple = 거짓으로 덮어 쓸 수 있습니다

요청 - 약속은 약속 기반의 응답을 제공합니다. 가 2xx 이외의 HTTP 응답 코드는 약속이 거부 될 것입니다. 이 설정 options.simple = 거짓으로 덮어 쓸 수 있습니다
```
var options = {
  method: 'POST',
  uri: 'http://api.posttestserver.com/post',
  body: {
  some: 'payload'
 },
  json: true // Automatically stringifies the body to JSON
};

rp(options)
.then(function (parsedBody) {
    // POST succeeded...
})
.catch(function (err) {
    // POST failed...
});
```

from https://stackoverflow.com/questions/6158933/how-is-an-http-post-request-made-in-node-js by cc-by-sa and MIT license

'NODEJS' 카테고리의 다른 글

[NODEJS] Node.js를 + Nginx에 - 지금 무엇? (0)	2020.09.16
[NODEJS] 중첩 된 약속을 제거 (0)	2020.09.16
[NODEJS] 어떻게 Node.js를에 Express.js에서 GET GET (쿼리 문자열) 변수? (0)	2020.09.16
[NODEJS] 어떻게 POST 쿼리 매개 변수를 검색? (0)	2020.09.16
[NODEJS] 어떻게 노드에 ES6 가져 오기를 사용할 수 있습니까? [복제] (0)	2020.09.16

복붙노트

[NODEJS] 어떻게 HTTP POST 요청은 Node.js를 이루어집니다?

어떻게 HTTP POST 요청은 Node.js를 이루어집니다?

해결법

1.여기에 구글 컴파일러 API에 POST 요청을하려면 Node.js를를 사용하는 예는 다음과 같습니다

2.당신이 요청 라이브러리를 사용하는 경우이 쉽게 많이 얻을 수 있습니다.

3.당신은 요청 라이브러리를 사용할 수 있습니다. https://www.npmjs.com/package/request

4.나는 생산을 위해 Restler와 바늘을 사용합니다. 그들은 둘 다 훨씬 더 강력한 기본 HttpRequest를보다. 그것은 기본 인증, 특수 헤더 항목 또는 업로드 / 다운로드 파일과 요청에 가능하다.

5.간단하고 의존성이없는. 당신은 결과를 기다리는 수 있도록 약속을 사용합니다. 그것은 응답 본문을 반환하고 응답 상태 코드를 확인하지 않습니다.

6.당신이 노드에 HTTP POST 요청을 만들기 위해 사용할 수있는 오픈 소스 라이브러리 수십 있습니다.

7.또한 Requestify, 내가 nodeJS을 위해 쓴 정말 멋진 간단한 HTTP 클라이언트를 사용할 수 있습니다 +는 캐싱을 지원합니다.

8.업데이트 2020 :

9.

10.모듈을 '요구'를 사용 : 이것은 내가 메이크업 요청에 사용하는 간단한 방법입니다.

11.나는 슈퍼 에이전트 (https://github.com/visionmedia/superagent)의 단순함을 좋아한다. 노드와 브라우저 모두에서 동일한 API.

12.당신이 약속을 기반으로 HTTP 요청을 찾고 있다면, Axios의 멋지게의 작업을 수행합니다.

13.에 게시 나머지 / JSON 요청 우리는 단순히 요청 패키지를 사용하여 우리는 JSON 변수에 보내야하는 값을 저장할 수 있습니다.

14.나는 이것을 달성하는 방법을 설명하는 비디오를 발견 https://www.youtube.com/watch?v=nuw48-u3Yrg

15.POST와 GET에 대한이 내 솔루션입니다.

17.

19.추가 구성 옵션 및 사용자 정의 헤더를 사용하는 axios.post 요청의 또 다른 Axios의 예를 게시.

20.요청 종속성을 이용하여.

21.요청 - 약속은 약속 기반의 응답을 제공합니다. 가 2xx 이외의 HTTP 응답 코드는 약속이 거부 될 것입니다. 이 설정 options.simple = 거짓으로 덮어 쓸 수 있습니다

'NODEJS' 카테고리의 다른 글

티스토리툴바