Nicht erfasster InvalidStateError: „Senden“ auf „WebSocket“ konnte nicht ausgeführt werden: Immer noch im VERBINDUNGS-Zustand

Lesezeit: 5 Minuten

Benutzeravatar von icedwater
Eiswasser

Wenn meine Seite geladen wird, versuche ich es send eine Nachricht an den Server, um eine Verbindung zu initiieren, aber es funktioniert nicht. Dieser Skriptblock befindet sich am Anfang meiner Datei:

var connection = new WrapperWS();
connection.ident();
// var autoIdent = window.addEventListener('load', connection.ident(), false);

Meistens sehe ich den Fehler im Titel:

Nicht erfasster InvalidStateError: „Senden“ auf „WebSocket“ konnte nicht ausgeführt werden: Immer noch im VERBINDUNGS-Zustand

Also versuchte ich es catch die Ausnahme, wie Sie unten sehen können, aber jetzt scheint es InvalidStateError ist nicht definiert und das erzeugt a ReferenceError.

Hier ist das Wrapper-Objekt für meine Websocket-Verbindung:

// Define WrapperWS

function WrapperWS() {
    if ("WebSocket" in window) {
        var ws = new WebSocket("ws://server:8000/");
        var self = this;

        ws.onopen = function () {
            console.log("Opening a connection...");
            window.identified = false;
        };
        ws.onclose = function (evt) {
            console.log("I'm sorry. Bye!");
        };
        ws.onmessage = function (evt) {
            // handle messages here
        };
        ws.onerror = function (evt) {
            console.log("ERR: " + evt.data);
        };

        this.write = function () {
            if (!window.identified) {
                connection.ident();
                console.debug("Wasn't identified earlier. It is now.");
            }
            ws.send(theText.value);
        };

        this.ident = function () {
            var session = "Test";
            try {
                ws.send(session);
            } catch (error) {
                if (error instanceof InvalidStateError) {
                    // possibly still 'CONNECTING'
                    if (ws.readyState !== 1) {
                        var waitSend = setInterval(ws.send(session), 1000);
                    }
                }
            }
        window.identified = true;
            theText.value = "Hello!";
            say.click();
            theText.disabled = false;
        };

    };

}

Ich teste mit Chromium auf Ubuntu.

  • Zu “InvalidStateError ist nicht definiert und das erzeugt einen ReferenceError”, glaube ich, dass Sie es überprüfen könnenif (error.name === "InvalidStateError") {

    – Collin Anderson

    20. Dezember 2021 um 17:08 Uhr

Benutzeravatar von Gigabla
Gigabla

Sie könnten Nachrichten über eine Proxy-Funktion senden, die darauf wartet, dass readyState 1 ist.

this.send = function (message, callback) {
    this.waitForConnection(function () {
        ws.send(message);
        if (typeof callback !== 'undefined') {
          callback();
        }
    }, 1000);
};

this.waitForConnection = function (callback, interval) {
    if (ws.readyState === 1) {
        callback();
    } else {
        var that = this;
        // optional: implement backoff for interval here
        setTimeout(function () {
            that.waitForConnection(callback, interval);
        }, interval);
    }
};

Dann benutze this.send anstelle von ws.sendund fügen Sie den Code, der anschließend ausgeführt werden soll, in einen Callback ein:

this.ident = function () {
    var session = "Test";
    this.send(session, function () {
        window.identified = true;
        theText.value = "Hello!";
        say.click();
        theText.disabled = false;
    });
};

Für etwas Stromlinienförmigeres könnten Sie nachsehen Versprechen.

  • Ich vermute, Sie haben vergessen zu liefern interval Parameter ein that.waitForConnection(callback, interval) mit , wenn du es drinnen anrufst setTimeout.

    – Serhii Holinei

    6. März 2015 um 12:41 Uhr

Manishs Benutzeravatar
Manisch

Dieser Fehler wird ausgelöst, weil Sie es sind Senden Sie Ihre Nachricht vor der WebSocket-Verbindung ist festgelegt.

Sie können es lösen, indem Sie einfach Folgendes tun:

conn.onopen = () => conn.send("Message");

Dies auföffnen -Funktion wartet darauf, dass Ihre WebSocket-Verbindung hergestellt wird, bevor Ihre Nachricht gesendet wird.

  • Möglicherweise müssen Sie die gesendete Nachricht json.stringify, aber das hat bei mir funktioniert: chatSocket.onopen = () => chatSocket.send(JSON.stringify({'message': 'Welcome to the chat. Type below to begin a conversation...' }));

    – ViaTech

    11. Juni 2020 um 14:57 Uhr


  • Das reicht meiner Erfahrung nach nicht aus. Manchmal erhalte ich immer noch die ursprüngliche Fehlermeldung des Posters, selbst mit Code wie dem, den Sie vorschlagen.

    – Hrabinowitz

    23. Dezember 2020 um 17:16 Uhr

  • Dies ist für die Client- oder Serverseite?

    – Shivam Sahil

    19. November 2021 um 4:53 Uhr

Benutzeravatar von Ramil Gilfanov
Ramil Gilfanov

Wenn Sie ein Websocket-Client-Objekt verwenden und von zufälligen App-Orten aus eine Verbindung herstellen, kann sich das Objekt im Verbindungsmodus befinden (gleichzeitiger Zugriff).

Wenn Sie nur über ein Websoket austauschen möchten, erstellen Sie eine Klasse mit versprechen und behalte es im Eigentum

class Ws {
  get newClientPromise() {
    return new Promise((resolve, reject) => {
      let wsClient = new WebSocket("ws://demos.kaazing.com/echo");
      console.log(wsClient)
      wsClient.onopen = () => {
        console.log("connected");
        resolve(wsClient);
      };
      wsClient.onerror = error => reject(error);
    })
  }
  get clientPromise() {
    if (!this.promise) {
      this.promise = this.newClientPromise
    }
    return this.promise;
  }
}

Single erstellen

window.wsSingleton = new Ws()

Verwenden Sie die clientPromise-Eigenschaft an jedem Ort der App

window.wsSingleton.clientPromise
  .then( wsClient =>{wsClient.send('data'); console.log('sended')})
  .catch( error => alert(error) )

http://jsfiddle.net/adqu7q58/11/

  • es zeigt immer noch einen Schließzustandsfehler in der unteren Zeile wsClient =>{wsClient.send(‘data’); console.log(‘gesendet’)})

    – UJ Indien

    9. November 2021 um 12:55 Uhr

