Attendre de retour d'une fonction javascript jusqu'à ce que condition

C'est un étrange problème. J'ai un client de l'objet que je suis la construction à l'aide de Crockford-esque public/privé:

var client = function() {
  var that, remote_data, other_data; 

  //add public interface
  that.doStuff = function(){...}

  //wait for remote resources to load
  remote_data = jsonRequest1();
  other_data  = jsonRequest2();

  return that;
};

Le problème, je vais avoir, c'est que j'ai besoin de charger une certaine distance l'JSON ressources avant de retourner les nouveaux " que " de l'objet (qui signale un prêt du client). Les données sont renvoyées de manière asynchrone (évidemment), et je suis en train de variables booléennes pour indiquer lors de chaque ressource distante est de retour.

J'ai pensé à faire quelque chose comme ce qui suit:

return whenInitialized(function() { return that; });

La whenInitialized fonction retourne si oui ou non les deux booléens drapeaux sont remplies. Je ne l'utiliserais avec une combinaison de setInterval, mais je suis sûr que cela ne fonctionne pas.

Serions heureux de recevoir vos suggestions.

OriginalL'auteur findchris | 2011-12-01

17

Afin d'exécuter du code après une opération asynchrone a réussi, vous avez besoin d'un continuation. C'est peut être juste un rappel que votre code d'appels lorsque les opérations sont terminées.

Quelque chose comme ceci:
```
var client = function(done) { //done is the callback
  var that, remote_data, other_data; 

  //add public interface
  that.doStuff = function(){...}

  //wait for remote resources to load
  var done1 = false, done2 = false;
  var complete1 = function() { done1 = true; if (done2) done(); };
  var complete2 = function() { done2 = true; if (done1) done(); };
  remote_data = jsonRequest1(complete1);
  other_data  = jsonRequest2(complete2);

  return that;
};
```
Mais le contrôle de ces drapeaux sont vraiment ennuyeux et n'est pas vraiment à l'échelle. Mieux, déclarative façon de le faire est d'utiliser quelque chose comme jQuery deferreds:
```
$.when(jsonRequest1(), jsonRequest2()).then(done);
```
+1 pour jQuery deferreds. Je viens juste de commencer à obtenir le blocage d'entre eux, et ils font de telles choses merveilleuses.
Grâce Jordão. Je comprends l'aide de la fonction de rappel du motif comme vous l'avez suggéré, en l'appelant le "fait" de rappel lorsque les données ont été chargées. Exemple d'utilisation: var my_client = client(function() { alert ('!'); }); Cependant, la my_client variable serait utilisable, dans un état non valide, en attendant le rappel. Comment concilier cela? Je suppose que la seule solution est de changer l'interface du client de sorte un retour client n'est pas prévu.
Johnson: oui, vous pourriez fournir à ce client pour le rappel: done(that), et ne rien retourner à partir de la client fonction. Puis votre code client, c'est comme: client(function(my_client) { ... });.

OriginalL'auteur Jordão
3

Vous pouvez faire une boucle (éventuellement avec un délai d'attente) pour attendre la async à la fin. Avertissement, ce sera (comme demandé) bloquer tous les autres fonctionnalités et peut causer le navigateur de geler si elle prend beaucoup trop de temps. Cependant, vous devriez vraiment comprendre manière asynchrone à faire ce que vous avez besoin au lieu de bloquer comme ça.
```
var syncRequest = function(options) {
    var is_finished = false;
    var result;
    var finished_callback = function(response) {
        is_finished = true;
        result = response.result;
    }

    ajax_request(options, finished_callback);

    //timeout in 30 seconds
    var timeout = (new Date()).getTime() + 30000;
    while ( !is_finished ) {
        if ( (new Date()).getTime() >= timeout ) {
            alert('Request timed out');
        }

        //do nothing, just block and wait for the request to finish
    }

    return result;
}
```
J'ai effectué une expérience similaire avant, mais j'ai toujours eu mon navigateur congelés. Puisque la plupart des navigateurs exécuter le code JavaScript dans un seul thread, c'est pas une bonne idée d'utiliser un bureau de vote (comme le JavaScript n'a pas sleep() ou quelque chose comme ça).
En effet. C'est un terrible solution, mais une valide pour ce que l'OP a demandé. Il est vraiment préférable de trouver un async moyen de le faire et je crois que tous les problèmes ont une async solution si vous pensez à ce sujet assez.
Si vous allez utiliser une solution de blocage pourquoi ne pas tout simplement faire une requête ajax synchrone en premier lieu?
L'OP a demandé une solution de blocage. Si vous êtes en train de faire JSONP vous ne pouvez pas faire un synchrone demande.

OriginalL'auteur six8

Vous devez vous connecter pour publier un commentaire.