Socket.IO — bu nima, real-time o'zaro aloqa kutubxonasi

Socket.IO nima?

Socket.IO — mijoz va server o'rtasida ikki tomonlama hodisaga asoslangan aloqa uchun ochiq kodli JavaScript kutubxonasi. U 2010 yilda dasturchi Guillermo Rauch tomonidan yaratilgan va shundan beri Node.js da real-time ilovalar uchun de-fakto standartga aylangan.

Mahalliy WebSocket API dan farqli o'laroq, Socket.IO qo'shimcha abstraksiyalarni ta'minlaydi: xonalar, nom fazolari, avtomatik qayta ulanish va ikkilik ma'lumot turlari. Kutubxona WebSocket ning alohida tatbiqi emas — u transport qatlami sifatida Engine.IO dan foydalanadi, u avval HTTP long-polling ulanishini o'rnatadi, so'ng WebSocket ga yangilashga harakat qiladi.

npm statistikasiga (2025) ko'ra, har hafta 12 milliondan ortiq socket.io paketi yuklab olinadi, bu uni Node.js ekotizimidagi eng mashhur kutubxonalardan biriga aylantiradi. Socket.IO barcha zamonaviy platformalarda qo'llab-quvvatlanadi: brauzerlar, iOS, Android, React Native va ish stoli ilovalari.

Yaratilish tarixi va versiyalar

Socket.IO 1.0 versiyasi 2014 yilda chiqarilgan va bir TCP ulanishi orqali bir nechta mantiqiy kanallarni multiplekslash imkonini beradigan nom fazolari (namespaces) tushunchasini joriy qilgan. 2.0 versiyasi (2017) ikkilik ma'lumotlarni qo'llab-quvvatlashni qo'shgan va tahlil samaradorligini yaxshilagan. Joriy 4.x versiyasi (2020–2025) TypeScript ni to'liq qo'llab-quvvatlash, masshtablash uchun flagman moslashish rejimi va yaxshilangan orqaga moslikni o'z ichiga oladi.

Har bir asosiy reliz API ning orqaga mosligini saqlaydi — socket.io@2 mijozi maxsus moslik rejimi orqali socket.io@4 serveriga ulanishi mumkin. Bu mijoz qismi bosqichma-bosqich yangilanadigan uzoq muddatli loyihalar uchun muhimdir.

Socket.IO qanday ishlaydi

Socket.IO arxitekturasi ikkita komponentdan iborat: server moduli (npm-paket socket.io) va mijoz moduli (npm-paket socket.io-client). Server Node.js HTTP(S) serveri ustida ishlaydi va transport qatlamini boshqarish uchun Engine.IO dan foydalanadi.

Birinchi ulanishda mijoz serverga HTTP so'rovi yuboradi. Engine.IO javob beradi va long-polling ulanishini o'rnatadi. Shundan so'ng mijoz transport protokolini WebSocket ga yangilash uchun so'rov yuboradi. Agar server WebSocket ni qo'llab-quvvatlasa, yangilash bir TCP sessiyasi doirasida amalga oshiriladi. Aks holda, ulanish long-polling da qoladi va ilova kodi o'zgarishni talab qilmaydi.

Socket.IO samaradorlik testlariga (2024) ko'ra, WebSocket dan foydalanganda kechikish xabar uzatish uchun 2–5 ms ni tashkil qiladi, long-polling esa HTTP qo'shimcha xarajatlari tufayli 150–300 ms qo'shadi. Transport tanlovi dasturchi uchun shaffofdir.

Engine.IO protokoli

