Comment est effectuée une requête HTTP POST dans node.js?


946

Comment puis-je faire une requête HTTP POST sortante, avec des données, dans node.js?


16
Comme suggéré dans la réponse de Jed Watson , je recommanderais fortement d'utiliser la demande sauf si vous écrivez une API de bas niveau.
namuol

4
Vous pouvez simplement utiliser node-fetchce qui est une implémentation de la fetchméthode JavaScript native pour effectuer des requêtes HTTP.
Fez Vrasta

Ce message couvre les scénarios d'utilisation de base pour l'utilisation de la demande. blog.modulus.io/node.js-tutorial-how-to-use-request-module
Shaswat Rungta

Réponses:


855

Voici un exemple d'utilisation de node.js pour effectuer une requête POST auprès de l'API Google Compiler:

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

J'ai mis à jour le code pour montrer comment publier des données à partir d'un fichier, au lieu de la chaîne codée en dur. Il utilise la fs.readFilecommande async pour y parvenir, publiant le code réel après une lecture réussie. S'il y a une erreur, elle est levée et s'il n'y a pas de données, le processus se termine avec une valeur négative pour indiquer l'échec.


4
L'en-tête de longueur de contenu est-il calculé correctement? Censé être des octets, non?
Eric

7
Notez que querystring.stringify() cela ne prend pas en charge les objets imbriqués , vous pouvez donc utiliser à la qs.stringify()place.
johndodo

51
Content-Lengthest un octet et pas nécessairement une longueur de chaîne (UTF-16, etc.). L'utilisation Buffer.byteLength(data)sera toujours correcte.
greenimpala

4
pour l'envoi de postdonnées standard, l'objet dans querystring.stringifydoit être votre propre objet de données, et non le courrier indésirable affiché dans cette réponse (qui peut être utile pour les objets basés sur des fichiers?). J'étais coincé là-dessus depuis des lustres ... stackoverflow.com/questions/9768192/… a fourni ma solution complète
RozzA

7
Gotcha: Si vous utilisez un site crypté en SSL, vous aurez besoin de la bibliothèque "https". Vous ne pouvez pas simplement changer le port en 443.
Dave Collins

1137

Cela devient beaucoup plus facile si vous utilisez la bibliothèque de requêtes .

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

En plus de fournir une belle syntaxe, il facilite les requêtes json, gère la signature automatique (pour twitter, etc.), peut faire des formulaires en plusieurs parties (par exemple pour télécharger des fichiers) et le streaming.

Pour installer la commande use request npm install request


153
{form: {key: 'value'}} doit être remplacé par {json: {key: 'value'}} (car la question n'est pas spécifique aux formulaires). Il faut aussi comprendre que 'form' et 'json' sont des mots-clés de bibliothèque de demande et ne font pas partie des données personnalisées (aussi trivial que ce dernier commentaire puisse apparaître, il m'a fallu un certain temps pour le comprendre ...)
blacelle

7
Je reviens toujours à cette question et réponse. Ce devrait vraiment être "la" réponse à la question.
Spencer Kormos

6
Vous méritez un badge en or uniquement pour cette réponse. Il est tellement plus utile que celui accepté ... et il existait déjà en 2012? Wow
Zoltán Schmidt

3
vous devrez peut-être ajouter une dépendance en exécutant cette commande 'npm install --save request'
Shady Sherif

18
Cette bibliothèque est obsolète.
Evorlor

138

Vous pouvez utiliser la bibliothèque de requêtes. https://www.npmjs.com/package/request

var request = require('request');

Pour publier des données JSON:

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

Pour publier des données 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);
});

Après examen dans leur documentation. il indique ce qui suit: json - définit le corps mais sur la représentation JSON de la valeur et ajoute Content-type: application / json header. En outre, analyse le corps de réponse en tant que JSON. Cela signifie que lorsque json = true, il définira l'en-tête et json et le corps. Sinon, aucun en-tête défini et analysé en tant que texte. (Comme l'exemple XML ci-dessus). Cela rend l'API de demande pratique et simpliste mais assez difficile à comprendre au premier abord.
Josiah Choi

