Socket.IO — vad är det, bibliotek för realtidsinteraktion

Vad är Socket.IO?

Socket.IO är ett öppen källkod JavaScript-bibliotek för tvåvägs händelsestyrd kommunikation mellan klient och server. Det skapades 2010 av utvecklaren Guillermo Rauch och har sedan dess blivit de facto-standarden för realtidsapplikationer på Node.js.

Till skillnad från det inbyggda WebSocket API erbjuder Socket.IO ytterligare abstraktioner: rum, namnrymder, automatisk återanslutning och binära datatyper. Biblioteket är ingen separat implementering av WebSocket — det använder Engine.IO som transportlager, som först etablerar en HTTP long-polling-anslutning och sedan försöker uppgradera till WebSocket.

Enligt npm-statistik (2025) laddas över 12 miljoner kopior av socket.io-paketet ner varje vecka, vilket gör det till ett av de mest populära biblioteken i Node.js-ekosystemet. Socket.IO stöds på alla moderna plattformar: webbläsare, iOS, Android, React Native och skrivbordsapplikationer.

Skapelsehistoria och versioner

Socket.IO version 1.0 släpptes 2014 och introducerade konceptet namnrymder (namespaces), som tillåter multiplexering av flera logiska kanaler över en enda TCP-anslutning. Version 2.0 (2017) lade till stöd för binär data och förbättrade parsningsprestanda. Den aktuella versionen 4.x (2020–2025) inkluderar fullt TypeScript-stöd, flaggskeppsanpassningsläge för skalning och förbättrad bakåtkompatibilitet.

Varje större utgåva behåller bakåtkompatibilitet för API — socket.io@2-klienten kan ansluta till socket.io@4-servern via ett särskilt kompatibilitetsläge. Detta är viktigt för långlivade projekt där uppdatering av klientsidan sker stegvis.

Hur Socket.IO fungerar

Socket.IO-arkitekturen består av två komponenter: servermodulen (npm-paketet socket.io) och klientmodulen (npm-paketet socket.io-client). Servern fungerar ovanpå en Node.js HTTP(S)-server och använder Engine.IO för att hantera transportlagret.

Vid första anslutningen skickar klienten en HTTP-förfrågan till servern. Engine.IO svarar och etablerar en long-polling-anslutning. Därefter skickar klienten en begäran om uppgradering av transportprotokollet till WebSocket. Om servern stöder WebSocket sker uppgraderingen inom samma TCP-session. Om inte, förblir anslutningen på long-polling och applikationskoden behöver inte ändras.

Enligt Socket.IO-prestandatester (2024) är latensen vid användning av WebSocket 2–5 ms per meddelandeöverföring, medan long-polling lägger till 150–300 ms på grund av HTTP-overhead. Valet av transport är transparent för utvecklaren.

Engine.IO-protokollet

Engine.IO är det lågnivåiga transportlager som Socket.IO är byggt på. Det ansvarar för att upprätta anslutning, välja transport, heartbeat (ping/pong) och bryta anslutningen. Huvudtyperna av Engine.IO-paket: open (initiering), close (stängning), ping/pong (livskontroll), upgrade (transportbyte), message (data).

Socket.IO bygger ovanpå Engine.IO sin egen händelsemodell — det är den utvecklaren arbetar med. Varje Socket.IO-meddelande är förpackat i ett Engine.IO-paket med typen message och en unik identifierare för leveransbekräftelse.

Nyckelfunktioner i Socket.IO

Socket.IO tillhandahåller en uppsättning funktioner som saknas i det inbyggda WebSocket API och som gör utvecklingen av realtidsapplikationer betydligt enklare. Låt oss titta på de viktigaste.

Automatisk återanslutning — klienten återställer automatiskt anslutningen vid avbrott med exponentiell fördröjning (100 ms, 200 ms, 400 ms... upp till maximum). Enligt SocketIO-dokumentationen (2024) är återförsöksinställningarna tillgängliga via parametrarna reconnectionDelay och reconnectionAttempts. Detta alternativ är avgörande för mobila applikationer där anslutningen kan brytas vid nätverksbyte.

Stöd för rum — servern kan gruppera sockets i rum och skicka meddelanden endast till medlemmar i ett specifikt rum. Rum kräver inte explicit skapande — de skapas vid första anslutningen av en socket. Rum är implementerade på processnivå och delas inte mellan olika servrar utan särskild adapter.

Namnrymder — logisk separation av kommunikationskanaler på en enda anslutning. Till exempel namnrymden /chat för chattmeddelanden och /notifications för notifikationer. Varje namnrymd har egna rum, middleware och hanterare. Namnrymder multiplexas över en enda TCP-anslutning, vilket sparar resurser.

Leveransbekräftelse — vid sändning av ett meddelande kan en callback-funktion skickas som anropas när servern bekräftar mottagandet. Detta implementeras genom en unik identifierare för varje paket. Bekräftelsemekanismen garanterar att kritiskt viktiga meddelanden (t.ex. betalningstransaktioner) har levererats till mottagaren.

