Kurs vibe coding z Claude Code · Moduł 11: Klon Spotify

Odtwarzacz i kolejka: polecenie z kryterium ukończenia

10 min czytania
W tej lekcji9

Ahoj! Załoga śpiewa szanty przy każdej wachcie, a nagrania leżą w folderze na pokładowym komputerze i każde trzeba włączać ręcznie. W tej lokacji budujesz Sea Shanty Sounds, klon Spotify: odtwarzacz z kolejką, playlisty i wyszukiwarkę. Zaczynasz od odtwarzacza, bo to najzdradliwszy kawałek klonu. Wygląda na gotowy po pierwszym kliknięciu Graj, a kłopoty zaczynają się dopiero wtedy, gdy utwór skończy się sam.

Czego się nauczysz

  • dopisać do polecenia kryterium ukończenia, które Claude sprawdzi sam;
  • przeczytać w Cursorze odtwarzacz, którego stan słucha zdarzeń audio, a nie kliknięć;
  • rozpoznać dwa źródła prawdy i przycisk, który pokazuje "Pauza", choć nic nie gra;
  • zadać pytanie poboczne przez /btw, które nie zaśmieca rozmowy.

Nowy port: projekt sea-shanty-sounds

Sea Shanty Sounds to osobna aplikacja, więc zakładasz ją poleceniem z lekcji 1_2, zmieniając tylko nazwę. Zanim klikniesz Yes, porównaj komendę z tą:

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

Dalej znana pętla: sesja w folderze sea-shanty-sounds, CLAUDE.md z importem @AGENTS.md, Vitest z poprawką @types/node z lekcji 4_1 i pierwszy commit. Do odtwarzacza potrzebujesz kilku plików dźwiękowych w public/audio/. Jeśli masz program ffmpeg, poproś Claude o cztery pliki MP3 z czystym tonem, każdy o innej wysokości i długości, a pierwszy dokładnie na 125 sekund. Bez ffmpeg poproś o te same tony w plikach WAV: to prosty format, który Claude zapisze krótkim skryptem Node.js bez dodatkowych programów, a element <audio> odtwarza go w głównych przeglądarkach. Inny ton w każdym pliku pozwoli Ci usłyszeć, który utwór gra.

Kryterium ukończenia

Dobre praktyki Claude Code mówią wprost, że Claude kończy pracę, gdy wygląda ona na skończoną. Jeśli nie ma niczego, co odpowie "zalicza" albo "nie zalicza", to Ty zostajesz jego jedynym sprawdzianem. Odtwarzacz to idealny przykład: po kliknięciu Graj wszystko działa, a błąd ujawnia się po dwóch minutach, gdy utwór się kończy.

Dlatego polecenie kończy się listą warunków pod hasłem "Będzie gotowe, gdy:". Każdy warunek da się sprawdzić testem albo komendą, a nie oceną "wygląda dobrze". Dokumentacja wymienia to jako pierwszy, najmniej rygorystyczny sposób: warunek w samym poleceniu, a Claude sam ocenia, kiedy jest spełniony, więc i tak prosisz o dowód. Mocniejsze stopnie poznasz w lekcji 10_4. Krok jest duży, więc zaczynasz od planu, jak w lekcji 1_6.

Polecenie dla Claude Code:

/plan Zbuduj odtwarzacz Sea Shanty Sounds. Typy Track, Artist i Album
w types/music.ts, cztery utwory z public/audio w lib/catalog.ts,
komponenty components/MusicPlayer.tsx i components/Queue.tsx:
graj i pauza, poprzedni i następny, pasek postępu z przewijaniem,
głośność, wyciszenie, losowo i powtarzanie (wył., wszystko, jeden).
Kolejka pokazuje, co gra i co będzie następne. Losowo i powtarzanie
trzymaj w jednym miejscu, czas formatuj jedną funkcją w lib/format.ts.
Będzie gotowe, gdy:
1. formatTime(125) zwraca "2:05", a formatTime(NaN) zwraca "0:00";
2. przycisk pokazuje "Pauza" tylko wtedy, gdy audio naprawdę gra,
   także gdy utwór skończy się sam albo audio zatrzyma się bez
   kliknięcia w przycisk;
