Files d'attente de tâches en TypeScript : guide complet pour débutants

Introduction aux files d'attente de tâches en TypeScript

La file d'attente de tâches (Queue) est l'une des structures de données fondamentales en programmation, fonctionnant selon le principe FIFO (First In, First Out — « premier entré, premier sorti »). Imaginez une file d'attente classique dans un magasin : le premier client qui fait la queue est servi en premier. En programmation, la file d'attente de tâches est utilisée partout : du traitement des requêtes sur un serveur à la gestion des opérations asynchrones dans un navigateur.

Dans cet article, nous allons voir comment créer et utiliser une file d'attente de tâches en TypeScript. Vous apprendrez à typer une file d'attente, à implémenter les méthodes de base et à l'appliquer dans des projets réels. Ce contenu est destiné aux développeurs débutants familiers avec les bases de TypeScript.

Opérations de base avec une file d'attente

Toute file d'attente de tâches doit prendre en charge plusieurs opérations de base :

• enqueue (ajouter un élément à la fin de la file d'attente) ;
• dequeue (extraire un élément du début de la file d'attente) ;
• peek (consulter le premier élément sans le supprimer) ;
• isEmpty (vérifier si la file d'attente est vide) ;
• size (connaître le nombre d'éléments).

En TypeScript, nous pouvons implémenter une file d'attente à l'aide d'un tableau ou d'une liste chaînée. Pour simplifier, commençons par un tableau.

Implémentation d'une file d'attente basée sur un tableau

Créons une classe Queue en utilisant les génériques — cela permettra de stocker des données de n'importe quel type :

class Queue<T> {    private items: T[] = [];

    // Ajouter un élément à la fin de la file d'attente    enqueue(element: T): void {        this.items.push(element);    }

    // Supprimer et retourner le premier élément    dequeue(): T | undefined {        return this.items.shift();    }

    // Consulter le premier élément sans le supprimer    peek(): T | undefined {        return this.items[0];    }

    // Vérifier si la file d'attente est vide    isEmpty(): boolean {        return this.items.length === 0;    }

    // Obtenir la taille de la file d'attente    size(): number {        return this.items.length;    }}

Vous pouvez maintenant créer une file d'attente pour tout type de données :

// File d'attente de chaînes de caractèresconst stringQueue = new Queue<string>();stringQueue.enqueue('Tâche 1');stringQueue.enqueue('Tâche 2');console.log(stringQueue.dequeue()); // 'Tâche 1'

// File d'attente de nombresconst numberQueue = new Queue<number>();numberQueue.enqueue(10);numberQueue.enqueue(20);console.log(numberQueue.peek()); // 10

Inconvénients de l'implémentation basée sur un tableau

La méthode shift() en JavaScript/TypeScript a une complexité O(n), car après la suppression du premier élément, tous les autres sont décalés. Pour de grands volumes de données, cela n'est pas efficace. La solution est d'implémenter une file d'attente basée sur un objet ou une liste chaînée.

File d'attente optimisée avec un objet

Pour éviter le décalage des éléments, nous allons stocker les éléments dans un objet et suivre les indices de début et de fin :

class OptimizedQueue<T> {    private items: Record<number, T> = {};    private head: number = 0;    private tail: number = 0;

    enqueue(element: T): void {        this.items[this.tail] = element;        this.tail++;    }

    dequeue(): T | undefined {        if (this.isEmpty()) {            return undefined;        }        const item = this.items[this.head];        delete this.items[this.head];        this.head++;        return item;    }

    peek(): T | undefined {        return this.items[this.head];    }

    isEmpty(): boolean {        return this.tail === this.head;    }

    size(): number {        return this.tail - this.head;    }}

Maintenant, les opérations enqueue et dequeue s'exécutent en O(1) — un temps constant, quelle que soit