Cours Vibe coding avec Claude Code · Module 11: Clone de Spotify

Lecteur et file d'attente : une demande avec un critère de fin

12 min de lecture
Dans cette leçon9

Ohé ! L'équipage chante des shanties à chaque quart, mais les enregistrements dorment dans un dossier de l'ordinateur de bord et il faut lancer chacun à la main. Dans cette location, tu construis Sea Shanty Sounds, un clone de Spotify : un lecteur avec file d'attente, des playlists et une recherche. Tu commences par le lecteur, car c'est le morceau le plus traître du clone. Il a l'air terminé après le premier clic sur Lecture, et les ennuis ne commencent que lorsque le morceau se termine tout seul.

Ce que tu vas apprendre

  • ajouter à la demande un critère de fin que Claude vérifiera lui-même ;
  • lire dans Cursor un lecteur dont l'état écoute les événements audio, pas les clics ;
  • repérer les deux sources de vérité et le bouton qui affiche "Pause" alors que rien ne joue ;
  • poser une question en passant avec /btw, sans encombrer la conversation.

Nouveau port : le projet sea-shanty-sounds

Sea Shanty Sounds est une application à part : tu la crées donc avec la commande de la leçon 1_2, en changeant seulement le nom. Avant de cliquer sur Yes, compare la commande avec celle-ci :

npx create-next-app@latest sea-shanty-sounds --ts --eslint --tailwind --app --no-src-dir --no-cache-components --agents-md --no-agent-feedback --use-npm

Ensuite, la boucle habituelle : une session dans le dossier sea-shanty-sounds, un CLAUDE.md qui importe @AGENTS.md, Vitest avec le correctif @types/node de la leçon 4_1 et un premier commit. Pour le lecteur, il te faut quelques fichiers sonores dans public/audio/. Si tu as le programme ffmpeg, demande à Claude quatre fichiers MP3 avec un son pur, chacun d'une hauteur et d'une durée différentes, le premier d'exactement 125 secondes. Sans ffmpeg, demande les mêmes sons en fichiers WAV : c'est un format simple que Claude écrit avec un court script Node.js, sans autre programme, et l'élément <audio> le lit dans les principaux navigateurs. Un son différent par fichier te permettra d'entendre quel morceau joue.

Le critère de fin

Les bonnes pratiques de Claude Code le disent sans détour : Claude s'arrête quand son travail a l'air terminé. S'il n'existe rien qui réponde "réussi" ou "échoué", c'est toi qui restes son seul juge. Le lecteur en est l'exemple parfait : après le clic sur Lecture tout fonctionne, et le bug n'apparaît qu'au bout de deux minutes, quand le morceau finit.

C'est pourquoi la demande se termine par une liste de conditions sous la mention "Ce sera fini quand :". Chaque condition se vérifie par un test ou une commande, pas par un jugement "ça a l'air bien". La documentation le cite comme le premier niveau, le moins strict : la condition est dans la demande elle-même et Claude juge seul quand elle est remplie, donc tu demandes quand même une preuve. Les niveaux plus solides, tu les verras dans la leçon 10_4. L'étape est grande, tu commences donc par un plan, comme dans la leçon 1_6.

Demande pour Claude Code :

/plan Construis le lecteur Sea Shanty Sounds. Les types Track, Artist
et Album dans types/music.ts, quatre morceaux de public/audio dans
lib/catalog.ts, les composants components/MusicPlayer.tsx et
components/Queue.tsx : lecture et pause, précédent et suivant, barre
de progression avec déplacement, volume, sourdine, aléatoire et
répétition (désactivée, tout, un). La file d'attente montre ce qui
joue et ce qui vient ensuite. Garde l'aléatoire et la répétition à un
seul endroit, formate le temps avec une seule fonction dans
lib/format.ts.
Ce sera fini quand :
1. formatTime(125) renvoie "2:05" et formatTime(NaN) renvoie "0:00" ;
2. le bouton affiche "Pause" seulement quand l'audio joue vraiment,
   y compris quand le morceau se termine tout seul ou que l'audio
   s'arrête sans clic sur le bouton ;
3. à la fin d'un morceau, le suivant joue, et avec la répétition de
   tout, après le dernier c'est le premier qui joue ;
4. un play() rejeté affiche un message au lieu de faire semblant de
   jouer.
