Bagaimana permintaan HTTP POST dibuat di node.js?


946

Bagaimana saya bisa membuat permintaan HTTP POST keluar, dengan data, di node.js?


16
Seperti yang disarankan dalam jawaban Jed Watson , saya sangat merekomendasikan menggunakan permintaan kecuali Anda sedang menulis API tingkat rendah.
namuol

4
Anda bisa menggunakan node-fetchyang merupakan implementasi dari fetchmetode JavaScript asli untuk membuat permintaan HTTP.
Fez Vrasta

Posting ini mencakup skenario penggunaan dasar untuk menggunakan permintaan. blog.modulus.io/node.js-tutorial-how-to-use-request-module
Shaswat Rungta

Kemungkinan duplikat Langkah
Abhijeet

Jawaban:


855

Berikut adalah contoh penggunaan node.js untuk membuat permintaan POST ke Google Compiler API:

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

Saya telah memperbarui kode untuk menunjukkan cara memposting data dari file, alih-alih string yang dikodekan. Ini menggunakan fs.readFileperintah async untuk mencapai ini, memposting kode aktual setelah berhasil dibaca. Jika ada kesalahan, itu dilemparkan, dan jika tidak ada data proses keluar dengan nilai negatif untuk menunjukkan kegagalan.


4
Apakah tajuk panjang konten dihitung dengan benar? Seharusnya byte, kan?
Eric

7
Catatan yang querystring.stringify() tidak mendukung objek bersarang , jadi Anda mungkin ingin menggunakannya qs.stringify().
johndodo

51
Content-Lengthadalah byte dan tidak harus panjang string (UTF-16 dll). Menggunakan Buffer.byteLength(data)akan selalu benar.
greenimpala

4
untuk mengirim postdata standar, objek di querystring.stringifyharus objek data Anda sendiri, bukan sampah yang ditampilkan dalam jawaban ini (yang mungkin berguna untuk objek berbasis file?). Saya terjebak pada hal itu selama berabad-abad ... stackoverflow.com/questions/9768192/… memberikan solusi lengkap saya
RozzA

7
Gotcha: Jika Anda menggunakan situs terenkripsi ssl, Anda memerlukan pustaka "https". Anda tidak bisa mengubah porta menjadi 443.
Dave Collins

1137

Ini menjadi jauh lebih mudah jika Anda menggunakan perpustakaan permintaan .

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

Selain menyediakan sintaksis yang bagus, permintaan json mudah, menangani penandatanganan otomatis (untuk twitter, dll.), Dapat melakukan formulir multi-bagian (misalnya untuk mengunggah file) dan streaming.

Untuk menginstal permintaan gunakan perintah npm install request


153
{form: {key: 'value'}} harus diganti oleh {json: {key: 'value'}} (karena pertanyaannya tidak spesifik untuk formulir). Kita juga harus mengerti 'form' dan 'json' adalah permintaan kata kunci perpustakaan dan bukan bagian dari data khusus (sepele seperti komentar terakhir ini bisa muncul, butuh beberapa waktu untuk mencari tahu ...)
blacelle

7
Saya terus kembali ke pertanyaan dan jawaban ini. Itu benar-benar harus menjadi "jawaban" untuk pertanyaan itu.
Spencer Kormos

6
Anda berhak mendapatkan lencana emas murni untuk jawaban ini. Ini jauh lebih berguna daripada yang diterima ... dan sudah ada kembali pada tahun 2012? Wow
Zoltán Schmidt

3
Anda mungkin perlu menambahkan ketergantungan dengan menjalankan perintah ini 'npm install --save request'
Shady Sherif

18
Perpustakaan ini sudah usang.
Evorlor

138

Anda dapat menggunakan perpustakaan permintaan. https://www.npmjs.com/package/request

var request = require('request');

Untuk mengirim data JSON:

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

Untuk mengirim data 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);
});

Setelah ditinjau dalam dokumentasi mereka. ini menyatakan sebagai berikut: json - menetapkan tubuh tetapi untuk representasi nilai JSON dan menambahkan tipe konten: header aplikasi / json. Selain itu, parsing badan respons sebagai JSON. Itu berarti ketika json = true, itu akan mengatur header dan json dan tubuh. Jika tidak, tidak ada tajuk yang ditetapkan, dan diurai sebagai teks. (Seperti contoh XML di atas). Itu membuat API permintaan berguna dan sederhana tetapi cukup sulit untuk dipahami pada saat pertama.
Josiah Choi

