Memory-Spiel: Fisher-Yates-Shuffle und CSS-Karten-Flip erklärt

VeröffentlichtToolMemory-Spiel: Karten umdrehen

Inhalt
  1. Warum Mischen und Karten-Umdrehen knifflig sind
  2. Fisher-Yates-Shuffle und CSS-Kartenflip selbst umsetzen
  3. Kartenanzahl je nach Spielfeldgröße
  4. Fazit
  5. Technische Grundlagen: So funktioniert das Memory-Spiel
  6. Vergleichstabelle: Shuffle-Algorithmen im Überblick
  7. Die 5 häufigsten Fehler bei der Entwicklung eines Memory-Spiels
  8. Workflow in 5 Schritten: Die Architektur eines gelungenen Kartenspiels
  9. 7 Tipps für die Entwicklung von Kartenspielen
  10. Entscheidungsbaum für Schwierigkeitsgrad und Spielfeldgröße
  11. Wichtige Fachbegriffe im Überblick
  12. Häufig gestellte Fragen

Ein Memory-Spiel, bei dem Sie Karten umdrehen und zusammengehörige Paare finden, folgt einfachen Regeln. Wer es selbst programmieren möchte, steht jedoch schnell vor zwei Fragen: Wie mischt man die Karten fair, und wie setzt man die Umdreh-Animation um? In diesem Artikel erfahren Sie, wie der Fisher-Yates-Shuffle die Kartenreihenfolge zufällig mischt und wie Sie den Umdreh-Effekt per CSS abhängig vom Kartenstatus umsetzen. Außerdem stellen wir ein Tool vor, mit dem Sie direkt spielen und Ihre Werte messen können.

Zusammenfassung ① Der Fisher-Yates-Shuffle durchläuft das Array von hinten und tauscht jedes Element mit einer zufälligen Position. So werden die Karten fair verteilt. ② Je nach Kartenstatus (isFlipped, isMatched) genügt es, bei demselben Element den Wert für transform: rotateY und den angezeigten Inhalt umzuschalten, um die Umdreh-Animation umzusetzen. ③ Sie müssen nichts selbst programmieren: Mit dem Tool „Memory-Spiel: Karten umdrehen“ können Sie sofort spielen und dabei Züge und Zeit messen.

Warum Mischen und Karten-Umdrehen knifflig sind

Beim Programmieren eines Memory-Spiels stoßen Sie zuerst auf die Frage, wie man die Karten fair mischt. Schreibt man den Code zum zufälligen Umsortieren eines Arrays zu naiv, entsteht eine Verzerrung: Bestimmte Karten landen häufiger an bestimmten Positionen, und das Spiel verliert an Reiz. Hinzu kommen eine Umdreh-Animation, bei der Vorder- und Rückseite beim Klick natürlich wechseln, sowie eine Zustandsverwaltung, die verhindert, dass eine dritte Karte angeklickt wird, bevor die Paarprüfung abgeschlossen ist.

Fisher-Yates-Shuffle und CSS-Kartenflip selbst umsetzen

1. Fisher-Yates-Shuffle und Paarprüfung

Der Fisher-Yates-Shuffle beginnt beim letzten Index des Arrays und geht Schritt für Schritt nach vorn. Dabei wird der Wert an der aktuellen Position mit dem Wert an einem zufällig gewählten Index innerhalb des bis dahin gültigen Bereichs getauscht.

Sie durchlaufen den Array-Index i rückwärts von N-1 bis 1. Dabei ermitteln Sie eine ganze Zahl j zwischen 0 und i, indem Sie den Wert von Math.random() × (i + 1) abrunden (Math.floor), und tauschen anschließend A[i] mit A[j].

Dieser Vorgang wird für jeden Index nur einmal ausgeführt, die Zeitkomplexität beträgt daher O(N). Entscheidend ist, dass jede mögliche Kartenanordnung mit derselben Wahrscheinlichkeit auftritt.

Die Bedingungen zur Beurteilung des Spielstatus im Überblick:

  • Vergleich der beiden gewählten Karten: Sind die emoji-Werte beider Karten gleich (firstCard.emoji === secondCard.emoji), wird nach 0,5 Sekunden isMatched = true gesetzt. Unterscheiden sie sich, wird nach 1 Sekunde isFlipped wieder auf false zurückgesetzt und die Karten werden erneut verdeckt dargestellt.
  • Auswertung von Zügen (Moves) und benötigter Zeit (Timer): Wenn Sie die Anzahl der Züge und die Zeit bis zum Finden aller Paare festhalten, können Sie damit das Kurzzeitgedächtnis verschiedener Spieler vergleichen.

