JavaScript est l'épine dorsale du Web, alimentant des fonctionnalités dynamiques côté client pour des milliards de sites Web et d'applications. Mais vous êtes-vous déjà demandé comment JavaScript opère sa magie en arrière-plan ? Dans cet article, nous approfondirons le fonctionnement interne de la nature monothread de JavaScript et explorerons le concept de programmation asynchrone.

Que signifie un seul thread ?

Quand nous disons que JavaScript est « monothread », cela signifie qu'il a une seule pile d'appels. La pile d'appels est essentiellement la structure dans laquelle JavaScript assure le suivi des fonctions en cours d'exécution. Il suit un ordre Last In, First Out (LIFO), ce qui signifie que la dernière fonction poussée vers la pile sera la première à se terminer. Voici un exemple de la façon dont cela fonctionne :

function first() {
    console.log('First function');
}

function second() {
    console.log('Second function');
}

first();
second();

Dans cet exemple, la fonction first() est ajoutée à la pile et exécutée. Une fois terminé, il est retiré et la fonction second() est placée sur la pile et exécutée ensuite.

Bien que les langages monothread puissent sembler limités car ils ne peuvent faire qu'une seule chose à la fois, l'utilisation intelligente des mécanismes asynchrones par JavaScript lui permet de simuler le multitâche.

La boucle d'événements et l'exécution asynchrone

JavaScript utilise l'exécution asynchrone pour gérer les opérations qui peuvent prendre beaucoup de temps, telles que les requêtes réseau, les E/S de fichiers ou les minuteurs. Bien qu'il soit monothread, il peut gérer plusieurs tâches simultanément grâce à la boucle d'événements et à la file d'attente de rappel.

La boucle des événements

La boucle d'événements est un concept central du modèle de concurrence de JavaScript. Sa principale responsabilité est de gérer la manière dont JavaScript gère l'exécution de code asynchrone. Voici comment cela fonctionne :

1. Le code synchrone s'exécute en premier. Lorsque JavaScript démarre, il exécute tout le code de la portée globale de manière synchrone, ligne par ligne, à l'aide de la pile d'appels.

2. Les tâches asynchrones sont envoyées aux API Web (comme setTimeout, fetch, etc.) ou aux API Node.js, où elles seront traitées en arrière-plan.

3. La file d'attente de rappel est l'endroit où les opérations asynchrones sont placées une fois qu'elles sont terminées.

4. La boucle d'événements vérifie en permanence si la pile d'appels est vide. Si la pile est vide, il prend le premier élément de la file d'attente de rappel et le place sur la pile d'appels, permettant ainsi son exécution.

La magie du JavaScript asynchrone réside dans cette interaction entre la boucle d'événements, la pile d'appels et la file d'attente de rappel. Les opérations asynchrones ne bloquent pas la pile d'appels, ce qui signifie que JavaScript peut continuer à exécuter d'autres codes en attendant la fin des tâches en arrière-plan.

Exemple : utilisation de setTimeout

Considérez l'exemple suivant avec une fonction setTimeout :

console.log('Start');

setTimeout(() => {
    console.log('This runs after 2 seconds');
}, 2000);

console.log('End');

Voici ce qui se passe étape par étape :

1. JavaScript imprime "Démarrer".

2. La fonction setTimeout est appelée, mais au lieu de bloquer l'exécution pendant 2 secondes, elle est envoyée à l'API Web, où elle s'exécute en arrière-plan.

3. JavaScript imprime "End", poursuivant son exécution sans attendre la fin de setTimeout.

4. Après 2 secondes, la fonction de rappel à l'intérieur de setTimeout est placée dans la file d'attente de rappel.

5. La boucle d'événements vérifie si la pile d'appels est vide (ce qui est le cas), puis pousse la fonction de rappel vers la pile et l'exécute, en affichant "Ceci s'exécute après 2 secondes".

Promesses et Async/Await

Une autre façon populaire de gérer les tâches asynchrones dans JavaScript moderne consiste à utiliser les promesses et la syntaxe async/wait, qui contribuent à rendre le code plus lisible en évitant les rappels profondément imbriqués (également connus sous le nom de « l'enfer des rappels »).

Une promesse représente l'achèvement (ou l'échec) éventuel d'une opération asynchrone et sa valeur résultante. Voici un exemple :

const promise = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve('Promise resolved!');
    }, 1000);
});

promise.then(result => {
    console.log(result);  // Output after 1 second: 'Promise resolved!'
});

Au lieu de nous fier aux rappels, nous pouvons utiliser then() pour gérer ce qui se passe lorsque la promesse est résolue. Si nous voulons gérer le code asynchrone de manière plus synchrone, nous pouvons utiliser async/await :

async function asyncExample() {
    const result = await promise;
    console.log(result);  // Output after 1 second: 'Promise resolved!'
}

asyncExample();

Cela rend le code plus propre et plus facile à comprendre, nous permettant « d'attendre » la fin des tâches asynchrones avant de passer à la ligne de code suivante, même si JavaScript reste non bloquant sous le capot.

Composants clés du modèle asynchrone de JavaScript

1. Pile d'appels : où le code synchrone est exécuté.

2. API Web/API Node.js : environnements externes dans lesquels les tâches asynchrones (telles que les requêtes réseau) sont gérées.

3. File d'attente de rappel : file d'attente dans laquelle les résultats des tâches asynchrones attendent d'être poussés vers la pile d'appels pour exécution.

4. Boucle d'événements : le système qui coordonne entre la pile d'appels et la file d'attente de rappel, garantissant que les tâches sont traitées dans le bon ordre.

Conclusion

La nature monothread de JavaScript peut sembler limitante à première vue, mais ses capacités asynchrones lui permettent de gérer efficacement plusieurs tâches. Grâce à des mécanismes tels que la boucle d'événements, les files d'attente de rappel et les promesses, JavaScript est capable de gérer des opérations complexes et non bloquantes tout en conservant un style de codage intuitif et synchrone.