C'est techniquement dans leurs documents, mais aucun des exemples ne le montre - seulement des données de formulaire. C'est une aiguille dans la botte de foin, et en tant que telle, c'est une énorme commission, car c'est la deuxième façon la plus fréquente d'utiliser ajax dans JS, et certainement l'une des plus courantes sur le Web.
Kyle Baker

L'utilisation de request.post est un peu plus agréable que de spécifier POST comme méthode. Voici quelques exemples de GitHub pour utiliser request.post
drorw

12
Cette bibliothèque est obsolète.
Evorlor

44

J'utilise Restler et Needle à des fins de production. Ils sont tous deux beaucoup plus puissants que httprequest natif. Il est possible de demander avec une authentification de base, une entrée d'en-tête spéciale ou même des fichiers de téléchargement.

Quant aux opérations post / get, elles sont également beaucoup plus simples à utiliser que les appels ajax bruts utilisant httprequest.

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

J'ai essayé request, node-form-data et superagent avant needle. l'aiguille était la seule qui fonctionnait correctement pour moi lors de la tentative de téléchargement d'un fichier de formulaire en plusieurs parties.
Paul Young

35

Simple et sans dépendance. Utilise une promesse pour que vous puissiez attendre le résultat. Il renvoie le corps de la réponse et ne vérifie pas le code d'état de la réponse.

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

Usage:

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

À quoi sert la writeméthode req,write()?
Ari

@Ari That écrit le corps de la demande ... nodejs.org/api/…
mpen

21

Vous pouvez également utiliser Requestify , un client HTTP vraiment cool et simple que j'ai écrit pour nodeJS +, il prend en charge la mise en cache.

Procédez simplement comme suit:

    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
Cela ne fonctionne pas pour moi, voir le problème ici: github.com/ranm8/requestify/issues/2
Erel Segal-Halevi

20

Mise à jour 2020:

J'ai vraiment apprécié phin - Le client HTTP Node.js ultra-léger

Il peut être utilisé de deux manières différentes. L'un avec des promesses (Async / Await) et l'autre avec des styles de rappel traditionnels.

Installer via: npm i phin

Directement depuis son fichier README avec await:

const p = require('phin')

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


Style (rappel) sans compromis:

const p = require('phin').unpromisified

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

En 2015, il existe maintenant une grande variété de bibliothèques différentes qui peuvent accomplir cela avec un codage minimal. Je préfère de loin les bibliothèques élégantes et légères pour les requêtes HTTP, sauf si vous avez absolument besoin de contrôler les éléments HTTP de bas niveau.

Une de ces bibliothèques est Unirest

Pour l'installer, utilisez npm.
$ npm install unirest

Et sur l' Hello, World!exemple auquel tout le monde est habitué.

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:
Beaucoup de gens suggèrent également l'utilisation de la demande [2]

Il convient de noter que les coulisses Unirestutilisent la requestbibliothèque.

Unirest fournit des méthodes pour accéder directement à l'objet de demande.

Exemple:

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

1
Un autre que j'ai trouvé qui semble assez bon est github.com/request/request qui semble un peu plus populaire qu'inireste au moins au moment de la rédaction de cet article
Lochlan

Je peux attester de la demande. C'est une très bonne bibliothèque. Je trouve que cette demande fournit plus de fonctionnalités de bas niveau, il est donc approprié de l'utiliser pour des applications spécifiques. Quand je ne me soucie pas nécessairement des choses de bas niveau, je trouve qu'Unirest est adéquat.
Levi Roberts

Pourquoi unirest serait-il considéré comme léger alors qu'il dépend de la demande? La demande elle-même a 22 dépendances, je ne vois pas comment c'est léger
raphadko

@raphadko Je suis sûr qu'au fil des ans, un ballonnement s'est produit. Assurez-vous de vérifier l'horodatage du moment où j'ai posté ma réponse;)
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);
});

Existe-t-il un moyen d'afficher le corps du message de demande sur la demande ou la réponse?
jacoballenwood

17

Il existe des dizaines de bibliothèques open-source que vous pouvez utiliser pour effectuer une requête HTTP POST dans Node.

1. Axios (recommandé)

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

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

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. Module HTTPS natif

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

Pour plus de détails, consultez cet article .


14

C'est la manière la plus simple que j'utilise pour faire une requête: en utilisant le module 'request'.

Commande pour installer le module 'request':

$ npm install request

Exemple de code:

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)

});