2. Umdreh-Transform abhängig vom Kartenstatus rendern

Der folgende Code zeigt das Emoji an, wenn die Karte umgedreht (isFlipped) oder bereits gepaart (isMatched) ist, andernfalls ein Fragezeichen. Vorder- und Rückseite sind keine getrennten Elemente: Ein einzelner Button und das darin liegende span schalten nur den angezeigten Inhalt und den transform-Wert um.


const isRevealed = card.isFlipped || card.isMatched;

<button
  onClick={() => handleCardClick(index)}
  style={{
    transform: isRevealed ? "rotateY(0deg)" : "rotateY(180deg)",
    transition: "transform 0.3s ease, background-color 0.3s ease",
    backgroundColor: card.isMatched ? "#0f172a" : isRevealed ? "#38bdf8" : "#475569"
  }}
>
  <span style={{ transform: isRevealed ? "rotateY(0deg)" : "rotateY(180deg)" }}>
    {isRevealed ? card.emoji : "❓"}
  </span>
</button>

Abhängig vom Wert von isRevealed wird der transform von Button und innerem span gemeinsam auf rotateY(0deg) oder rotateY(180deg) gesetzt, dazu kommt lediglich ein ease-Übergang von 0,3 Sekunden. Auch ohne 3D-Eigenschaften wie perspective oder backface-visibility lässt sich die Umdreh-Interaktion umsetzen: Ein einziger Statuswert ändert gleichzeitig den angezeigten Inhalt und den Drehwinkel.

3. Hinweise zur Zustandsverwaltung bei der Entwicklung eines Puzzles

  1. Schutz vor schnellen Mehrfachklicks (Double-Click-Bug): Nachdem die zweite Karte gewählt wurde, dauert es bis zur Paarentscheidung 0,5 Sekunden (bei einem Treffer) bzw. 1 Sekunde (bei einem Fehlversuch). Klickt der Spieler in dieser Zeit eine dritte Karte an, gerät der Spielstatus durcheinander. Das müssen Sie verhindern. Mit einem Flag isLocked = true sperren Sie Klickeingaben vorübergehend, bis die Paarprüfung abgeschlossen ist (Lock-Mechanismus).
  2. Zeitpunkt der Siegprüfung (Win Condition): Rufen Sie innerhalb des setTimeout-Callbacks every(...) auf dem soeben aktualisierten Array matchedCards auf, um zu prüfen, ob alle Paare gefunden sind. So vermeiden Sie den Fehler, dass ein noch nicht neu gerenderter, älterer React-State gelesen und die Siegbedingung verpasst wird.

Hinweis Sie müssen die obige Logik nicht selbst programmieren, sondern können das Tool „Memory-Spiel: Karten umdrehen“ direkt ausprobieren. Wählen Sie die Stufe 4x4 oder 6x6, verfolgen Sie Züge und Zeit in Echtzeit und testen Sie so Ihr Arbeitsgedächtnis.

Wenn Sie Shuffle-Algorithmus und Umdreh-Code nicht selbst schreiben, sondern gleich ausprobieren möchten, probieren Sie unser Tool aus.

Memory-Spiel: Karten umdrehen

Finden Sie auf einem 4x4- oder 6x6-Feld die passenden verdeckten Emoji-Kartenpaare und testen Sie dabei Ihr Kurzzeitgedächtnis sowie Ihre Anzahl an Zügen.

Kartenanzahl je nach Spielfeldgröße

SpielfeldgrößeKarten insgesamtAnzahl der Paare
4x416 Karten8 Paare
6x636 Karten18 Paare

Fazit

  • Der Fisher-Yates-Shuffle durchläuft das Array von hinten und tauscht jeden Wert mit einer zufälligen Position, sodass die Karten fair gemischt werden.
  • Je nach Kartenstatus (isFlipped, isMatched) genügt es, den angezeigten Inhalt und den Wert von transform: rotateY umzuschalten, um die Umdreh-Animation umzusetzen.
  • Ohne Lock-Mechanismus, der weitere Klicks vor Abschluss der Paarprüfung blockiert, kann der Spielstatus durcheinandergeraten.
  • Statt alles selbst zu programmieren, können Sie mit dem Tool „Memory-Spiel: Karten umdrehen“ auf 4x4- und 6x6-Feldern sofort Züge und Zeit messen.
