Jakie są różnice między socket.io i websockets w node.js?
Czy oba są technologiami wypychania serwerów? Jedyne różnice, które czułem, to:

1. gniazdo.io pozwoliło mi wysyłać / emitować wiadomości, podając nazwę zdarzenia.

2. W przypadku socket.io wiadomość z serwera dotrze do wszystkich klientów, ale dla tego samego w websockets byłem zmuszony zachować tablicę wszystkich połączeń i przejść przez nią pętlę, aby wysłać wiadomości do wszystkich klientów.

Zastanawiam się także, dlaczego inspektorzy sieci (np. Chrome / firebug / fiddler) nie są w stanie przechwycić tych wiadomości (z socket.io/websocket) z serwera?

Proszę to wyjaśnić.

Jego zalety polegają na tym, że upraszcza korzystanie z WebSockets, jak opisano w punkcie 2, i co ważniejsze, zapewnia przełączanie awaryjne na inne protokoły w przypadku, gdy WebSockets nie są obsługiwane w przeglądarce lub na serwerze. Unikałbym bezpośredniego korzystania z WebSockets, chyba że dobrze znasz środowiska, w których one nie działają i jesteś w stanie obejść te ograniczenia.

To dobry odczyt zarówno na WebSockets, jak i Socket.IO.

http://davidwalsh.name/websocket

Nieporozumienia

Istnieje kilka typowych nieporozumień dotyczących WebSocket i Socket.IO:

1. Pierwszym nieporozumieniem jest to, że używanie Socket.IO jest znacznie łatwiejsze niż używanie WebSocket, co nie wydaje się być prawdą. Zobacz przykłady poniżej.

2. Drugim nieporozumieniem jest to, że WebSocket nie jest szeroko obsługiwany w przeglądarkach. Zobacz więcej informacji.

3. Trzecie nieporozumienie polega na tym, że Socket.IO obniża połączenie jako awarię starszych przeglądarek. Zakłada, że ​​przeglądarka jest stara i uruchamia połączenie AJAX z serwerem, które później jest uaktualniane w przeglądarkach obsługujących WebSocket, po wymianie ruchu. Szczegóły poniżej.

Mój eksperyment

Napisałem moduł npm, aby zademonstrować różnicę między WebSocket a Socket.IO:

• https://www.npmjs.com/package/websocket-vs-socket.io
• https://github.com/rsp/node-websocket-vs-socket.io

Jest to prosty przykład kodu po stronie serwera i po stronie klienta - klient łączy się z serwerem za pomocą WebSocket lub Socket.IO, a serwer wysyła trzy komunikaty w odstępach 1s, które są dodawane do DOM przez klienta.

Po stronie serwera

Porównaj przykład użycia serwera WebSocket i Socket.IO do wykonania tego samego w aplikacji Express.js:

Serwer WebSocket

Przykład serwera WebSocket przy użyciu Express.js:

var path = require('path');
var app = require('express')();
var ws = require('express-ws')(app);
app.get('/', (req, res) => {
  console.error('express connection');
  res.sendFile(path.join(__dirname, 'ws.html'));
});
app.ws('/', (s, req) => {
  console.error('websocket connection');
  for (var t = 0; t < 3; t++)
    setTimeout(() => s.send('message from server', ()=>{}), 1000*t);
});
app.listen(3001, () => console.error('listening on http://localhost:3001/'));
console.error('websocket example');

Źródło: https://github.com/rsp/node-websocket-vs-socket.io/blob/master/ws.js

Serwer Socket.IO

Przykład serwera Socket.IO przy użyciu Express.js:

var path = require('path');
var app = require('express')();
var http = require('http').Server(app);
var io = require('socket.io')(http);
app.get('/', (req, res) => {
  console.error('express connection');
  res.sendFile(path.join(__dirname, 'si.html'));
});
io.on('connection', s => {
  console.error('socket.io connection');
  for (var t = 0; t < 3; t++)
    setTimeout(() => s.emit('message', 'message from server'), 1000*t);
});
http.listen(3002, () => console.error('listening on http://localhost:3002/'));
console.error('socket.io example');

Źródło: https://github.com/rsp/node-websocket-vs-socket.io/blob/master/si.js

Strona klienta

Porównaj przykład użycia klienta WebSocket i Socket.IO do zrobienia tego samego w przeglądarce:

Klient WebSocket

Przykład klienta WebSocket z waniliowym JavaScript:

var l = document.getElementById('l');
var log = function (m) {
    var i = document.createElement('li');
    i.innerText = new Date().toISOString()+' '+m;
    l.appendChild(i);
}
log('opening websocket connection');
var s = new WebSocket('ws://'+window.location.host+'/');
s.addEventListener('error', function (m) { log("error"); });
s.addEventListener('open', function (m) { log("websocket connection open"); });
s.addEventListener('message', function (m) { log(m.data); });

Źródło: https://github.com/rsp/node-websocket-vs-socket.io/blob/master/ws.html

Klient Socket.IO

Przykład klienta Socket.IO przy użyciu waniliowego JavaScript:

var l = document.getElementById('l');
var log = function (m) {
    var i = document.createElement('li');
    i.innerText = new Date().toISOString()+' '+m;
    l.appendChild(i);
}
log('opening socket.io connection');
var s = io();
s.on('connect_error', function (m) { log("error"); });
s.on('connect', function (m) { log("socket.io connection open"); });
s.on('message', function (m) { log(m); });