Vous pouvez également utiliser le module «http» intégré de Node.js pour effectuer une demande.


1
Cette bibliothèque est obsolète.
Yuri Tkachenko

12

J'aime la simplicité de superagent ( https://github.com/visionmedia/superagent ). Même API sur le nœud et le navigateur.

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

Il existe également un nœud-fetch ( https://www.npmjs.com/package/node-fetch ), qui possède une API qui correspond fetchaux navigateurs - cependant cela nécessite un encodage manuel des chaînes de requête, ne gère pas automatiquement les types de contenu, ou comme le fait tout autre superagent de travail.


1
Et contrairement à l'aiguille, unirest et co, il est léger (superagent: 16k, unirest: 1M, aiguille: 530K)
Lars

9

Si vous recherchez des requêtes HTTP basées sur des promesses, axios fait bien son travail.

  const axios = require('axios');

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

OU

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

6

Pour poster une requête Rest / JSON
Nous pouvons simplement utiliser le package de requête et enregistrer les valeurs que nous devons envoyer dans la variable Json.

Installez d'abord le package requis dans votre console à la demande d'installation de npm --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
Ne créez jamais votre propre chaîne de requête. Vous négligez de coder correctement vos valeurs. Node.js a une bibliothèque à cet effet: nodejs.org/api/querystring.html
Brad

Cette bibliothèque est obsolète.
Yuri Tkachenko

4

J'ai trouvé une vidéo qui explique comment y parvenir: https://www.youtube.com/watch?v=nuw48-u3Yrg

Il utilise le module "http" par défaut avec les modules "querystring" et "stringbuilder". L'application prend deux nombres (en utilisant deux zones de texte) à partir d'une page Web et lors de la soumission, retourne la somme de ces deux (ainsi que la persistance des valeurs dans les zones de texte). C'est le meilleur exemple que j'ai pu trouver ailleurs.

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

C'est ma solution pour POSTet GET.

À propos de la Postméthode:

Si le corps est un objet JSON, il est donc important de le désérialiser avec JSON.stringifyet éventuellement de définir l'en- Content-Lenghttête en conséquence:

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

avant de l'écrire à la demande:

request.write( bodyString );

À propos des deux Getet des Postméthodes:

Le timeoutpeut se produire comme une socketdéconnexion, vous devez donc enregistrer son gestionnaire comme:

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

pendant que le requestgestionnaire est

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

Je suggère fortement d'enregistrer les deux gestionnaires.

Le corps de réponse est fragmenté, vous devez donc concaténer des morceaux au datagestionnaire:

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

Au endl' bodycontiendra tout le corps de réponse:

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

Il est sûr d'envelopper avec un try... catch theJSON.parse` car vous ne pouvez pas être sûr qu'il s'agit d'un json bien formaté et il n'y a aucun moyen de s'en assurer au moment où vous faites la demande.

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

Usage:

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

Après avoir eu beaucoup de mal à créer un utilitaire de bas niveau pour gérer le message et obtenir des demandes pour mon projet, j'ai décidé de publier mes efforts ici. Sur le modèle de la réponse acceptée, voici un extrait pour effectuer des requêtes POST http et https pour l'envoi de données 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
Vous n'utilisez jamais les post_data sérialisées? l'écriture en tant qu'objet js est-elle convertie en tampon par défaut?
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);
});

Ou vous pouvez utiliser cette bibliothèque:

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

requestbibliothèque est obsolète.
Yuri Tkachenko

3

Axios est un client HTTP basé sur les promesses pour le navigateur et Node.js. Axios facilite l'envoi de requêtes HTTP asynchrones aux points de terminaison REST et la réalisation d'opérations CRUD. Il peut être utilisé en JavaScript simple ou avec une bibliothèque telle que Vue ou 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

Publier un autre exemple axios d'une demande axios.post qui utilise des options de configuration supplémentaires et des en-têtes personnalisés.

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

En utilisant la dépendance de demande .

Solution simple:

 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
d'où requestvient-il?
CodyBugstein

Cette bibliothèque est obsolète.
Yuri Tkachenko

0

Request-PromiseFournit une réponse basée sur la promesse. Les codes de réponse http autres que 2xx entraîneront le rejet de la promesse. Cela peut être écrasé en définissant 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...
});
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.