Memory-Spiel: Karten umdrehen

Finden Sie auf einem 4x4- oder 6x6-Feld die passenden verdeckten Emoji-Kartenpaare und testen Sie dabei Ihr Kurzzeitgedächtnis sowie Ihre Anzahl an Zügen.


Technische Grundlagen: So funktioniert das Memory-Spiel

Für ein rundum gelungenes Kartenspiel genügt reines Programmieren nicht. Sie brauchen ein Verständnis von Algorithmen, Rendering-Engines und kognitiver Psychologie.

1. Der mathematische Beweis für den Fisher-Yates-Shuffle

Der Kern eines zufälligen Mischens: Alle N! (Fakultät) möglichen Permutationen müssen mit exakt der gleichen Wahrscheinlichkeit von 1/N! auftreten. Bei einem Array der Größe N durchläuft der Fisher-Yates-Algorithmus die Indizes rückwärts vom Ende her. Dabei wählt er aus dem verbleibenden Bereich zufällig ein Element aus und tauscht es. Berechnet man mathematisch die Wahrscheinlichkeit, dass eine bestimmte Karte an einer bestimmten Position landet, ergibt sich für die erste Karte an einem bestimmten Platz 1/N, für die nächste 1/(N−1). Multipliziert man alles, erhält man ganz natürlich 1/N × (N−1) × ... × 1 = 1/N! – und damit eine perfekte Gleichverteilung (Uniform Distribution). Die Variante <pre>sort(() => Math.random() - 0.5)</pre> hängt dagegen stark von der Funktionsweise des internen Sortieralgorithmus ab, etwa Timsort in der V8-Engine. Die Verteilung ist deshalb ungleichmäßig, und es entstehen unvorhersehbare Verzerrungen.

2. CSS-3D-Transform-Architektur

Damit eine Karte tatsächlich so aussieht, als würde sie im dreidimensionalen Raum umgedreht, müssen Sie die Rendering-Pipeline des Browsers gezielt steuern.

  • perspective
    : Verleiht dem 3D-Raum Tiefe und erzeugt bei der Drehung einen perspektivischen Effekt.
  • transform-style: preserve-3d
    : Sorgt dafür, dass die Kindelemente den 3D-Raum des Elternelements teilen.
  • backface-visibility: hidden
    : Blendet die Rückseite einer Karte aus, wenn sie nach vorne zeigt. Liegen Vorder- und Rückseite übereinander, entsteht so ein natürlicher Übergang.
  • rotateY(180deg)
    : Dreht die Karte um 180 Grad um die Y-Achse und damit um. Diese Eigenschaften werden per GPU-Hardwarebeschleunigung verarbeitet und sorgen auch auf Mobilgeräten für flüssige Animationen mit 60 Bildern pro Sekunde (60 FPS).

3. Zustandsautomat (State Machine) in React

Bei einem Spiel, in dem asynchrone Animationen und Nutzerinteraktionen zusammenkommen, ist ein strikter endlicher Zustandsautomat (FSM) unverzichtbar.

  • IDLE: Wartezustand, in dem keine Karte ausgewählt ist.
  • ONE_SELECTED: Die erste Karte wurde angeklickt und umgedreht.
  • TWO_SELECTED (LOCKED): Zustand unmittelbar nach dem Klick auf die zweite Karte. Weitere Klicks (isLocked) werden konsequent blockiert.
  • CHECK_MATCH: Rechenzustand, in dem die Werte der beiden Karten verglichen werden.
  • RESET / MATCHED: Bei einem Treffer bleiben die Karten fixiert, andernfalls werden sie wieder auf die Rückseite gedreht.
  • CHECK_WIN: Prüft, ob alle Karten gefunden wurden, und löst gegebenenfalls den Sieg aus.

4. Kognitive Psychologie: Arbeitsgedächtnis und visuell-räumliches Gedächtnis

Dieses Spiel ist mehr als bloße Unterhaltung, denn es steckt neurowissenschaftliches Prinzip darin. Nach dem Modell des Kognitionspsychologen Nelson Cowan ist die Kapazität des Arbeitsgedächtnisses (Working Memory) auf etwa 4 ± 1 Chunks begrenzt; George Millers klassische Theorie nennt eine Grenze von 7 ± 2. Ein Kartenspiel beansprucht im Arbeitsgedächtnismodell von Baddeley besonders stark den „visuell-räumlichen Notizblock" (Visuospatial Sketchpad). Räumliche Positionen und visuelle Bilder (Emojis) werden dabei im Kurzzeitgedächtnis verknüpft, was als Training für neuronale Netzwerke im Gehirn wirkt.


