एक HTTP POST अनुरोध नोड.जेएस में कैसे किया जाता है?


945

मैं डेटा के साथ, नोड.जेएस में एक आउटबाउंड HTTP पोस्ट अनुरोध कैसे बना सकता हूं?


16
जैसा कि जेड वॉटसन के जवाब में सुझाया गया है , मैं अनुरोध का उपयोग करने की दृढ़ता से सलाह दूंगा जब तक कि आप निम्न-स्तरीय एपीआई नहीं लिख रहे हों।
नामुलोल

4
आप बस उसी का उपयोग कर सकते हैं node-fetchजो fetchHTTP अनुरोध करने के लिए देशी जावास्क्रिप्ट पद्धति का कार्यान्वयन है ।
Fez Vrasta

यह पोस्ट अनुरोध का उपयोग करने के लिए मूल उपयोग परिदृश्यों को शामिल करती है। blog.modulus.io/node.js-tutorial-how-to-use-request-module
शास्वत रूंगटा

जवाबों:


855

Google कंपाइलर API के लिए POST अनुरोध करने के लिए node.js का उपयोग करने का एक उदाहरण यहां दिया गया है:

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

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

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

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

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

}

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

मैंने कोड को अपडेट किया है कि हार्डकोड स्ट्रिंग के बजाय किसी फ़ाइल से डेटा कैसे पोस्ट किया जाए, यह दिखाने के लिए। इसे fs.readFileप्राप्त करने के लिए यह async कमांड का उपयोग करता है , एक सफल पढ़ने के बाद वास्तविक कोड को पोस्ट करना। यदि कोई त्रुटि है, तो इसे फेंक दिया जाता है, और यदि कोई डेटा नहीं है तो प्रक्रिया विफलता को इंगित करने के लिए एक नकारात्मक मान के साथ बाहर निकलती है।


4
क्या कंटेंट-लेंथ हेडर की सही गणना की गई है? बाइट्स माना जाता है, है ना?
एरिक

7
ध्यान दें कि querystring.stringify() नेस्टेड ऑब्जेक्ट का समर्थन नहीं करता है , इसलिए आप qs.stringify()इसके बजाय उपयोग करना चाह सकते हैं ।
जॉन्डोडो

51
Content-Lengthबाइट्स और जरूरी नहीं कि स्ट्रिंग लेंथ (UTF-16 आदि) हो। उपयोग Buffer.byteLength(data)करना हमेशा सही होगा।
हरियालीवाला

4
मानक पोस्टडेटा भेजने के लिए, ऑब्जेक्ट querystring.stringifyआपके स्वयं के डेटा ऑब्जेक्ट होना चाहिए, न कि इस उत्तर में प्रदर्शित रद्दी (जो फ़ाइल आधारित ऑब्जेक्ट के लिए उपयोगी हो सकता है?)। मैं उम्र के लिए उस पर अटक गया था ... stackoverflow.com/questions/9768192/… ने मेरा पूरा समाधान उपलब्ध कराया
RozzA

7
Gotcha: यदि आप ssl-एन्क्रिप्टेड साइट का उपयोग कर रहे हैं, तो आपको "https" लाइब्रेरी की आवश्यकता होगी। आप पोर्ट को केवल 443 में नहीं बदल सकते।
डेवि कोलिन्स

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
मैं इस सवाल और जवाब पर वापस आता रहता हूं। यह वास्तव में प्रश्न का उत्तर "" होना चाहिए।
स्पेंसर कोरमोस

6
आप इस जवाब के लिए पूरी तरह से एक सुनहरा बिल्ला चाहते हैं। यह स्वीकृत एक की तुलना में बहुत अधिक उपयोगी है ... और यह 2012 में पहले से ही अस्तित्व में था? वाह
ज़ोल्टन श्मिट

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 - शरीर सेट करता है, लेकिन JSON के मान का प्रतिनिधित्व करता है और सामग्री-प्रकार जोड़ता है: अनुप्रयोग / json हैडर। इसके अतिरिक्त, JSON के रूप में प्रतिक्रिया निकाय को पार्स करता है। इसका मतलब है कि जब json = true, यह हेडर और json और बॉडी सेट करेगा। अन्यथा, कोई हेडर सेट नहीं है, और पाठ के रूप में पार्स करें। (उपरोक्त XML उदाहरण की तरह)। यह अनुरोध एपीआई को सरल और सरल बनाता है लेकिन पहली बार में समझने में काफी कठिन है।
जोशियाह चोई

यह तकनीकी रूप से उनके डॉक्स में है, लेकिन कोई भी उदाहरण यह नहीं दिखाता है - केवल डेटा बनाते हैं। यह हिस्टैक में एक सुई है, और इस तरह, यह एक विशाल गर्भाधान है, क्योंकि यह दूसरा सबसे लगातार तरीका है जो मैं जेएस में अजाक्स का उपयोग करता हूं, कभी भी, और निश्चित रूप से वेब पर सबसे आम में से एक है।
काइल बेकर

रिक्वेस्ट का उपयोग करना। पोस्ट के रूप में पोस्ट को निर्दिष्ट करने की तुलना में IMO कुछ हद तक अच्छा है। यहाँ GitHub से request.post का उपयोग करने के
drorw

12
इस पुस्तकालय को हटा दिया गया है।
Evorlor

44

