node.js - Hoe wordt een HTTP POST-verzoek gedaan in node.js?

Hoe kan ik een uitgaand HTTP POST-verzoek doen, met gegevens, in node.js?

Antwoord 1, autoriteit 100%

Hier is een voorbeeld van het gebruik van node.js om een POST-verzoek in te dienen bij de 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);
  }
});

Ik heb de code bijgewerkt om te laten zien hoe u gegevens uit een bestand kunt plaatsen, in plaats van de hardcoded string. Het gebruikt de ASYNC fs.readFileopdracht om dit te bereiken, de daadwerkelijke code na een succesvolle lees te plaatsen. Als er een fout is, wordt het gegooid en als er geen gegevens zijn, wordt het proces afgesloten met een negatieve waarde om falen aan te geven.

Antwoord 2, Autoriteit 130%

`request`WORDT WORDT GESCHIKT. Het wordt aanbevolen u gebruikt een alternatief

In geen enkele specifieke volgorde en vreselijk onvolledig:

Native HTTP / S, const https = require('https');
Node-fetch
Axios
heeft
Superagent
gebogen
make-fetch-gebeuren
Unetch
tiny-json-http
naald
urllib

statistieken vergelijking
Sommige code-voorbeelden

Origineel antwoord:

Dit krijgt een stuk eenvoudiger als u de verzoek bibliotheek gebruikt.

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

Afgezien van het verstrekken van een leuke syntaxis, maakt JSON gemakkelijk aan, behandelt OAuth-ondertekening (voor Twitter, enz.), kan multi-part-formulieren uitvoeren (bijvoorbeeld voor het uploaden van bestanden) en streaming.

Om de opdracht van het verzoek te installeren Gebruik npm install request

Antwoord 3, Autoriteit 15%

U kunt aanvraagbibliotheek gebruiken. https://www.npmjs.com/package/request

var request = require('request');

Om JSON-gegevens te plaatsen:

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

om XML-gegevens te plaatsen:

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

Antwoord 4, autoriteit 7%

Eenvoudig en afhankelijkheidsvrij. Gebruikt een Promise zodat u het resultaat kunt afwachten. Het retourneert de hoofdtekst van het antwoord en controleert de statuscode van het antwoord niet.

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

Gebruik:

async function main() {
    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',
        })
    })
}
main().catch(err => {
    console.log(err)
})

Antwoord 5, Autoriteit 5%

Ik gebruik restler en naald voor productiedoeleinden.
Ze zijn allebei veel krachtiger dan inheemse httprequest. Het is mogelijk om te vragen met basisverificatie, speciale koptekstang of zelfs upload / downloadbestanden.

Wat betreft post / Werking, zijn ze ook veel eenvoudiger om te gebruiken dan RAW AJAX-oproepen met behulp van HTTPREQUEST.

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

Antwoord 6, Autoriteit 4%

Er zijn tientallen open-source-bibliotheken beschikbaar die u kunt gebruiken om een HTTP-postverzoek in het knooppunt te maken.

1. Axios (aanbevolen)

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

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

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. Native HTTPS-module

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

Bekijk dit artikelvoor meer informatie.

Antwoord 7, autoriteit 3%

Update 2020:

Ik heb echt genoten van phin– De ultralichte Node. js HTTP-client

Het kan op twee verschillende manieren worden gebruikt. Een met beloften (Async/Await) en de andere met traditionele callback-stijlen.

Installeer via: npm i phin

Rechtstreeks uit de README met await:

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

Onbeloofde (callback) stijl:

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

Vanaf 2015is er nu een grote verscheidenheid aan verschillende bibliotheken die dit kunnen bereiken met minimale codering. Ik geef veel de voorkeur aan elegante lichtgewicht bibliotheken voor HTTP-verzoeken, tenzij je absoluut controle over de low-level HTTP-dingen nodig hebt.

Een dergelijke bibliotheek is Unirest

Gebruik npmom het te installeren.
$ npm install unirest

En naar het voorbeeld van Hello, World!waar iedereen aan gewend is.

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

Extra:
Veel mensen suggereren ook het gebruik van request [ 2 ]

Het zou de moeite waard moeten zijn om op te merken dat achter de schermen Unirestde requestBibliotheek gebruiken.

UNIREST biedt methoden voor het rechtstreeks van het verzoekobject.

Voorbeeld:

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

Antwoord 8, Autoriteit 2%

U kunt ook Verhorsen , een echt coole en eenvoudige HTTP-client die ik schreef voor NODEJS + IT ondersteunt caching.

Doe gewoon het volgende:

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