Vérifie les conditions 1 à 4 avec des tests Vitest, puis lance
npm run lint, npx tsc --noEmit et npm run build. Montre les commandes
et leurs résultats.

La condition 2 est le piège. Le code le plus simple qu'un agent puisse écrire change le texte du bouton au moment du clic, donc la condition 2 impose une autre conception : l'état du lecteur doit découler de ce que fait l'élément <audio>. Lis le plan et vérifie qu'il dit d'où le bouton sait que le morceau est fini. Si tu veux la discipline complète de la leçon 4_1, ajoute : "Écris d'abord les tests des conditions 1 à 4 et montre qu'ils échouent".

Ce que Claude a écrit : les types et un seul formateur

Ouvre types/music.ts dans Cursor. Un morceau a l'artiste et l'album comme objets, le chemin du fichier et la durée en secondes :

export interface Track {
  id: string;
  title: string;
  artist: Artist;
  album: Album;
  src: string; // "/audio/hymne.mp3"
  duration: number; // en secondes
  genre: Genre;
}

genre est un genre pris dans une courte liste, qui servira dans la leçon 10_3 pour les recommandations. Le temps affiché passe par une seule fonction de lib/format.ts :

export function formatTime(seconds: number): string {
  if (!Number.isFinite(seconds) || seconds < 0) return "0:00";
  const whole = Math.floor(seconds);
  const minutes = Math.floor(whole / 60);
  const rest = whole % 60;
  return `${minutes}:${String(rest).padStart(2, "0")}`;
}

padStart(2, "0") ajoute un zéro devant, donc 5 secondes donnent "05". La première ligne n'est pas de la prudence excessive : selon MDN, la propriété duration d'un élément audio vaut NaN tant que le navigateur n'a pas chargé les données du fichier, et Infinity pour un flux en direct. Sans cette ligne, la barre afficherait "NaN:NaN". Chez nous, le test a renvoyé "2:05" pour 125 secondes et "0:00" pour NaN.

Ce que Claude a écrit : l'état écoute l'audio

Ouvre components/MusicPlayer.tsx. Le plus important est l'effet qui s'abonne aux événements de l'élément <audio>, c'est-à-dire aux messages que le lecteur envoie de lui-même :

useEffect(() => {
  const audio = audioRef.current;
  if (!audio) return;
  const syncPlaying = () => setIsPlaying(!audio.paused);
  const syncTime = () => setCurrentTime(audio.currentTime);
  audio.addEventListener("play", syncPlaying);
  audio.addEventListener("pause", syncPlaying);
  audio.addEventListener("emptied", syncPlaying);
  audio.addEventListener("timeupdate", syncTime);
  return () => {
    audio.removeEventListener("play", syncPlaying);
    audio.removeEventListener("pause", syncPlaying);
    audio.removeEventListener("emptied", syncPlaying);
    audio.removeEventListener("timeupdate", syncTime);
  };
}, []);