Vergleichstabelle: Shuffle-Algorithmen im Überblick

Wir haben verschiedene Methoden zum Mischen von Arrays hinsichtlich Leistung und Effizienz aus mathematischer und technischer Sicht verglichen.

AlgorithmusZeitkomplexitätPlatzkomplexitätGleichverteilung (Bias Score)Schwierigkeit der ImplementierungPraxistauglichkeit
Fisher-Yates (Knuth) ShuffleO(N)O(1) (In-place)Perfekt (1/N!)MittelSehr gut (empfohlen)
Naive Random SortO(N log N)O(N) (zusätzlicher Speicher)Sehr schlecht (starke Verzerrung)EinfachSehr schlecht (nicht verwenden)
Random Index ExtractionO(N2) (bei splice)O(N)GutMittelSchlecht (geringe Leistung)
Sattolo's AlgorithmO(N)O(1)Nur für zyklische PermutationenMittelMittelmäßig (für Spiele ungeeignet)

Die Tabelle zeigt klar: Bei einem Kartenspiel, in dem alle Elemente vollständig zufällig gemischt werden müssen, ist allein der Fisher-Yates-Algorithmus die richtige Wahl. Er arbeitet mit O(N) schnell und speichereffizient und bietet eine mathematisch bewiesene Fairness.


Die 5 häufigsten Fehler bei der Entwicklung eines Memory-Spiels

  1. Übermäßiger Einsatz der Sortierung mit Math.random() - 0.5: Je nach Browser-Engine wird die Zufälligkeit stark beeinträchtigt, und ab einer Array-Länge von 10 kann es sogar passieren, dass die Sortierung gar nicht mehr richtig funktioniert.
  2. Fehlender Click Lock während der Animationsverzögerung: Klicks, die in den 0,5 bis 1 Sekunden zwischen dem Umdrehen der Karten und der Auswertung des Ergebnisses erfolgen, müssen ignoriert werden. Sonst wird die Zustandsvariable verfälscht, und das Spiel lässt sich nicht mehr fortsetzen.
  3. Memory Leak durch nicht aufgeräumte setTimeout-Aufrufe: Wenn Sie beim Unmount einer React-Komponente den Timer nicht aufräumen, läuft der Callback im Hintergrund weiter. Er versucht dann, einen nicht mehr existierenden Zustand zu aktualisieren, und es kommt zum Absturz (Crash).
  4. Fest einprogrammierte Grid-Koordinaten: Mobile Geräte und Desktop haben unterschiedliche Seitenverhältnisse. Verwenden Sie dennoch feste Pixelwerte wie 800px, bricht das responsive Layout völlig zusammen.
  5. Zu schwere, hochauflösende Bilder: Wenn Sie für die Kartenmotive nicht optimierte PNG- oder JPG-Dateien verwenden, wird das Laden langsamer, und die Kartenvorderseiten erscheinen verzögert mit einem Flackern (FOUC). Wir empfehlen ausdrücklich leichte SVGs oder native Emojis.

Workflow in 5 Schritten: Die Architektur eines gelungenen Kartenspiels

  1. Schritt 1: Datenmodell entwerfen und Emoji-Paare erzeugen Definieren Sie Kartenobjekte mit einer eindeutigen ID und einem Wert, der das Paar bildet. Bereiten Sie zum Beispiel 8 Emojis vor und duplizieren Sie jedes einmal, sodass ein Array mit 16 Einträgen entsteht.
  2. Schritt 2: Fisher-Yates-Algorithmus anwenden Lassen Sie das vorbereitete Array mit 16 Einträgen durch die Fisher-Yates-Shuffle-Logik laufen. So erhalten Sie ein perfekt zufällig gemischtes Kartendeck.
  3. Schritt 3: 3D-Flip-Karten-Komponente bauen Kombinieren Sie CSS <pre>perspective</pre> und <pre>transform: rotateY()</pre>, um eine UI-Komponente mit physischer Anmutung zu gestalten, deren Vorder- und Rückseite sich sanft umdrehen.
  4. Schritt 4: Zustandsautomat und Lock-Schutz verbinden Setzen Sie ein globales <pre>isLocked</pre>-Flag, das die Klick-Events steuert. Binden Sie außerdem eine asynchrone Logik an, die nach dem Aufdecken von zwei Karten mit 1 Sekunde Verzögerung prüft, ob sie zusammenpassen.
  5. Schritt 5: Stoppuhr, Zugzähler und Siegesdialog ergänzen Starten Sie mit Spielbeginn einen Timer, der sekundenweise hochzählt, und erhöhen Sie bei jedem Umdrehen einer Karte einen Zähler. Daraus bauen Sie den abschließenden Ergebnisbildschirm.

