5 Node.js HTTP-Anforderungsmethoden, die jeder Entwickler beherrschen sollte

Node.js hat die Backend-Entwicklung mit seinem ereignisgesteuerten, nicht blockierenden E/A-Modell revolutioniert. Von zentraler Bedeutung für die Entwicklung robuster Webanwendungen, APIs und Microservices ist die Fähigkeit, HTTP-Anfragen effizient und zuverlässig zu stellen. Ob beim Abrufen von Daten aus externen APIs, bei der Kommunikation zwischen Diensten oder bei der Integration mit Plattformen von Drittanbietern – die Beherrschung der HTTP-Anfragemethoden in Node.js ist unerlässlich.

Zwar gibt es zahlreiche Bibliotheken, die die HTTP-Kommunikation vereinfachen, doch erst das Verständnis der wichtigsten Werkzeuge und ihrer Vor- und Nachteile versetzt Entwickler in die Lage, für jedes Szenario die richtige Methode auszuwählen. Dieser Artikel befasst sich mit fünf leistungsstarken HTTP-Anfragemethoden in Node.js: die nativen http/https Module, axios, node-fetch, got, Und elf. Jede bietet einzigartige Vorteile hinsichtlich Leistung, Entwicklererfahrung und Funktionsumfang.

1. Die nativen HTTP- und HTTPS-Module: Die Core Foundation

Das Herzstück von Node.js bildet die integrierte http Und https Module. Diese bieten einen Low-Level-Zugriff auf HTTP-Client-Funktionen ohne externe Abhängigkeiten. Sie sind zwar etwas ausführlich, bieten jedoch unübertroffene Kontrollmöglichkeiten und eignen sich ideal für leistungskritische Anwendungen oder minimalistische Umgebungen.

Die wichtigsten Vorteile

• Keine externen Abhängigkeiten
• Volle Kontrolle über Header, Timeouts und Streaming
• Native Integration mit Node.js-Streams
• Geringer Speicherbedarf

Eine GET-Anfrage senden

javascript
const https = require('https');

const options = {
  hostname: 'api.github.com',
  path: '/repos/nodejs/node',
  headers: {
    'User-Agent': 'node-js-app'
  }
};

https.get(options, (res) => {
  let data = '';

  res.on('data', (chunk) => {
    data += chunk;
  });

  res.on('end', () => {
    const repo = JSON.parse(data);
    console.log(`Das Node.js-Repo hat ${repo.stargazers_count} Sterne`);
  });
}).on('error', (err) => {
  console.error('Anfrage fehlgeschlagen:', err.message);
});

POST-Anfrage mit JSON-Nutzdaten

javascript
const https = require('https');

const postData = JSON.stringify({
  title: 'Neuer Beitrag',
  body: 'Das ist der Inhalt',
  userId: 1
});

const options = {
  hostname: 'jsonplaceholder.typicode.com',
  path: '/posts',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData)
  }
};

const req = https.request(options, (res) => {
  let response = '';

  res.on('data', (chunk) => {
    response += chunk;
  });

  res.on('end', () => {
    console.log('Antwort:', JSON.parse(response));
  });
});

req.on('error', (err) => {
  console.error('Fehler:', err.message);
});

req.write(postData);
req.end();

Die nativen Module spielen ihre Stärken besonders in Streaming-Szenarien aus. Bei großen Datei-Uploads oder -Downloads können Sie Streams direkt weiterleiten:

javascript
const fs = require('fs');
const https = require('https');

const fileStream = fs.createReadStream('large-file.zip');
const req = https.request({
  hostname: 'example.com',
  path: '/upload',
  method: 'POST',
  headers: {
    'Content-Type': 'application/octet-stream'
  }
});

fileStream.pipe(req);

Die nativen Module sind zwar leistungsstark, erfordern jedoch die manuelle Behandlung von Sonderfällen wie Weiterleitungen, Timeouts und der JSON-Auswertung. Dadurch eignen sie sich weniger für das schnelle Prototyping, sind aber perfekt, wenn jedes Byte und jede Millisekunde zählt.