Engine.IO — Socket.IO qurilgan past darajadagi transport qatlami. U ulanishni o'rnatish, transportni tanlash, heartbeat (ping/pong) va ulanishni uzish uchun javobgardir. Engine.IO paketlarining asosiy turlari: open (ishga tushirish), close (yopish), ping/pong (hayotni tekshirish), upgrade (transportni o'zgartirish), message (ma'lumot).

Socket.IO Engine.IO ustida o'zining hodisa modelini quradi — dasturchi aynan shu bilan ishlaydi. Har bir Socket.IO xabari Engine.IO paketiga message turi bilan va yetkazib berishni tasdiqlash uchun noyob identifikator bilan o'raladi.

Socket.IO ning asosiy xususiyatlari

Socket.IO mahalliy WebSocket API da mavjud bo'lmagan va real-time ilovalarni ishlab chiqishni sezilarli darajada osonlashtiradigan funksiyalar to'plamini taqdim etadi. Keling, asosiylarini ko'rib chiqaylik.

Avtomatik qayta ulanish — mijoz uzilishda eksponensial kechikish bilan (100 ms, 200 ms, 400 ms... maksimalgacha) avtomatik ravishda ulanishni tiklaydi. Socket.IO hujjatlariga (2024) ko'ra, qayta urinish sozlamalari reconnectionDelay va reconnectionAttempts parametrlari orqali mavjud. Bu variant tarmoq o'zgarishida ulanish uzilishi mumkin bo'lgan mobil ilovalar uchun juda muhimdir.

Xonalarni qo'llab-quvvatlash — server soketlarni xonalarda guruhlab, xabarlarni faqat ma'lum bir xona a'zolariga yuborishi mumkin. Xonalar aniq yaratishni talab qilmaydi — ular birinchi soket qo'shilganda yaratiladi. Xonalar jarayon darajasida amalga oshiriladi va maxsus adapterlarsiz turli serverlar o'rtasida taqsimlanmaydi.

Nom fazolari — bitta ulanishda aloqa kanallarini mantiqiy ajratish. Masalan, chat xabarlari uchun /chat va bildirishnomalar uchun /notifications nom fazosi. Har bir nom fazosining o'z xonalari, middleware va ishlovchilari bor. Nom fazolari bitta TCP ulanishi orqali multiplekslanadi, bu resurslarni tejaydi.

Yetkazib berishni tasdiqlash — xabar yuborishda server qabul qilishni tasdiqlaganida chaqiriladigan callback funksiyasini uzatish mumkin. Bu har bir paketning noyob identifikatori orqali amalga oshiriladi. Tasdiqlash mexanizmi muhim xabarlarning (masalan, to'lov operatsiyalari) qabul qiluvchiga yetkazilganligini kafolatlaydi.

Socket.IO vs WebSocket: taqqoslash

Socket.IO va mahalliy WebSocket o'rtasidagi tanlov loyiha talablariga bog'liq. WebSocket barcha zamonaviy brauzerlar tomonidan qo'llab-quvvatlanadigan standartlashtirilgan protokol (RFC 6455). Socket.IO WebSocket ni transport sifatida ishlatadigan, ammo qo'shimcha funksiyalarni qo'shadigan kutubxonadir.

Loyiha maksimal samaradorlik va minimal mijoz hajmini talab qilsa — mahalliy WebSocket ni tanlang. Ishonchli yetkazib berish, guruhlash va hodisa modeli kerak bo'lsa — Socket.IO tayyor abstraksiyalar tufayli ishlab chiqish vaqtini 2–3 marta qisqartiradi.

State of JS 2024 so'roviga ko'ra, real-time ilova dasturchilarining 67% i Socket.IO ni API qulayligi va chekka holatlarning o'rnatilgan ishlovi (tarmoq uzilishi, qayta ulanish, ikkilik ma'lumotlar) tufayli afzal ko'radi.

Loyihada Socket.IO ni qanday ulash

Socket.IO ni o'rnatish ikkita paketni talab qiladi: server va mijoz. Node.js loyihasi uchun asosiy konfiguratsiyani ko'rib chiqaylik. Server HTTP serverini yaratadi, Socket.IO ni ishga tushiradi va mijozlarning ulanish va uzilish hodisalarini boshqaradi.

Socket.IO hujjatlariga (2024) ko'ra, server o'rnatilgan http modulidan foydalanib Expresssiz ishga tushirilishi mumkin, ammo real loyihalarda HTTP so'rovlarini marshrutlash uchun odatda Express yoki Fastify ishlatiladi.

Node.js da server kodi

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('Mijoz ulandi:', socket.id);

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

    socket.on('disconnect', () => {
        console.log('Mijoz uzildi');
    });
});

server.listen(3000, () => {
    console.log('Server 3000 portida ishlaydi');
});

Brauzerda mijoz kodi

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

Socket.IO da hodisalar va xonalar

Socket.IO hodisa modeli nomlangan hodisalarga asoslangan. Server va mijoz ma'lum bir hodisa nomiga bog'langan xabarlarni yuboradi va qabul qiladi. Payload satr, JSON obyekti yoki ikkilik ma'lumot (Buffer, ArrayBuffer, Blob) bo'lishi mumkin.

Har bir hodisa ACK (acknowledgement) — qabul qiluvchi tomonidan hodisa qayta ishlangandan so'ng jo'natuvchi tomonda bajariladigan callback funksiyasini uzatishni qo'llab-quvvatlaydi. Bu hodisa modeli ustida request-response namunaini amalga oshirishga imkon beradi. ACK faqat qabul qiluvchi callbackni aniq chaqirganda ishlaydi.

Socket.IO hujjatlariga (2024) ko'ra, optimal samaradorlik uchun bitta xabarning maksimal hajmi 1 MB dan oshmasligi kerak. Kattaroq xabarlar qismlarga bo'linishi yoki alohida kanal orqali uzatilishi kerak.

Xonalar bilan ishlash

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

Socket.IO ni masshtablash

Gorizontal masshtablash Socket.IO bir nechta server jarayonlari o'rtasida holatni taqsimlash muammosini hal qilishni talab qiladi. Xonalar, nom fazolari va ulangan soketlar ro'yxati bitta jarayonning xotirasida saqlanadi va adaptersiz boshqa jarayonlarga ko'rinmaydi.

Rasmiy Socket.IO adapterlari: redis (Redis Pub/Sub orqali), mongodb (MongoDB change streams orqali), cluster (Node.js cluster ko'p jarayonli rejimi uchun). Adapter Socket.IO instansiyalari o'rtasida xabar brokeri sifatida ishlaydi. Xonaga hodisa yuborilganda, adapter uni Redis da nashr etadi va barcha serverlar bildirishnoma oladi.

Socket.IO yuk testlariga (2024) ko'ra, Redis adapteri bilan 4 serverdan iborat klaster 10 ms dan kam kechikish bilan 400 000 tagacha bir vaqtning o'zida ulanishni qayta ishlaydi. Adaptersiz bitta Node.js jarayonining maksimal sig'imi 1 GB xotirada taxminan 100 000 ulanishni tashkil qiladi.

Redis adapterini konfiguratsiya qilish

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

Kubernetes yoki Docker Swarm dan foydalanganda, bir mijozdan kelgan so'rovlar bir xil serverga tushishi uchun qo'shimcha session affinity (sticky sessions) ni sozlash tavsiya etiladi, aks holda har bir qayta ulanishda tayinlash o'zgarishi mumkin.