Comment attendre un WebSocket readyState pour changer

Je suis en train de mettre en œuvre un WebSocket avec un repli à une interrogation. Si la connexion WebSocket réussit, readyState devient 1, mais si elle échoue, readyState est de 3, et je commence à interroger.

J'ai essayé quelque chose comme ceci:

var socket = new WebSocket(url);
socket.onmessage = onmsg;
while (socket.readyState == 0)
{
}
if (socket.readyState != 1)
{
    //fall back to polling
    setInterval(poll, interval);
}

Je m'attendais à socket.readyState de mettre à jour de manière asynchrone, et permettez-moi de le lire immédiatement. Cependant, lorsque je l'exécute, mon navigateur se bloque (je l'ai laissé ouvert pendant environ une demi-minute avant d'abandonner).

J'ai pensé que peut-être il y avait un onreadyStateChanged événement, mais je n'ai pas vu un seul dans le MDN référence.

Comment dois-je être mise en œuvre? Apparemment vide, la boucle ne fonctionne pas, et il n'y a aucun événement pour ce.

Hum... je suis peut-être raté quelque chose, mais pourquoi n'utilisez-vous pas socket.onopen?
Je ne pense pas que socket.onopen se déclenche si la prise n'est jamais ouvert.
Oui, mais que votre code faire dans ce cas? "D'attente pour socket ouvert" n'est évidemment pas une réponse, je suppose. )
Il devrait revenir à l'interrogation si la prise ne s'ouvre pas.
Je suis encore un peu perdu, désolé, mais quel est le problème avec l'aide de onerror gestionnaire d'événement pour cela?
Ne onerror feu dans ce cas, lorsque readyState va de 0 à 3 immédiatement?
Je pense que vous êtes à la recherche à onclose...
laissez-nous continuer cette discussion dans le chat

InformationsquelleAutor Kendall Frey | 2012-11-24

C'est simple et ça fonctionne parfaitement... vous pouvez ajouter une condition sur le temps maximal, ou le numéro d'essayer de la rendre plus solide...

function sendMessage(msg){
    //Wait until the state of the socket is not ready and send the message when it is...
    waitForSocketConnection(ws, function(){
        console.log("message sent!!!");
        ws.send(msg);
    });
}

//Make the function wait until the connection is made...
function waitForSocketConnection(socket, callback){
    setTimeout(
        function () {
            if (socket.readyState === 1) {
                console.log("Connection is made")
                if (callback != null){
                    callback();
                }
            } else {
                console.log("wait for connection...")
                waitForSocketConnection(socket, callback);
            }

        }, 5); //wait 5 milisecond for the connection...
}

C'est peut-être juste me manque quelque chose, mais lorsque j'exécute ton code j'ai une erreur m'indiquant que "le rappel n'est pas une fonction". Pourquoi est-ce que la fonction de rappel en fonction de la if(callback != null){ callback(); }
La solution appropriée est d'utiliser les gestionnaires d'événements, par Axel réponse.
Ce qui semble étrange pour moi, c'est l'idée de websockets cours d'une poussée de la technologie, mais ayant readyState comme synchrone, non-poussoir d'appel.

InformationsquelleAutor user3215378

24

Ici est une version plus élaborée explication. Tout d'abord, vérifiez le navigateur de l'API, comme tous les navigateurs seront sur les dernières RFC. Vous pouvez consulter le

Vous ne voulez pas exécuter une boucle pour vérifier en permanence la readystate, il est supplémentaire que vous n'avez pas besoin. Une meilleure approche est de comprendre tous les événements relatifs à un readystate changer, et puis de fil de façon appropriée. Ils sont comme suit:

onclose Un écouteur d'événement pour être appelé lors de la connexion WebSocket readyState changements à FERMÉ. L'auditeur reçoit un CloseEvent nommé "fermer".

onerror Un écouteur d'événement à être appelée lorsqu'une erreur se produit. C'est un simple événement nommé "erreur".

onmessage Un écouteur d'événement à appeler lorsqu'un message est reçu par le serveur. L'auditeur reçoit une classe messageevent nommé "message".

onopen Un écouteur d'événement pour être appelé lors de la connexion WebSocket readyState changements à OUVRIR; cela indique que la connexion est prêt à envoyer et recevoir des données. L'événement est simple avec le nom "ouvrir".

JS est entièrement basé sur l'événement, de sorte que vous devez juste le fil de tous ces événements et de vérifier pour la readystate, de cette façon, vous pouvez passer de WS dans les bureaux de vote en conséquence.

Je vous recommande de regarder le Mozilla de référence, il est plus facile à lire que le document RFC et il vous donnera un bon aperçu de l'API et comment il fonctionne: voir https://developer.mozilla.org/en-US/docs/WebSockets/WebSockets_reference/WebSocket

