5 Node.js HTTP-förfrågningsmetoder som varje utvecklare bör behärska

Node.js har revolutionerat backend-utvecklingen med sin händelsestyrda, icke-blockerande I/O-modell. För att kunna bygga robusta webbapplikationer, API:er och mikrotjänster är det avgörande att kunna skicka HTTP-förfrågningar på ett effektivt och tillförlitligt sätt. Oavsett om det handlar om att hämta data från externa API:er, kommunicera mellan tjänster eller integrera med tredjepartsplattformar är det avgörande att behärska HTTP-förfrågningsmetoderna i Node.js.

Även om det finns många bibliotek som förenklar HTTP-kommunikationen, ger en förståelse för de viktigaste verktygen och deras för- och nackdelar utvecklare möjlighet att välja rätt metod för varje situation. Den här artikeln tar upp fem kraftfulla HTTP-förfrågningsmetoder i Node.js: den inbyggda http/https moduler, axios, node-fetch, got, och elva. Var och en erbjuder unika fördelar när det gäller prestanda, utvecklingsupplevelse och funktionsutbud.

1. De inbyggda HTTP- och HTTPS-modulerna: Core Foundation

I hjärtat av Node.js finns den inbyggda http och https moduler. Dessa ger åtkomst på låg nivå till HTTP-klientfunktioner utan externa beroenden. Även om de är ganska detaljerade erbjuder de oöverträffad kontroll och är idealiska för prestandakritiska applikationer eller minimala miljöer.

De viktigaste fördelarna

• Inga externa beroenden
• Fullständig kontroll över rubriker, tidsgränser och strömning
• Inbyggd integration med Node.js-strömmar
• Minimalt minnesbehov

Skapa en GET-förfrågan

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(`Node.js-repositoriet har ${repo.stargazers_count} stjärnor`);
  });
}).on('error', (err) => {
  console.error('Begäran misslyckades:', err.message);
});

POST-förfrågan med JSON-data

javascript
const https = require('https');

const postData = JSON.stringify({
  title: 'Nytt inlägg',
  body: 'Detta är innehållet',
  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('Svar:', JSON.parse(response));
  });
});

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

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

De inbyggda modulerna kommer verkligen till sin rätt i strömningssammanhang. Vid uppladdning eller nedladdning av stora filer kan du vidarebefordra strömmarna direkt:

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

Även om de inbyggda modulerna är kraftfulla kräver de manuell hantering av specialfall som omdirigeringar, tidsgränser och JSON-tolkning. Detta gör dem mindre lämpliga för snabb prototyputveckling, men perfekta när varje byte och millisekund räknas.

2. Axios: Den löftesbaserade kraftkällan

Axios har blivit den de facto-standarden för HTTP-förfrågningar i Node.js och webbläsarmiljöer. Dess löftesbaserade API, automatisk JSON-tolkning och omfattande funktionsuppsättning gör det otroligt utvecklarvänligt.

Varför utvecklare älskar Axios

• Automatisk omvandling av JSON-förfrågningar och -svar
• Inbyggt XSRF-skydd
• Avlyssnare för förfrågningar och svar
• Konfiguration av timeout
• Begäranden som kan avbrytas via CancelToken

Installation och grundläggande användning

bash

npm install axios

javascript
const axios = require('axios');

// GET-förfrågan
axios.get('https://api.github.com/repos/nodejs/node')
  .then(response => {
    console.log(`Stjärnor: ${response.data.stargazers_count}`);
  })
  .catch(error => {
    console.error('Fel:', error.message);
  });

// POST med konfiguration
axios.post(
'https://jsonplaceholder.typicode.com/posts',
  {
    title: 'New Post',
    body: 'Content here',
    userId: 1
  },
  {
    headers: {
 'Authorization': 'Bearer token123',
 'Custom-Header': 'value'
    },
    timeout: 5000
  }
).then(res => {
  console.log('Skapad:', res.data);
});

Avancerade funktioner: Interceptors

Med hjälp av interceptorer kan man ändra förfrågningar eller svar på global nivå:

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

// Response interceptor
axios.interceptors.response.use(
  response => {
    const endTime = new Date();
    const duration = endTime - response.config.metadata.startTime;
    console.log(`Request took ${duration}ms`);
    return response;
  },
  error => {
    console.error('API Error:', error.response?.status);
    return Promise.reject(error);
  }
);

Begäran om avbokning

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

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

// Avbryt begäran
source.cancel('Åtgärden avbruten av användaren');

Axios är särskilt lämpligt för företagsapplikationer där konsekvent felhantering, loggning och modifiering av förfrågningar är avgörande. Dess webbläsarkompatibilitet gör det dessutom idealiskt för isomorfa applikationer.

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

Fetch API, som är en integrerad del av moderna webbläsare, erbjuder ett överskådligt, promise-baserat gränssnitt för HTTP-förfrågningar. node-fetch för med sig detta välbekanta API till Node.js, vilket gör det perfekt för utvecklare som går över från frontend till backend.

Viktiga funktioner

