node.js에서 HTTP POST 요청은 어떻게 이루어 집니까?


946

node.js에서 데이터와 함께 아웃 바운드 HTTP POST 요청을 만들려면 어떻게해야합니까?


16
Jed Watson의 답변 에서 제안한 것처럼 저수준 API를 작성하지 않는 한 요청을 사용하는 것이 좋습니다 .
namuol

4
HTTP 요청을 만들기 위해 node-fetch기본 fetchJavaScript 메소드 의 구현 인을 사용할 수 있습니다 .
Fez Vrasta

이 포스트는 요청을 사용하기위한 기본 사용 시나리오를 다룹니다. blog.modulus.io/node.js-tutorial-how-to-use-request-module
Shaswat Rungta

답변:


855

다음은 node.js를 사용하여 Google 컴파일러 API에 POST 요청을하는 예입니다.

// 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이를 달성하기 위해 async 명령을 사용하여 읽은 후 실제 코드를 게시합니다. 오류가 있으면 오류가 발생하고 데이터가 없으면 프로세스는 음수 값으로 종료하여 실패를 나타냅니다.


4
내용 길이 헤더가 올바르게 계산됩니까? 바이트라고 가정합니까?
Eric

7
참고 querystring.stringify() 중첩 된 개체를 지원하지 않습니다 사용할 수 있도록, qs.stringify()대신.
johndodo

51
Content-Length바이트이며 반드시 문자열 길이 일 필요는 없습니다 (UTF-16 등). 사용 Buffer.byteLength(data)은 항상 정확합니다.
greenimpala

4
표준 포스트 querystring.stringify데이터 를 전송하려면 객체 가이 답변에 표시되는 정크가 아닌 자신의 데이터 객체 여야합니다 (파일 기반 객체에 유용 할 수 있습니까?). 나는

7
문제 : SSL 암호화 사이트를 사용하는 경우 "https"라이브러리가 필요합니다. 포트를 443으로 변경할 수는 없습니다.
Dave Collins

1137

요청 라이브러리 를 사용하면 훨씬 쉬워집니다 .

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 install request


153
{form : {key : 'value'}}은 {json : {key : 'value'}}로 대체해야합니다 (질문이 양식에 국한되지 않기 때문에). 하나는 '형태'와 'JSON'을 이해 요청 라이브러리 키워드 및 사용자 정의 데이터의 일부입니다해야합니다 (이 마지막 코멘트가 나타날 수만큼 사소한, 그것은 ... 그림을 좀 시간이 걸렸)
blacelle

7
나는이 질문과 답변으로 계속 돌아옵니다. 그것은 실제로 질문에 대한 "답"이어야합니다.
스펜서 Kormos

6
이 답변에는 순전히 황금 배지가 필요합니다. 그것은 허용 된 것보다 훨씬 유용합니다 ... 2012 년에 이미 존재 했습니까? 와우
Zoltán Schmidt

3
'npm install --save request'명령을 실행하여 종속성을 추가해야 할 수도 있습니다
Shady Sherif

18
이 라이브러리는 더 이상 사용되지 않습니다.
Evorlor

138

요청 라이브러리를 사용할 수 있습니다. 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);
});

xml 데이터를 게시하려면

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

그들의 문서에서 검토 후. json-body를 설정하고 값의 JSON 표현으로 설정하고 Content-type : application / json header를 추가합니다. 또한 응답 본문을 JSON으로 구문 분석합니다. 즉, json = true 인 경우 헤더와 json 및 본문을 설정합니다. 그렇지 않으면 헤더가 설정되지 않고 텍스트로 구문 분석됩니다. (위의 XML 예제처럼). 따라서 요청 API가 편리하고 단순하지만 처음에는 이해하기가 어렵습니다.
Josiah Choi

기술적으로 문서에 있지만 예제는 양식 데이터 만 보여주지 않습니다. 이것은 건초 더미의 바늘이며, 따라서 JS에서 아약스를 사용하는 두 번째로 가장 빈번한 방법이며 웹에서 가장 일반적인 것 중 하나이기 때문에 큰 생략입니다.
Kyle Baker

request.post를 사용하면 POST를 메소드로 지정하는 것보다 IMO가 다소 좋습니다. 다음은 request.post를 사용하는 GitHub의
drorw

