Wat zijn de verschillen tussen socket.io en websockets in?
node.js?
Zijn het beide server push-technologieën?
De enige verschillen die ik voelde was,

1. socket.io stond me toe berichten te verzenden/uitzenden door een gebeurtenisnaam op te geven.

2. In het geval van socket.io zal een bericht van de server alle clients bereiken, maar voor hetzelfde in websockets moest ik een reeks van alle verbindingen behouden en er doorheen lopen om berichten naar alle clients te verzenden.

Ook,
Ik vraag me af waarom webinspecteurs (zoals Chrome/firebug/fiddler) deze berichten (van socket.io/websocket) niet van de server kunnen halen?

Verduidelijk dit.

Antwoord 1, autoriteit 100%

De voordelen zijn dat het het gebruik van WebSockets vereenvoudigt zoals je in #2 hebt beschreven, en waarschijnlijk nog belangrijker, het biedt fail-overs naar andere protocollen in het geval dat WebSockets niet worden ondersteund door de browser of server. Ik zou WebSockets niet rechtstreeks gebruiken, tenzij je goed weet in welke omgevingen ze niet werken en je in staat bent om die beperkingen te omzeilen.

Dit is goed te lezen voor zowel WebSockets als Socket.IO.

http://davidwalsh.name/websocket

Antwoord 2, autoriteit 93%

Misvattingen

Er zijn weinig algemene misvattingen over WebSocket en Socket.IO:

1. De eerste misvatting is dat het gebruik van Socket.IO aanzienlijk eenvoudiger is dan het gebruik van WebSocket, wat niet het geval lijkt te zijn. Zie voorbeelden hieronder.

2. De tweede misvatting is dat WebSocket niet breed wordt ondersteund in de browsers. Zie hieronder voor meer informatie.

3. De derde misvatting is dat Socket.IO de verbinding downgradet als een terugval op oudere browsers. Het gaat er in feite van uit dat de browser oud is en start een AJAX-verbinding met de server, die later wordt geüpgraded op browsers die WebSocket ondersteunen, nadat er wat verkeer is uitgewisseld. Zie hieronder voor details.

Mijn experiment

Ik heb een npm-module geschreven om het verschil tussen WebSocket en Socket.IO te demonstreren:

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

Het is een eenvoudig voorbeeld van code aan de server- en clientzijde – de client maakt verbinding met de server via WebSocket of Socket.IO en de server verzendt drie berichten met intervallen van 1 seconde, die door de client aan de DOM worden toegevoegd .

Serverzijde

Vergelijk het server-side voorbeeld van het gebruik van WebSocket en Socket.IO om hetzelfde te doen in een Express.js-app:

WebSocket-server

WebSocket-servervoorbeeld met 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');

Bron: https://github.com/Rsp/node -WebSocket-vs-Socket.io/blob/master/ws.js

Socket.io-server

Socket.io Server Voorbeeld met 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');

Bron: https://github.com/Rsp/node -WebSocket-vs-Socket.io/blob/master/si.js

client-side

Vergelijk het voorbeeld van de client-zijde van het gebruik van WebSocket en Socket.io om hetzelfde te doen in de browser:

Websocket-client

Voorbeeld van WebSocket Client met behulp van Vanilla 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); });

Bron: https://github.com/Rsp/node -Websocket-vs-Socket.io/blob/master/ws.html

Socket.io Client

Socket.io Client Voorbeeld met behulp van Vanilla 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); });

Bron: https://github.com/Rsp/node -WebSocket-vs-Socket.io/blob/master/si.html

Netwerkverkeer

Om het verschil in netwerkverkeer te zien, kun je mijn test uitvoeren . Hier zijn de resultaten die ik heb:

Webswebsocket Resultaten

2 aanvragen, 1,50 KB, 0,05 S

Vanaf die 2 verzoeken:

1. HTML pagina zelf
2. verbinding upgrade naar webso’s

(het verzoek van de verbinding upgrade is zichtbaar op de ontwikkelaarstools met een reactie van 101 schakelprotocollen.)

Socket.IO-resultaten

6 aanvragen, 181,56 KB, 0,25 s

Vanaf die 6 aanvragen:

1. De HTML-pagina zelf
2. Socket.io’s JavaScript (180 kilobytes)
3. Eerste Lange Polling Ajax-aanvraag
4. Second Long Polling Ajax-aanvraag
5. Derde Long Polling Ajax-aanvraag
6. verbinding upgrade naar webso’s

Screenshots

Websitetrookjes die ik op localhost heb gekregen:

Socket.io resultaten die ik op localhost heb gekregen:

Test zelf

Snelstart:

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

Open http: // localhost: 3001 / in uw browser, open ontwikkelaarstools met Shift + Ctrl + I, open het tabblad Netwerk en Laad de pagina opnieuw met CTRL + R om het netwerkverkeer voor de Websocket-versie te bekijken.

Open http: // localhost: 3002 / in uw browser, open ontwikkelaarstools met Shift + Ctrl + I, open het tabblad Netwerk en Laad de pagina opnieuw met CTRL + R om het netwerkverkeer voor de socket.io-versie te bekijken.

Om te verwijderen:

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

Browser-compatibiliteit

Vanaf juni 2016 werkt WebSocket op alles behalve Opera Mini, inclusief dat wil zeggen hoger dan 9.

Dit is de browsercompatibiliteit van Websocket op Kan ik vanaf juni 2016 gebruiken:

Zie http://caniuse.com/websockets voor up-to-date info.

Antwoord 3, Autoriteit 10%

Ik ga een argument geven tegen het gebruik van Socket.io.

Ik denk dat het geen goed idee is om socket.io alleen te gebruiken omdat het fallbacks heeft. Laat IE8 RIPpen.

In het verleden zijn er veel gevallen geweest waarin nieuwe versies van NodeJS socket.io hebben gebroken. Je kunt deze lijsten bekijken voor voorbeelden… https://github.com/socketio/socket. io/issues?q=install+error

Als je een Android-app gaat ontwikkelen of iets dat moet werken met je bestaande app, zou je waarschijnlijk meteen goed met WS kunnen werken, socket.io kan daar wat problemen opleveren…

Bovendien is de WS-module voor Node.JS verbazingwekkend eenvoudig te gebruiken.

Antwoord 4, autoriteit 8%

tl;dr;

Ze vergelijken is als het vergelijken van Restaurantvoedsel(soms duur, en misschien niet 100% je wilt) met zelfgemaakt voedsel, waarbij je elk moet verzamelen en laten groeien een van de ingrediënten zelf.

Misschien als je gewoon een appel wilt eten, is de laatste beter. Maar als je iets ingewikkelds wilt en je bent alleen, dan is het echt niet de moeite waard om zelf te koken en alle ingrediënten te maken.

Ik heb met beide gewerkt. Hier is mijn ervaring.

SocketIO

• Heeft automatisch verbinden

• Heeft naamruimten

• Heeft kamers

• Heeft abonnementsservice

• Heeft een vooraf ontworpen communicatieprotocol

  (over het protocol gesproken om u aan te melden, af te melden of een bericht naar een specifieke kamer te sturen, u moet ze allemaal zelf ontwerpen in websockets)

• Heeft goede ondersteuning voor loggen

• Heeft integratie met services zoals redis

• Heeft terugval in het geval dat WS niet wordt ondersteund (nou ja, het komt echter steeds vaker voor)

• Het is een bibliotheek. Wat betekent, het helpt je zaak in alle opzichten. WebSockets is een protocol, geen bibliotheek, die socketio hoe dan ook gebruikt.

• De hele architectuur wordt ondersteund en ontworpen door iemand die niet u is, dus u hoeft dus geen tijd met het ontwerpen en implementeren van iets van het bovenstaande, maar u kunt rechtstreeks naar coderende bedrijfsregels gaan.

• heeft een community omdat het een bibliotheek is (u kunt geen community voor HTTP of Websockets: P zijn slechts normen / protocollen)

websockets

