Können Sie auf den Javascript-Rückruf warten?

Ich versuche, die Dialogbibliothek für jQuery-Warnungen von zu verwenden http://abeautifulsite.net/notebook/87 anstelle der Standardwarnungen (die meiner Meinung nach ziemlich schrecklich aussehen). Dies scheint eine großartige Bibliothek zu sein, aber es gibt kein Beispiel für die Verwendung der jConfirm-Bibliothek.

Ich muss so etwas tun:

function confirm() {
        var result = false;
        var response = false;
        jConfirm('are you sure?', 'Confirmation Dialog',
          function(r) {
            result = r;
            response = true;
            return r;
        });
        if (response == true) {
            alert(result);
            return result;
        }
        else {
            //wait for response
            alert('hi');
        }
    }

und mein Anruf von meinem .net-Button:

Ich habe einen Kommentar auf der Website des Plugins gepostet (erst heute Morgen) und Google-Suchen nach Javascript durchgeführt und darauf gewartet, dass ein Rückruf ohne Ergebnisse abgeschlossen wird.

Irgendwelche Ideen, wie man den Rückruf richtig verwendet, um das Ergebnis zu erhalten, bevor der Rest des Javascripts ausgeführt wird?

Danke.

Sie haben gerade eine große Einschränkung in JavaScript getroffen. Sobald Ihr Code in die asynchrone Welt eintritt, gibt es keine Möglichkeit mehr, zu einem klassischen prozeduralen Ausführungsablauf zurückzukehren.

In Ihrem Beispiel wäre die Lösung, eine Schleife zu erstellen, die darauf wartet, dass die Antwort ausgefüllt wird. Das Problem ist, dass JavaScript keine Anweisung bereitstellt, die es Ihnen ermöglicht, eine Endlosschleife auszuführen, ohne 100 % der Verarbeitungsleistung zu verbrauchen. So blockieren Sie am Ende den Browser, manchmal bis zu dem Punkt, an dem Ihr Benutzer die eigentliche Frage nicht beantworten kann.

Hier hilft nur, am asynchronen Modell festzuhalten und es beizubehalten. Mein Rat ist, dass Sie jeder Funktion, die asynchrone Arbeit leisten muss, einen Rückruf hinzufügen sollten, damit der Aufrufer am Ende Ihrer Funktion etwas ausführen kann.

function confirm(fnCallback) 
{
    jConfirm('are you sure?', 'Confirmation Dialog', function(r) 
    {
        // Do something with r 

        fnCallback && fnCallback(r); // call the callback if provided
    });
}

// in the caller

alert('begin');

confirm(function(r)
{
    alert(r);

    alert('end');
})

