mitmario.dev

Synthese: die Stoppuhr

JavaScript Im Browser 4 Min Lesezeit 3 BeispieleLektion 7 von 8

Start, Pause, Weiter und Zurücksetzen. So eine Stoppuhr sieht nach einer Fingerübung aus. Sie bringt aber die Timer aus diesem Abschnitt zusammen, und es gibt drei Stellen, an denen es beim ersten Mal leicht danebengeht.

Zählen ist nicht rechnen

Zählen gegen rechnen
const gezaehltFeld = document.getElementById("gezaehlt");
const gerechnetFeld = document.getElementById("gerechnet");
const abweichungFeld = document.getElementById("abweichung");

const start = performance.now();
let gezaehlt = 0;

setInterval(() => {
  // Bei jedem Durchlauf 10 dazuzählen.
  gezaehlt = gezaehlt + 10;

  // Die Differenz zum Startzeitpunkt rechnen.
  const gerechnet = Math.round(performance.now() - start);

  gezaehltFeld.textContent = String(gezaehlt);
  gerechnetFeld.textContent = String(gerechnet);
  abweichungFeld.textContent = String(gerechnet - gezaehlt);
}, 10);

// Eine halbe Sekunde lang nichts tun außer den Stapel besetzen.
// Das Intervall kommt in dieser Zeit nicht dran.
document.getElementById("beschaeftigen").addEventListener("click", () => {
  const beginn = performance.now();
  while (performance.now() - beginn < 500) {
  }
});

Am nächsten liegt ein Intervall alle zehn Millisekunden, das bei jedem Durchlauf zehn dazuzählt.

Das geht schief, weil die Zeitangabe ein Mindestwert ist. Ist der Stapel beschäftigt, kommt ein Durchlauf zu spät oder fällt ganz aus, und im Hintergrundtab läuft das Intervall höchstens einmal je Sekunde. Firefox verspätet jeden Durchlauf sogar im Leerlauf ein wenig. Dort liegt die gezählte Uhr nach einer Minute rund zwei Sekunden zurück.

Richtig ist, sich den Startzeitpunkt zu merken und bei jedem Durchlauf die Differenz zu rechnen. performance.now() - start ist die Zeit seit dem Start, egal wie unpünktlich das Intervall ist. performance.now() zählt Millisekunden seit dem Laden der Seite und läuft immer nur vorwärts. Date.now() ginge auch, folgt aber der Uhr des Rechners, und wenn die sich umstellt, springt die Stoppuhr mit.

Das Intervall bestimmt dann nur noch, wie oft neu gezeichnet wird, und nicht mehr, welche Zeit dasteht. Ob es alle 10 oder alle 50 Millisekunden feuert, ändert an der Uhr nichts. Die Anzeige läuft nur mehr oder weniger flüssig.

Im ersten Beispiel stehen beide Uhren nebeneinander, mit ihrer Abweichung. Ein Klick auf „Rechner beschäftigen“ besetzt den Stapel eine halbe Sekunde lang. Die gezählte Uhr fällt um fast genau diese halbe Sekunde zurück, und die gerechnete stimmt weiter.

Pause braucht eine zweite Zahl

Eine Uhr, die nur laufen kann, braucht einen Startzeitpunkt. Eine Uhr mit Pause braucht zwei Zahlen.

  • gestartet ist der Zeitpunkt, an dem zuletzt auf Start gedrückt wurde.
  • angesammelt ist die Zeit, die vor der letzten Pause schon zusammengekommen war.

Die verstrichene Zeit ist dann angesammelt plus, falls die Uhr gerade läuft, performance.now() - gestartet.

Beim Pausieren wandert der laufende Teil in angesammelt, und das Intervall stoppt. Beim Weiterlaufen wird gestartet neu gesetzt und das Intervall wieder gestartet. Beim Zurücksetzen sind beide Zahlen null.

Wenn du das mit einer einzigen Zahl lösen willst, landest du früher oder später bei einer Uhr, die nach der Pause die Pausenzeit mitzählt.

Zustand ändern, dann neu zeichnen

Zustand ändern, dann neu zeichnen
const anzeige = document.getElementById("anzeige");

// Der ganze Zustand steht an einer Stelle.
let wert = 0;

// Eine Funktion bringt die Anzeige auf den Stand. Nur sie
// fasst das DOM an.
function zeichnen() {
  anzeige.textContent = String(wert);
}

// Jeder Handler ändert nur den Zustand und zeichnet neu.
document.getElementById("plus").addEventListener("click", () => {
  wert = wert + 1;
  zeichnen();
});