2. Axios: Das leistungsstarke Unternehmen auf Basis von „Promise“

Axios hat sich zum De-facto-Standard für HTTP-Anfragen in Node.js- und Browserumgebungen entwickelt. Dank seiner Promise-basierten API, der automatischen JSON-Auswertung und seines umfangreichen Funktionsumfangs ist es für Entwickler äußerst benutzerfreundlich.

Warum Entwickler Axios lieben

• Automatische Umwandlung von JSON-Anfragen und -Antworten
• Integrierter XSRF-Schutz
• Anfrage- und Antwort-Interceptoren
• Timeout-Konfiguration
• Stornierbare Anfragen über CancelToken

Installation und grundlegende Bedienung

bash

npm install axios

javascript
const axios = require('axios');

// GET-Anfrage
axios.get('https://api.github.com/repos/nodejs/node')
  .then(response => {
    console.log(`Sterne: ${response.data.stargazers_count}`);
  })
  .catch(error => {
    console.error('Fehler:', error.message);
  });

// POST mit Konfiguration
axios.post(
'https://jsonplaceholder.typicode.com/posts',
  {
    title: 'Neuer Beitrag',
    body: 'Inhalt hier',
    userId: 1
  },
  {
    headers: {
 'Authorization': 'Bearer token123',
 'Custom-Header': 'value'
    },
    timeout: 5000
  }
).then(res => {
  console.log('Erstellt:', res.data);
});

Erweiterte Funktionen: Interceptors

Mit Interceptors lassen sich Anfragen oder Antworten global ändern:

javascript
// Request-Interceptor
axios.interceptors.request.use(config => {
  config.headers['X-Request-ID'] = generateId();
  config.metadata = { startTime: new Date() };
  return config;
});

// Antwort-Interceptor
axios.interceptors.response.use(
  response => {
    const endTime = new Date();
    const duration = endTime - response.config.metadata.startTime;
    console.log(`Die Anfrage dauerte ${duration} ms`);
    return response;
  },
  error => {
    console.error('API-Fehler:', error.response?.status);
    return Promise.reject(error);
  }
);

Stornierungsanträge

javascript
const CancelToken = axios.CancelToken;
const source = CancelToken.source();

axios.get('/data', {
  cancelToken: source.token
}).catch(thrown => {
  if (axios.isCancel(thrown)) {
    console.log('Anfrage abgebrochen');
  }
});

// Die Anfrage abbrechen
source.cancel('Vorgang vom Benutzer abgebrochen');

Axios eignet sich besonders gut für Unternehmensanwendungen, bei denen eine konsistente Fehlerbehandlung, Protokollierung und Anpassung von Anfragen von entscheidender Bedeutung sind. Dank seiner Browserkompatibilität ist es zudem ideal für isomorphe Anwendungen geeignet.

3. node-fetch: Die Fetch-API für Node.js

Die Fetch-API, die in modernen Browsern nativ integriert ist, bietet eine übersichtliche, Promise-basierte Schnittstelle für HTTP-Anfragen. node-fetch bringt diese vertraute API in Node.js und eignet sich damit ideal für Entwickler, die vom Frontend zum Backend wechseln.

Hauptmerkmale

• Vertraute, browserähnliche API
• Geringer Speicherbedarf (~4 KB)
• Unterstützung für Streams
• Einhaltung der WHATWG-Fetch-Spezifikation

Einrichtung

bash
npm install node-fetch

Grundlegende Verwendung (CommonJS)

javascript
const fetch = require('node-fetch');

// GET-Anfrage
fetch('https://api.github.com/repos/nodejs/node')
  .then(res => res.json())
  .then(data => {
    console.log(`Sterne: ${data.stargazers_count}`);
  })
  .catch(err => {
    console.error('Abruf fehlgeschlagen:', err);
  });

// POST mit JSON
fetch('https://jsonplaceholder.typicode.com/posts', {
  method: 'POST',
  body: JSON.stringify({
    title: 'fetch post',
    body: 'using node-fetch',
    userId: 1
  }),
  headers: {
    'Content-Type': 'application/json'
  }
})
.then(res => res.json())
.then(data => console.log(data));