3. po końcu utworu gra następny, a przy powtarzaniu wszystkiego
   po ostatnim gra pierwszy;
4. odrzucone play() pokazuje komunikat zamiast udawać, że gra.
Warunki 1-4 sprawdź testami Vitest, potem npm run lint,
npx tsc --noEmit i npm run build. Pokaż komendy i ich wyniki.

Warunek 2 to haczyk. Najprostszy kod, jaki agent może napisać, przełącza napis na przycisku przy kliknięciu, więc warunek 2 wymusza inny projekt: stan odtwarzacza ma wynikać z tego, co robi element <audio>. Przeczytaj plan i sprawdź, czy mówi, skąd przycisk wie, że utwór się skończył. Jeśli chcesz pełnej dyscypliny z lekcji 4_1, dopisz jeszcze: "Najpierw napisz testy warunków 1-4 i pokaż, że padają".

Co napisał Claude: typy i jeden formater

Otwórz w Cursorze types/music.ts. Utwór ma wykonawcę i album jako obiekty, ścieżkę do pliku i długość w sekundach:

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

genre to gatunek z krótkiej listy, a przyda się w lekcji 10_3 przy poleceniach. Czas na ekranie przechodzi przez jedną funkcję z 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") dopisuje zero z przodu, więc 5 sekund to "05". Pierwsza linia nie jest przesadną ostrożnością: według MDN właściwość duration elementu audio zwraca NaN, dopóki przeglądarka nie wczyta danych pliku, a dla transmisji na żywo Infinity. Bez tej linii pasek pokazałby "NaN:NaN". U nas test zwrócił "2:05" dla 125 sekund i "0:00" dla NaN.

Co napisał Claude: stan słucha audio

Otwórz components/MusicPlayer.tsx. Najważniejszy jest efekt, który podpina się pod zdarzenia elementu <audio>, czyli komunikaty, które odtwarzacz wysyła sam:

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 zmienia się tylko tutaj, zawsze na to, co mówi audio.paused. Według MDN zdarzenie pause przychodzi, gdy paused ma już wartość true, a timeupdate kilka razy na sekundę w trakcie grania (MDN podaje od około 4 do 66 razy). Na końcu utworu przychodzi najpierw pause, potem ended: tak opisuje to specyfikacja HTML i tak było w naszej przeglądarce. emptied ma swój powód: przy zmianie pliku przeglądarka zatrzymała stary utwór bez zdarzenia pause, wysłała tylko abort i emptied. Wersja bez emptied po przejściu do uszkodzonego pliku pokazywała u nas "Pauza", choć nic nie grało.

return z funkcją sprzątającą odpina każdego słuchacza, gdy odtwarzacz znika ze strony. Prawdziwy kod ma jeszcze słuchacza loadedmetadata, który zapisuje długość utworu, gdy przeglądarka ją pozna.

Co napisał Claude: przycisk tylko prosi

Przycisk Graj nie ustawia stanu. Prosi element audio o zmianę, a stan dogoni rzeczywistość przez zdarzenia:

function togglePlay() {
  const audio = audioRef.current;
  if (!audio) return;
  if (audio.paused) {
    setAutoPlay(true);
    audio.play().catch(() => setError("Przeglądarka nie pozwoliła odtworzyć utworu. Kliknij Graj jeszcze raz."));
  } else {
    audio.pause();
  }
}

Według MDN play() zwraca obietnicę, którą przeglądarka odrzuca, gdy nie pozwala grać, na przykład błędem NotAllowedError, a strona nie powinna pokazywać interfejsu, który zakłada, że odtwarzanie ruszyło. Znasz to z feedu w lekcji 9_1. Tu odrzucenie zostawia napis Graj, bo zdarzenie play nie przyszło, i pokazuje komunikat. autoPlay to stan atrybutu autoPlay na <audio>: od pierwszego kliknięcia Graj każdy nowy utwór startuje sam, gdy przeglądarka go wczyta.

