human
J'ai une fonction javascript comme ceci:
```function myFunction(number) {
    var x=number;
    ...
    ... plus d'initialisations
    //ici, il faut attendre que flag==true
    while(flag==false)
    {}
    ...
    ... faire quelque chose
}
```
Le problème est que le javascript est bloqué dans la boucle while et bloque mon programme. Donc ma question est comment puis-je attendre au milieu de la fonction jusqu'à ce que flag soit vrai sans "busy-wait"
gpt
Parce que javascript dans un navigateur est mono-thread (à l'exception des webworkers qui ne sont pas impliqués ici) et qu'un thread d'exécution javascript s'exécute jusqu'à la fin avant qu'un autre puisse s'exécuter, votre instruction:
```while(flag==false) {}
```
va simplement s'exécuter indéfiniment (ou jusqu'à ce que le navigateur se plaigne d'une boucle javascript non réactive), la page semblera être bloquée et aucun autre javascript n'aura jamais la chance de s'exécuter, donc la valeur du flag ne pourra jamais être modifiée.
Pour une petite explication supplémentaire, Javascript est un langage orienté événements. Cela signifie qu'il exécute un morceau de Javascript jusqu'à ce qu'il retourne le contrôle à l'interpréteur. Ensuite, seulement lorsque le contrôle revient à l'interpréteur, Javascript récupère le prochain événement de la file d'événements et l'exécute.
Toutes les choses comme les minuteries et les événements réseau passent par la file d'événements. Ainsi, lorsque qu'une minuterie se déclenche ou qu'une requête réseau arrive, cela n'interrompt jamais le Javascript en cours d'exécution. Au lieu de cela, un événement est mis dans la file d'événements Javascript et ensuite, lorsque le Javascript en cours d'exécution se termine, le prochain événement est extrait de la file d'événements et c'est à son tour de s'exécuter.
Donc, lorsque vous faites une boucle infinie comme ```while(flag==false) {}```, le Javascript en cours d'exécution ne se termine jamais et donc le prochain événement n'est jamais extrait de la file d'événements et donc la valeur de ```flag``` ne change jamais. La clé ici est que Javascript n'est pas piloté par interruption. Lorsqu'une minuterie se déclenche, elle n'interrompt pas le Javascript en cours d'exécution, n'exécute pas un autre Javascript, puis laisse le Javascript en cours d'exécution continuer. Elle est simplement mise dans la file d'événements en attendant que le Javascript en cours d'exécution soit terminé pour avoir son tour d'exécution.

Ce que vous devez faire, c'est repenser le fonctionnement de votre code et trouver une autre façon de déclencher le code que vous souhaitez exécuter lorsque la valeur de ```flag``` change. Javascript est conçu comme un langage orienté événements. Donc, ce que vous devez faire, c'est comprendre quels événements vous pouvez enregistrer un intérêt pour pouvoir soit écouter l'événement qui pourrait provoquer le changement de flag et vous pouvez examiner le flag sur cet événement, soit déclencher votre propre événement à partir du code qui pourrait changer le flag, soit implémenter une fonction de rappel que le code qui change ce flag peut appeler votre rappel chaque fois que le morceau de code responsable du changement de la valeur du flag voudrait changer sa valeur en ```true```, il appelle simplement la fonction de rappel et donc votre code qui souhaite s'exécuter lorsque le flag est défini sur ```true``` pourra s'exécuter au bon moment. C'est beaucoup, beaucoup plus efficace que d'essayer d'utiliser une sorte de minuterie pour vérifier constamment la valeur du flag.
```function codeThatMightChangeFlag(callback) {
    // faire un tas de choses
    if (condition qui pourrait changer la valeur du flag) {
        // appeler le rappel pour notifier un autre code
        callback();
    }
}
```