Wie wird eine HTTP-POST-Anforderung in node.js gestellt?

946

Wie kann ich eine ausgehende HTTP-POST-Anfrage mit Daten in node.js stellen?

Kennzeichen
quelle
16
Wie in der Antwort von Jed Watson vorgeschlagen , würde ich die Verwendung von request dringend empfehlen, es sei denn, Sie schreiben eine API auf niedriger Ebene.
Namuol
4
Sie können einfach node-fetcheine Implementierung der nativen fetchJavaScript-Methode verwenden, um HTTP-Anforderungen zu stellen.
Fez Vrasta
Dieser Beitrag behandelt die grundlegenden Verwendungsszenarien für die Verwendung von Anforderungen. blog.modulus.io/node.js-tutorial-how-to-use-request-module
Shaswat Rungta

Antworten:

855

Hier ist ein Beispiel für die Verwendung von node.js, um eine POST-Anforderung an die Google Compiler-API zu senden:

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

Ich habe den Code aktualisiert, um zu zeigen, wie Daten aus einer Datei anstelle der fest codierten Zeichenfolge veröffentlicht werden. Dazu wird der fs.readFileBefehl async verwendet, der den tatsächlichen Code nach einem erfolgreichen Lesevorgang veröffentlicht. Wenn ein Fehler vorliegt, wird er ausgelöst, und wenn keine Daten vorhanden sind, wird der Prozess mit einem negativen Wert beendet, um einen Fehler anzuzeigen.

onteria_
quelle
4
Wird der Content-Length-Header korrekt berechnet? Soll Bytes sein, oder?
Eric
7
Beachten Sie, dass querystring.stringify() verschachtelte Objekte nicht unterstütztqs.stringify() werden. Verwenden Sie sie stattdessen.
Johndodo
51
Content-Lengthist Bytes und nicht unbedingt Stringlänge (UTF-16 usw.). Die Verwendung Buffer.byteLength(data)wird immer korrekt sein.
Greenimpala
4
Für das Senden von Standard-Postdaten sollte das Objekt in querystring.stringifyIhr eigenes Datenobjekt sein, nicht der Junk, der in dieser Antwort angezeigt wird (was kann für dateibasierte Objekte nützlich sein?). Ich war ewig dabei ... stackoverflow.com/questions/9768192/… lieferte meine Komplettlösung
RozzA
7
Gotcha: Wenn Sie eine SSL-verschlüsselte Site verwenden, benötigen Sie die Bibliothek "https". Sie können nicht einfach den Port auf 443 ändern.
Dave Collins
1137

Dies wird viel einfacher, wenn Sie die Anforderungsbibliothek verwenden.

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

Abgesehen von der Bereitstellung einer netten Syntax erleichtert es JSON-Anfragen, erledigt das Signieren (für Twitter usw.), kann mehrteilige Formulare (z. B. zum Hochladen von Dateien) und Streaming erstellen.

Verwenden Sie zum Installieren der Anforderung den Befehl npm install request