12
이 라이브러리는 더 이상 사용되지 않습니다.
Evorlor

44

생산 목적으로 RestlerNeedle 을 사용 합니다. 그것들은 네이티브 httprequest보다 훨씬 강력합니다. 기본 인증, 특수 헤더 항목 또는 파일 업로드 / 다운로드로 요청할 수 있습니다.

post / get 작업의 경우 httprequest를 사용하는 원시 ajax 호출보다 사용이 훨씬 간단합니다.

needle.post('https://my.app.com/endpoint', {foo:'bar'}, 
    function(err, resp, body){
        console.log(body);
});

요청 전에 node-form-data 및 superagent 요청을 시도했습니다. 여러 부분으로 된 양식 파일 업로드를 시도 할 때 needle이 나에게 올바르게 작동하는 유일한 도구였습니다.
Paul Young

35

간단하고 의존성이 없습니다. 약속을 사용하여 결과를 기다릴 수 있습니다. 응답 본문을 반환하고 응답 상태 코드를 확인하지 않습니다.

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

사용 write방법 은 무엇입니까 req,write()?
Ari

@Ari 그것은 요청의 본문을 쓴다 ... nodejs.org/api/…
mpen

21

nodeJS + 용으로 작성한 정말 시원하고 간단한 HTTP 클라이언트 인 Requestify 를 사용할 수 있습니다 . 캐싱을 지원합니다.

다음을 수행하십시오.

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

1
그것은 나를 위해 작동하지 않습니다, 여기에 문제를 참조하십시오 : github.com/ranm8/requestify/issues/2
Erel Segal-Halevi

20

2020 업데이트 :

난 정말 즐기고했습니다 망막 기억을 - 울트라 경량 Node.js를 HTTP 클라이언트를

두 가지 방법으로 사용할 수 있습니다. 하나는 약속 (Async / Await)이고 다른 하나는 전통적인 콜백 스타일입니다.

다음을 통해 설치하십시오. npm i phin

README에서 await다음을 사용하십시오 .

const p = require('phin')

await p({
    url: 'https://ethanent.me',
    method: 'POST',
    data: {
        hey: 'hi'
    }
})


확실하지 않은 (콜백) 스타일 :

const p = require('phin').unpromisified

p('https://ethanent.me', (err, res) => {
    if (!err) console.log(res.body)
})

현재 2,015 최소 코딩이 수행 할 수있는 다른 라이브러리의 다양한 해주기있다. 저수준 HTTP 항목에 대한 제어가 절대적으로 필요하지 않으면 HTTP 요청에 대해 우아한 경량 라이브러리를 선호합니다.

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

설치하려면를 사용하십시오 npm.
$ npm install unirest

그리고 Hello, World!모든 사람에게 익숙한 모범에.

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사용 한다는 점은 주목할 가치가 request있습니다.

Unirest는 요청 객체에 직접 액세스하기위한 메소드를 제공합니다.

예:

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

1
내가보기에 꽤 좋아 보이는 또 다른 하나는 github.com/request/request입니다. 이것은 적어도이 글을 쓰는 시점에서 unirest보다 조금 더 인기있는 것 같습니다
Lochlan

요청을 증명할 수 있습니다. 아주 좋은 도서관입니다. 요청이 더 낮은 수준의 기능을 제공하므로 특정 응용 프로그램에 사용하는 것이 좋습니다. 저수준의 물건을 신경 쓰지 않아도 Unirest가 적합하다는 것을 알았습니다.
Levi Roberts

요청에 따라 유니 레스트가 가벼운 것으로 간주되는 이유는 무엇입니까? 22 종속성을 자체를했다 요청, 나는이 경량 표시되지 않습니다
raphadko

@raphadko 나는 수년 동안 기능 팽창이 발생했다고 확신합니다. 나는 내 대답을 게시 할 때의 타임 스탬프를 확인해야합니다)
레위 로버츠

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

요청 또는 응답에서 요청 게시 본문을 보는 방법이 있습니까?
jacoballenwood 16:07에

17

Node에서 HTTP POST 요청을 작성하는 데 사용할 수있는 수십 개의 오픈 소스 라이브러리가 있습니다.

1. Axios (권장)

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

2. 바늘

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

3. 요청

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

