equivalente cURL in Node.js?

Sto cercando di utilizzare le informazioni da una richiesta HTTP utilizzando Node.js (ovvero chiamare un servizio Web remoto ed echo la risposta al client).

In PHP avrei usato cURL per farlo. Qual è la migliore pratica in Node?

Vedere la documentazione per il modulo HTTP per un esempio completo:

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

Il httpmodulo utilizzato per eseguire i server viene utilizzato anche per effettuare richieste remote.

Ecco l'esempio nei loro documenti:

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

puoi facilmente usare il modulo di richiesta:

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

Codice di esempio:

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

Poiché sembra che node-curlsia morto, l'ho biforcato, rinominato e modificato per renderlo più arricciato e compilare sotto Windows.

node-libcurl

Esempio di utilizzo:

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 è asincrono e al momento non c'è modo di usarlo sincrono (e probabilmente non lo farà mai).

È ancora in versione alfa, ma questo cambierà presto e l'aiuto è apprezzato.

Ora è possibile utilizzare Easyhandle direttamente per le richieste di sincronizzazione, ad esempio:

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

Inoltre, il progetto è stabile ora!

MODIFICARE:

Per i nuovi progetti, si prega di astenersi dall'utilizzare la richiesta, poiché ora il progetto è in modalità Gran Bretagna e alla fine sarà deprecato

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

Invece, consiglierei Axios , la libreria è in linea con gli standard più recenti di Node e ci sono alcuni plugin disponibili per migliorarlo, consentendo risposte simulate al server, tentativi automatici e altre funzionalità.

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

O usando async / await:

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

Di solito uso REQUEST, è un client HTTP semplificato ma potente per Node.js

https://github.com/request/request

È su NPM npm install request

Ecco un esempio di utilizzo:

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

bene se hai davvero bisogno di un equivalente ricciolo puoi provare node-curl

npm install node-curl

probabilmente dovrai aggiungere libcurl4-gnutls-dev.

Gli esempi sopra funzionano ma non arrivano al punto di trattare davvero un esempio del mondo reale (ad esempio quando si elaborano dati provenienti da più blocchi. Una cosa di cui è necessario assicurarsi è che si dispone di un gestore "on chunk" che spinge i dati in un array (il modo più veloce per farlo in JS) e un gestore 'on end' che li unisce tutti in modo da poterli restituire.

Ciò è particolarmente necessario quando lavori con grandi richieste (oltre 5000 righe) e il server ti invia un sacco di dati.

Ecco un esempio in uno dei miei programmi (coffeescript): https://gist.github.com/1105888

Che ne dici, ad esempio, di https://github.com/joyent/node/wiki/modules#wiki-tcp . Un sommario molto veloce =>

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

C'è un modulo npm per fare un ricciolo come una richiesta, npm curlrequest .

Passo 1: $npm i -S curlrequest

Passaggio 2: nel file del nodo

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

Per ulteriore lettura e comprensione, npm curlrequest

Utilizzare il modulo npm richiesta e dopo la chiamata

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

Per la migliore pratica, utilizzare anche un modulo di registrazione Winston o semplicemente console.log semplice e quindi eseguire l'applicazione come

npm start output.txt 

Il risultato del comando sopra genererà un file txt su root con tutti i dati stampati in console.log

Ho finito per usare la libreria grunt-shell .

Ecco la mia idea di base per la mia attività Grunt completamente implementata per chiunque stia pensando di lavorare con l'API EdgeCast. Nel mio esempio troverai che uso una grunt-shell per eseguire il comando curl che cancella il CDN.

Questo è quello che ho finito dopo aver passato ore a cercare di ottenere una richiesta HTTP per funzionare all'interno di Node. Sono stato in grado di farlo funzionare in Ruby e Python, ma non ho soddisfatto i requisiti di questo progetto.

Utilizza reqclient , inoltre è un piccolo modulo client requestche ti consente di registrare tutte le attività con stile cURL (opzionale, per ambienti di sviluppo). Dispone anche di funzioni interessanti come analisi di URL e parametri, integrazioni di autenticazione, supporto cache, ecc.

Ad esempio, se si crea un oggetto client e fare una richiesta:

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

Accederà alla console in questo modo:

[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 richiesta restituirà un oggetto Promise , quindi devi gestire thene catchcosa fare del risultato.

reqclientè disponibile con NPM , è possibile installare il modulo con: npm install reqclient.

Ho avuto un problema con l'invio dei dati POST al cloud DB da IOT RaspberryPi, ma dopo ore sono riuscito a farlo subito.

Ho usato il prompt dei comandi per farlo.

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

Il prompt dei comandi mostrerà i problemi - nome utente / pass errati; cattiva richiesta ecc.

- Posizione del database / serverURL (ho usato un semplice database gratuito Cloudant) --user è il nome utente della parte di autenticazione: pass Ho inserito tramite l'API pass -X definisce quale comando chiamare (PUT, GET, POST, DELETE) -H tipo di contenuto - Cloudant riguarda il database dei documenti, in cui viene utilizzato JSON - il contenuto dei dati stesso ordinato come JSON

Modulo di richiesta npm Il nodo di richiesta moulde è buono da usare, ha impostazioni di opzioni per la richiesta get / post e inoltre è ampiamente usato anche nell'ambiente di produzione.

Potresti provare a usare qualcosa del genere

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

Puoi provare a utilizzare l'app POSTMAN Chrome per la tua richiesta e puoi generare il codice js del nodo da lì

È possibile utilizzare il modulo di richiesta npm. Super semplice da usare. La richiesta è progettata per essere il modo più semplice possibile per effettuare chiamate http. Supporta HTTPS e segue i reindirizzamenti per impostazione predefinita.

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