7 Tipps für die Entwicklung von Kartenspielen

  1. Hardwarebeschleunigung optimieren: Wenn Sie Kartenelementen, die animiert werden, die Eigenschaft <pre>will-change: transform</pre> zuweisen, kann der Browser GPU-Ressourcen vorab reservieren. So vermeiden Sie Ruckeln.
  2. Timer per Page Visibility API beim Tabwechsel pausieren: Damit die Zeit nicht weiterläuft, wenn Nutzer zu einem anderen Browser-Tab wechseln, sollten Sie die Eigenschaft <pre>document.hidden</pre> auswerten und die Stoppuhr anhalten.
  3. Saubere Soundausgabe mit der Web Audio API: Statt des HTML5-Audio-Tags können Sie Oszillatoren oder Puffer der Web Audio API verwenden. Dadurch lassen sich Soundeffekte erzeugen, die exakt zum Zeitpunkt des Klicks und ohne Verzögerung abgespielt werden.
  4. Smartes Grid nutzen: Mit der CSS-Grid-Funktion <pre>repeat(auto-fit, minmax(...))</pre> ordnen sich Spalten und Zeilen der Karten ohne Media Queries automatisch und flexibel an die Bildschirmgröße an.
  5. Bestleistung dauerhaft mit LocalStorage speichern: Speichern Sie die minimale Zugzahl und die kürzeste Zeit des Spielers als JSON im Browser-Speicher. So bleibt auch beim nächsten Besuch ein Ziel vor Augen.
  6. Tastatur- und Barrierefreiheit (A11y) mit ARIA: Damit auch sehbehinderte Menschen spielen können, setzen Sie <pre>aria-label</pre> und <pre>tabindex</pre> sinnvoll ein und belegen die Tasten Enter und Leertaste mit Ereignissen. So lässt sich das Spiel auch ohne Maus komfortabel spielen.
  7. Jetzt direkt mit einem fertigen Web-Tool spielen: Probieren geht über Studieren. Bevor Sie selbst programmieren, können Sie sich für Ihre Konzeption inspirieren lassen und mit dem Tool am Ende dieser Seite sofort losspielen.

Entscheidungsbaum für Schwierigkeitsgrad und Spielfeldgröße

Die optimale Spielbalance hängt von der Zielgruppe und vom verwendeten Gerät ab.

  • 4x4-Feld (16 Karten, 8 Paare)
    • Zielgruppe: Kinder, ältere Menschen, Gelegenheitsspieler für zwischendurch
    • Geeignete Geräte: ältere Smartphones mit kleinem Bildschirm
    • Merkmale: kurze Spielzeit von durchschnittlich etwa 1 bis 2 Minuten, geringe kognitive Belastung.
  • 6x6-Feld (36 Karten, 18 Paare)
    • Zielgruppe: Erwachsene, die ihr Gehirn trainieren möchten, Puzzle-Fans
    • Geeignete Geräte: Tablets und Desktop-Monitore
    • Merkmale: anspruchsvolles räumliches Gedächtnis, hohe Konzentration bei durchschnittlich mehr als 5 Minuten Spielzeit.
  • Zeitmodus (Timed Challenge)
    • Zielgruppe: ehrgeizige Hardcore-Gamer, die den Wettbewerb mögen
    • Bedingung: Das Feld muss innerhalb einer Zeitvorgabe gelöst werden, oder es gilt ein Endlosmodus, in dem das Feld immer weiter wächst. Das sorgt für einen starken Dopaminkick.

Wichtige Fachbegriffe im Überblick

  • Fisher-Yates-Shuffle (Fisher-Yates Shuffle): Standardalgorithmus für zufällige Permutationen, der die Elemente eines Arrays in linearer Zeit ohne mathematische Verzerrung vollständig durchmischt.
  • Arbeitsgedächtnis (Working Memory): Kurzzeitige Gehirnfunktion, die Informationen vorübergehend im Kopf behält und für kognitive Operationen nutzt.
  • Zustandsautomat (State Machine): Softwarearchitektur, bei der die endlich vielen möglichen Zustände eines Systems definiert sind und Zustandsübergänge eindeutig durch Ereignisse ausgelöst werden.
  • backface-visibility: Zentrale CSS-Eigenschaft, die bei 3D-Drehungen festlegt, ob die Rückseite eines Elements dargestellt wird.
  • transform: rotateY: Eigenschaft, die ein HTML-Element der 2D-Ebene um die Y-Achse dreht und so eine räumliche Wirkung erzeugt.
  • Zeitkomplexität O(N): Maß für einen effizienten Algorithmus, dessen Rechenzeit linear mit der Größe N der Eingabedaten wächst.