4. 기본 HTTPS 모듈

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

자세한 내용은이 기사를 확인 하십시오 .


14

이것이 '요청'모듈을 사용하여 요청하는 가장 간단한 방법입니다.

'요청'모듈을 설치하는 명령 :

$ 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'모듈을 사용하여 요청을 할 수도 있습니다.


1
이 라이브러리는 더 이상 사용되지 않습니다.
유리 Tkachenko

12

나는 수퍼 에이전트의 단순성을 좋아합니다 ( 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가있는 node-fetch ( https://www.npmjs.com/package/node-fetch )도 있습니다. fetch그러나 수동 쿼리 문자열 인코딩이 필요하거나 컨텐츠 유형을 자동으로 처리하지 않습니다. 다른 작업 슈퍼 에이전트도 마찬가지입니다.


1
그리고 바늘, unirest 및 co와는 달리 경량으로 제공됩니다 (슈퍼 에이전트 : 16k, unirest : 1M, 바늘 : 530K)
Lars

9

약속 기반 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'})

6

휴식 / JSON 요청을 게시하려면
하기 요청 패키지를 사용하여 Json 변수에 보내야하는 값을 저장하면됩니다.

먼저 npm install request --save로 콘솔에 require 패키지를 설치하십시오

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

2
자체 쿼리 문자열을 작성하지 마십시오. 값을 올바르게 인코딩하지 않고 있습니다. Node.js는이 목적을위한 라이브러리를 가지고 있습니다 : nodejs.org/api/querystring.html
Brad

이 라이브러리는 더 이상 사용되지 않습니다.
유리 Tkachenko

4

이를 달성하는 방법을 설명하는 비디오를 찾았습니다 : https://www.youtube.com/watch?v=nuw48-u3Yrg

"querystring"및 "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);

4

이 내 솔루션 POSTGET.

[정보] Post방법 :

본문이 JSON 객체 인 경우 직렬화를 해제하고 이에 따라 헤더를 JSON.stringify설정하는 것이 중요합니다 Content-Lenght.

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

요청에 쓰기 전에 :

request.write( bodyString );

GetPost방법에 대한 정보 :

timeoutA와 발생할 수 socket분리, 그래서 당신은 핸들러 등을 등록해야합니다 :

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핸들러입니다

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

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

응답 본문이 청크되므로 data처리기 에서 청크를 연결해야 합니다.

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

상기 endbody전체 응답 본문을 포함합니다 :

      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인지 확실하지 않으며 요청을 할 때 그것을 확신 할 수있는 방법이 없기 때문에 try... catch theJSON.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') );
    });

4

게시물을 처리하고 프로젝트에 대한 요청을 받기 위해 저수준 유틸리티를 만드는 동안 많은 어려움을 겪은 후 여기에 노력을 게시하기로 결정했습니다. 허용 된 답변의 줄에 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
    });

}

2
직렬화 된 post_data? js 객체로 쓰는 것이 기본적으로 버퍼로 변환됩니까?
ThatBrianDude

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

request라이브러리는 더 이상 사용되지 않습니다.
유리 Tkachenko

3

Axios는 브라우저 및 Node.js를위한 약속 기반 HTTP 클라이언트입니다. Axios를 사용하면 비동기 HTTP 요청을 REST 엔드 포인트로 쉽게 보내고 CRUD 작업을 수행 할 수 있습니다. 일반 JavaScript 또는 Vue 또는 React와 같은 라이브러리와 함께 사용할 수 있습니다.

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

2

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

var postData = {
  email: "test@test.com",
  password: "password"
};

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

axios.post('http://<host>:<port>/<path>', postData, axiosConfig)
.then((res) => {
  console.log("RESPONSE RECEIVED: ", res);
})
.catch((err) => {
  console.log("AXIOS ERROR: ", err);
})


0

요청 종속성 을 사용 합니다.

간단한 해결책 :

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

3
어디에서 request왔습니까?
CodyBugstein

이 라이브러리는 더 이상 사용되지 않습니다.
유리 Tkachenko

0

Request-Promise약속 기반 응답을 제공합니다. 2xx 이외의 http 응답 코드는 약속을 거부합니다. options.simple = false를 설정하여 덮어 쓸 수 있습니다.

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...
});
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.