JavaScript Academy · Leçon

Cas d’usage et limites

Sachez quand les workers sont utiles et ce qu’ils ne peuvent pas faire.

Cas d’usage et limites est une leçon JavaScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage JavaScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours JavaScript Academy comprend 4 leçons au total.

À quoi servent les workers

Les workers Web sont particulièrement utiles lorsque vous devez effectuer un travail intensif pour le CPU qui bloquerait autrement l’interface utilisateur :

Traitement d’images et de vidéos
Analyse de grands fichiers (CSV, JSON)
Cryptographie et hachage
Physique, analyse de données et simulations

Aucun accès au DOM

La principale limitation est la suivante : les workers ne peuvent pas accéder au DOM. Il n’existe ni document ni window. Ils calculent les données et les renvoient ; le thread principal met à jour l’interface utilisateur.

// Inside a worker:
// document.querySelector(...) -> ReferenceError
// Workers have no DOM at all.

Ce qui est disponible

Les workers disposent toujours de nombreuses API utiles : fetch, setTimeout, WebSocket, IndexedDB, crypto et les tableaux typés. La récupération et le stockage des données fonctionnent donc très bien dans un thread distinct.

// Inside a worker this is valid:
// const res = await fetch('/data.json');
// const json = await res.json();
// self.postMessage(json);

Limites du clonage structuré

Rappelez-vous que les messages sont copiés par clonage structuré. Vous ne pouvez pas envoyer de fonctions, de nœuds DOM ni d’instances de classes avec des méthodes, mais uniquement leurs données sérialisables.

// Cannot be sent:
// worker.postMessage(() => {});      // function - fails
// worker.postMessage(document.body); // DOM node - fails

Coût du démarrage et des messages

La création d’un worker et la sérialisation des messages ont un coût. Pour les tâches minuscules, le coût de la communication peut dépasser le bénéfice. Les workers sont rentables pour un travail important et continu.

Garder les workers actifs

Créer un nouveau worker pour chaque tâche est inefficace. Réutilisez un worker à longue durée de vie et envoyez-lui de nombreux messages, ou gérez un petit groupe de workers pour travailler en parallèle.

// Reuse one worker for many tasks:
const worker = new Worker('worker.js');
function run(task) {
  worker.postMessage(task);
}
// Avoid: new Worker(...) on every single call.

Groupes de workers

Pour utiliser plusieurs cœurs du CPU, créez plusieurs workers et répartissez les tâches entre eux. Suivez ceux qui sont inactifs et attribuez le travail entrant à ceux qui sont disponibles.

const pool = [];
for (let i = 0; i < 4; i++) {
  pool.push(new Worker('worker.js'));
}
// Round-robin or queue tasks across the pool.

Partager la mémoire

Pour les cas avancés, SharedArrayBuffer permet aux threads de partager directement la mémoire (avec Atomics pour un accès sûr). Cette fonctionnalité nécessite des en-têtes d’isolation interorigines particuliers et peut facilement être mal utilisée.

// Requires COOP/COEP headers to be enabled.
// const shared = new SharedArrayBuffer(1024);
// Atomics.add(view, 0, 1); // safe concurrent update

Isolation des erreurs

Une erreur non interceptée dans un worker ne fait pas planter la page. Elle se manifeste comme un événement error sur le worker ; vous devez le gérer pour consigner l’erreur ou redémarrer le worker.

worker.onerror = (e) => {
  console.log('worker failed:', e.message);
  // optionally recreate the worker here
};

Quand ne pas utiliser de workers

N’utilisez pas de workers lorsque la tâche est triviale, nécessite des mises à jour constantes du DOM ou consiste principalement à attendre le réseau (fetch asynchrone ne bloque déjà pas l’exécution). Utilisez-les pour les tâches véritablement limitées par le CPU.

Mettre tout en pratique

Les workers Web échangent l’accès direct au DOM et le partage facile des données contre un véritable parallélisme. Utilisez-les pour les calculs lourds, communiquez par messages, réutilisez les workers et transférez les grands tampons pour garder votre application rapide et fluide.

Vérification rapide

Testez votre compréhension des cas d’utilisation et des limites des workers.

Récapitulatif

Vous avez appris les cas d’utilisation et les limites des workers :

Ils sont parfaits pour les tâches intensives pour le CPU, mais n’ont pas accès au DOM.
De nombreuses API (fetch, IndexedDB, crypto) sont disponibles.
Les messages sont clonés de manière structurée ; les fonctions et les nœuds DOM ne peuvent donc pas être envoyés.
Réutilisez les workers ou les groupes de workers pour amortir le coût du démarrage.
Les erreurs restent isolées dans le worker.

Vous avez terminé la partie sur les workers Web. Ensuite, IndexedDB.

Questions Fréquemment Posées

La leçon « Cas d’usage et limites » est-elle gratuite ?

Oui — le texte complet de « Cas d’usage et limites » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours JavaScript Academy, passe à CoddyKit PRO. Le cours JavaScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Cas d’usage et limites » ?

Sachez quand les workers sont utiles et ce qu’ils ne peuvent pas faire. Tu pratiques JavaScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer JavaScript Academy ?

Aucune expérience préalable n'est requise. JavaScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Cas d’usage et limites » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon JavaScript Academy ?

Oui. Chaque leçon JavaScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à JavaScript Academy