Node.js'de bir HTTP POST isteği nasıl yapılır?


946

Node.js dosyasında verileri içeren bir HTTP POST isteğini nasıl yapabilirim?


16
Jed Watson'ın cevabında önerildiği gibi , düşük seviyeli bir API yazmadığınız sürece istek kullanmanızı şiddetle tavsiye ederim .
namuol

4
Sadece HTTP istekleri yapmak node-fetchiçin yerel fetchJavaScript yönteminin bir uygulaması olan kullanabilirsiniz .
Fez Vrasta

Bu yazı, isteği kullanma ile ilgili temel kullanım senaryolarını kapsar. blog.modulus.io/node.js-tutorial-how-to-use-request-module
Shaswat Rungta

Yanıtlar:


855

Google Derleyici API'sından POST isteği yapmak için node.js kullanımına bir örnek:

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

Sabit kodlu dize yerine bir dosyadan nasıl veri gönderileceğini göstermek için kodu güncelledim. Bunu fs.readFilebaşarmak için async komutunu kullanır ve başarılı bir okumadan sonra gerçek kodu gönderir. Bir hata varsa, atılır ve veri yoksa, işlemin arızayı belirtmek için negatif bir değerle çıkar.


4
İçerik uzunluğu başlığı doğru hesaplanmış mı? Bayt olması gerekiyordu, değil mi?
Eric

7
Not querystring.stringify() iç içe nesneleri desteklemez Kullanmak isteyebilirsiniz böylece, qs.stringify()bunun yerine.
johndodo

51
Content-Lengthbayttır ve dize uzunluğu olması gerekmez (UTF-16 vb.). Kullanımı Buffer.byteLength(data)her zaman doğru olacaktır.
greenimpala

4
standart postdata göndermek için, içindeki nesnenin querystring.stringifybu cevapta görüntülenen önemsiz değil (veri tabanlı nesneler için yararlı olabilir mi?) kendi veri nesneniz olması gerekir.
Yaşlarımda

7
Gotcha: SSL şifreli bir site kullanıyorsanız, "https" kütüphanesine ihtiyacınız olacaktır. Bağlantı noktasını 443 olarak değiştiremezsiniz
Dave Collins

1137

İstek kitaplığını kullanırsanız bu çok daha kolay olur .

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

Güzel bir sözdizimi sağlamanın yanı sıra, json isteklerini kolaylaştırır, oauth imzalamayı (twitter vb. İçin) işler, çok parçalı formlar (örneğin dosya yüklemek için) ve akış gerçekleştirebilir.

İsteği yüklemek için komutunu kullanın npm install request


153
{form: {key: 'value'}}, {json: {key: 'value'}} ile değiştirilmelidir (soru formlara özgü olmadığından). Bir de 'form' ve 'json', özel verilerin bir parçası değil, istek kitaplığı anahtar kelimeleri olduğunu anlamak zorunda (bu son yorum görünebilir gibi önemsiz, anlamaya biraz zaman aldı ...)
blacelle

7
Bu soruya cevap vermeye devam ediyorum. Sorunun cevabı gerçekten "" olmalıdır.
Spencer Kormos

6
Sadece bu cevap için altın bir rozet hak ediyorsun. Kabul edilenden çok daha yararlı ... ve 2012'de zaten var mı? Vay canına
Zoltán Schmidt

3
'npm install --save request' komutunu çalıştırarak bağımlılık eklemeniz gerekebilir
Shady Sherif

18
Bu kütüphane kullanımdan kaldırıldı.
Evorlor

138

İstek kitaplığını kullanabilirsiniz. https://www.npmjs.com/package/request

var request = require('request');

JSON verilerini yüklemek için:

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

Xml verilerini yüklemek için:

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

Belgelerinde inceledikten sonra. json - gövdeyi ancak değerin JSON temsiline ayarlar ve Content-type: application / json header öğesini ekler. Ayrıca, yanıt gövdesini JSON olarak ayrıştırır. Bu, json = true olduğunda, üstbilgi, json ve gövde ayarlayacağı anlamına gelir. Aksi takdirde, başlık ayarlanmaz ve metin olarak ayrıştırılır. (Yukarıdaki XML örneği gibi). Bu, istek API'sini kullanışlı ve basit hale getirir, ancak ilk kez anlaşılması oldukça zordur.
Josiah Choi

Teknik olarak dokümanlarındadır, ancak örneklerin hiçbiri bunu göstermez - sadece form verileri. Samanlıkta bir iğne ve bu nedenle, büyük bir ommisyon, çünkü bu JS'de ajax'ı şimdiye kadar kullandığım ikinci en sık yol ve kesinlikle web'de en yaygın olanlardan biri.
Kyle Baker