Co napisał Claude: kolejka i powtarzanie

Tryby powtarzania i wybór następnego utworu siedzą w czystych funkcjach w lib/queue.ts, więc łatwo je przetestować. Typ RepeatMode powstaje z tablicy trybów: as const zostawia w niej trzy dokładne napisy, a (typeof REPEAT_MODES)[number] zbiera je w typ "off" | "all" | "one", więc funkcja nie przyjmie literówki:

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;
}

Przycisk powtarzania przechodzi po tablicy w kółko: wył., wszystko, jeden i znowu wył. null znaczy "koniec kolejki, nic więcej nie gra", a przy powtarzaniu wszystkiego po ostatnim utworze wraca indeks 0. Powtarzanie jednego utworu robi sama przeglądarka przez atrybut loop={repeat === "one"}. MDN pisze, że przy włączonym loop zdarzenie ended w ogóle nie przychodzi: u nas utwór na końcu wrócił na początek bez pause i bez ended.

Losowania w nextIndex nie ma i tak ma zostać. W tym samym pliku leży funkcja shuffled, która tasuje kopię listy i nie rusza oryginału, co sprawdza osobny test. Kliknięcie Losowo stawia grający utwór na początku kolejki, za nim tasuje resztę i ustawia indeks 0, więc muzyka się nie przerywa, a nextIndex dalej idzie po kolei. Drugie kliknięcie przywraca kolejność z katalogu i odnajduje w niej grający utwór. Tego szukaj, gdy czytasz kod: losowanie zmienia kolejkę raz, a nie wybiera nowego utworu przy każdym końcu, bo wtedy ten sam utwór mógłby zagrać dwa razy z rzędu.

Przejście po końcu utworu obsługuje osobny efekt:

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]);

Zależności to zwykłe liczby i napis, więc efekt podpina świeżego słuchacza tylko wtedy, gdy zmieni się utwór, długość kolejki albo tryb. Stan losowania i powtarzania żyje tylko w MusicPlayer. Queue dostaje kolejkę i indeks w propsach, pokazuje "Teraz gra" i listę "Następne", czyli queue.slice(index + 1), a przycisk Usuń stoi tylko przy utworach, które dopiero będą grać. Usunięcie ich nie przesuwa więc indeksu tego, co gra. Głośność to suwak od 0 do 1, bo według MDN volume przyjmuje właśnie taki zakres.