N'oubliez pas de faire un rappel pour une nouvelle tentative si vous avez une défaillance et de sondage jusqu'à ce que le callback de succès de la reconnexion est déclenché.
- "vous pouvez consulter la rubrique"...? (Je sais c'est vieux)
- La lecture de ce, fait de tous les sens, à l'exception de tous les on événements à ne pas exposer la fermeture et de la connexion. Seulement onopen, onclose et les événements d'erreur. Je ne veux pas être l'envoi d'un message en bas d'un ws en clôture de l'etat.
- ce qui est également démontré ici: pegaxchange.com/2018/03/23/websocket-client
InformationsquelleAutor Axel
6

Regard sur http://dev.w3.org/html5/websockets/

De la recherche pour "gestionnaire d'Événement" et de trouver la Table.

onopen -> ouvrir

onmessage -> message

onerror ->erreur

onclose ->close
```
function update(e){ /*Do Something*/};
var ws = new WebSocket("ws://localhost:9999/");

ws.onmessage = update;
```
- Je upvoted parce que le w3 lien a été utile.
- Je serais bien si w3 offre une véritable machine de l'etat le schéma de la readyState. E. g. cela peut aller de se CONNECTER à FERMÉ lorsque la connexion est refusée par la destination.
InformationsquelleAutor Stefan Wendelmann

Je ne suis pas à l'aide de mise en commun à tous. Au lieu de cela, j'utilise la file d'attente.
Je crée d'abord de la nouvelle fonction d'envoi et une file d'attente:

var msgs = []
function send (msg) {
  if (ws.readyState !== 1) {
    msgs.push(msg)
  } else {
    ws.send(msg)
  }
}

Puis j'ai besoin de lire et d'envoyer lorsque la connexion est établie la première fois:

function my_element_click () {
  if (ws == null){
    ws = new WebSocket(websocket_url)
    ws.onopen = function () {
      while (msgs.length > 0) {
        ws.send(msgs.pop())
      }
    }
    ws.onerror = function(error) {
      //do sth on error
    }
  } 
  msg = {type: 'mymessage', data: my_element.value}
  send(JSON.stringify(msg))
}

Connexion WebSocket dans cet exemple est créé uniquement sur le premier clic. Généralement, sur la deuxième messages commencent à être envoyé directement.

InformationsquelleAutor Jan Topiński

0

Votre boucle while est probablement le blocage de votre fil. Essayez d'utiliser:
```
setTimeout(function(){
    if(socket.readyState === 0) {
        //do nothing
    } else if (socket.readyState !=1) {
        //fallback
        setInterval(poll, interval);
    }
}, 50);
```
- Et la première if est nécessaire pour quoi exactement?
- Si je comprends bien, readyState n'est pas mis à jour immédiatement. C'est pourquoi j'ai utilisé une boucle.
- Honnêtement, je ne sais pas, je suis en supposant même que la boucle while dans OP question. Il peut bien sûr être retiré, sauf si l'OP a besoin de quelque chose fait tout socket.readyState === 0, je vais essayer de ne pas laisser quoi que ce soit jusqu'à l'assomption.
- J'ai besoin de faire quelque chose pendant readyState est égale à zéro, et que c'est d'attendre.
- J'essaierais d'une boucle pour vérifier pour le socket change @KendallFrey, avec une courte setTimeout pour vérifier à nouveau si c'est toujours 0, et quitter si elle a changé. Pas l'idéal, le tout en doit travail, mais ça rend le diagnostic plus facile sans elle.
InformationsquelleAutor agryson
0

Dans mon cas d'utilisation, j'ai voulu montrer un message d'erreur sur l'écran si la connexion échoue.
```
let $connectionError = document.getElementById("connection-error");

setTimeout( () => {
  if (ws.readyState !== 1) {
    $connectionError.classList.add( "show" );
  }
}, 100 );  //ms
```
Noter que dans Safari (9.1.2) n error événement est déclenché - sinon je l'aurais placé dans le gestionnaire d'erreur.

InformationsquelleAutor akauppi
-1

Tout comme vous avez défini un onmessage gestionnaire, vous pouvez également définir un onerror gestionnaire. Celle-ci sera appelée lorsque la connexion échoue.
```
var socket = new WebSocket(url);
socket.onmessage = onmsg;
socket.onerror = function(error) {
    //connection failed - try polling
}
```
- J'ai testé, et il n'a pas d'incendie.
- Je l'utilise dans mon application, et c'est assez fiable chaque fois qu'il ya quelque chose de mal avec la connexion au serveur. Avez-vous encore occupés de spin dans votre code? Il peut garder la JS moteur trop occupé à exécuter la gestion des erreurs.
- J'ai commenté la boucle while, et fait un test rapide avec onerror. Il n'a pas été exécutée. Je suis sûr que le serveur n'est pas de clôture immédiatement, soit, depuis onopen n'est pas de courir. Je pense que, plutôt que d'une erreur, le serveur rejette la connexion.
- Avance rapide jusqu'en 2016... Il ne fait pas de feu sur Safari (9.1.2), mais sur Chrome et Firefox.
InformationsquelleAutor Philipp

Vous devez vous connecter pour publier un commentaire.