Request.post kullanmak, yöntem olarak POST belirtmekten biraz IMO'dur. GitHub'dan request.post
drorw

12
Bu kütüphane kullanımdan kaldırıldı.
Evorlor

44

Kullandığım Restler ve İğne üretim amaçlı. Her ikisi de yerel httprequest'ten çok daha güçlüdür. Temel kimlik doğrulama, özel başlık girişi veya hatta dosya yükleme / indirme ile istekte bulunmak mümkündür.

Post / get işlemi ile ilgili olarak, httprequest kullanarak ham ajax çağrılarına göre kullanımı çok daha basittir.

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

İğne öncesi istek, düğüm-form-veri ve süper-denemeyi denedim. iğne, çok parçalı bir form dosyası yüklemesi yapmaya çalışırken benim için doğru çalışan tek kişiydi.
Paul Young

35

Basit ve bağımlılık içermez. Sonucu beklemeniz için bir Söz kullanır. Yanıt gövdesini döndürür ve yanıt durum kodunu kontrol etmez.

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

Kullanımı:

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

Ne için writeyöntem req,write()kullanılır?
Ari

@Ari Bu isteğin gövdesini yazar ... nodejs.org/api/…
mpen

21

Ayrıca kullanabilirsiniz Requestify , ben nodeJS için yazdığı gerçekten serin ve basit bir HTTP istemcisi + önbelleğe almayı destekler.

Sadece aşağıdakileri yapın:

    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
Benim için işe yaramıyor, sorunu buradan görebilirsiniz: github.com/ranm8/requestify/issues/2
Erel Segal-Halevi

20

2020 Güncellemesi:

Phin gerçekten keyif aldım - Ultra hafif Node.js HTTP istemcisi

İki farklı şekilde kullanılabilir. Biri Promises (Async / Await) ve diğeri geleneksel geri arama stilleri.

Yükleme yöntemi: npm i phin

Doğrudan README'den await:

const p = require('phin')

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


Korumasız (geri arama) stili:

const p = require('phin').unpromisified

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

2015 itibariyle, bunu minimal kodlamayla başarabilen çok çeşitli kütüphaneler var. Ben kesinlikle düşük seviye HTTP şeyler kontrol gerekmedikçe HTTP istekleri için zarif hafif kütüphaneleri tercih ederim.

Böyle bir kütüphane Unirest

Kurmak için kullanın npm.
$ npm install unirest

Ve Hello, World!herkesin alışkın olduğu örnek üzerine .

var unirest = require('unirest');

unirest.post('http://example.com/helloworld')
.header('Accept', 'application/json')
.send({ "Hello": "World!" })
.end(function (response) {
  console.log(response.body);
});


Ekstra:
Pek çok kişi de istek kullanımını öneriyor [2]

Perde arkasında kütüphaneyi Unirestkullandığını belirtmek gerekir request.

Unirest, istek nesnesine doğrudan erişmek için yöntemler sağlar.

Misal:

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

1
Oldukça iyi bulduğum bir diğeri, en azından bu yazıdan itibaren en unirest'ten biraz daha popüler gibi görünen github.com/request/request.
Lochlan

Talep edebilirim. Çok iyi bir kütüphane. Bu isteğin daha düşük düzeyde işlevsellik sağladığını ve bu nedenle belirli uygulamalar için kullanılmasının uygun olduğunu düşünüyorum. Düşük seviyeli şeyleri önemsemediğim zaman, Unirest'i yeterli buluyorum.
Levi Roberts

İsteğe bağlı olduğunda neden unirest hafif kabul edilir?
İsteğin

@raphadko Eminim yıllar geçtikçe bir özellik şişkinliği yaşandı. Cevabımı gönderdiğim zaman damgasını kontrol ettiğinizden emin olun;)
Levi Roberts

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

istek gönderisi gövdesini istekte veya yanıtta görüntülemenin bir yolu var mı?
jacoballenwood

17

Düğümde bir HTTP POST isteği yapmak için kullanabileceğiniz düzinelerce açık kaynaklı kütüphane bulunmaktadır.

1. Axios (Önerilen)

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. İğne

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. Talep

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. Yerel HTTPS Modülü

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

Ayrıntılar için bu makaleye göz atın .


14

İstek yapmak için kullandığım en basit yol budur: 'request' modülünü kullanmak.