Przegląd kapitana

  1. Stan z kliknięcia. Typowy błąd agenta to setIsPlaying(!isPlaying) w togglePlay i ani jednego słuchacza play i pause. U nas taka wersja przeszła lint i tsc, a test z warunku 2 oblał: Unable to find role="button" and name "Graj". Wyszukaj w pliku (Cmd+F na Macu, Ctrl+F na Windowsie) setIsPlaying(: jedyne trafienie ma stać w słuchaczu zdarzeń.
  2. Jedno źródło prawdy. Wyszukaj w projekcie (Cmd+Shift+F) useState<RepeatMode>. Dwa trafienia, na przykład w MusicPlayer i w rodzicu z funkcją onRepeat, to dwie kopie tego samego stanu: przycisk pokazuje jedno, a odtwarzacz robi drugie.
  3. Sprzątanie. Każde addEventListener w efekcie ma swoje removeEventListener w return. Policz trafienia obu nazw.
  4. Jeden formater. padStart znajdziesz tylko w lib/format.ts. Drugi, prawie taki sam formater w Queue.tsx to kopia, która kiedyś zacznie liczyć inaczej.
  5. Dowód. Wynik testów i buildu w odpowiedzi Claude to pierwszy dowód, a drugi sprawdzasz w przeglądarce. Uruchom npm run dev, kliknij Graj, otwórz narzędzia deweloperskie i w konsoli wpisz document.querySelector("audio").pause(). Przycisk ma zmienić się na Graj, choć go nie kliknąłeś.

Te punkty wrócą przy każdym kolejnym odtwarzaczu. Jeśli powtarzasz je trzeci raz, zapisz je jako własnego subagenta recenzenta, tak jak video-reviewer z lekcji 9_5.

Następny krok

Jeśli w kodzie coś Cię zdziwiło, nie musisz dokładać tego do rozmowy. Dokumentacja Claude Code opisuje /btw jako pytanie o bieżącą pracę, które nie trafia do historii rozmowy:

/btw dlaczego efekt z handleEnded ma zależności [index, queue.length, repeat]?

Claude odpowiada z tego, co już jest w rozmowie, czyli z kodu, który sam napisał. Nie ma przy tym narzędzi: nie czyta plików i nie uruchamia komend. Odpowiedź pojawia się w nakładce, którą zamykasz spacją, Enterem albo Escape, a /btw działa nawet wtedy, gdy Claude jest w trakcie pracy. Gdy potrzebujesz czegoś nowego z projektu, potrzebujesz subagenta, a do tego wrócisz w lekcji 10_3.

Gdy testy i przeglądarka się zgadzają, poproś o commit, na przykład "Odtwarzacz i kolejka". W edytorze poniżej czeka odtwarzacz w miniaturze z udawanym dźwiękiem, który liczy sekundy. Zakończ utwór przyciskiem, zatrzymaj go "z zewnątrz", a potem włącz błąd agenta i porównaj napis na przycisku z tym, co naprawdę gra.

Zapamiętaj: pozytywka kapitana gra, dopóki ktoś słucha nuty, a nie dopóki trybiki ładnie wyglądają, a przycisk odtwarzacza ma mówić to, co słychać, a nie to, co ktoś kliknął.

Kod do tej lekcji: App.jsx
// Odtwarzacz w miniaturze: udawane audio liczy sekundy i wysyła zdarzenia jak <audio>
import { useEffect, useState } from 'react';

const tracks = [
  { id: 't1', title: 'Hymn piratów', duration: 8 },
  { id: 't2', title: 'Werble bitewne', duration: 6 },
  { id: 't3', title: 'Szanta o wyspie', duration: 10 },
  { id: 't4', title: 'Pieśń krakena', duration: 5 },
];

const REPEAT_MODES = ['off', 'all', 'one'];
const REPEAT_LABELS = { off: 'Powtarzanie: wył.', all: 'Powtarzanie: wszystko', one: 'Powtarzanie: jeden' };

// Jeden formater czasu dla całego odtwarzacza
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 }); // udawany element <audio>
  const [isPlaying, setIsPlaying] = useState(false); // to, co pokazuje przycisk
  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];

  // Zdarzenie z udawanego audio. Bez błędu agenta przycisk słucha play, pause i 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() odrzucone (NotAllowedError): żadnego zdarzenia play
      if (!agentBug) setError('Przeglądarka nie pozwoliła odtworzyć utworu. Kliknij Graj jeszcze raz.');
      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); // zmiana pliku: paused = true bez zdarzenia pause
    if (play && !blockPlay) {
      setAudio({ paused: false, time: 0 });
      emit('play', false);
    } else {
      setAudio({ paused: true, time: 0 });
    }
  }

  function togglePlay() {
    if (agentBug) {
      // błąd agenta: przycisk przełącza napis sam i nie słucha audio
      if (isPlaying) pauseAudio();
      else playAudio();
      setIsPlaying(!isPlaying);
      return;
    }
    if (audio.paused) playAudio();
    else pauseAudio();
  }

  // Zegar udawanego audio: co sekundę dolicza czas, na końcu utworu wysyła pause i 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: bez pause i bez 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">Poprzedni</button>
            <button type="button" onClick={togglePlay} className="rounded-full bg-white px-5 py-2 font-semibold text-black">
              {isPlaying ? 'Pauza' : 'Graj'}
            </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">Następny</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 naprawdę: <strong>{reallyPlaying ? 'gra' : 'stoi'}</strong>. Przycisk mówi: <strong>{isPlaying ? 'Pauza' : 'Graj'}</strong>.</p>
          {lying && <p className="mt-1 font-semibold">Przycisk kłamie: pokazuje coś innego, niż słychać.</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">Przewiń pod koniec</button>
          <button type="button" onClick={pauseAudio} className="rounded bg-gray-700 px-3 py-1">Zatrzymaj z zewnątrz</button>
        </div>

        <div className="rounded-xl bg-gray-900 p-3 text-sm">
          <p className="text-gray-400">Teraz gra</p>
          <p>{track.title}</p>
          <p className="mt-2 text-gray-400">Następne</p>
          {tracks.slice(index + 1).length === 0 && <p className="text-gray-500">Kolejka jest pusta.</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)} />
            Błąd agenta: setIsPlaying(!isPlaying) zamiast zdarzeń
          </label>
          <label className="flex items-center gap-2">
            <input type="checkbox" checked={blockPlay} onChange={(e) => setBlockPlay(e.target.checked)} />
            Przeglądarka odrzuca play() (NotAllowedError)
          </label>
        </div>

        <div className="rounded-xl bg-black p-3 font-mono text-xs text-green-400">
          <p className="text-gray-400">Zdarzenia audio (najnowsze na górze):</p>
          {log.map((line, i) => <p key={i}>{line}</p>)}
        </div>
      </div>
    </div>
  );
}

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Po co polecenie dla Claude Code kończy się listą "Będzie gotowe, gdy:"?

  2. 2. Co zwraca formatTime(NaN) w odtwarzaczu z lekcji i skąd bierze się NaN?