मैं उत्पादन उद्देश्यों के लिए रेस्लर और सुई का उपयोग करता हूं । वे देशी निंदकों की तुलना में बहुत अधिक शक्तिशाली हैं। मूल प्रमाणीकरण, विशेष हेडर प्रविष्टि या यहां तक ​​कि अपलोड / डाउनलोड फ़ाइलों के साथ अनुरोध करना संभव है।

पोस्ट / ऑपरेशन के लिए के रूप में, वे भी स्पष्ट ajax कॉल की तुलना में उपयोग करने के लिए अधिक सरल हैं।

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

मैंने सुई से पहले अनुरोध, नोड-फॉर्म-डेटा और सुपरएगेंट की कोशिश की। मल्टीपर्ट फॉर्म फाइल अपलोड करने की कोशिश के दौरान सुई केवल एक ही थी जो मेरे लिए सही ढंग से काम करती थी।
पॉल यंग

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 राईट अनुरोध के शरीर ... यही कारण है कि nodejs.org/api/...
mpen

21

तुम भी उपयोग कर सकते हैं Requestify , एक बहुत शांत और सरल HTTP ग्राहक मैं NodeJS के लिए लिखा था + यह कैशिंग का समर्थन करता है।

बस निम्नलिखित करें:

    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

इसके साथ सीधे इसे पढ़ें 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)
})

के रूप में 2015 वहाँ अब विभिन्न पुस्तकालयों कि कम से कम कोडिंग के साथ ऐसा कर सकते हैं की एक विस्तृत विविधता है। जब तक आपको बिल्कुल निम्न स्तर के 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 पर्याप्त है।
लेवी रॉबर्ट्स

जब अनुरोध पर निर्भर करता है, तो यह क्यों हल्का होगा? अनुरोध में स्वयं 22 निर्भरताएं हैं, मैं यह नहीं देखता कि यह कितना हल्का है
रेपचाको

@ प्रपेडको मुझे यकीन है कि पिछले कुछ वर्षों में ब्लोट हुआ है। जब मैंने अपना उत्तर पोस्ट किया हो, तो टाइमस्टैम्प की जांच अवश्य करें;
लेवी रॉबर्ट्स

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

क्या अनुरोध या प्रतिक्रिया पर अनुरोध पोस्ट बॉडी को देखने का कोई तरीका है?
याकूबलेनवुड

17

दर्जनों ओपन-सोर्स लाइब्रेरी उपलब्ध हैं जिनका उपयोग आप नोड में HTTP POST अनुरोध करने के लिए कर सकते हैं।

1. अक्ष (अनुशंसित)

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. मूल एचटीटीपीएस मॉड्यूल

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
इस पुस्तकालय को हटा दिया गया है।
यूरी टेकचेंको

12

मुझे सुपरगेंट ( https://github.com/visionmedia/superagent ) की सादगी पसंद है । नोड और ब्राउज़र दोनों पर समान एपीआई।

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

नोड-भ्रूण ( https://www.npmjs.com/package/node-fetch ) भी है, जिसमें एक एपीआई है जो fetchब्राउज़र से मेल खाता है - हालांकि इसके लिए मैन्युअल क्वेरी स्ट्रिंग एन्कोडिंग की आवश्यकता होती है, स्वचालित रूप से सामग्री प्रकारों को संभाल नहीं करता है, या तो किसी भी अन्य काम की अतिशयोक्ति करता है।


1
और सुई के विपरीत, निर्विवाद और सह, यह हल्के होने पर प्रदान करता है (अतिरंजित: 16k, निर्विवाद: 1M, सुई: 530K)
लार्स

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 स्थापित अनुरोध द्वारा स्थापित करें - सेव करें

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
ब्रैड

इस पुस्तकालय को हटा दिया गया है।
यूरी टेकचेंको

4

मुझे एक वीडियो मिला जिसमें बताया गया है कि इसे कैसे प्राप्त किया जा सकता है: https://www.youtube.com/watch?v=nuw48-u3Yrg

यह डिफॉल्ट "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

के लिए यह मेरा समाधान POSTऔर GET

Postविधि के बारे में :

यदि शरीर एक JSON ऑब्जेक्ट है, तो यह महत्वपूर्ण है कि इसे इसके साथ जोड़ा जाए JSON.stringifyऔर संभवतः Content-Lenghtउसी के अनुसार हेडर सेट करें :

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

अनुरोध पर इसे लिखने से पहले:

request.write( bodyString );

दोनों तरीकों Getऔर Postतरीकों के बारे में :

timeoutएक के रूप में हो सकता है 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());
        }
      });

यह एक के साथ लपेटने के लिए सुरक्षित है try... 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पुस्तकालय को हटा दिया गया है।
यूरी टकचेंको

3

Axios ब्राउज़र और Node.js. के लिए एक HTTP आधारित वादा है। एक्सियोस ने आरईएस एंडपॉइंट्स के अतुल्यकालिक HTTP अनुरोध भेजना और सीआरयूडी संचालन करना आसान बना दिया है। इसका उपयोग सादे जावास्क्रिप्ट में या 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 अनुरोध का एक और अक्षीय उदाहरण पोस्ट करना जो अतिरिक्त कॉन्फ़िगरेशन विकल्प और कस्टम हेडर का उपयोग करता है।

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

इस पुस्तकालय को हटा दिया गया है।
यूरी टकचेंको

0

Request-Promiseवादा आधारित प्रतिक्रिया प्रदान करता है। 2xx के अलावा http प्रतिक्रिया कोड अस्वीकार किए जाने के वादे का कारण बनेगा। यह विकल्प सेट करके ओवरराइट किया जा सकता है। सरल = गलत

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...
});
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.