cURL équivalent dans Node.js?

Je cherche à utiliser les informations d'une demande HTTP en utilisant Node.js (c'est-à-dire appeler un service Web distant et faire écho à la réponse au client).

En PHP, j'aurais utilisé cURL pour faire cela. Quelle est la meilleure pratique dans Node?

Consultez la documentation du module HTTP pour un exemple complet:

https://nodejs.org/api/http.html#http_http_request_options_callback

Le httpmodule que vous utilisez pour exécuter les serveurs est également utilisé pour effectuer des requêtes à distance.

Voici l'exemple dans leurs documents:

var http = require("http");

var options = {
  host: 'www.google.com',
  port: 80,
  path: '/upload',
  method: 'POST'
};

var req = http.request(options, function(res) {
  console.log('STATUS: ' + res.statusCode);
  console.log('HEADERS: ' + JSON.stringify(res.headers));
  res.setEncoding('utf8');
  res.on('data', function (chunk) {
    console.log('BODY: ' + chunk);
  });
});

req.on('error', function(e) {
  console.log('problem with request: ' + e.message);
});

// write data to request body
req.write('data\n');
req.write('data\n');
req.end();

vous pouvez facilement utiliser le module de demande:

https://www.npmjs.com/package/request

Exemple de code:

var request = require('request');
request('http://www.google.com', function (error, response, body) {
  if (!error && response.statusCode == 200) {
    console.log(body) // Show the HTML for the Google homepage. 
  }
  else {
    console.log("Error "+response.statusCode)
  }
})

Puisqu'il semble node-curlmort, je l'ai bifurqué, renommé et modifié pour être plus curl et compiler sous Windows.

node-libcurl

Exemple d'utilisation:

var Curl = require( 'node-libcurl' ).Curl;

var curl = new Curl();

curl.setOpt( Curl.option.URL, 'www.google.com' );
curl.setOpt( 'FOLLOWLOCATION', true );

curl.on( 'end', function( statusCode, body, headers ) {

    console.info( statusCode );
    console.info( '---' );
    console.info( body.length );
    console.info( '---' );
    console.info( headers );
    console.info( '---' );
    console.info( this.getInfo( Curl.info.TOTAL_TIME ) );

    this.close();
});

curl.on( 'error', function( err, curlErrorCode ) {

    console.error( err.message );
    console.error( '---' );
    console.error( curlErrorCode );

    this.close();

});

curl.perform();