• Je hebt de absolute controle, afhankelijk van wie je bent, dit kan heel goed of erg slecht zijn
• Het is zo licht als het krijgt (onthoud, het is een protocol, geen bibliotheek)
• Ontwerp je je eigen architectuur & amp; protocol
• heeft geen autoconnect, je implementeert het zelf als je het wilt
• heeft geen abonnementservice, u ontwerpt het
• heeft geen logging, u implementeert het
• heeft geen fullback-ondersteuning
• heeft geen kamers of naamruimten. Als u dergelijke concepten wilt, implementeert u ze zelf
• heeft niets voor alles, u zult degene zijn die alles implementeert
• U moet eerst ons concentreren op de technische onderdelen en het ontwerpen van alles wat komt en gaat van en naar uw websockets
• Je moet eerst je ontwerpen debuggen, en dit gaat je lang duren

Uiteraard kun je zien dat ik vooringenomen ben naar Socketio. Ik zou het graag willen zeggen, maar ik ben het echt niet.

Ik vecht er echt tegen om SocketIO niet te gebruiken. Ik wil het niet gebruiken. Ik vind het leuk om mijn eigen spullen te ontwerpen en mijn eigen problemen zelf op te lossen. Maar als je een bedrijf wilt hebben en niet alleen een project van 1000 regels, en je gaat voor Websockets kiezen, dan moet je alles zelf implementeren.Je moet alles debuggen . U moet uw eigen abonnementsservice maken. Uw eigen protocol. Je eigen alles. En je moet ervoor zorgen dat alles behoorlijk geavanceerd is. En onderweg maak je VEEL fouten. Je zult tonnen tijd besteden aan het ontwerpen en debuggen van alles. Dat deed ik en doe ik nog steeds. Ik gebruik websocketsen de reden dat ik hier ben, is omdat ze ondraaglijk zijn voor een man die probeert om te gaan met het oplossen van bedrijfsregels voor zijn startup en in plaats daarvan omgaat met Websocket-ontwerpjargon.

Websockets kiezen voor een grote applicatie is geen gemakkelijke optie als je een eenmansleger bent of een klein team. Ik heb meer code in Websockets geschreven dan ooit met SocketIO in het verleden, en alles wat ik te zeggen heb is … Kies SocketIO als je een afgewerkt product en ontwerp wilt.(tenzij je wilt iets heel eenvoudigs in functionaliteit)

Antwoord 5, autoriteit 8%

Het gebruik van Socket.IO is in feite hetzelfde als het gebruik van jQuery – u wilt oudere browsers ondersteunen, u hoeft minder code te schrijven en de bibliotheek zal voorzien van fallbacks. Socket.io gebruikt de websockets-technologie indien beschikbaar, en zo niet, controleert het beste beschikbare communicatietype en gebruikt het.

Antwoord 6, autoriteit 3%

https://socket.io/docs/#What-Socket- IO-is-not(met mijn nadruk)

Wat Socket.IO niet is

Socket.IO is NIETeen WebSocket-implementatie. Hoewel Socket.IO indien mogelijk inderdaad WebSocket als transport gebruikt, voegt het wat metadata toe aan elk pakket: het pakkettype, de naamruimte en het pakket-ID wanneer een berichtbevestiging nodig is. Daarom kan een WebSocket-client geenverbinding maken met een Socket.IO-serveren een Socket.IO-client nietook verbinding kunnen maken met een WebSocket-server. Zie de protocolspecificatie hier.

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

Antwoord 7

Socket.IO gebruikt WebSocket en wanneer WebSocket niet beschikbaar is, gebruikt het fallback-algoritme om realtime verbindingen te maken.

Antwoord 8

Zelfs als moderne browsers WebSockets nu ondersteunen, denk ik dat het niet nodig is om SocketIO weg te gooien en het heeft nog steeds zijn plaats in elk hedendaags project. Het is gemakkelijk te begrijpen en persoonlijk heb ik geleerd hoe WebSockets werken dankzij SocketIO.

Zoals gezegd in dit onderwerp, zijn er tal van integratiebibliotheken voor Angular, React, enz. en definitietypen voor TypeScript en andere programmeertalen.

Het andere punt dat ik zou toevoegen aan de verschillen tussen socket.io en WebSockets is dat clustering met socket.io geen big deal is. Socket.io biedt adapters die kan worden gebruikt om het te koppelen aan redi’s om de schaalbaarheid te verbeteren. U hebt ederhetis en socket.io-redis bijvoorbeeld.

Ja, ik weet, socket-spil bestaat, maar dat is off-topic.