Secara teknis dalam dokumen mereka, tetapi tidak ada contoh yang menunjukkannya - hanya berupa data. Ini adalah jarum di tumpukan jerami, dan dengan demikian, itu adalah peninggalan besar, karena ini adalah cara kedua yang paling sering saya gunakan ajax di JS, pernah, dan tentu saja salah satu yang paling umum di web.
Kyle Baker

Menggunakan request.post adalah IMO agak lebih bagus daripada menetapkan POST sebagai metode. Berikut adalah beberapa contoh dari GitHub untuk menggunakan request.post
drorw

12
Perpustakaan ini sudah usang.
Evorlor

44

Saya menggunakan Restler dan Needle untuk keperluan produksi. Keduanya jauh lebih kuat daripada httprequest asli. Dimungkinkan untuk meminta dengan otentikasi dasar, entri tajuk khusus atau bahkan mengunggah / mengunduh file.

Adapun operasi pasca / dapatkan, mereka juga jauh lebih mudah digunakan daripada panggilan ajax mentah menggunakan httprequest.

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

Saya mencoba permintaan, node-form-data dan superagent sebelum jarum. jarum adalah satu-satunya yang bekerja dengan benar untuk saya ketika mencoba melakukan unggahan file bentuk multi-bagian.
Paul Young

35

Sederhana dan bebas ketergantungan. Gunakan Janji sehingga Anda bisa menunggu hasilnya. Ini mengembalikan tubuh respons dan tidak memeriksa kode status respons.

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

Pemakaian:

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

Untuk apa writemetode req,write()digunakan?
Ari

@Ari Itu menulis isi permintaan ... nodejs.org/api/…
mpen

21

Anda juga dapat menggunakan Requestify , klien HTTP yang benar-benar keren dan sederhana yang saya tulis untuk nodeJS + yang mendukung caching.

Lakukan saja hal berikut:

    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
Tidak berfungsi untuk saya, lihat masalah di sini: github.com/ranm8/requestify/issues/2
Erel Segal-Halevi

20

Pembaruan 2020:

Saya benar-benar menikmati phin - klien HTTP Node.js yang sangat ringan

Ini dapat digunakan dalam dua cara berbeda. Satu dengan Janji (Async / Menunggu) dan yang lainnya dengan gaya panggilan balik tradisional.

Instal melalui: npm i phin

Langsung dari README dengan await:

const p = require('phin')

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


Gaya tidak dipanggil (panggilan balik):

const p = require('phin').unpromisified

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

Pada 2015 sekarang ada berbagai perpustakaan yang berbeda yang dapat melakukan ini dengan pengkodean minimal. Saya lebih suka pustaka ringan yang elegan untuk permintaan HTTP kecuali Anda benar-benar membutuhkan kontrol dari hal-hal HTTP tingkat rendah.

Salah satu perpustakaan tersebut adalah Unirest

Untuk menginstalnya, gunakan npm.
$ npm install unirest

Dan menjadi Hello, World!contoh bahwa semua orang terbiasa.

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:
Banyak orang juga menyarankan penggunaan permintaan [2]

Perlu dicatat bahwa di balik layar Unirestmenggunakanrequest perpustakaan.

Unirest menyediakan metode untuk mengakses objek permintaan secara langsung.

Contoh:

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

1
Satu lagi yang saya temukan yang terlihat cukup bagus adalah github.com/request/request yang tampaknya sedikit lebih populer daripada yang paling tidak menarik pada saat tulisan ini dibuat
Lochlan

Saya bisa membuktikan permintaan. Ini adalah perpustakaan yang sangat bagus. Saya menemukan bahwa permintaan menyediakan fungsionalitas tingkat rendah yang lebih banyak sehingga sangat tepat untuk menggunakannya untuk aplikasi tertentu. Ketika saya tidak perlu peduli dengan hal-hal tingkat rendah, saya menemukan Unirest cukup.
Levi Roberts

Mengapa unirest dianggap ringan ketika itu tergantung pada permintaan? Permintaan itu sendiri memiliki 22 dependensi, saya tidak melihat bagaimana ini ringan
raphadko

@raphadko Saya yakin bahwa selama bertahun-tahun fitur mengasapi telah terjadi. Pastikan untuk memeriksa stempel waktu ketika saya memposting jawaban saya;)
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);
});

apakah ada cara untuk melihat isi posting permintaan baik pada permintaan atau tanggapan?
jacoballenwood

17

Ada puluhan pustaka sumber terbuka yang bisa Anda gunakan untuk membuat permintaan HTTP POST di Node.

1. Axios (Disarankan)

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

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

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. Modul HTTPS Asli

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

Untuk detailnya, lihat artikel ini .


14

Ini adalah cara paling sederhana yang saya gunakan untuk membuat permintaan: menggunakan modul 'permintaan'.

Perintah untuk menginstal modul 'permintaan':