Źródło: https://github.com/rsp/node-websocket-vs-socket.io/blob/master/si.html

Ruch sieciowy

Aby zobaczyć różnicę w ruchu sieciowym, możesz uruchomić mój test . Oto wyniki, które otrzymałem:

Wyniki WebSocket

2 żądania, 1,50 KB, 0,05 s

Z tych 2 wniosków:

1. Sama strona HTML
2. aktualizacja połączenia do WebSocket

(Żądanie aktualizacji połączenia jest widoczne w narzędziach programisty z odpowiedzią 101 Protokoły przełączające.)

Wyniki Socket.IO

6 wniosków, 181,56 KB, 0,25 s

Z tych 6 wniosków:

1. sama strona HTML
2. JavaScript Socket.IO (180 kilobajtów)
3. pierwsze długie żądanie AJAX z odpytywaniem
4. drugie długie żądanie AJAX z przepytywaniem
5. trzecie długie żądanie AJAX z odpytywaniem
6. aktualizacja połączenia do WebSocket

Zrzuty ekranu

Wyniki WebSocket, które otrzymałem na localhost:

Wyniki Socket.IO, które dostałem na localhost:

Sprawdź się

Szybki start:

# Install:
npm i -g websocket-vs-socket.io
# Run the server:
websocket-vs-socket.io

Otwórz http: // localhost: 3001 / w przeglądarce, otwórz narzędzia programistyczne za pomocą Shift + Ctrl + I, otwórz kartę Sieć i ponownie załaduj stronę za pomocą Ctrl + R, aby zobaczyć ruch sieciowy dla wersji WebSocket.

Otwórz http: // localhost: 3002 / w przeglądarce, otwórz narzędzia programistyczne za pomocą Shift + Ctrl + I, otwórz kartę Sieć i ponownie załaduj stronę za pomocą Ctrl + R, aby zobaczyć ruch sieciowy dla wersji Socket.IO.

Aby odinstalować:

# Uninstall:
npm rm -g websocket-vs-socket.io

Kompatybilność z przeglądarkami

Od czerwca 2016 WebSocket działa na wszystkim oprócz Opery Mini, w tym IE wyższej niż 9.

Oto kompatybilność przeglądarki WebSocket w Czy mogę używać od czerwca 2016:

Aktualne informacje można znaleźć na stronie http://caniuse.com/websockets .

Zamierzam przedstawić argument przeciwko używaniu socket.io.

Myślę, że używanie socket.io tylko dlatego, że ma awarie, nie jest dobrym pomysłem. Niech IE8 RIP.

W przeszłości było wiele przypadków, w których nowe wersje NodeJS zepsuły socket.io. Możesz sprawdzić te listy w poszukiwaniu przykładów ... https://github.com/socketio/socket.io/issues?q=install+error

Jeśli zdecydujesz się stworzyć aplikację na Androida lub coś, co musi współpracować z istniejącą aplikacją, prawdopodobnie dobrze byłoby pracować z WS od razu, socket.io może sprawić ci problemy ...

Dodatkowo moduł WS dla Node.JS jest niezwykle prosty w użyciu.

Korzystanie z Socket.IO jest w zasadzie podobne do korzystania z jQuery - chcesz obsługiwać starsze przeglądarki, musisz napisać mniej kodu, a biblioteka zapewni awarie. Socket.io korzysta z technologii websockets, jeśli jest dostępna, a jeśli nie, sprawdza najlepszy dostępny rodzaj komunikacji i korzysta z niej.

Nawet jeśli współczesne przeglądarki obsługują teraz WebSockets, myślę, że nie ma potrzeby wyrzucania SocketIO i nadal ma swoje miejsce w każdym współczesnym projekcie. Łatwo to zrozumieć i osobiście nauczyłem się, jak działa WebSockets dzięki SocketIO.

Jak powiedziano w tym temacie, istnieje wiele bibliotek integracyjnych dla Angular, React itp. Oraz typów definicji dla TypeScript i innych języków programowania.

Inną kwestią, którą chciałbym dodać do różnic między Socket.io i WebSockets, jest to, że grupowanie w Socket.io nie jest wielkim problemem. Socket.io oferuje Adaptery , których można użyć do połączenia go z Redis w celu zwiększenia skalowalności. Na przykład masz ioredis i socket.io-redis .

Tak, wiem, SocketCluster istnieje, ale to nie na temat.

Socket.IO korzysta z WebSocket, a gdy WebSocket nie jest dostępny, używa rezerwowego algorytmu do nawiązywania połączeń w czasie rzeczywistym.

https://socket.io/docs/#What-Socket-IO-is-not (z moim naciskiem )

Czym nie jest Socket.IO

Socket.IO NIE jest implementacją WebSocket. Chociaż Socket.IO rzeczywiście używa WebSocket jako transportu, gdy jest to możliwe, dodaje do każdego pakietu pewne metadane: typ pakietu, przestrzeń nazw i identyfikator pakietu, gdy potrzebne jest potwierdzenie komunikatu. Dlatego klient WebSocket nie będzie mógł połączyć się z serwerem Socket.IO , a klient Socket.IO nie będzie mógł połączyć się z serwerem WebSocket . Zobacz specyfikację protokołu tutaj .

// WARNING: the client will NOT be able to connect!
const client = io('ws://echo.websocket.org');