Streaming-Antworten

javascript
fetch('https://example.com/large-file.zip')
  .then(res => {
    const dest = fs.createWriteStream('downloaded.zip');
    res.body.pipe(dest);
  });

AbortController für den Abbruch

javascript
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 5000);

fetch('https://slow-api.com/data', {
  signal: controller.signal
})
.then(res => res.json())
.catch(err => {
  if (err.name === 'AbortError') {
    console.log('Zeitüberschreitung bei der Anfrage');
  }
});

node-fetch ist ideal für Entwickler, die die moderne Fetch-API-Syntax bevorzugen und nur ein Minimum an Abstraktion wünschen. Version 3+ unterstützt ESM nativ und ist damit zukunftssicher für moderne Node.js-Anwendungen.

4. Got: Der benutzerfreundliche HTTP-Client

Got ist eine funktionsreiche, benutzerfreundliche HTTP-Anfrage-Bibliothek, die speziell für Node.js entwickelt wurde. Sie erweitert die native Fetch-API um sinnvolle Standardwerte und leistungsstarke Erweiterungen.

Besondere Merkmale

• Für Menschen verständliche Fehlermeldungen
• Automatischer Wiederholungsversuch mit exponentiellem Backoff
• Paginierung anfordern
• Cache-Unterstützung
• Fortschrittsberichterstattung
• Hooks für den Lebenszyklus einer Anfrage

Einrichtung

bash
npm install got

Grundlegende Verwendung

javascript
const got = require('got');

// Einfacher GET-Aufruf
got('https://api.github.com/repos/nodejs/node').json()
  .then(data => {
    console.log(`Stars: ${data.stargazers_count}`);
  });

// POST mit Wiederholungsversuch
got.post('https://jsonplaceholder.typicode.com/posts', {
  json: {
    title: 'got request',
    body: 'content',
    userId: 1
  },
  retry: {
    limit: 3,
    methods: ['POST'],
    statusCodes: [413, 429]
  }
}).json().then(console.log);

Streaming mit Progress

javascript
const stream = got.stream('https://example.com/large-file.zip');

stream.on('downloadProgress', progress => {
  console.log(`${progress.transferred} Bytes heruntergeladen`);
});

const writeStream = fs.createWriteStream('file.zip');
stream.pipe(writeStream);

Hooks zur Anpassung

javascript
const client = got.extend({
  hooks: {
    beforeRequest: [
 options => {
 options.headers['x-request-id'] = generateId();
      }
    ],
    afterResponse: [
 response => {
 response.requestDuration = Date.now() - response.requestStart;
 return response;
 }
    ]
  }
});

Got bewährt sich in Produktionsumgebungen, in denen Zuverlässigkeit, Beobachtbarkeit und Entwicklererfahrung eine wichtige Rolle spielen. Seine durchdachten Standardeinstellungen reduzieren den Boilerplate-Code und gewährleisten gleichzeitig Flexibilität.

5. Undici: Der Hochleistungs-Anwärter

Undici (italienisch für “elf”) ist ein moderner HTTP/1.1-Client, der vom Node.js-Kernteam für Node.js entwickelt wurde. Der Schwerpunkt liegt auf Leistung, Korrektheit und der Einhaltung von Standards.

Leistungsvorteile

• In JavaScript geschrieben, wobei leistungskritische Teile in C++ implementiert sind
• Verbindungspooling
• HTTP/1.1-Pipelining
• Vollduplex-Streams
• Kein Overhead im Vergleich zu nativen Modulen

Einrichtung

bash
npm install undici

Grundlegende Verwendung

javascript
const { request } = require('undici');

async function makeRequest() {
  const { statusCode, body } = await request('https://api.github.com/repos/nodejs/node');

  console.log('Status:', statusCode);

  for await (const data of body) {
    console.log('Datenblock:', data.toString());
  }
}

makeRequest();

Verwendung des Clients mit Verbindungspooling

javascript
const { Client } = require('undici');

const client = new Client('https://api.github.com');