isPlaying ne change qu'ici, toujours pour valoir ce que dit audio.paused. Selon MDN, l'événement pause arrive quand paused vaut déjà true, et timeupdate plusieurs fois par seconde pendant la lecture (MDN donne d'environ 4 à 66 fois). À la fin d'un morceau, pause arrive d'abord, puis ended : c'est ce que décrit la spécification HTML, et c'est ce qui s'est passé dans notre navigateur. emptied a sa raison d'être : lors du changement de fichier, le navigateur a arrêté l'ancien morceau sans événement pause, en envoyant seulement abort et emptied. La version sans emptied affichait chez nous "Pause" après le passage à un fichier abîmé, alors que rien ne jouait.

Le return avec la fonction de nettoyage détache chaque écouteur quand le lecteur disparaît de la page. Le vrai code a encore un écouteur loadedmetadata, qui enregistre la durée du morceau dès que le navigateur la connaît.

Ce que Claude a écrit : le bouton ne fait que demander

Le bouton Lecture ne fixe pas l'état. Il demande à l'élément audio de changer, et l'état rattrape la réalité grâce aux événements :

function togglePlay() {
  const audio = audioRef.current;
  if (!audio) return;
  if (audio.paused) {
    setAutoPlay(true);
    audio.play().catch(() => setError("Le navigateur n'a pas autorisé la lecture. Clique à nouveau sur Lecture."));
  } else {
    audio.pause();
  }
}

Selon MDN, play() renvoie une promesse que le navigateur rejette quand il n'autorise pas la lecture, par exemple avec une erreur NotAllowedError, et la page ne doit pas afficher une interface qui suppose que la lecture a démarré. Tu connais ça depuis le feed de la leçon 9_1. Ici, le rejet laisse le texte Lecture, parce que l'événement play n'est pas arrivé, et affiche un message. autoPlay est l'état de l'attribut autoPlay de <audio> : dès le premier clic sur Lecture, chaque nouveau morceau démarre tout seul quand le navigateur l'a chargé.

Ce que Claude a écrit : la file d'attente et la répétition

Les modes de répétition et le choix du morceau suivant vivent dans des fonctions pures de lib/queue.ts, faciles à tester. Le type RepeatMode naît du tableau des modes : as const y garde trois textes exacts, et (typeof REPEAT_MODES)[number] les réunit dans le type "off" | "all" | "one", donc la fonction n'acceptera pas une faute de frappe :

export const REPEAT_MODES = ["off", "all", "one"] as const;
export type RepeatMode = (typeof REPEAT_MODES)[number];

export function nextIndex(current: number, length: number, repeat: RepeatMode): number | null {
  if (current + 1 < length) return current + 1;
  return repeat === "all" ? 0 : null;
}

Le bouton de répétition parcourt le tableau en boucle : désactivée, tout, un, puis de nouveau désactivée. null signifie "fin de la file, plus rien ne joue", et avec la répétition de tout, après le dernier morceau on revient à l'indice 0. La répétition d'un seul morceau, c'est le navigateur qui s'en charge avec l'attribut loop={repeat === "one"}. MDN écrit que, quand loop est actif, l'événement ended n'arrive pas du tout : chez nous, le morceau est reparti du début à sa fin, sans pause et sans ended.

Il n'y a pas d'aléatoire dans nextIndex, et ça doit rester ainsi. Le même fichier contient une fonction shuffled, qui mélange une copie de la liste sans toucher à l'original, ce que vérifie un test à part. Un clic sur Aléatoire place le morceau en cours au début de la file, mélange le reste derrière lui et met l'indice à 0 : la musique ne s'arrête pas et nextIndex continue dans l'ordre. Un second clic rétablit l'ordre du catalogue et y retrouve le morceau en cours. C'est ce qu'il faut chercher en lisant le code : l'aléatoire change la file une seule fois et ne choisit pas un nouveau morceau à chaque fin, sinon le même morceau pourrait jouer deux fois de suite.

Le passage à la fin d'un morceau est géré par un effet à part :

useEffect(() => {
  const audio = audioRef.current;
  if (!audio) return;
  function handleEnded() {
    const next = nextIndex(index, queue.length, repeat);
    if (next !== null) setIndex(next);
  }
  audio.addEventListener("ended", handleEnded);
  return () => audio.removeEventListener("ended", handleEnded);
}, [index, queue.length, repeat]);

Les dépendances sont de simples nombres et un texte, donc l'effet n'attache un écouteur tout neuf que lorsque le morceau, la longueur de la file ou le mode change. L'état de l'aléatoire et de la répétition ne vit que dans MusicPlayer. Queue reçoit la file et l'indice en props, affiche "En cours de lecture" et la liste "À suivre", c'est-à-dire queue.slice(index + 1), et le bouton Retirer n'apparaît que devant les morceaux qui ne sont pas encore joués. Les retirer ne décale donc pas l'indice de celui qui joue. Le volume est un curseur de 0 à 1, car selon MDN volume accepte justement cette plage.

La revue du capitaine

  1. L'état tiré du clic. L'erreur typique de l'agent est setIsPlaying(!isPlaying) dans togglePlay et aucun écouteur play ou pause. Chez nous, cette version a passé le lint et tsc, et le test de la condition 2 a échoué : Unable to find role="button" and name "Lecture". Cherche dans le fichier (Cmd+F sur Mac, Ctrl+F sous Windows) setIsPlaying( : la seule occurrence doit se trouver dans l'écouteur d'événements.
  2. Une seule source de vérité. Cherche dans le projet (Cmd+Shift+F) useState<RepeatMode>. Deux occurrences, par exemple dans MusicPlayer et dans le parent avec une fonction onRepeat, ce sont deux copies du même état : le bouton en montre une et le lecteur applique l'autre.
  3. Le nettoyage. Chaque addEventListener d'un effet a son removeEventListener dans le return. Compte les occurrences des deux noms.
  4. Un seul formateur. Tu ne dois trouver padStart que dans lib/format.ts. Un second formateur presque identique dans Queue.tsx est une copie qui finira par compter autrement.
  5. La preuve. Le résultat des tests et du build dans la réponse de Claude est une première preuve, la seconde, tu la vérifies dans le navigateur. Lance npm run dev, clique sur Lecture, ouvre les outils de développement et tape dans la console document.querySelector("audio").pause(). Le bouton doit repasser à Lecture alors que tu n'as pas cliqué dessus.

Ces points reviendront à chaque nouveau lecteur. Si tu les répètes pour la troisième fois, enregistre-les comme ton propre sous-agent relecteur, comme video-reviewer de la leçon 9_5.

Étape suivante

Si quelque chose t'a surpris dans le code, inutile de l'ajouter à la conversation. La documentation de Claude Code décrit /btw comme une question sur le travail en cours qui n'entre pas dans l'historique de la conversation :

/btw pourquoi l'effet avec handleEnded a-t-il les dépendances [index, queue.length, repeat] ?

Claude répond à partir de ce qui est déjà dans la conversation, c'est-à-dire du code qu'il a lui-même écrit. Il n'a pas d'outils pour cela : il ne lit pas de fichiers et ne lance pas de commandes. La réponse apparaît dans une surcouche que tu fermes avec Espace, Entrée ou Échap, et /btw fonctionne même quand Claude est en plein travail. Quand tu as besoin de quelque chose de nouveau dans le projet, il te faut un sous-agent, et tu y reviendras dans la leçon 10_3.

Quand les tests et le navigateur sont d'accord, demande un commit, par exemple "Lecteur et file d'attente". Dans l'éditeur ci-dessous t'attend un lecteur en miniature avec un faux son qui compte les secondes. Termine un morceau avec le bouton, arrête-le "de l'extérieur", puis active l'erreur de l'agent et compare le texte du bouton avec ce qui joue vraiment.

À retenir : la boîte à musique du capitaine joue tant que quelqu'un écoute la note, pas tant que les rouages ont l'air jolis, et le bouton d'un lecteur doit dire ce qu'on entend, pas ce qu'on a cliqué.

Code de cette leçon : App.jsx
// Lecteur en miniature : un faux audio compte les secondes et envoie des événements comme <audio>
import { useEffect, useState } from 'react';

const tracks = [
  { id: 't1', title: 'Hymne des pirates', duration: 8 },
  { id: 't2', title: 'Tambours de bataille', duration: 6 },
  { id: 't3', title: "Shanty de l'île", duration: 10 },
  { id: 't4', title: 'Chant du kraken', duration: 5 },
];

const REPEAT_MODES = ['off', 'all', 'one'];
const REPEAT_LABELS = { off: 'Répétition : désactivée', all: 'Répétition : tout', one: 'Répétition : un' };

// Un seul formateur de temps pour tout le lecteur
function formatTime(seconds) {
  if (!Number.isFinite(seconds) || seconds < 0) return '0:00';
  const whole = Math.floor(seconds);
  return `${Math.floor(whole / 60)}:${String(whole % 60).padStart(2, '0')}`;
}

function nextIndex(current, length, repeat) {
  if (current + 1 < length) return current + 1;
  return repeat === 'all' ? 0 : null;
}

export default function App() {
  const [index, setIndex] = useState(0);
  const [audio, setAudio] = useState({ paused: true, time: 0 }); // faux élément <audio>
  const [isPlaying, setIsPlaying] = useState(false); // ce qu'affiche le bouton
  const [autoPlay, setAutoPlay] = useState(false);
  const [repeat, setRepeat] = useState('off');
  const [log, setLog] = useState([]);
  const [error, setError] = useState('');
  const [agentBug, setAgentBug] = useState(false);
  const [blockPlay, setBlockPlay] = useState(false);
  const track = tracks[index];

  // Événement du faux audio. Sans l'erreur de l'agent, le bouton écoute play, pause et emptied.
  function emit(name, paused) {
    setLog((l) => [`${name} (paused = ${paused})`, ...l].slice(0, 8));
    if (!agentBug && ['play', 'pause', 'emptied'].includes(name)) setIsPlaying(!paused);
  }

  function playAudio() {
    if (blockPlay) {
      // play() rejeté (NotAllowedError) : aucun événement play
      if (!agentBug) setError("Le navigateur n'a pas autorisé la lecture. Clique à nouveau sur Lecture.");
      return;
    }
    setError('');
    setAutoPlay(true);
    setAudio((a) => ({ ...a, paused: false }));
    emit('play', false);
  }

  function pauseAudio() {
    setAudio((a) => ({ ...a, paused: true }));
    emit('pause', true);
  }

  function startTrack(i, play) {
    setIndex(i);
    emit('emptied', true); // changement de fichier : paused = true sans événement pause
    if (play && !blockPlay) {
      setAudio({ paused: false, time: 0 });
      emit('play', false);
    } else {
      setAudio({ paused: true, time: 0 });
    }
  }

  function togglePlay() {
    if (agentBug) {
      // erreur de l'agent : le bouton change son texte tout seul et n'écoute pas l'audio
      if (isPlaying) pauseAudio();
      else playAudio();
      setIsPlaying(!isPlaying);
      return;
    }
    if (audio.paused) playAudio();
    else pauseAudio();
  }

  // Horloge du faux audio : ajoute une seconde à chaque tick, à la fin du morceau envoie pause et ended
  useEffect(() => {
    if (audio.paused) return;
    const id = setTimeout(() => {
      const time = audio.time + 1;
      if (time < track.duration) {
        setAudio({ paused: false, time });
      } else if (repeat === 'one') {
        setAudio({ paused: false, time: 0 }); // loop : sans pause et sans ended
      } else {
        setAudio({ paused: true, time: track.duration });
        emit('pause', true);
        emit('ended', true);
        const next = nextIndex(index, tracks.length, repeat);
        if (next !== null) startTrack(next, autoPlay);
      }
    }, 1000);
    return () => clearTimeout(id);
  }, [audio, index, repeat, agentBug, autoPlay, blockPlay]);

  const reallyPlaying = !audio.paused;
  const lying = isPlaying !== reallyPlaying;

  return (
    <div className="min-h-screen bg-gray-950 p-4 text-white">
      <div className="mx-auto max-w-xl space-y-4">
        <div className="rounded-xl bg-gray-900 p-4">
          <p className="text-lg font-semibold">{track.title}</p>
          <div className="mt-3 flex flex-wrap items-center gap-2">
            <button type="button" onClick={() => startTrack(Math.max(0, index - 1), autoPlay)} className="rounded bg-gray-700 px-3 py-1">Précédent</button>
            <button type="button" onClick={togglePlay} className="rounded-full bg-white px-5 py-2 font-semibold text-black">
              {isPlaying ? 'Pause' : 'Lecture'}
            </button>
            <button type="button" onClick={() => { const n = nextIndex(index, tracks.length, repeat); if (n !== null) startTrack(n, autoPlay); }} className="rounded bg-gray-700 px-3 py-1">Suivant</button>
            <button type="button" onClick={() => setRepeat(REPEAT_MODES[(REPEAT_MODES.indexOf(repeat) + 1) % REPEAT_MODES.length])} className="rounded bg-gray-700 px-3 py-1 text-sm">
              {REPEAT_LABELS[repeat]}
            </button>
          </div>
          <p className="mt-3 text-sm text-gray-300">
            {formatTime(audio.time)} / {formatTime(track.duration)}
          </p>
          {error && <p className="mt-2 text-sm text-red-400">{error}</p>}
        </div>

        <div className={`rounded-xl p-3 text-sm ${lying ? 'bg-red-900' : 'bg-gray-800'}`}>
          <p>Audio en réalité : <strong>{reallyPlaying ? 'joue' : 'arrêté'}</strong>. Le bouton dit : <strong>{isPlaying ? 'Pause' : 'Lecture'}</strong>.</p>
          {lying && <p className="mt-1 font-semibold">Le bouton ment : il montre autre chose que ce qu&apos;on entend.</p>}
        </div>

        <div className="flex flex-wrap gap-2 text-sm">
          <button type="button" onClick={() => setAudio((a) => ({ ...a, time: Math.max(0, track.duration - 2) }))} className="rounded bg-gray-700 px-3 py-1">Avancer vers la fin</button>
          <button type="button" onClick={pauseAudio} className="rounded bg-gray-700 px-3 py-1">Arrêter de l&apos;extérieur</button>
        </div>

        <div className="rounded-xl bg-gray-900 p-3 text-sm">
          <p className="text-gray-400">En cours de lecture</p>
          <p>{track.title}</p>
          <p className="mt-2 text-gray-400">À suivre</p>
          {tracks.slice(index + 1).length === 0 && <p className="text-gray-500">La file d&apos;attente est vide.</p>}
          <ol>
            {tracks.slice(index + 1).map((t, i) => (
              <li key={t.id}>
                <button type="button" onClick={() => startTrack(index + 1 + i, true)} className="hover:underline">
                  {t.title} ({formatTime(t.duration)})
                </button>
              </li>
            ))}
          </ol>
        </div>

        <div className="space-y-1 text-sm">
          <label className="flex items-center gap-2">
            <input type="checkbox" checked={agentBug} onChange={(e) => setAgentBug(e.target.checked)} />
            Erreur de l&apos;agent : setIsPlaying(!isPlaying) au lieu des événements
          </label>
          <label className="flex items-center gap-2">
            <input type="checkbox" checked={blockPlay} onChange={(e) => setBlockPlay(e.target.checked)} />
            Le navigateur rejette play() (NotAllowedError)
          </label>
        </div>

        <div className="rounded-xl bg-black p-3 font-mono text-xs text-green-400">
          <p className="text-gray-400">Événements audio (les plus récents en haut) :</p>
          {log.map((line, i) => <p key={i}>{line}</p>)}
        </div>
      </div>
    </div>
  );
}

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. Pourquoi la demande pour Claude Code se termine-t-elle par une liste "Ce sera fini quand :" ?

  2. 2. Que renvoie formatTime(NaN) dans le lecteur de la leçon, et d'où vient NaN ?

Voici 2 des 7 questions de cette leçon. Réponds aux autres dans le jeu.

Tâches pratiques dans le jeu

  • Tri horizontal

    Range sur une seule ligne l'appel de lecture avec la gestion du rejet :

  • Tri horizontal

    Range sur une seule ligne le calcul des morceaux qui joueront après le morceau courant :

  • Éditeur de code

    Composant lecteur de musique

  • Clique dans l'ordre

    Clique sur les éléments pour construire la condition de togglePlay qui vérifie si l'audio est arrêté :

  • Clique dans l'ordre

    Clique sur les éléments pour construire la fonction qui règle l'état du bouton d'après l'élément audio :

  • Tri horizontal

    Range sur une seule ligne le réglage du volume de l'élément audio à la moitié :

  • Tri vertical

    Range les modes de répétition comme ils se suivent dans le tableau REPEAT_MODES que parcourt le bouton :

  • Tri horizontal

    Range sur une seule ligne le retour de formatTime :

  • Clique dans l'ordre

    Clique sur les éléments pour brancher l'écoute de la progression :

  • Éditeur de code

    Interface de gestion de la file d'attente

  • Tri vertical

    Range ce qui se passe à la fin d'un morceau quand la répétition est désactivée et qu'il y a un suivant dans la file :

  • Tri vertical

    Range les lignes de l'effet qui passe au morceau suivant :

  1. QuestionLe critère de fin
  2. QuestionDurée d'un morceau inconnue
  3. Remets dans l'ordreplay() avec gestion du rejet
  4. Remets dans l'ordreLa liste À suivre de la file d'attente
  5. Exercice de codePratique : Interface du lecteur de musique
  6. QuestionLe bouton Lecture ne fait que demander
  7. Clique dans l'ordreLa condition audio.paused
  8. Clique dans l'ordreL'état tiré de audio.paused
  9. QuestionLa question en passant /btw
  10. Remets dans l'ordreUn volume de 0 à 1
  11. Remets dans l'ordreL'ordre des modes de répétition
  12. QuestionLa répétition de tout
  13. Remets dans l'ordreLes secondes avec un zéro devant
  14. Clique dans l'ordreConstruis l'addEventListener de timeupdate
  15. Exercice de codePratique : Composant file d'attente
  16. QuestionLa répétition d'un seul morceau
  17. Remets dans l'ordreLa fin d'un morceau pas à pas
  18. Remets dans l'ordreL'effet avec l'écouteur ended
  19. QuestionRetirer de la file d'attente

Articles utiles