Socket.IO vs WebSocket: jämförelse

Valet mellan Socket.IO och inbyggd WebSocket beror på projektkraven. WebSocket är ett standardiserat protokoll (RFC 6455) som stöds av alla moderna webbläsare. Socket.IO är ett bibliotek som använder WebSocket som transport men lägger till ytterligare funktioner.

Om projektet kräver maximal prestanda och minimal klientstorlek — välj inbyggd WebSocket. Om pålitlig leverans, gruppering och händelsemodell behövs — förkortar Socket.IO utvecklingstiden med 2–3 gånger tack vare färdiga abstraktioner.

Enligt State of JS 2024-undersökningen föredrar 67 % av utvecklarna av realtidsapplikationer Socket.IO på grund av API-bekvämlighet och inbyggd hantering av kantfall (nätverksavbrott, återanslutning, binär data).

Hur man ansluter Socket.IO i ett projekt

Installation av Socket.IO kräver två paket: server och klient. Låt oss titta på grundkonfigurationen för ett Node.js-projekt. Servern skapar en HTTP-server, initierar Socket.IO och hanterar klienters anslutnings- och frånkopplingshändelser.

Enligt Socket.IO-dokumentationen (2024) kan servern startas utan Express med den inbyggda http-modulen, men i verkliga projekt används vanligtvis Express eller Fastify för routning av HTTP-förfrågningar.

Serverkod i Node.js

const express = require('express');
const http = require('http');
const Server = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server, {
    cors: { origin: '*' }
});

io.on('connection', (socket) => {
    console.log('Klient ansluten:', socket.id);

    socket.emit('welcome', { message: 'Hello from server' });

    socket.on('disconnect', () => {
        console.log('Klient frånkopplad');
    });
});

server.listen(3000, () => {
    console.log('Servern körs på port 3000');
});

Klientkod i webbläsaren

import { io } from 'socket.io-client';

const socket = io('http://localhost:3000', {
    transports: ['websocket', 'polling'],
    reconnectionDelay: 1000
});

socket.on('welcome', (data) => {
    console.log(data.message);
});

socket.emit('chat message', {
    user: 'Alice',
    text: 'Hello everyone!'
});

Händelser och rum i Socket.IO

Socket.IO-händelsemodellen är baserad på namngivna händelser. Servern och klienten skickar och tar emot meddelanden kopplade till ett specifikt händelsenamn. Payload kan vara en sträng, JSON-objekt eller binär data (Buffer, ArrayBuffer, Blob).

Varje händelse stöder ACK (acknowledgement) — överföring av en callback-funktion som körs på avsändarsidan efter att händelsen har bearbetats av mottagaren. Detta gör det möjligt att implementera request-response-mönstret ovanpå händelsemodellen. ACK fungerar bara om mottagaren explicit anropar callbacken.

Enligt Socket.IO-dokumentationen (2024) bör den maximala storleken på ett enskilt meddelande inte överstiga 1 MB för optimal prestanda. Större meddelanden bör delas upp i fragment eller skickas via en separat kanal.

Arbeta med rum

io.on('connection', (socket) => {
    socket.join('room-1');

    socket.to('room-1').emit('user joined', {
        userId: socket.id
    });

    io.to('room-1').emit('message', {
        text: 'Broadcast to room'
    });

    socket.leave('room-1');
});

Skalning av Socket.IO

Horisontell skalning av Socket.IO kräver lösning av problemet med tillståndsdelning mellan flera serverprocesser. Rum, namnrymder och listan över anslutna sockets lagras i minnet av en process och är inte synliga för andra processer utan adapter.

Officiella Socket.IO-adapter: redis (via Redis Pub/Sub), mongodb (via MongoDB change streams), cluster (för flerprocessläget Node.js cluster). Adaptern fungerar som en meddelandemäklare mellan Socket.IO-instanser. När en händelse skickas till ett rum publicerar adaptern den i Redis och alla servrar får ett meddelande.

Enligt Socket.IO-belastningstester (2024) hanterar ett kluster med 4 servrar med Redis-adapter upp till 400 000 samtidiga anslutningar med latens under 10 ms. Utan adapter är den maximala kapaciteten för en Node.js-process cirka 100 000 anslutningar med 1 GB minne.

Konfiguration av Redis-adapter

const Server = require('socket.io');
const RedisAdapter = require('@socket.io/redis-adapter');
const Redis = require('ioredis');

const pubClient = new Redis({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();
const io = new Server(server);
io.adapter(RedisAdapter(pubClient, subClient));

Vid användning av Kubernetes eller Docker Swarm rekommenderas ytterligare konfiguration av session affinity (sticky sessions) så att förfrågningar från samma klient når samma server, annars kan tilldelningen ändras vid varje återanslutning.