Abschnitt 19 · Lektion 5
Zufall und Bewegung
Ein Würfel braucht eine Zahl von 1 bis 6. Eine Liste braucht für einen Eintrag eine Nummer, die es nur einmal gibt, und ein Ladebalken eine Bewegung, die auf jedem Bildschirm gleich schnell läuft. Für alle drei hat der Browser fertige Werkzeuge. Und bei jedem davon kann man eine typische Kleinigkeit falsch machen.
Zufall
<p>Zufallszahlen, ein zufälliger Eintrag und eine Kennung.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} // Math.random liefert eine Zahl von 0 bis knapp unter 1.
console.log("Roh:", Math.random());
// Rezept 1: eine ganze Zahl von min bis einschließlich max.
function zufallsZahl(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
// Rezept 2: ein zufälliger Eintrag aus einer Liste.
function zufallsEintrag(liste) {
return liste[Math.floor(Math.random() * liste.length)];
}
const wuerfe = [];
for (let i = 0; i < 12; i++) {
wuerfe.push(zufallsZahl(1, 6));
}
console.log("Zwölf Würfe:", wuerfe.join(" "));
console.log("Kleinster:", Math.min(...wuerfe), "Größter:", Math.max(...wuerfe));
console.log("Zufällig gewählt:", zufallsEintrag(["HTML", "CSS", "JavaScript"]));
// Für Kennungen ist Math.random die falsche Wahl.
console.log("Kennung:", crypto.randomUUID());
console.log("Noch eine:", crypto.randomUUID()); Math.random() liefert eine Kommazahl von 0 bis knapp unter 1. Die 1 selbst kommt nie heraus. Daran hängen die beiden Rezepte, die im Alltag reichen.
- Eine ganze Zahl von
minbis einschließlichmaxentsteht aus mal der Spanne, abrunden, plusmin. Mit dem+ 1in der Spanne zähltmaxmit. An dieser Stelle vertut man sich leicht. - Ein zufälliger Eintrag aus einer Liste entsteht aus mal der Länge, abrunden, als Index benutzen.
Hast du beide einmal in eine kleine Hilfsdatei geschrieben, schreibst du sie nie wieder.
Für Kennungen etwas anderes
Math.random() ist nicht dafür gedacht, eindeutige oder unvorhersehbare Werte zu erzeugen. Die Zahlen sehen zufällig aus. Sie stammen aber aus einer Berechnung, die sich fortsetzen lässt.
Für Kennungen gibt es crypto.randomUUID(), wie die Zwischenablage nur auf Seiten über https oder localhost. Es liefert einen Text in einem festen Format, mit Bindestrichen an festen Stellen. Eine Wiederholung ist so unwahrscheinlich, dass niemand mit ihr rechnen muss.
Sobald ein Wert eindeutig oder nicht erratbar sein muss, nehme ich nie Math.random.
requestAnimationFrame
<div class="bahn"><div class="balken"></div></div>
<p>
<button id="start" type="button">Start</button>
<button id="stopp" type="button">Stopp</button>
</p>
<p id="stand"></p> body {
font-family: system-ui, sans-serif;
}
.bahn {
width: 320px;
height: 24px;
background: #e7e5e4;
}
.balken {
width: 0;
height: 24px;
background: #0d9488;
} const balken = document.querySelector(".balken");
const stand = document.getElementById("stand");
const DAUER = 2000;
const ZIEL = 300;
let frameId = null;
let beginn = 0;
function schritt(jetzt) {
// Die Zeitmarke kommt vom Browser. Damit rechnest du,
// nicht mit einem festen Schritt je Bild.
const anteil = Math.min(1, (jetzt - beginn) / DAUER);
balken.style.width = `${Math.round(ZIEL * anteil)}px`;
stand.textContent = `${Math.round(anteil * 100)} Prozent`;
if (anteil < 1) {
frameId = requestAnimationFrame(schritt);
} else {
frameId = null;
}
}
document.getElementById("start").addEventListener("click", () => {
if (frameId !== null) {
cancelAnimationFrame(frameId);
}
beginn = performance.now();
frameId = requestAnimationFrame(schritt);
});
document.getElementById("stopp").addEventListener("click", () => {
if (frameId !== null) {
cancelAnimationFrame(frameId);
frameId = null;
stand.textContent = stand.textContent + " (angehalten)";
}
}); Für Bewegung gibt es requestAnimationFrame. Es bekommt eine Funktion, und der Browser ruft sie vor dem nächsten Bild auf. Vom setInterval aus Lektion 15.1 unterscheidet es sich in zwei Punkten.
- Es läuft im Takt des Bildschirms. Ein
setIntervalmit 16 Millisekunden trifft den Takt mal und mal nicht, und dann fällt ein Bild aus oder wird doppelt gezeichnet. Das sieht man. - Es pausiert in einem versteckten Tab. Ein
setIntervalläuft dort weiter und verbraucht Rechenzeit und Akku für etwas, das niemand sieht.
Mit einem versteckten Tab ist dabei wirklich ein Tab des Browsers gemeint. Wechselst du auf den Reiter Console, läuft die Animation hier weiter. Schaltest du nach dem Start um, wartest kurz und schaltest zurück, steht der Balken schon am Ende. Die Seite ist nur verdeckt und nicht weg.
Wie bei den Timern kommt eine Nummer zurück, und cancelAnimationFrame hält die Bewegung damit an. Auch das Anhalten gehört wie bei den Timern dazu, sobald die Bewegung in einer Komponente steckt, die wieder abgebaut wird (Lektion 18.6).
Nach dem Start kannst du im Inspector am Balken mitverfolgen, was passiert. Im Auskunftsstreifen wächst die Breite mit, etwa 117 × 24, 164 × 24, 234 × 24 und so weiter bis 300 × 24. Das ist dieselbe Zahl, die die Funktion gerade in style.width schreibt, nur aus der anderen Richtung gelesen. Welche Zwischenwerte dort vorbeikommen, hängt am Takt und ist bei jedem Lauf ein wenig anders. Eingeschaltet wird der Inspector erst nach dem Start. Ein eingeschalteter Inspector fängt nämlich den Klick auf „Start“ ab und friert seine Auswahl auf dem Button ein, und dann steht dort zwei Sekunden lang button#start statt des Balkens.
Gerechnet wird mit der Zeitmarke
<p>Zwei Rechnungen, dieselbe Zahl von Bildern.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} const DAUER = 1000;
const ZIEL = 300;
// Fassung A: fester Schritt je Bild, ausgelegt auf 60 Hz.
function mitFestemSchritt(bilderProSekunde) {
let x = 0;
const bilder = bilderProSekunde;
for (let i = 0; i < bilder; i++) {
x = x + ZIEL / 60;
}
return Math.round(x);
}
// Fassung B: gerechnet aus der vergangenen Zeit.
function mitZeitmarke(bilderProSekunde) {
let x = 0;
const bilder = bilderProSekunde;
for (let i = 0; i < bilder; i++) {
const vergangen = ((i + 1) / bilderProSekunde) * 1000;
x = ZIEL * Math.min(1, vergangen / DAUER);
}
return Math.round(x);
}
console.log("Nach einer Sekunde auf 60 Hz:");
console.log(" fester Schritt:", mitFestemSchritt(60));
console.log(" Zeitmarke:", mitZeitmarke(60));
console.log("Nach einer Sekunde auf 120 Hz:");
console.log(" fester Schritt:", mitFestemSchritt(120));
console.log(" Zeitmarke:", mitZeitmarke(120));
console.log("Das Ziel waren", ZIEL, "Pixel."); Die Funktion bekommt einen Wert übergeben, die Zeit, zu der dieses Bild gezeichnet wird, und damit wird gerechnet. Gemeint ist keine Uhrzeit. Es ist eine Zahl in Millisekunden seit dem Laden der Seite, mit Nachkommastellen. performance.now() liefert dieselbe Zahl, falls du den Startzeitpunkt selbst festhalten willst. Für Zeitpunkte im Kalender bleibt Date.now() zuständig. Für Dauern ist diese Uhr die genauere, und deshalb misst die Stoppuhr aus Abschnitt 15 schon mit ihr.
Verlockend wäre, bei jedem Aufruf einen festen Betrag dazuzuzählen, ausgelegt auf 60 Bilder pro Sekunde. Auf einem 60-Hertz-Bildschirm stimmt das. Auf einem 120-Hertz-Bildschirm läuft die Animation dann doppelt so schnell und auf einem überlasteten Gerät zu langsam.
Im dritten Beispiel stehen beide Rechnungen nebeneinander, einmal mit 60 und einmal mit 120 Bildern. Die Fassung mit der Zeitmarke landet in beiden Fällen bei 300 Pixeln. Die andere landet einmal bei 300 und einmal bei 600.
Das Muster ist immer dasselbe. Beim Start wird der Anfangszeitpunkt gemerkt. In jedem Bild ergibt die Differenz einen Anteil, der bis 1 wächst, daraus folgt die Position, und bei 1 ist es vorbei.
Im Reiter Debug kannst du dir das von innen ansehen. Drückst du dort Aufzeichnen und startest danach die Animation im zweiten Beispiel, findest du jedes einzelne Bild wieder. Auf einem Bildschirm mit 60 Hertz sind das rund 616 Schritte, davon 121 Durchläufe der Zeilen 13 bis 20. Neben der Zeile mit dem Anteil steht jedes Mal sein neuer Wert, etwa anteil=0.0049…, anteil=0.0132…, anteil=0.0215…, bis am Ende anteil=1 kommt und frameId auf null geht. Mit welchem Wert die Reihe anfängt, hängt am Augenblick des Klicks. In Firefox ist der erste sogar knapp negativ, anteil=-0.0037…. Dort kann die Zeitmarke des ersten Bildes vor dem performance.now() im Klick liegen, und dann gibt es einen Durchlauf mehr. Die Breite -1px nimmt der Browser gar nicht erst an.
Daran lassen sich zwei Sachen ablesen. 121 Bilder in zwei Sekunden sind rund 60 pro Sekunde, und das ist mit „im Takt des Bildschirms“ gemeint. Außerdem ist der Abstand zwischen zwei Anteilen immer ungefähr derselbe, 0.0083. Mal die zwei Sekunden Dauer sind das 16,6 Millisekunden, die Zeit zwischen zwei Bildern. Diese Zahl steht nirgends in der Funktion. Sie kommt aus der Uhr.
Was CSS selbst kann
Für vieles davon braucht es gar kein JavaScript. Soll ein Element an eine andere Stelle gleiten oder sich ein- und ausblenden, ist das in CSS eine Zeile transition. Der Browser macht das dann selbst, oft ganz ohne den Hauptfaden zu belasten, und die Animation ruckelt nicht, während JavaScript gerade etwas anderes rechnet.
requestAnimationFrame bleibt für das, was CSS nicht kann. Etwa wenn der Verlauf von Daten abhängt, wenn auf einen Zwischenstand reagiert werden muss oder wenn auf eine Zeichenfläche gemalt wird.
In der Aufgabe entstehen zwei Funktionen zum Zufall und zwei, die einen Balken laufen lassen und anhalten.
Zum Mitnehmen
Eine Animation rechnet mit der Zeitmarke des Browsers. Mit einem festen Schritt je Bild liefe sie auf einem schnellen Bildschirm doppelt so schnell. Kennungen kommen aus crypto.randomUUID, nie aus Math.random.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe im Editor, direkt im Browser geprüft
Öffnet sich mit dem Basis Konto.