Antwoord 9, Autoriteit 2%

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

Antwoord 10, autoriteit 2%

Dit is de eenvoudigste manier die ik gebruik om een verzoek in te dienen: met de module ‘verzoek’.

Opdracht om module ‘verzoek’ te installeren:

$ npm install request

Voorbeeldcode:

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

Je kunt ook de ingebouwde ‘http’-module van Node.js gebruiken om een verzoek in te dienen.

Antwoord 11

Ik hou van de eenvoud van superagent (https://github.com/visionmedia/superagent) . Dezelfde API op zowel node als browser.

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

Er is ook node-fetch (https://www.npmjs.com/package/ node-fetch), die een API heeft die overeenkomt met fetchuit de browsers – dit vereist echter handmatige codering van querytekenreeksen, verwerkt niet automatisch inhoudstypen, of dus een van de andere werk-superagenten doet.

Antwoord 12

Als u op beloften gebaseerde HTTP-verzoeken zoekt, doet axioszijn werk goed.

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

Antwoord 13

Rest/JSON-verzoek plaatsen
We kunnen eenvoudig het aanvraagpakket gebruiken en de waarden die we moeten verzenden opslaan in de Json-variabele.

Installeer eerst het vereiste pakket in uw console door:
npm installatieverzoek –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)
               }
    );

Antwoord 14

Dit is mijn oplossing voor Posten Get.

Over de Post-methode:

Als de body een JSON-object is, is het belangrijk om het te deserialiseren met JSON.stringifyen eventueel de Content-Lenght-header dienovereenkomstig in te stellen:

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

voordat u het naar het verzoek schrijft:

request.write( bodyString );

Over de methoden Geten Post:

De timeoutkan optreden als een socketontkoppeling, dus u moet de handler registreren zoals:

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

terwijl de requesthandler is

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

Ik raad ten zeerste aan om beide handlers te registreren.

De hoofdtekst van het antwoord is in stukken verdeeld, dus u moet de stukken samenvoegen bij de data-handler:

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

Aan het endzal de bodyde hele response body bevatten:

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

Het is veilig om te wrappen met een try…catchtheJSON.parse` omdat je er niet zeker van kunt zijn dat het een goed geformatteerde json is en daar is er geen manier om er zeker van te zijn op het moment dat u het verzoek doet.

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

Gebruik:

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

Antwoord 15

Ik heb een video gevonden waarin wordt uitgelegd hoe je dit kunt bereiken: https://www .youtube.com/watch?v=nuw48-u3Yrg

Het gebruikt standaard “HTTP” -module samen met “QueryString” en “StringBuilder” -modules. De applicatie duurt twee cijfers (met behulp van twee tekstvakken) van een webpagina en bij verzending, retourneert de som van die twee (samen met aanhoudende de waarden in de tekstvakken). Dit is het beste voorbeeld dat ik ergens anders kon vinden.

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

Antwoord 16

Na veel moeite worstelen tijdens het maken van een hulpprogramma met een laag niveau om het bericht aan te pakken en verzoeken te krijgen voor mijn project, besloot ik mijn inspanningen hier te boeken. Veel in de lijnen van geaccepteerd antwoord, hier is een fragment voor het maken van HTTP- en HTTPS-postverzoeken voor het verzenden van JSON-gegevens.

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

Antwoord 17

Axios is een belofte gebaseerde HTTP-client voor de browser en node.js. Axios maakt het eenvoudig om asynchrone HTTP-verzoeken te verzenden om eindpunten te rusten en crud-operaties uit te voeren. Het kan in het gewone javascript of met een bibliotheek zoals VUE of reageren worden gebruikt.

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

Antwoord 18

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

of u zou deze bibliotheek kunnen gebruiken:

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

Antwoord 19

Een ander axios-voorbeeld van een Axios.Post-verzoek plaatsen dat extra configuratie-opties en aangepaste headers gebruikt.

var postData = {
  email: "[email protected]",
  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);
})

Antwoord 20

Door verzoek-afhankelijkheid te gebruiken.

Eenvoudige oplossing:

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

Antwoord 21

Request-PromiseBiedt op beloften gebaseerde respons.
Andere HTTP-antwoordcodes dan 2xx zorgen ervoor dat de belofte wordt afgewezen. Dit kan worden overschreven door options.simple = false in te stellen

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

Previous articleCount (): parameter moet een array zijn of een object dat teldbare fout in PHP

Next articleCorrecte manier om regel naar bestand te schrijven?

Hoe wordt een HTTP POST-verzoek gedaan in node.js?