Benutzeravatar von Amir Fo
Amir Fo

Methode 1: Überprüfen Sie die Verbindung

Sie können ein Promise auflösen, wenn der Socket verbunden ist:

async function send(data) {
    await checkConnection();
    ws.send(data);
}

Implementierung

Dieser Trick wird mit einem Array von Resolvern implementiert.

let ws = new WebSocket(url);

let connection_resolvers = [];
let checkConnection = () => {
    return new Promise((resolve, reject) => {
        if (ws.readyState === WebSocket.OPEN) {
            resolve();
        }
        else {
            connection_resolvers.push({resolve, reject});
        }
    });
}

ws.addEventListener('open', () => {
    connection_resolvers.forEach(r => r.resolve())
});

Methode 2: Auf Verbindung warten

Sie können ein Promise auflösen, wenn der Socket nicht verbunden ist:

const MAX_RETRIES = 4;
async function send(data, retries = 0) {
    try {
        ws.send(data);
    } 
    catch (error) {
        if (retries < MAX_RETRIES error.name === "InvalidStateError") {
            await waitForConnection();
            send(data, retries + 1);
        }
        else {
            throw error;
        }
    }
}

Implementierung

Dieser Trick wird mit einem Array von Resolvern implementiert.

let ws = new WebSocket(url);

let connection_resolvers = [];
let waitForConnection = () => {
    return new Promise((resolve, reject) => {
        connection_resolvers.push({resolve, reject});
    });
}

ws.addEventListener('open', () => {
    connection_resolvers.forEach(r => r.resolve())
});

Meine Meinung ist, dass die zweite Methode eine etwas gute Leistung hat!

Es ist möglich, Funktionen und readyState mit setTimeout zu verwenden.

function openSocket()
{
    webSocket = new WebSocket("");
}
function sendData()
{
    if(webSocket.readyState)
    {
        webSocket.send(JSON.stringify(
        {
            "event"     : "", 
            "message"   : ""
        }));
    }
    else
    {
        setTimeout(sendData, 1000);
    }
}
function eventHandler()
{
    webSocket.onmessage = function(e)
    {
        data  = JSON.parse(e.data);
        event = data.event;

        switch (event)
        {...}
    }
}

openSocket();
sendData();
enentHandler();

1405070cookie-checkNicht erfasster InvalidStateError: „Senden“ auf „WebSocket“ konnte nicht ausgeführt werden: Immer noch im VERBINDUNGS-Zustand

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy