Bonjour à tous,

Je suis un débutant en JS mais ce langage m'intéresse vraiment ! 
Je vous cache pas que j'ai un peu de mal avec l'aspect événementiel de JS et j'adorerai savoir quel est le meilleur moyen de répondre à mon besoin.

Je dois appeler une fonction test au bout d'un certain temps ( lorsqu'une condition est vérifiée ).  une fois que cette fonction est appelée, je dois revenir en attente que la condition repasse à True.

Donc je pensais à faire une fonction wait de cette manière : 

            function test(){
                wait(test);
            }
            
            function wait(nextFunction){
                var counter=0;
                console.log('(1) Counter value : ',counter);
                interval=setInterval(function(){
                    console.log("(2) Counter value : '",counter);
                    if (counter<2){
                        counter++;
                    }
                    else{
                        console.log('Calling Test');
                        test();
                        clearInterval(interval);
                    }
                },200);
            }
            
            wait(test);

 Je veux donc qu'à chaque fois que compteur passe à 2 : la fonction test soit appelée, puis derrière qu'elle ré-appelle cette routine. Mais à l’exécution,

 J'ai un petit problème : le premier call de test fonctionne, mais ensuite la valeur de counter passe de 0 à 2. J'imagine que c'est un problème de portée de variables.

Faut-il que je m'interesse un peu plus en détail aux évenements ? du genre appeler mes fonctions par evenement ? 

Je vous remercie d'avance pour la moindre aide que vous pourrez m'apporter

-
Edité par Chivunito 14 juin 2018 à 22:21:29

<< Je dois appeler une fonction [...] au bout d'un certain temps >>

setInterval(Function, Number) exécute une fonction une fois toutes les x millisecondes (plusieurs exécutions) ; setTimeout(Function, Number) exécute une fonction au bout de x millisecondes (une seule exécution).

De fait, je dirais que setTimeout est mieux adaptée à ce que tu cherches à faire.

<< [Je dois appeler une fonction] lorsqu'une condition est vérifiée >>

Ben, i' faut savoir l'ami... Contrainte de temps ou condition ?

<< Une fois que cette fonction est appelée, je dois revenir en attente que la condition repasse à true. >>

L'attente, qu'elle soit synchrone (while (condition != true) continue ; test() ) ou asynchrone (const i = setInterval(function () { if (condition == true) { clearInterval(i) ; test() } }, 200)), c'est pas trop à la mode JS...

Si tu en as l'occasion, je te conseille d'utiliser les callbacks :

const x = {
   _condition: false,

   get condition() {
      return this._condition
   },

   set condition(value) {
      this._condition = value

      if (value == true) this.onConditionTrue()
   },

   // Callback.
   onConditionTrue: function () {}
}

x.onConditionTrue = test

x.condition = true
x.condition = false
x.condition = true

Cela dit, ça peut être difficile, surtout si on n'a pas la main sur les objets qu'on manipule.

<< Je veux donc qu'à chaque fois que compteur passe à 2, la fonction [...] soit appelée >>

Dans le cas d'un petit système, implémenter un compteur en boucle avec des callbacks, c'est un peu overkill à mon goût. Je partirais donc plutôt sur un setInterval.

Dans le code que tu donnes, il me semble que :

• nextFunction n'est pas utilisé, de fait, tous les appels à wait(test) sont équivalents à wait() ;
• counter devrait être déclaré en dehors de wait ;
• Ici, interval est une variable globale (équivalent à window.interval), le déclarer avec var, let, ou const le ramènerait dans le scope de la fonction (c-à-d wait) ;
• interval = ... et clearInterval(interval) laissent à penser qu'il ne s'agit pas un compteur infini, mais ce n'est peut-être pas un problème ?
• test ne devrait pas appeler wait.

Au final, je pense que tu es très proche de ce que tu veux faire, il n'y a que des ajustements mineurs à faire.

Bonne continuation.
Novax.

-
Edité par Anonyme 16 juin 2018 à 21:47:41