$ npm install request

Kode contoh:

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)

});

Anda juga dapat menggunakan modul 'http' bawaan Node.js untuk mengajukan permintaan.


1
Perpustakaan ini sudah usang.
Yuri Tkachenko

12

Saya suka kesederhanaan superagent ( https://github.com/visionmedia/superagent ). API yang sama di kedua node dan browser.

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

Ada juga pengambilan simpul ( https://www.npmjs.com/package/node-fetch ), yang memiliki API yang cocok fetchdengan peramban - namun ini memerlukan pengodean string kueri manual, tidak secara otomatis menangani jenis konten, atau jadi salah satu dari superagent pekerjaan lain tidak.


1
Dan berbeda dengan jarum, unirest dan co, itu memberikan menjadi ringan (superagent: 16k, unirest: 1M, jarum: 530K)
Lars

9

Jika Anda mencari permintaan HTTP berdasarkan janji, aksioma melakukan tugasnya dengan baik.

  const axios = require('axios');

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

ATAU

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

6

Untuk Posting Istirahat / Permintaan JSON
Kita cukup menggunakan paket permintaan dan menyimpan nilai-nilai yang harus kita kirim dalam variabel Json.

Pertama instal paket yang diperlukan di konsol Anda dengan npm install request --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)
               }
    );

2
Jangan pernah membangun string kueri Anda sendiri. Anda lalai menyandikan nilai-nilai Anda dengan benar. Node.js memiliki perpustakaan untuk tujuan ini: nodejs.org/api/querystring.html
Brad

Perpustakaan ini sudah usang.
Yuri Tkachenko

4

Saya menemukan video yang menjelaskan cara mencapai ini: https://www.youtube.com/watch?v=nuw48-u3Yrg

Ini menggunakan modul "http" bersama dengan modul "querystring" dan "stringbuilder". Aplikasi mengambil dua angka (menggunakan dua kotak teks) dari halaman web dan setelah mengirimkan, mengembalikan jumlah dari dua (bersama dengan mempertahankan nilai-nilai dalam kotak teks). Ini adalah contoh terbaik yang bisa saya temukan di tempat lain.

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

Ini solusi saya untuk POSTdan GET.

Tentang Postmetode ini:

Jika tubuh adalah objek JSON, jadi penting untuk deserialize dengan JSON.stringifydan mungkin mengatur Content-Lenghtheader sesuai:

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

sebelum menuliskannya ke permintaan:

request.write( bodyString );

Tentang keduanya Getdan Postmetode:

The timeoutdapat terjadi sebagaisocket putuskan, sehingga Anda harus mendaftar handler-nya seperti:

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

sedangkan requestpawang

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

Saya sangat menyarankan untuk mendaftarkan kedua penangan.

Badan respons terpotong, jadi Anda harus menyumbang potongan pada datapawang:

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

Pada bagian endyang bodyakan berisi seluruh badan respons:

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

Aman untuk dibungkus dengan try... catch theJSON.parse` karena Anda tidak dapat memastikan bahwa itu adalah json yang diformat dengan baik sebenarnya dan tidak ada cara untuk memastikannya pada saat Anda melakukan permintaan.

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

Pemakaian:

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

Setelah banyak berjuang sambil menciptakan utilitas tingkat rendah untuk menangani posting dan mendapatkan permintaan untuk proyek saya, saya memutuskan untuk mengirim upaya saya di sini. Banyak jawaban yang diterima, berikut adalah cuplikan untuk membuat http dan https permintaan POST untuk mengirim data JSON.

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
Anda tidak pernah menggunakan post_data berseri? apakah menulis sebagai objek js dikonversi ke buffer secara default?
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);
});

Atau Anda dapat menggunakan perpustakaan ini:

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

requestperpustakaan telah ditinggalkan.
Yuri Tkachenko

3

Axios adalah klien HTTP berbasis janji untuk browser dan Node.js. Axios memudahkan untuk mengirim permintaan HTTP asinkron ke titik akhir REST dan melakukan operasi CRUD. Ini dapat digunakan dalam JavaScript biasa atau dengan perpustakaan seperti Vue atau 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

Memposting contoh aksioma lain dari permintaan axios.post yang menggunakan opsi konfigurasi tambahan dan header kustom.

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

Dengan menggunakan permintaan ketergantungan .

Solusi sederhana:

 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
mana requestberasal?
CodyBugstein

Perpustakaan ini sudah usang.
Yuri Tkachenko

0

Request-PromiseMemberikan respons berdasarkan janji. Kode respons http selain 2xx akan menyebabkan janji ditolak. Ini dapat ditimpa dengan mengatur 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...
});
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.