• Ett välbekant API som liknar det i en webbläsare
• Lättviktig (~4 KB)
• Stöd för strömmar
• Överensstämmelse med WHATWG:s Fetch-specifikation

Installation

bash
npm install node-fetch

Grundläggande användning (CommonJS)

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

// GET-förfrågan
fetch('https://api.github.com/repos/nodejs/node')
  .then(res => res.json())
  .then(data => {
    console.log(`Stjärnor: ${data.stargazers_count}`);
  })
  .catch(err => {
    console.error('Hämtningen misslyckades:', err);
  });

// POST med 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));

Strömningssvar

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

AbortController för avbrytning

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('Request timed out');
  }
});

node-fetch är perfekt för utvecklare som föredrar den moderna Fetch API-syntaxen och vill ha så lite abstraktion som möjligt. Version 3+ har inbyggt stöd för ESM, vilket gör den framtidssäker för moderna Node.js-applikationer.

4. Got: Den användarvänliga HTTP-klienten

Got är ett funktionsrikt och användarvänligt bibliotek för HTTP-förfrågningar som är särskilt utformat för Node.js. Det utökar det inbyggda Fetch-API:et med praktiska standardinställningar och kraftfulla tillägg.

Utmärkande funktioner

• Felmeddelanden som är lätta att förstå
• Automatisk omförsök med exponentiell fördröjning
• Begär sidindelning
• Cache-stöd
• Lägesrapportering
• Hooks för begäranens livscykel

Installation

bash
npm install got

Grundläggande användning

javascript
const got = require('got');

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

// POST med omförsök
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 med framsteg

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

stream.on('downloadProgress', progress => {
  console.log(`Hämtade ${progress.transferred} byte`);
});

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

Anpassningsfunktioner

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 utmärker sig i produktionsmiljöer där tillförlitlighet, observerbarhet och utvecklarupplevelse är avgörande. Dess genomtänkta standardinställningar minskar behovet av standardkod samtidigt som flexibiliteten bibehålls.

5. Undici: En högpresterande utmanare

Undici (italienska för “elva”) är en modern HTTP/1.1-klient som utvecklats för Node.js av Node.js-kärnteamet. Den är inriktad på prestanda, korrekthet och efterlevnad av standarder.

Prestandafördelar

• Skrivet i JavaScript, med prestandakritiska delar i C++
• Anslutningspoolning
• HTTP/1.1-pipelining
• Full duplex-strömmar
• Inga extra kostnader jämfört med inbyggda moduler

Installation

bash
npm install undici

Grundläggande användning

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('Data chunk:', data.toString());
  }
}

makeRequest();

Använda Client med anslutningspool

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('Concurrent requests completed');
}

concurrentRequests();

Uppladdning via streaming

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('Response status:', statusCode);
  }),
  (err) => {
    if (err) console.error('Pipeline failed:', err);
  }
);

Undici representerar framtiden för HTTP-klienter i Node.js. Dess prestanda kan mäta sig med inbyggda moduler samtidigt som den erbjuder ett modernt API. Den är särskilt lämplig för applikationer med hög genomströmning och mikrotjänster.

Jämförelse och när man ska använda respektive alternativ

Prestandajämförelser (förfrågningar/sekund)

Undici: 18 500
Native: 16 200
Got: 12 800
node-fetch:    11 500
Axios: 9 800

Bästa praxis för alla metoder

1. Hantera alltid fel — Nätverksavbrott är oundvikliga
2. Ställ in tidsgränser — Förhindra väntande förfrågningar
3. Verifiera svaren — Kontrollera statuskoder och innehåll
4. Använd anslutningspooling för flera förfrågningar till samma värd
5. Implementera logik för nya försök vid tillfälliga fel
6. Övervaka begärandestatistik i produktion
7. Följ hastighetsbegränsningarna av externa API:er

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

Slutsats

Att behärska HTTP-förfrågningsmetoderna i Node.js är avgörande för att kunna bygga robusta applikationer. Varje metod fyller olika syften:

• Användning inbyggda moduler när du behöver fullständig kontroll och inga beroenden
• Välj Axios för företagsapplikationer som kräver omfattande funktioner och enhetlighet
• Välj node-fetch när du vill använda det välbekanta Fetch API:et i webbläsaren
• Välj Fick för produktionssystem där tillförlitlighet och övervakningsbarhet är viktiga
• Anta Elva för maximal prestanda i moderna Node.js-applikationer

De bästa Node.js-utvecklarna kan inte bara en metod – de vet när och varför man ska använda var och en av dem. Börja med den som passar ditt projekts omedelbara behov, och utöka sedan dina kunskaper efter hand. Ditt framtida jag (och dina produktionssystem) kommer att tacka dig.

På Carmatec, våra erfarna Node.js-utvecklare Håll dig i framkant genom att sätta dig in i de senaste uppdateringarna i Node.js, inklusive utvecklingen inom Undici och inbyggt stöd för HTTP/2 och HTTP/3. Anlita Node.js-utvecklare från Carmatec för att bygga effektiva, skalbara och framtidssäkra applikationer som utnyttjar det bästa inom modern webbutveckling.