Jed Watson
quelle
153
{form: {key: 'value'}} sollte durch {json: {key: 'value'}} ersetzt werden (da die Frage nicht formularspezifisch ist). Man muss auch verstehen, dass 'form' und 'json' Schlüsselwörter für Anforderungsbibliotheken sind und nicht Teil der benutzerdefinierten Daten sind (so trivial dieser letzte Kommentar auch sein
mag,
7
Ich komme immer wieder auf diese Frage und Antwort zurück. Es sollte wirklich "die" Antwort auf die Frage sein.
Spencer Kormos
6
Sie verdienen ein goldenes Abzeichen nur für diese Antwort. Es ist so viel nützlicher als das akzeptierte ... und es gab es bereits 2012? Wow
Zoltán Schmidt
3
Möglicherweise müssen Sie die Abhängigkeit hinzufügen, indem Sie den Befehl 'npm install --save request'
Shady Sherif
18
Diese Bibliothek ist veraltet.
Evorlor
138

Sie können die Anforderungsbibliothek verwenden. https://www.npmjs.com/package/request

var request = require('request');

So veröffentlichen Sie JSON-Daten:

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

So veröffentlichen Sie XML-Daten:

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);
});
Josiah Choi
quelle
Nach Überprüfung in ihrer Dokumentation. Es gibt Folgendes an: json - Setzt den Body aber auf die JSON-Darstellung des Werts und fügt den Inhaltstyp: application / json-Header hinzu. Analysiert außerdem den Antworttext als JSON. Das heißt, wenn json = true ist, werden Header und json und body gesetzt. Andernfalls wird kein Header festgelegt und als Text analysiert. (Wie das obige XML-Beispiel). Das macht die Anforderungs-API praktisch und simpel, aber auf den ersten Blick ziemlich schwer zu verstehen.
Josiah Choi
Es ist technisch in ihren Dokumenten, aber keines der Beispiele zeigt es - nur Formulardaten. Es ist eine Nadel im Heuhaufen, und als solche ist es eine große Provision, da dies die zweithäufigste Art ist, Ajax in JS zu verwenden, und sicherlich eine der häufigsten im Internet.
Kyle Baker
Die Verwendung von request.post ist IMO etwas besser als die Angabe von POST als Methode. Hier sind einige Beispiele von GitHub für die Verwendung von request.post
drorw
12
Diese Bibliothek ist veraltet.
Evorlor
44

Ich benutze Restler und Needle für Produktionszwecke. Sie sind beide viel leistungsfähiger als native httprequest. Es ist möglich, mit Basisauthentifizierung, speziellem Header-Eintrag oder sogar Upload / Download-Dateien anzufordern.

Die Post / Get-Operation ist auch viel einfacher zu verwenden als rohe Ajax-Aufrufe mit httprequest.

needle.post('https://my.app.com/endpoint', {foo:'bar'}, 
    function(err, resp, body){
        console.log(body);
});
Grant Li
quelle
Ich habe Request, Node-Form-Data und Superagent vor der Nadel ausprobiert. Die Nadel war die einzige, die für mich richtig funktionierte, als ich versuchte, einen mehrteiligen Formulardatei-Upload durchzuführen.
Paul Young
35

Einfach und abhängigkeitsfrei. Verwendet ein Versprechen, damit Sie das Ergebnis abwarten können. Es gibt den Antworttext zurück und überprüft den Antwortstatuscode nicht.

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

Verwendungszweck:

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',
    })
})
mpen
quelle
Wofür wird die writeMethode req,write()verwendet?
Ari
@Ari Das schreibt den Text der Anfrage ... nodejs.org/api/…
mpen
21

Sie können auch Requestify verwenden , einen wirklich coolen und einfachen HTTP-Client, den ich für nodeJS + geschrieben habe und der das Caching unterstützt.

Gehen Sie einfach wie folgt vor:

    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();
    });
ranm8
quelle
1
Es funktioniert nicht für mich, siehe das Problem hier: github.com/ranm8/requestify/issues/2
Erel Segal-Halevi
20

Update 2020:

Ich habe phin wirklich genossen - den ultraleichten Node.js HTTP-Client

Es kann auf zwei verschiedene Arten verwendet werden. Einer mit Versprechen (Async / Await) und der andere mit traditionellen Rückrufstilen.

Installation über: npm i phin

Direkt aus der README mit await:

const p = require('phin')

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


Unversprechener (Rückruf-) Stil:

const p = require('phin').unpromisified

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

Ab 2015 gibt es eine Vielzahl unterschiedlicher Bibliotheken, die dies mit minimaler Codierung erreichen können. Ich bevorzuge elegante, leichte Bibliotheken für HTTP-Anfragen, es sei denn, Sie benötigen unbedingt die Kontrolle über das HTTP-Material auf niedriger Ebene.