async function concurrentRequests() {
  const promises = Array(10).fill().map(() =>
    client.request({
 path: '/repos/nodejs/node',
 method: 'GET'
    }).then(({ body }) => body.json())
  );

  const results = await Promise.all(promises);
  console.log('Parallele Anfragen abgeschlossen');
}

concurrentRequests();

Streaming-Upload

javascript
const { pipeline } = require('stream');
const fs = require('fs');

const client = new Client('https://httpbin.org');

pipeline(
  fs.createReadStream('data.json'),
  client.stream({
    path: '/post',
    method: 'POST',
    headers: { 'content-type': 'application/json' }
  }, ({ statusCode }) => {
    console.log('Antwortstatus:', statusCode);
  }),
  (err) => {
    if (err) console.error('Pipeline fehlgeschlagen:', err);
  }
);

Undici steht für die Zukunft der HTTP-Clients in Node.js. Seine Leistung kann mit nativen Modulen mithalten und bietet gleichzeitig eine moderne API. Es eignet sich besonders für Anwendungen mit hohem Durchsatz und Microservices.

Vergleich und Anwendungsfälle

Leistungs-Benchmarks (Anfragen/Sekunde)

Undici: 18.500
Native: 16.200
Got: 12.800
node-fetch:    11.500
Axios: 9.800

Bewährte Vorgehensweisen für alle Methoden

1. Behandeln Sie Fehler stets — Netzwerkausfälle sind unvermeidbar
2. Zeitlimits festlegen — Verhindern, dass Anfragen hängen bleiben
3. Antworten überprüfen — Statuscodes und Inhalt überprüfen
4. Verbindungspooling verwenden bei mehreren Anfragen an denselben Host
5. Wiederholungslogik implementieren bei vorübergehenden Ausfällen
6. Anforderungsmetriken überwachen in Produktion
7. Ratenbegrenzungen einhalten externer APIs

javascript
// Generic error handling pattern
async function safeRequest(requestFn) {
  try {
    const response = await requestFn();
    if (response.status >= 400) {
      throw new Error(`HTTP ${response.status}`);
    }
    return response.data;
  } catch (error) {
    if (error.code === 'ENOTFOUND') {
      // DNS failure
    } else if (error.code === 'ECONNRESET') {
      // Connection reset
    }
    throw error;
  }
}

Abschluss

Die Beherrschung der HTTP-Anfragemethoden in Node.js ist für die Entwicklung robuster Anwendungen von grundlegender Bedeutung. Jede Methode erfüllt unterschiedliche Anforderungen:

• Verwenden Sie native Module wenn Sie absolute Kontrolle und keinerlei Abhängigkeiten benötigen
• Wählen Sie Axios für geschäftliche Anwendungen die umfangreiche Funktionen und Konsistenz erfordern
• Auswahl node-fetch wenn Sie die bekannte Browser-Fetch-API nutzen möchten
• Wählen Sie Habe für Produktionssysteme, bei denen Zuverlässigkeit und Beobachtbarkeit gefragt sind
• Adoptieren Elf für maximale Leistung in modernen Node.js-Anwendungen

Die besten Node.js-Entwickler kennen nicht nur eine Methode – sie wissen auch, wann und warum sie die jeweilige Methode einsetzen sollten. Beginnen Sie mit der Methode, die den unmittelbaren Anforderungen Ihres Projekts entspricht, und bauen Sie Ihr Fachwissen im Laufe der Zeit weiter aus. Ihr zukünftiges Ich (und Ihre Produktionssysteme) werden es Ihnen danken.

Bei Carmatec, unsere erfahrenen Node.js-Entwickler Bleiben Sie immer einen Schritt voraus und machen Sie sich mit den neuesten Updates in Node.js vertraut, darunter die Weiterentwicklungen bei Undici sowie die native Unterstützung von HTTP/2 und HTTP/3. Node.js-Entwickler einstellen von Carmatec, um effiziente, skalierbare und zukunftsfähige Anwendungen zu entwickeln, die die besten Praktiken der modernen Webentwicklung nutzen.