Häufig gestellte Fragen

Q1. Wie kann ich beweisen, dass meine Shuffle-Logik mathematisch fair (Provably Fair) ist?

A1. Führen Sie etwa 100.000 Simulationen durch und messen Sie die Häufigkeiten im Array. Wenn Sie ein Array der Größe 3, [A, B, C], 100.000-mal mischen und die Wahrscheinlichkeit, dass A an erster Stelle landet, genau gegen 33,333 % konvergiert, ist der Algorithmus fair. Fisher-Yates besteht diesen Test einwandfrei. Bei einer simplen zufälligen Sortierung per Subtraktion sehen Sie dagegen sofort, dass bestimmte Karten mit einer Häufigkeit von über 60 % an bestimmten Positionen verbleiben.

Q2. Wie verhindere ich, dass der Timer aus dem Ruder läuft, wenn Nutzer auf dem Smartphone kurz in eine andere App wechseln?

A2. Asynchrone Timer in JavaScript werden gedrosselt (Throttling), sobald der Browser-Tab inaktiv ist. Sie laufen dann langsamer oder stoppen ganz. Um das zu vermeiden, merken Sie sich den Zeitstempel beim Start. Über <pre>document.addEventListener('visibilitychange')</pre> speichern Sie die bis dahin angefallene Zeit und pausieren den Timer, sobald der Tab nicht mehr sichtbar ist. Diese Logik sollten Sie unbedingt umsetzen.

Q3. Macht ein tägliches Kartenspiel zum Umdrehen das Gehirn tatsächlich leistungsfähiger?

A3. Laut Erkenntnissen der kognitiven Neurowissenschaft fördert ein solches Training des räumlichen Gedächtnisses (Spatial Memory) die Aktivierung des präfrontalen Kortex (Prefrontal Cortex). Es erhöht nicht einfach den Intelligenzquotienten. Vielmehr verbessert sich die Effizienz der neuronalen Verbindungen, mit denen kurzzeitig aufgenommene visuelle Informationen im Arbeitsgedächtnis gehalten und schnell wieder abgerufen werden. Das kann Ihrem Kurzzeitgedächtnis im Alltag spürbar helfen.

Dieser Artikel basiert auf unserem koreanischen Original. Koreanisches Original lesen

Ähnliche Artikel

  1. Kurzlink prüfen: Wohin führt bit.ly vor dem Klick?So sehen Sie, wohin ein Kurzlink wirklich führt, ohne ihn zu öffnen: Location-Header lesen, 301 und 302 unterscheiden und mehrfache Weiterleitungen verstehen.
  2. Schach-Notation lesen: Koordinaten wie e4 und Nf3 verstehenSo lesen Sie e4 und Nf3 in der algebraischen Notation: Linien und Reihen auf dem Brett erklärt, dazu Übung mit dem Schachbrett-Koordinaten-Trainer.
  3. Online-Notizblock: Warum Notizen nach Cache-Leeren bleibenWarum ein Online-Notizblock nach dem Löschen des Caches erhalten bleibt, auf anderen Geräten und im privaten Modus aber fehlt – erklärt am Browser-Speicher.
  4. 10 Sekunden ohne Timer zählen: So schätzen Sie die Zeit genauWie Sie ohne Timer möglichst genau 10 Sekunden zählen und warum sich die gefühlte Zeit von Mensch zu Mensch unterscheidet. Mit Tipps zum Rhythmus.
  5. CSS aspect-ratio berechnen: padding-top-Hack und 16:9-FormelSo fixieren Sie Seitenverhältnisse wie 16:9 und 4:3 mit aspect-ratio und berechnen den padding-top-Prozentwert für ältere Browser per Formel.
  6. CSS vertikal zentrieren: Flexbox, Grid, Absolute & line-heightCSS vertikal zentrieren mit Flexbox, Grid, Absolute und line-height: Die fünf Methoden mit Code, Formel und Kompatibilitätsbericht im direkten Vergleich.

Passende Tools