Perform est asynchrone, et il n'y a aucun moyen de l'utiliser de manière synchrone actuellement (et ne l'aura probablement jamais).

Il est toujours en version alpha, mais cela va bientôt changer et l'aide est appréciée.

Il est maintenant possible d'utiliser le Easyhandle directement pour les demandes de synchronisation, par exemple:

var Easy = require( 'node-libcurl' ).Easy,
    Curl = require( 'node-libcurl' ).Curl,
    url = process.argv[2] || 'http://www.google.com',
    ret, ch;

ch = new Easy();

ch.setOpt( Curl.option.URL, url );

ch.setOpt( Curl.option.HEADERFUNCTION, function( buf, size, nmemb ) {

    console.log( buf );

    return size * nmemb;
});

ch.setOpt( Curl.option.WRITEFUNCTION, function( buf, size, nmemb ) {

    console.log( arguments );

    return size * nmemb;
});

// this call is sync!
ret = ch.perform();

ch.close();

console.log( ret, ret == Curl.code.CURLE_OK, Easy.strError( ret ) );

De plus, le projet est maintenant stable!

ÉDITER:

Pour les nouveaux projets, veuillez ne pas utiliser request, car le projet est maintenant en mode maitainance et sera finalement obsolète

https://github.com/request/request/issues/3142

Au lieu de cela, je recommanderais Axios , la bibliothèque est conforme aux dernières normes de Node, et il existe des plugins disponibles pour l'améliorer, permettant des réponses de serveur simulées, des tentatives automatiques et d'autres fonctionnalités.

https://github.com/axios/axios

const axios = require('axios');

// Make a request for a user with a given ID
axios.get('/user?ID=12345')
  .then(function (response) {
    // handle success
    console.log(response);
  })
  .catch(function (error) {
    // handle error
    console.log(error);
  })
  .then(function () {
    // always executed
  });

Ou en utilisant async / await:

try{
    const response = await axios.get('/user?ID=12345');
    console.log(response)
} catch(axiosErr){
    console.log(axiosErr)
}

J'utilise habituellement REQUEST, c'est un client HTTP simplifié mais puissant pour Node.js

https://github.com/request/request

C'est sur NPM npm install request

Voici un exemple d'utilisation:

var request = require('request');

request('http://www.google.com', function (error, response, body) {
   if (!error && response.statusCode == 200) {
       console.log(body) // Show the HTML for the Google homepage.
   }
})

si vous avez vraiment besoin d'un équivalent curl, vous pouvez essayer node-curl

npm install node-curl

vous devrez probablement ajouter libcurl4-gnutls-dev.

Les exemples ci-dessus fonctionnent mais ne vont pas jusqu'à traiter réellement un exemple du monde réel (c'est-à-dire lorsque vous traitez des données provenant de plusieurs blocs. Une chose dont vous devez vous assurer est que vous avez un gestionnaire "on chunk" qui pousser les données dans un tableau (moyen le plus rapide de le faire dans JS) et un gestionnaire «on end» qui les joint tous ensemble afin que vous puissiez le retourner.

Cela est particulièrement nécessaire lorsque vous travaillez avec de grosses requêtes (plus de 5000 lignes) et que le serveur vous envoie un tas de données.

Voici un exemple dans l'un de mes programmes (coffeescript): https://gist.github.com/1105888

Que diriez-vous par exemple de https://github.com/joyent/node/wiki/modules#wiki-tcp . Un résumé très rapide =>

• https://github.com/visionmedia/superagent
• https://github.com/mikeal/request

Il y a le module NPM pour faire une boucle comme demande, npm curlrequest.

Étape 1: $npm i -S curlrequest

Étape 2: dans votre fichier de nœud

let curl = require('curlrequest')
let options = {} // url, method, data, timeout,data, etc can be passed as options 
curl.request(options,(err,response)=>{
// err is the error returned  from the api
// response contains the data returned from the api
})

Pour plus de lecture et de compréhension, npm curlrequest

Utilisez le module request npm et après l'appel

var request = require('request');
request('http://www.google.com', function (error, response, body) {
  console.log('error:', error); // Print the error if one occurred
  console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
  console.log('body:', body); // Print the HTML for the Google homepage.
});

Pour les meilleures pratiques, utilisez également un module winston logger ou un simple console.log, puis exécutez votre application comme

npm start output.txt 

Le résultat de la commande ci-dessus générera un fichier txt à la racine avec toutes les données que vous avez imprimées dans console.log

J'ai fini par utiliser la bibliothèque grunt-shell .

Voici l' essentiel de ma source pour ma tâche Grunt entièrement implémentée pour quiconque envisage de travailler avec l'API EdgeCast. Vous trouverez dans mon exemple que j'utilise un grunt-shell pour exécuter la commande curl qui purge le CDN.

C'est ce que j'ai fini avec après avoir passé des heures à essayer d'obtenir une requête HTTP pour fonctionner dans Node. J'ai pu en faire fonctionner un en Ruby et Python, mais je ne répondais pas aux exigences de ce projet.

Utilise reqclient , c'est un petit module client en plus requestqui vous permet de journaliser toute l'activité avec le style cURL (optionnel, pour les environnements de développement). Possède également des fonctionnalités intéressantes telles que l'analyse des URL et des paramètres, les intégrations d'authentification, la prise en charge du cache, etc.

Par exemple, si vous créez un objet client et effectuez une requête:

var RequestClient = require("reqclient").RequestClient;
var client = new RequestClient({
        baseUrl:"http://baseurl.com/api/v1.1",
        debugRequest:true, debugResponse:true
    });

var resp = client.post("client/orders", {"client":1234,"ref_id":"A987"}, {headers: {"x-token":"AFF01XX"}})

Il enregistrera dans la console quelque chose comme ceci:

[Requesting client/orders]-> -X POST http://baseurl.com/api/v1.1/client/orders -d '{"client": 1234, "ref_id": "A987"}' -H '{"x-token": "AFF01XX"}' -H Content-Type:application/json
[Response   client/orders]<- Status 200 - {"orderId": 1320934}

La demande renverra un objet Promise , vous devez donc gérer thenet catchquoi faire avec le résultat.

reqclientest disponible avec NPM , vous pouvez installer le module avec: npm install reqclient.

J'ai eu un problème pour envoyer des données POST vers le cloud DB à partir d'IOT RaspberryPi, mais après des heures, j'ai réussi à faire les choses correctement.

J'ai utilisé l'invite de commande pour le faire.

sudo curl --URL http://<username>.cloudant.com/<database_name> --user <api_key>:<pass_key> -X POST -H "Content-Type:application/json" --data '{"id":"123","type":"987"}'

L'invite de commande montrera les problèmes - mauvais nom d'utilisateur / passe; mauvaise demande etc.

--URL base de données / emplacement du serveur (j'ai utilisé une base de données Cloudant gratuite simple) --user est le nom d'utilisateur de la partie d'authentification: passe que j'ai entré via l'API pass -X définit la commande à appeler (PUT, GET, POST, DELETE) -H type de contenu - Cloudant concerne la base de données de documents, où JSON est utilisé - le contenu des données lui-même est trié en JSON

Module Request npm Request node moulde est bon à utiliser, il a des paramètres d'options pour obtenir / post request et il est également largement utilisé dans l'environnement de production.

Vous voudrez peut-être essayer d'utiliser quelque chose comme ça

curl = require('node-curl');
curl('www.google.com', function(err) {
  console.info(this.status);
  console.info('-----');
  console.info(this.body);
  console.info('-----');
  console.info(this.info('SIZE_DOWNLOAD'));
});

Vous pouvez essayer d'utiliser l'application POSTMAN Chrome pour votre demande et vous pouvez générer du code node js à partir de là

Vous pouvez utiliser le module request npm. Super simple à utiliser. Request est conçu pour être le moyen le plus simple possible de passer des appels http. Il prend en charge HTTPS et suit les redirections par défaut.

var request = require('request');
request('http://www.google.com', function (error, response, body) {
  console.log('error:', error); // Print the error if one occurred
  console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
  console.log('body:', body); // Print the HTML for the Google homepage.
});