To 2 z 7 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż w jednej linii wywołanie odtwarzania z obsługą odrzucenia:

  • Układanie w poziomie

    Ułóż w jednej linii wyliczenie utworów, które zagrają po bieżącym:

  • Edytor kodu

    Music player component

  • Klikanie w kolejności

    Kliknij elementy, aby zbudować warunek z togglePlay, który sprawdza, czy audio stoi:

  • Klikanie w kolejności

    Kliknij elementy, aby zbudować funkcję, która ustawia stan przycisku według elementu audio:

  • Układanie w poziomie

    Ułóż w jednej linii ustawienie głośności elementu audio na połowę:

  • Układanie w pionie

    Uporządkuj tryby powtarzania tak, jak stoją w tablicy REPEAT_MODES, po której chodzi przycisk:

  • Układanie w poziomie

    Ułóż w jednej linii zwrot wyniku z formatTime:

  • Klikanie w kolejności

    Kliknij elementy, aby podłączyć nasłuchiwanie postępu:

  • Edytor kodu

    Queue management interface

  • Układanie w pionie

    Uporządkuj, co dzieje się na końcu utworu przy powtarzaniu wyłączonym, gdy w kolejce jest następny:

  • Układanie w pionie

    Uporządkuj linie efektu, który przechodzi do następnego utworu:

  1. PytanieKryterium ukończenia
  2. PytanieDługość nieznanego utworu
  3. Ułóż w kolejnościplay() z obsługą odrzucenia
  4. Ułóż w kolejnościLista Następne w kolejce
  5. Zadanie z kodemPraktyka: Music player UI
  6. PytaniePrzycisk Graj tylko prosi
  7. Kliknij w kolejnościWarunek audio.paused
  8. Kliknij w kolejnościStan z audio.paused
  9. PytaniePytanie poboczne /btw
  10. Ułóż w kolejnościGłośność od 0 do 1
  11. Ułóż w kolejnościKolejność trybów powtarzania
  12. PytaniePowtarzanie wszystkiego
  13. Ułóż w kolejnościSekundy z zerem z przodu
  14. Kliknij w kolejnościZbuduj addEventListener timeupdate
  15. Zadanie z kodemPraktyka: Queue component
  16. PytaniePowtarzanie jednego utworu
  17. Ułóż w kolejnościKoniec utworu krok po kroku
  18. Ułóż w kolejnościEfekt ze słuchaczem ended
  19. PytanieUsuwanie z kolejki

Przydatne artykuły