'İstek' modülünü kurma komutu:

$ npm install request

Örnek kod:

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)

});

İstekte bulunmak için Node.js'nin yerleşik 'http' modülünü de kullanabilirsiniz.


1
Bu kütüphane kullanımdan kaldırıldı.
Yuri Tkachenko

12

Superagent'ın basitliğini seviyorum ( https://github.com/visionmedia/superagent ). Hem düğümde hem de tarayıcıda aynı API.

;(async function() {
  var response = await superagent.post('http://127.0.0.1:8125/', {age: 2})
  console.log(response)
})

Tarayıcılardan eşleşen bir API'ya sahip olan düğüm getirme ( https://www.npmjs.com/package/node-fetch ) vardır fetch- ancak bu, manuel sorgu dizesi kodlaması gerektirir, içerik türlerini otomatik olarak işlemez veya böylece diğer herhangi bir süper emekli çalışır.


1
Ve iğne, en unir ve co'nun aksine, hafif olmayı sağlar (süper: 16k, en unirest: 1M, iğne: 530K)
Lars

9

Söz tabanlı HTTP istekleri arıyorsanız, axios işini güzel yapıyor.

  const axios = require('axios');

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

VEYA

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

6

Dinlenme / JSON İsteğini Göndermek İçin
İstek paketini kullanabilir ve Json değişkeninde göndermemiz gereken değerleri kaydedebiliriz.

Önce gerekli paketi npm kurulum isteği ile konsolunuza kurun - kaydet

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
Asla kendi sorgu dizenizi oluşturmayın. Değerlerinizi doğru şekilde kodlamayı ihmal ediyorsunuz. Node.js'nin
Brad

Bu kütüphane kullanımdan kaldırıldı.
Yuri Tkachenko

4

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ğerlere devam etmekle birlikte). Bu, başka bir yerde bulabileceğim en iyi örnek.

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

Bu benim POSTve benim çözümüm GET.

Hakkında Postyöntemle:

Gövde bir JSON nesnesiyse, nesneyi serileştirmek JSON.stringifyve muhtemelen Content-Lenghtüstbilgiyi buna göre ayarlamak önemlidir :

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

talebe yazmadan önce:

request.write( bodyString );

Hem Hakkında Getve Postyöntemlere:

timeoutBir şekilde oluşabilir socketkesmek, böylece onun işleyicisi gibi kaydetmeniz gerekir:

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

requestişleyici iken

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

Her iki işleyiciyi de kaydetmenizi şiddetle tavsiye ediyorum.

Yanıt gövdesi yığınlanmıştır, bu nedenle dataişleyicideki yığınları birleştirmelisiniz :

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

At bütün tepki vücudu içerecektir: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());
        }
      });

Aslında iyi biçimlendirilmiş bir json olduğundan emin olamadığından ve isteği yaptığınızda emin olmanın bir yolu olmadığından try... yakalamak theJSON.parse` ile sarmak güvenlidir .

Modül: 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);

Kullanımı:

// 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

Postayı ele almak ve projem için istek almak için düşük seviyeli bir yardımcı program oluştururken çok uğraştıktan sonra, çabalarımı buraya göndermeye karar verdim. Kabul edilen cevap satırlarında, JSON verilerini göndermek için http ve https POST istekleri yapmak için bir snippet.

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
Serileştirilmiş post_data'yı hiç kullanmadınız mı? js nesnesi olarak yazmak varsayılan olarak arabelleğe dönüşüyor mu?
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);
});

Veya bu kütüphaneyi kullanabilirsiniz:

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

requestkitaplık kullanımdan kaldırıldı.
Yuri Tkachenko

3

Axios, tarayıcı ve Node.js için vaat tabanlı bir HTTP istemcisidir. Axios, REST uç noktalarına eşzamansız HTTP istekleri göndermeyi ve CRUD işlemlerini kolaylaştırır. Düz JavaScript'te veya Vue veya React gibi bir kitaplıkla kullanılabilir.

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

Ek yapılandırma seçenekleri ve özel üstbilgiler kullanan axios.post isteğine başka bir axios örneği gönderme.

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

İstek bağımlılığını kullanarak .

Basit çözüm:

 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
nereden requestgeliyor
CodyBugstein

Bu kütüphane kullanımdan kaldırıldı.
Yuri Tkachenko

0

Request-PromiseSöz bazlı yanıt verir. 2xx dışındaki http yanıt kodları sözün reddedilmesine neden olur. Bunun üzerine options.simple = false ayarlanarak yazılabilir.

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...
});
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.