Eine solche Bibliothek ist Unirest

Verwenden Sie zum Installieren npm.
$ npm install unirest

Und auf das Hello, World!Beispiel, an das jeder gewöhnt ist.

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:
Viele Leute schlagen auch die Verwendung von Anfragen vor [2]

Es sollte erwähnenswert sein, dass hinter den Kulissen Unirestdie requestBibliothek verwendet wird.

Unirest bietet Methoden für den direkten Zugriff auf das Anforderungsobjekt.

Beispiel:

var Request = unirest.get('http://mockbin.com/request');
Levi Roberts
quelle
1
Eine andere, die ich fand, die ziemlich gut aussieht, ist github.com/request/request, die zumindest zum Zeitpunkt dieses Schreibens ein bisschen populärer als unirest zu sein scheint
Lochlan
Ich kann es bestätigen. Es ist eine sehr gute Bibliothek. Ich finde, dass die Anfrage mehr Funktionen auf niedriger Ebene bietet, daher ist es angebracht, sie für bestimmte Anwendungen zu verwenden. Wenn ich mich nicht unbedingt um das Low-Level-Zeug kümmere, finde ich Unirest angemessen.
Levi Roberts
Warum sollte unirest als leicht angesehen werden, wenn es von der Anfrage abhängt? Anfrage selbst hat 22 Abhängigkeiten, ich sehe nicht, wie leicht das ist
Raphadko
@raphadko Ich bin sicher, dass im Laufe der Jahre Feature Bloat aufgetreten ist. Überprüfen Sie unbedingt den Zeitstempel, zu dem ich meine Antwort gepostet habe;)
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);
});
Giulio Roggero
quelle
Gibt es eine Möglichkeit, den Text des Anforderungsposts entweder in der Anforderung oder in der Antwort anzuzeigen?
Jacoballenwood
17

Es stehen Dutzende von Open-Source-Bibliotheken zur Verfügung, mit denen Sie eine HTTP-POST-Anforderung in Node erstellen können.

1. Axios (empfohlen)

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

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

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. Natives HTTPS-Modul

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

Weitere Informationen finden Sie in diesem Artikel .

Attacomsian
quelle
14

Dies ist der einfachste Weg, um eine Anfrage zu stellen: Verwenden des Moduls 'Anfrage'.

Befehl zum Installieren des Anforderungsmoduls:

$ npm install request

Beispielcode:

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)

});

Sie können auch das integrierte 'http'-Modul von Node.js verwenden, um Anfragen zu stellen.

Piyush Sagar
quelle
1
Diese Bibliothek ist veraltet.
Yuri Tkachenko
12

Ich mag die Einfachheit von Superagent ( https://github.com/visionmedia/superagent ). Gleiche API auf Knoten und Browser.

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

Es gibt auch Node-Fetch ( https://www.npmjs.com/package/node-fetch ), dessen API mit fetchden Browsern übereinstimmt. Dies erfordert jedoch eine manuelle Codierung der Abfragezeichenfolge, verarbeitet Inhaltstypen nicht automatisch oder so macht jeder der anderen Arbeit Superagent.

Pascal Belloncle
quelle
1
Und im Gegensatz zu Nadel, unirest und co liefert es leicht (Superagent: 16k, unirest: 1M, Nadel: 530K)
Lars
9

Wenn Sie nach vielversprechenden HTTP-Anfragen suchen, erledigt axios seine Aufgabe gut.

  const axios = require('axios');

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

ODER

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

So veröffentlichen Sie Rest- / JSON-Anforderungen
Wir können einfach das Anforderungspaket verwenden und die Werte, die wir senden müssen, in der Json-Variablen speichern.

Installieren Sie zuerst das erforderliche Paket in Ihrer Konsole mit der npm-Installationsanforderung --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)
               }
    );