document.getElementById("mal-zwei").addEventListener("click", () => {
  wert = wert * 2;
  zeichnen();
});

document.getElementById("zurueck").addEventListener("click", () => {
  wert = 0;
  zeichnen();
});

zeichnen();

Das ist dasselbe Muster wie beim Zähler in Lektion 12.8, und hier lohnt es sich noch mehr.

Jeder Handler ändert den Zustand und ruft danach eine Funktion auf, die die Anzeige auf diesen Stand bringt. Kein Handler fasst das DOM direkt an.

Was das bringt, merkst du, sobald etwas dazukommt. Bekommt die Anzeige eine Rundenzeit dazu, ändert sich genau eine Funktion. Zeichnet stattdessen jeder Handler selbst, ändern sich vier, und der fünfte wird vergessen.

Bei der Stoppuhr wird zeichnen() deshalb vom Intervall aufgerufen und von jedem Button. Der Button braucht das, denn sonst bliebe nach dem Zurücksetzen die alte Zeit stehen, bis das nächste Intervall feuert, und nach dem Zurücksetzen feuert gar keines mehr.

Aufräumen an drei Stellen

Zweimal Start, zweimal so schnell
const ohneFeld = document.getElementById("ohne");
const mitFeld = document.getElementById("mit");

let ohne = 0;
let mit = 0;
let kennung = null;

document.getElementById("start").addEventListener("click", () => {
  // Ohne Schutz startet jeder Klick ein weiteres Intervall.
  setInterval(() => {
    ohne = ohne + 1;
    ohneFeld.textContent = String(ohne);
  }, 200);

  // Mit Schutz passiert nichts, wenn schon eines läuft.
  if (kennung === null) {
    kennung = setInterval(() => {
      mit = mit + 1;
      mitFeld.textContent = String(mit);
    }, 200);
  }
});

Die dritte Stelle, an der es klemmt, ist das Intervall selbst.

Beim Start darf kein zweites dazukommen, wenn schon eines läuft. Im dritten Beispiel zählt die ungeschützte Uhr nach dem zweiten Klick auf Start doppelt so schnell, denn zwei Intervalle erhöhen dieselbe Zahl. Die Kennung des ersten ist dabei längst verloren, und stoppen lässt es sich auch nicht mehr.

Im Reiter „Debug“ wird daraus ein Muster, denn die Aufzeichnung läuft auch dann weiter, wenn du zwischendurch woanders klickst. Wenn du während einer Aufzeichnung im Reiter „Browser“ zweimal auf Start drückst, stehen im Protokoll auf zwei Schritte der ungeschützten Uhr immer einer der geschützten, im selben Takt. Die Zahlen daneben laufen auseinander. Ab dem zweiten Klick wächst ohne doppelt so schnell wie mit.

Bei der Pause kommt clearInterval mit der Kennung, und die Kennung steht danach auf null. Am null erkennt man, ob gerade etwas läuft.

Beim Zurücksetzen kommt dasselbe, auch wenn die Uhr pausiert ist. Ein clearInterval auf eine Kennung, die es nicht mehr gibt, ist harmlos.

Ob gerade ein Intervall läuft, siehst du also an der Kennung selbst, und kennung === null heißt, es läuft keines. Eine zweite Variable, die dasselbe noch einmal sagt und irgendwann etwas anderes behauptet, brauchst du damit nicht.

Die Anzeige formatieren

Aus 65432 Millisekunden soll 01:05:43 werden, und das sieht erstaunlich oft falsch aus.

Der Weg dahin führt über Ganzzahldivision und Rest, also Math.floor und % aus dem zweiten Abschnitt. Hundertstel sind die Millisekunden durch zehn, Sekunden die Hundertstel durch hundert, Minuten die Sekunden durch sechzig. padStart(2, "0") füllt jede Zahl als Text vorn mit Nullen auf zwei Stellen auf. Ohne das springt die Anzeige zwischen 1:5:3 und 11:15:43 hin und her.

In der Aufgabe ist diese Funktion vorgegeben, und es geht um die drei Buttons der Stoppuhr, Start, Pause und Zurücksetzen.

Zum Mitnehmen

Eine Stoppuhr rechnet die Differenz zum Startzeitpunkt, und das Intervall sagt nur, wann neu gezeichnet wird. Für die Pause braucht sie eine zweite Zahl, und ein neues Intervall startet nur, wenn die Kennung null ist.

Jetzt du

Basis Konto, kostenlos

Zu 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.