Warten Sie auf den Rückruf, bevor Sie die Schleife fortsetzen

Habe ich eine for-Schleife wechsele ich durch.

Möchte ich ein custom modal und warten auf eine Antwort, bevor Sie fortsetzen.

Wie kann ich das erreichen? Ich weiß, ich habe zu warten, für einen Rückruf.

Wie in diesem Beispiel:

 for(var x in array){
            alert(x);
            console.log(x);
        }

Es tut genau das, was ich will. Aber ich will nicht noch drei Tasten.
Aber warnen ist nicht Teil von javascript(? Es ist in den browser.)

So, habt Ihr eine Idee?

Ich dachte an sowas:

var run = true;
function foo(){
    if (run){
        setTimeout(foo, 500);
    }
}

function stop(){
    run = false;
}

foo();

warten und dann für einen Stopp, die Anrufe auf eine Schaltfläche klicken, bevor Sie fortfahren. Aber ist dies tatsächlich gute Praxis?

Oder verwenden Sie eine lambda-Funktion, die als parameter der customAlert und eine "Globale" variable, die enthält die aktuelle position des array gehe ich durch und tun Sie dies mit den Funktionen. Wie: Prüfen, ob array ist halt immer keys größer als X.
Führen Sie dann die Funktion erneut aus, und jedes mal, erhöhen Sie die globalen X.

Danke lostsource für den code:
Oh, ich habe eine Idee; ich werde einfach lostsource die Lösung innerhalb einer anonymen Funktion, so dass ich nicht bekommen, Globale Variablen. Ausgezeichnet.

(function(){

})();

InformationsquelleAutor der Frage Muqito | 2013-01-18

  1. 71

    Vorausgesetzt, dies ist dein array

    var list = ['one','two','three'];

    Können Sie versuchen, mit diesem loop /callback-Ansatz

    var x = 0;
var loopArray = function(arr) {
    customAlert(arr[x],function(){
        //set x to next item
        x++;

        //any more items in array? continue loop
        if(x < arr.length) {
            loopArray(arr);   
        }
    }); 
}

function customAlert(msg,callback) {
    //code to show your custom alert
    //in this case its just a console log
    console.log(msg);

    //do callback when ready
    callback();
}

    Verwendung:

    //start 'loop'
loopArray(list);

    JSFiddle hier: http://jsfiddle.net/D9AXp/

    InformationsquelleAutor der Antwort lostsource

  2. 2

    MaggiQall, ich weiß, Sie haben eine Antwort, aber ich habe eine flexible Lösung, die möglicherweise für Sie von Interesse sein oder vielleicht jemand anderes.

    Die Lösung hängt davon ab, jQuery (1.7+) und jQuery UI ist dialogaber implementiert ist, als eine eigene Methode der Array-Prototyp, nicht als jQuery-plugin.

    Hier ist die Array-Methode :

    Array.prototype.runDialogSequence = function(dialogCallback, startIndex, endIndex){
    startIndex = Math.max(0, startIndex || 0);
    endIndex = Math.min(this.length - 1, endIndex || this.length - 1);
    var sequenceIndex = 0,
        arr = this,
        dfrd = $.Deferred().resolve(startIndex);
    function makeCloseFn(seqData){
        return function(event, ui){
            if(seqData.continue_) { seqData.dfrd.resolve(seqData.arrayIndex+1, seqData); } //continue dialog sequence
            else { seqData.dfrd.reject(seqData.arrayIndex, seqData); } //break dialog sequence
        }
    }
    $.each(this, function(i){
        if(i < startIndex || i > endIndex) { return true; }//continue
        dfrd = dfrd.then(function(arrayIndex){
            var seqData = {
                dfrd: $.Deferred(),
                arrayIndex: arrayIndex,
                sequenceIndex: ++sequenceIndex,
                length: 1 + endIndex - startIndex,
                item: arr[arrayIndex],
                continue_: false
            };
            dialogCallback(seqData).on("dialogclose", makeCloseFn(seqData));
            return seqData.dfrd.promise();
        });
    });
    return dfrd.promise();
}

    Array.runDialogSequence() stützt sich auf :

    • Ein Dialogfeld Vorlage in das Dokument Körper, fit zu sein, aufgefüllt mit text/Werte.
    • eine array-ähnliche Objekte (in der Regel javascript-Objekte) enthält die Daten, die erforderlich sind, um füllen Sie die Dialogbox, in der Reihenfolge.
    • vorbei, da das erste argument, eine korrekt konstruierte "openDialog" - Funktion.

    Hier ist ein Beispiel "openDialog" - Funktion mit Erläuterungen :

    function openDialog(seqData){
    /*
    seqData is an object with the following properties:
        dfrd: A Deferred object associated with the current dialog. Normally resolved by Array.runDialogSequence() to run through the sequence or rejected to break it, but can be resolved/rejected here to force the dialog sequence to continue/break. If resolved, then pass (seqData.arrayIndex+1, seqData), or custom values. If rejected, typically pass (seqData.arrayIndex, seqData).
        arrayIndex: The current array index.
        sequenceIndex: The current index within the sequence. Normally the same as arrayIndex but Differs when a non-zero startIndex is specified.
        length: The full length of the dialog sequence.
        item: The current item from the array.
        continue_: (false) Set to true to allow the sequence to continue.
    */
    var item = seqData.item;
    var $d = $("#d");
    $d.dialog({
        title: 'Dialog (' + seqData.sequenceIndex + ' of ' + seqData.length + ')',
        modal: true,
        buttons: {
            "Continue": function(){
                seqData.continue_ = true;//set to true before closing to go to next dialog.
                $(this).dialog("close");
            },
            "Cancel": function(){
                $(this).dialog('close');//closing with seqData.continue_ set to its default value false will break the dialog sequence.
            }
        }
    }).find("#message").text(item);//Typically you will do a lot more here to populate the dialog with item data.
    return $d;//openDialog() must return a dialog container, jQuery-wrapped.
}

    Array.runDialogSequence() gibt ein jQuery - promise ermöglicht benutzerdefinierte Aktionen durchgeführt werden, wenn der dialog-Sequenz abgeschlossen ist (done-Funktion) oder ist gebrochen in der Mitte der Sequenz (fail-Funktion).

    Hier sind ein paar Beispiel-Aufrufe :

    //Simplest possible
$("#myButton1").click(function(){
    myArray.runDialogSequence(openDialog);
});

//Call with custom startIndex and endIndex, and chanined `.then()` to provide custom actions on break/completion.
$("#myButton2").click(function(){
    myArray.runDialogSequence(openDialog, 1, 3).then(function(i, seqData){
        alert('All dialogs complete - last item = "' + seqData.item + '"');
    }, function(i, seqData){
        alert('Dialog sequence was broken at item ' + i + ' "' + seqData.item + '"');
    });
});

    DEMO

    Dies ist so nah an eine verallgemeinerte Lösung als meine Phantasie es zulässt.

    InformationsquelleAutor der Antwort Beetroot-Beetroot

Schreibe einen Kommentar