Prakhar Sharma
quelle
2
Erstellen Sie niemals eine eigene Abfragezeichenfolge. Sie vernachlässigen es, Ihre Werte richtig zu kodieren. Node.js hat eine Bibliothek für genau
Brad
Diese Bibliothek ist veraltet.
Yuri Tkachenko
4

Ich habe ein Video gefunden, in dem erklärt wird, wie dies erreicht werden kann: https://www.youtube.com/watch?v=nuw48-u3Yrg

Es verwendet das Standardmodul "http" zusammen mit den Modulen "querystring" und "stringbuilder". Die Anwendung nimmt zwei Zahlen (unter Verwendung von zwei Textfeldern) von einer Webseite und gibt beim Senden die Summe dieser beiden zurück (zusammen mit dem Beibehalten der Werte in den Textfeldern). Dies ist das beste Beispiel, das ich irgendwo anders finden könnte.

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);
user203687
quelle
4

Das ist meine Lösung für POSTund GET.

Über die PostMethode:

Wenn der Body ein JSON-Objekt ist, ist es wichtig, ihn zu deserialisieren JSON.stringifyund möglicherweise den Content-LenghtHeader entsprechend festzulegen:

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

bevor Sie es an die Anfrage schreiben:

request.write( bodyString );

Über beide Getund PostMethoden:

Das timeoutkann als socketUnterbrechung auftreten, daher müssen Sie den Handler wie folgt registrieren:

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

während der requestHandler ist

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

Ich empfehle dringend, beide Handler zu registrieren.

Der Antworttext ist aufgeteilt, daher müssen Sie Teile am dataHandler zusammenfassen:

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

An der endder bodywird die gesamte Antwort Körper enthalten:

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

Es ist sicher, mit einem try... catch theJSON.parse` zu ​​verpacken, da Sie nicht sicher sein können, dass es sich tatsächlich um einen gut formatierten JSON handelt, und es zum Zeitpunkt der Anforderung keine Möglichkeit gibt, sich dessen sicher zu sein.

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

Verwendungszweck:

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

Nachdem ich viel Mühe hatte, ein Dienstprogramm auf niedriger Ebene zu erstellen, um den Beitrag zu bearbeiten und Anfragen für mein Projekt zu erhalten, beschloss ich, meine Bemühungen hier zu veröffentlichen. In Anlehnung an die akzeptierte Antwort finden Sie hier einen Ausschnitt zum Erstellen von http- und https-POST-Anforderungen zum Senden von JSON-Daten.

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

}
manyu
quelle
2
Sie verwenden niemals die serialisierten post_data? Konvertiert das Schreiben als js-Objekt standardmäßig in einen Puffer?
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);
});

Oder Sie könnten diese Bibliothek verwenden:

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);
Jitendra Virani
quelle
requestBibliothek ist veraltet.
Yuri Tkachenko
3

Axios ist ein vielversprechender HTTP-Client für den Browser und Node.js. Mit Axios ist es einfach, asynchrone HTTP-Anforderungen an REST-Endpunkte zu senden und CRUD-Operationen auszuführen. Es kann in einfachem JavaScript oder mit einer Bibliothek wie Vue oder React verwendet werden.

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);
        })
Abhinavxeon
quelle
2

Veröffentlichen eines weiteren axios-Beispiels für eine axios.post-Anforderung, die zusätzliche Konfigurationsoptionen und benutzerdefinierte Header verwendet.

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

Matthew Rideout
quelle
0

Durch Verwendung der Anforderungsabhängigkeit .

Einfache Lösung:

 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)
            }
        });
Shashwat Gupta
quelle
3
woher requestkommen aus?
CodyBugstein
Diese Bibliothek ist veraltet.
Yuri Tkachenko
0

Request-PromiseBietet eine vielversprechende Antwort. Andere http-Antwortcodes als 2xx führen dazu, dass das Versprechen abgelehnt wird. Dies kann durch Setzen von options.simple = false überschrieben werden

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