Erstellen von HTTP-Anfragen in Node.js mit Got

Beim Erstellen von Anwendungen in Node.js ist das Senden von HTTP-Anfragen eine grundlegende Aufgabe, unabhängig davon, ob Sie mit externen APIs interagieren, Daten abrufen oder zwischen Diensten kommunizieren. Obwohl Node.js über ein integriertes http-Modul zum Senden von Anfragen verfügt, ist es nicht die benutzerfreundlichste oder funktionsreichste Lösung. Hier kommen Bibliotheken wie Got ins Spiel.

Got ist ein leichter, funktionsreicher und auf Versprechen basierender HTTP-Client für Node.js. Es vereinfacht den Prozess der Erstellung von HTTP-Anfragen, bietet eine saubere API, automatische Wiederholungsversuche, Unterstützung für Streams und mehr. In diesem Artikel erfahren Sie, wie Sie Got zum Senden von HTTP-Anfragen und zum Behandeln von Fehlern verwenden.

Warum Got für HTTP-Anfragen wählen?

Bevor Sie sich mit dem Code befassen, ist es wichtig zu verstehen, warum Got für viele Entwickler die bevorzugte Wahl ist:

• Einfache API: Got bietet eine saubere und intuitive API, die es einfach macht, verschiedene Arten von HTTP-Anfragen auszuführen.
• Promise-basiert: Got ist vollständig Promise-basiert, sodass Sie die Async/Await-Syntax für saubereren und besser lesbaren Code verwenden können.
• Automatische Wiederholungsversuche: Got kann Anfragen bei Netzwerkfehlern oder anderen Problemen automatisch wiederholen, was besonders nützlich ist, um die Zuverlässigkeit Ihrer Anwendung zu verbessern.
• Unterstützung für Streams: Got unterstützt Streaming, was zum Herunterladen großer Dateien oder zum Arbeiten mit Daten in Blöcken nützlich ist.
• Anpassbar: Got ist hochgradig anpassbar und bietet Optionen zum Ändern von Headern, Abfrageparametern, Zeitüberschreitungen und mehr.

Got installieren

Um mit Got zu beginnen, müssen Sie es zunächst in Ihrem Node.js-Projekt installieren. Wenn Sie noch kein Node.js-Projekt eingerichtet haben, befolgen Sie diese Schritte:

1. Initialisieren Sie Ihr Projekt:Öffnen Sie Ihr Terminal und erstellen Sie ein neues Verzeichnis für Ihr Projekt:

   mkdir got-http-requests
   cd got-http-requests
   npm init -y

Dieser Befehl erstellt ein neues Projektverzeichnis und initialisiert es mit einer package.json-Datei.

1. Got installieren: Als nächstes installieren Sie Got mit npm:

   npm install got

Got ist jetzt zu Ihrem Projekt hinzugefügt und Sie können damit beginnen, HTTP-Anfragen zu stellen.

HTTP-Anfragen mit Got stellen

Got erleichtert die Durchführung verschiedener Arten von HTTP-Anfragen. Lassen Sie uns einige häufige Anwendungsfälle durchgehen.

1. Eine einfache GET-Anfrage stellen

Eine GET-Anfrage ist die häufigste Art von HTTP-Anfrage und wird normalerweise zum Abrufen von Daten von einem Server verwendet. Mit Got ist das Stellen einer GET-Anfrage ganz einfach:

const got = require('got');

(async () => {
    try {
        const response = await got('https://jsonplaceholder.typicode.com/posts/1');
        console.log('GET Request:');
        console.log(response.body);
    } catch (error) {
        console.error('Error in GET request:', error.message);
    }
})();

• Erklärung:
• Endpunkt: https://jsonplaceholder.typicode.com/posts/1 ist eine Test-API, die die Details eines Beitrags mit der ID 1 zurückgibt.
• Got-Syntax: Die got(url)-Funktion sendet eine GET-Anfrage an die angegebene URL. Die Antwort wird als Versprechen behandelt, sodass wir mit „await“ auf die Antwort warten können.
• Antwort: Der Antworttext wird in der Konsole protokolliert, die die JSON-Daten des Beitrags enthält.

2. Eine POST-Anfrage stellen

Eine POST-Anfrage wird verwendet, um Daten an einen Server zu senden, oft um eine neue Ressource zu erstellen. Mit Got können Sie JSON-Daten ganz einfach in einer POST-Anfrage senden:

const got = require('got');

(async () => {
    try {
        const response = await got.post('https://jsonplaceholder.typicode.com/posts', {
            json: {
                title: 'foo',
                body: 'bar',
                userId: 1
            },
            responseType: 'json'
        });
        console.log('POST Request:');
        console.log(response.body);
    } catch (error) {
        console.error('Error in POST request:', error.message);
    }
})();

• Erklärung:
• Endpunkt: https://jsonplaceholder.typicode.com/posts wird verwendet, um einen neuen Beitrag auf dem Server zu erstellen.
• JSON-Daten: Mit der JSON-Option in der Got-Anfrage können Sie die zu sendenden Daten angeben. Hier senden wir einen neuen Beitrag mit Titel, Text und Benutzer-ID.
• Antwort: Die Antwort des Servers, die die zusammen mit einer neuen ID gesendeten Daten enthält, wird in der Konsole protokolliert.

3. Umgang mit Fehlern

Bei HTTP-Anfragen können Netzwerkprobleme oder Serverfehler auftreten. Got bietet eine einfache Möglichkeit, mit diesen Fehlern umzugehen:

const got = require('got');

(async () => {
    try {
        const response = await got('https://nonexistent-url.com');
        console.log(response.body);
    } catch (error) {
        console.error('Error handling example:', error.message);
    }
})();

• Erklärung:
• Nicht vorhandene URL: In diesem Beispiel wird versucht, eine GET-Anfrage an eine URL zu stellen, die nicht existiert.
• Fehlerbehandlung: Got gibt automatisch einen Fehler aus, wenn die Anfrage fehlschlägt. Der Catch-Block erfasst diesen Fehler und protokolliert die Fehlermeldung in der Konsole.

Erweiterte Funktionen von Got

Bei Got geht es nicht nur darum, einfache GET- und POST-Anfragen zu stellen. Es verfügt über mehrere erweiterte Funktionen, die Ihnen bei der Bewältigung komplexerer Szenarien helfen können.

1. Anfrageoptionen anpassen

Mit Got können Sie Anfragen anpassen, indem Sie Header, Abfrageparameter, Zeitüberschreitungen und mehr festlegen:

const got = require('got');

(async () => {
    try {
        const response = await got('https://jsonplaceholder.typicode.com/posts/1', {
            headers: {
                'User-Agent': 'My-Custom-Agent'
            },
            searchParams: {
                userId: 1
            },
            timeout: 5000
        });
        console.log('Customized Request:');
        console.log(response.body);
    } catch (error) {
        console.error('Error in customized request:', error.message);
    }
})();

• Explanation:
• Headers: You can set custom headers using the headers option. Here, we set a custom User-Agent.
• Query Parameters: The searchParams option allows you to add query parameters to the URL.
• Timeout: The timeout option sets the maximum time (in milliseconds) the request can take before throwing an error.

2. Streaming with Got

Got supports streaming, which is useful for handling large data or working with files:

const fs = require('fs');
const got = require('got');

(async () => {
    const downloadStream = got.stream('https://via.placeholder.com/150');
    const fileWriterStream = fs.createWriteStream('downloaded_image.png');

    downloadStream.pipe(fileWriterStream);

    fileWriterStream.on('finish', () => {
        console.log('Image downloaded successfully.');
    });
})();

• Explanation:
• Streaming: The got.stream(url) function initiates a streaming GET request. The data is piped directly to a writable stream, such as a file.
• File Writing: The fs.createWriteStream() function is used to write the streamed data to a file.

Download the source code here.

Conclusion

Got is a versatile and powerful library for making HTTP requests in Node.js. It simplifies the process of interacting with web services by providing a clean and intuitive API, while also offering advanced features like error handling, timeouts, and streams. Whether you’re building a simple script or a complex application, Got is an excellent choice for handling HTTP requests.

By using Got, you can write cleaner, more maintainable code and take advantage of its robust feature set to meet the needs of your application. So the next time you need to make an HTTP request in Node.js, consider using Got for a hassle-free experience.

Thanks for reading…

Happy Coding!

The post Making HTTP Requests in Node.js with Got first appeared on Innovate With Folasayo.

The post Making HTTP Requests in Node.js with Got appeared first on Innovate With Folasayo.

Das obige ist der detaillierte Inhalt vonErstellen von HTTP-Anfragen in Node.js mit Got. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!