jConfirm('are you sure?', 'Confirmation Dialog',
    function(r) {
        result = r;
        response = true;
        return r;
    }
);
if (response == true) {

Dies verrät ein Missverständnis der Abfolge von Ereignissen, die bei der Verwendung von asynchronem Code auftreten. Nur weil Sie es inline geschrieben haben, bedeutet das nicht, dass es strikt von oben nach unten ausgeführt wird.

1. jConfirm wird aufgerufen und erhält eine Funktion als einen seiner Parameter, die es sich merkt.
2. jConfirm zeigt seine Benutzeroberfläche auf der Seite an und kehrt sofort zurück.
3. Die Zeile „if (response==true)“ wird ausgeführt. Eigentlich sollte das nur ‘if (response)’ lauten, der boolsche Vergleich ist überflüssig. Aber in jedem Fall ist die Antwort natürlich falsch. Ihre Funktion gibt auf und wird beendet, wodurch die Kontrolle an den Browser zurückgegeben wird.
4. Der Benutzer klickt auf die Benutzeroberfläche von jConfirm.
5. jConfirm springt erst jetzt in Aktion und ruft die Funktion zurück, die Sie ihm gegeben und an die es sich früher erinnert hat.
6. Ihre verschachtelte Funktion setzt die Antwort viel zu spät auf wahr, als dass die Bedingung „if (response==true)“ etwas damit anfangen könnte.

Sie haben als Alternative “//auf Antwort warten” geschrieben, aber es gibt keinen JavaScript-Code, den Sie schreiben können, der dies tatsächlich tut. Ihre Funktion muss zurückkehren, um die Kontrolle an den Browser zurückzugeben, bevor der Browser die Click-Ereignisse auf der jConfirm-Benutzeroberfläche auslösen kann, die die Verarbeitung fortsetzen.

Es gibt Möglichkeiten, asynchronen Code in einem synchronen Kontext (und umgekehrt) funktionieren zu lassen – insbesondere Threads und Coroutinen (und ihre Generatoren für begrenzte Beziehungen). JavaScript hat jedoch keine dieser Funktionen, daher müssen Sie Ihren Code so schreiben, dass er zu dem synchronen oder asynchronen Modell passt, das Ihre Bibliothek verwendet.

Da der Rückruf asynchron ist (zumindest in dem Sinne, dass er darauf wartet, dass der Benutzer etwas tut), ist es möglicherweise einfacher, das zu handhaben, was Sie innerhalb des Rückrufs tun müssen:

function confirm() {
    jConfirm('are you sure?', 'Confirmation Dialog', function(r) {
        if (r) doSomething();
    });
}

@klogan [comments]

Ich nehme an, Sie haben diese von Hier?

Die Seite gibt Ihnen Ihre Antwort: (siehe unter Verwendung)

Diese Methoden geben nicht die gleichen Werte zurück wie Confirm() und Prompt(). Auf die resultierenden Werte müssen Sie über eine Callback-Funktion zugreifen. (Weitere Einzelheiten finden Sie in der Demo.)

@klogan

Der Punkt, den ich zu machen versuche, ist, dass es keinen wirklich einfachen Weg gibt, das zu erreichen, was Sie wollen. Du versuchst zu korrelieren prozedural und ereignisgesteuert Programmieren – etwas, bei dem JavaScript Ihnen nicht hilft.

Punkt: Am besten vermeiden Sie es Dies versuchen, ereignisgesteuert in prozedural zu zwingen.

function confirm() {
    var result = false;
    var response = false;

    jConfirm('are you sure?', 'Confirmation Dialog',
      function(r) {
        result = r;
        response = true;
    });

    while(!response) continue; // wait
    return result;
}

Technisch, jaaber auf einer Website würde ich das nicht machen.

Schauen Sie sich an Narratives JavaScriptdie auf basiert Narzisse.

Narrative JavaScript ist eine kleine Erweiterung der JavaScript-Sprache, die Blockierungsfunktionen für asynchrone Ereignisrückrufe ermöglicht. Das macht asynchronen Code erfrischend lesbar und verständlich.

Selen verwendet diese Technologie.

Aktualisieren

Kasse JavaScript-Stränge:

JavaScript Strands fügt der JavaScript-Sprache Unterstützung für Koroutinen und kooperative Threads hinzu, um Blockierungsfunktionen für asynchrone Ereignisrückrufe zu aktivieren. Dadurch wird Code, der einen asynchronen Betrieb verwendet, viel linearer, lesbarer und überschaubarer. Strands basiert auf Narrative JavaScript, das von Neil Mix geschrieben wurde, und ein Großteil von Narrative JavaScript ist in Strands geblieben, einschließlich eines Großteils dieser Dokumentation.

In JavaScript kann Ihr Code nicht einfach warten, bis ein Event ausgelöst wird – das Event muss immer von einem separaten, asynchronen Event-Handler behandelt werden. Manchmal ist das in Ordnung, aber es zwingt oft, was eine einfache Folge von Aussagen sein sollte, in knorrige Verrenkungen. Es unterbricht auch die Möglichkeit, Funktionalität zu kapseln, da aufrufende Funktionen wissen müssen, dass sie einen Callback-Handler bereitstellen müssen. Strands bietet die Möglichkeit, Ausführungsthreads auszusetzen und fortzusetzen. Die Ausführung kann ausgesetzt werden, wenn das Ereignis beendet ist. Auf diese Weise können Sie schwer lesbare asynchrone Ereignisbehandlung in einfachem, linearem, lesbarem Code schreiben, der die Implementierung kapselt.

Ich würde annehmen, dass Sie die Antwort so packen müssten. Ich glaube nicht, dass Sie einen Rückruf brauchen.

function confirm() {
        var response = jConfirm('are you sure?', 'Confirmation Dialog');
        if (response) {
            alert(result);
        }
        else {
            //wait for response
            alert('hi');
        }
    }

Ich denke, ich habe eine mögliche Lösung für dieses Problem gefunden. Ich habe diesen Artikel gelesen:
http://treasure4developer.wordpress.com/2008/06/23/calling-postback-event-from-javascript/

Grundsätzlich ist die Idee, dass Sie das Postback von Javascript erzwingen. Zuerst stellte ich fest, dass das Postback funktionieren würde, aber mein Schaltflächenereignis nicht aufrufen würde, aber nachdem ich den Artikel gelesen hatte, stellte ich fest, dass ich erkennen konnte, ob es sich um ein Javascript-Postback handelte, und rief einfach a Methode zur Verarbeitung

Grüße DotnetShadow

Wie die Jungs sagten, es gibt keinen Weg! aber … wie wir in meinem Land (Brasilien) sagen, le gambi:

wir können sowas machen:

<h:commandLink styleClass="linkValor xExcluir" value="x"  
                     onclick="if(confirmar('Confirmar excluir.','Deseja realmente excluir este registro?', this)) return true; else return false;"
                     action="#{mBeanPesquisarLinhas.excluir}"/>

und das Javascript:

function confirmar(titulo, msg, elemento) { 

    if ($(elemento).attr('sim')) {      
        $(elemento).removeAttr('sim');      
        return true;
    } else if ($(elemento).attr('nao')) {       
        $(elemento).removeAttr('nao');      
        return false;
    } else {
        $("#dialog-confirm").html('<p>' + msg + '</p>').dialog({
            resizable : false,
            height : 200,
            modal : true,
            title : titulo,
            buttons : {
                "Sim" : function() {
                    $(this).dialog("close");
                    $(elemento).attr('sim', 'sim');
                    $(elemento).click();
                },
                "Não" : function() {
                    $(this).dialog("close");
                    $(elemento).attr('nao', 'nao');
                    $(elemento).click();
                }
            }
        });
    }

    return false;
}

Es ist das gleiche Problem, aber mit jquery-ui.

Tschüss und ich hoffe, das kann jemandem helfen.