Skip to content

HTML5 Spickzettel

Fünfte Revision von HTML mit neuen semantischen Elementen und APIs.

01

Semantische Elemente

Dokumentstruktur

HTML5 führte semantische Elemente ein, die ihre Bedeutung für Browser und Entwickler beschreiben. header, nav, main, article, aside, footer definieren die Dokumentstruktur. DOCTYPE html aktiviert den Standards-Modus, lang verbessert Barrierefreiheit und SEO, und charset UTF-8 ist für korrektes Encoding Pflicht.

html5
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Page Title</title>
</head>
<body>
  <header>Header content</header>
  <nav>Navigation</nav>
  <main>
    <article>Article content</article>
    <aside>Sidebar</aside>
  </main>
  <footer>Footer</footer>
</body>
</html>

Header & Footer

header repräsentiert einleitenden Inhalt (Logos, Titel, Suchformulare) und darf mehrfach auftreten. footer hält abschließenden Inhalt wie Copyright, Links oder Kontakt. Beide können innerhalb von sectioning-Elementen wie article oder section genutzt werden, nicht nur auf Seitenebene.

html5
<header>
  <h1>Site Title</h1>
  <p>Tagline</p>
</header>

<footer>
  <nav>
    <a href="/about">About</a>
    <a href="/contact">Contact</a>
  </nav>
  <small>&copy; 2024 Example</small>
</footer>

Navigations-Element

nav ist großen Navigationsblöcken vorbehalten. Nicht jede Linkliste braucht nav — nur Gruppen, die für die Seitennavigation bedeutsam sind. aria-label nutzen, um mehrere nav-Elemente zu unterscheiden (z. B. main vs. breadcrumb). aria-current zeigt die aktuelle Seite an.

html5
<nav aria-label="Main navigation">
  <ul>
    <li><a href="/" aria-current="page">Home</a></li>
    <li><a href="/blog">Blog</a></li>
    <li><a href="/about">About</a></li>
  </ul>
</nav>

<nav aria-label="Breadcrumb">
  <ol>
    <li><a href="/">Home</a></li>
    <li><a href="/blog">Blog</a></li>
    <li aria-current="page">Post</li>
  </ol>
</nav>

Main & Article

main umwickelt den dominierenden Inhalt der Seite und sollte nur einmal pro Seite auftreten (mappt auf das 'main'-ARIA-Landmark). article ist eine in sich geschlossene Komposition — ein Blogpost, ein Nachrichtentext oder ein Widget — unabhängig wiederverwendbar. section gruppiert thematisch verwandten Inhalt, immer mit einer Überschrift.

html5
<body>
  <header>Site header</header>
  <main>
    <article>
      <h1>Blog Post Title</h1>
      <p>Body content...</p>
      <section>
        <h2>Subsection</h2>
        <p>More content</p>
      </section>
    </article>
  </main>
</body>

Section & Aside

section gruppiert verwandten Inhalt und sollte immer eine Überschrift enthalten. aside repräsentiert Inhalt, der am Rand zum Hauptinhalt gehört — Seitenleisten, Pull-Zitate oder Werbung. Beide verbessern die Dokumentgliederung. aria-labelledby nutzen, um sections einen zugänglichen Namen zu geben.

html5
<section aria-labelledby="features-heading">
  <h2 id="features-heading">Features</h2>
  <p>Feature description</p>
</section>

<aside aria-label="Related links">
  <h2>Related</h2>
  <ul>
    <li><a href="/post-2">Next post</a></li>
  </ul>
</aside>

Figure & Figcaption

figure gruppiert Inhalt (Bilder, Code-Listings, Zitate), der aus dem Hauptfluss referenziert wird, mit figcaption als Bildunterschrift. figcaption muss erstes oder letztes Kind sein. figure beschränkt sich nicht auf Bilder — sie funktioniert für jeden in sich geschlossenen Inhalt wie Code-Snippets oder Blockquotes.

html5
<figure>
  <img src="chart.png" alt="Sales chart showing growth">
  <figcaption>Figure 1: Quarterly sales growth in 2024.</figcaption>
</figure>

<figure>
  <blockquote>
    <p>The best way to predict the future is to invent it.</p>
  </blockquote>
  <figcaption>— Alan Kay</figcaption>
</figure>
02

Formular-Erweiterungen

Neue Input-Typen

HTML5 ergänzte Input-Typen wie email, url, tel, date, time, color, range, number, month, week und datetime-local. Browser liefern native Validierung und spezialisierte UI (Datumswähler, Farbwähler). type=email/url triggern automatische Formatvalidierung beim Absenden des Formulars.

html5
<form>
  <label>Email: <input type="email" required></label>
  <label>URL: <input type="url"></label>
  <label>Phone: <input type="tel"></label>
  <label>Date: <input type="date"></label>
  <label>Time: <input type="time"></label>
  <label>Color: <input type="color"></label>
  <label>Range: <input type="range" min="0" max="100"></label>
  <label>Number: <input type="number" min="0" step="0.01"></label>
  <button>Submit</button>
</form>

Datalist-Autocomplete

datalist liefert Autocomplete-Vorschläge für ein input über das list-Attribut. Anders als select können Nutzer freien Text tippen oder einen Vorschlag wählen. Der value jeder option wird zum Vorschlag. datalist degradiert auf nicht unterstützenden Browsern graceful zu einem normalen Textfeld.

html5
<label>
  Choose a browser:
  <input list="browsers" name="browser">
</label>
<datalist id="browsers">
  <option value="Chrome">
  <option value="Firefox">
  <option value="Safari">
  <option value="Edge">
</datalist>

Output-Element

output repräsentiert das Ergebnis einer Berechnung oder Nutzeraktion. Es hat eine über JS zugängliche value-Eigenschaft und ein for-Attribut, das die beitragenden Inputs referenziert. Es ist ein form-assoziiertes Element, sein Wert wird also mit dem Formular gesendet. Perfekt für Live-Rechner.

html5
<form oninput="result.value = (+a.value + +b.value)">
  <input type="number" name="a" value="0">
  +
  <input type="number" name="b" value="0">
  =
  <output name="result" for="a b">0</output>
</form>

Progress & Meter

progress zeigt den Fortschritt einer Aufgabe (value/max); ohne value ist der Zustand unbestimmt. meter zeigt eine skalare Messung innerhalb eines bekannten Bereichs, mit low/high/optimum-Schwellen, die die Farbe beeinflussen. meter ist read-only und nicht für Fortschrittsanzeige gedacht.

html5
<label>Uploading:
  <progress value="70" max="100">70%</progress>
</label>

<label>Disk usage:
  <meter value="0.6" min="0" max="1" low="0.4" high="0.8" optimum="0.2">
    60%
  </meter>
</label>

<!-- Indeterminate progress -->
<progress>Processing...</progress>

Form-Attribut & Fieldset

Das form-Attribut verknüpft ein input, fieldset oder button per id mit einem Formular, selbst wenn das Element nicht darin verschachtelt ist. fieldset gruppiert verwandte Steuerungen und legend liefert eine Beschriftung. disabled auf dem fieldset deaktiviert alle enthaltenen Steuerungen auf einen Schlag.

html5
<form id="myForm" action="/submit" method="post"></form>

<!-- Input outside the form, but associated via form attribute -->
<label>
  Name:
  <input type="text" name="name" form="myForm" required>
</label>

<fieldset form="myForm" disabled>
  <legend>Shipping Options</legend>
  <label><input type="radio" name="ship" value="standard"> Standard</label>
  <label><input type="radio" name="ship" value="express"> Express</label>
</fieldset>

<button type="submit" form="myForm">Submit</button>

Placeholder & Autofocus

placeholder zeigt einen Hinweis im Eingabefeld und verschwindet bei Fokus — kein Ersatz für ein label. autofocus fokussiert das Element beim Laden der Seite (sparsam nutzen, einer pro Seite). autocomplete steuert, ob sich der Browser frühere Werte merkt. title liefert einen Tooltip, sollte aber zugängliche Labels nicht ersetzen.

html5
<form>
  <label>
    Search:
    <input type="search" name="q"
           placeholder="Type to search..."
           autofocus
           autocomplete="off">
  </label>
  <label>
    Hint text:
    <input type="text" name="hint" title="Helpful tooltip">
  </label>
  <button type="submit">Go</button>
</form>
03

Formular-Validierung

required-Attribut

Das boolesche required-Attribut markiert ein Feld als Pflichtfeld; der Browser blockiert das Absenden und zeigt eine Fehlerblase, wenn es leer ist. Es funktioniert auf allen text-, number-, checkbox-, radio-, file- und select-Steuerungen. Mit den CSS-Pseudoklassen :invalid und :valid für visuelles Feedback paaren.

html5
<form>
  <label>
    Email (required):
    <input type="email" name="email" required>
  </label>
  <label>
    Optional phone:
    <input type="tel" name="phone">
  </label>
  <button>Submit</button>
</form>

Pattern-Validierung

pattern akzeptiert einen JavaScript-regulären Ausdruck (ohne Schrägstriche), dem der Wert entsprechen muss. Anker mit ^ und $ empfohlen. Das title-Attribut gibt Nutzern bei Fehlschlag einen Hinweis. Pattern ist implizit verankert für type=email/url, aber explizit für textbasierte Inputs.

html5
<form>
  <label>
    Product code:
    <input type="text" name="code"
           pattern="[A-Z]{3}-\d{4}"
           title="Three letters, hyphen, four digits (e.g., ABC-1234)"
           required>
  </label>
  <label>
    Hex color:
    <input type="text" name="color" pattern="^#[0-9A-Fa-f]{6}$">
  </label>
  <button>Submit</button>
</form>

Min, Max & Step

min und max definieren untere und obere Grenzen für numerische und Datums-Inputs. step legt die Schrittweite fest; Werte müssen min + n*step entsprechen. step='any' erlaubt jede Dezimalzahl. Der Browser lehnt außerhalb liegende Werte beim Absenden ab und passt Spinner-Klicks an.

html5
<form>
  <label>
    Quantity:
    <input type="number" name="qty" min="1" max="99" step="1" value="1">
  </label>
  <label>
    Price:
    <input type="number" name="price" min="0" step="0.01">
  </label>
  <label>
    Date range:
    <input type="date" name="start" min="2024-01-01" max="2024-12-31">
  </label>
  <button>Submit</button>
</form>

minlength & maxlength

minlength und maxlength begrenzen die Zeichenzahl für text-Inputs und textareas. minlength triggert die Validierung nur, wenn das Feld einen Wert hat (mit required für Pflichtfelder kombinieren). maxlength sperrt Eingaben über dem Limit hart und verhindert Weiteres Tippen.

html5
<form>
  <label>
    Username (3-20 chars):
    <input type="text" name="user" minlength="3" maxlength="20" required>
  </label>
  <label>
    Bio (max 280 chars):
    <textarea name="bio" maxlength="280"></textarea>
  </label>
  <button>Submit</button>
</form>

Constraint-Validation-API

Die Constraint Validation API exponiert validity.valid, valueMissing, typeMismatch, patternMismatch, tooShort, rangeOverflow und mehr. setCustomValidity(msg) zeigt eine eigene Meldung (leerer String räumt auf). checkValidity() gibt einen Boolean zurück und feuert das invalid-Ereignis; reportValidity() zeigt auch die UI.

html5
<form id="f">
  <label>
    Username:
    <input name="u" required minlength="3">
  </label>
  <button>Submit</button>
</form>

<script>
  const input = document.querySelector('#f input[name=u]');
  input.addEventListener('input', () => {
    if (input.validity.valueMissing) {
      input.setCustomValidity('Please pick a username.');
    } else if (input.validity.tooShort) {
      input.setCustomValidity('At least 3 characters.');
    } else {
      input.setCustomValidity('');
    }
  });
</script>

novalidate & formnovalidate

novalidate am Formular deaktiviert die Browser-Validierung komplett — nützlich, wenn per JS validiert wird. formnovalidate auf einem Submit-Button überspringt die Validierung nur für dessen Absendung (z. B. ein 'Entwurf speichern', das unvollständige Daten erlaubt). Beide senden das Formular trotzdem ab.

html5
<!-- Browser validation disabled for whole form -->
<form novalidate>
  <label>Email: <input type="email" name="e" required></label>
  <button>Save draft</button>
  <!-- Skip validation only for this button -->
  <button type="submit" formnovalidate>Cancel</button>
</form>
04

Canvas-Zeichnen

Canvas-Element & 2D-Kontext

canvas ist eine Bitmap-Zeichenfläche. getContext('2d') liefert den 2D-Rendering-Kontext; 'webgl' einen 3D-Kontext. Die width/height-Attribute setzen die Zeichnungs-Buffer-Größe (nicht die CSS-Größe). Für knackiges Rendering auf Retina-Displays den Buffer mit devicePixelRatio skalieren. Fallback-Inhalt kommt zwischen die Tags.

html5
<canvas id="cv" width="400" height="300">
  Your browser does not support canvas.
</canvas>

<script>
  const canvas = document.getElementById('cv');
  const ctx = canvas.getContext('2d');
  // High-DPI scaling
  const dpr = window.devicePixelRatio || 1;
  canvas.width = 400 * dpr;
  canvas.height = 300 * dpr;
  ctx.scale(dpr, dpr);
</script>

Rechtecke zeichnen

fillRect(x, y, w, h) zeichnet ein gefülltes Rechteck, strokeRect nur den Umriss, und clearRect löscht Pixel zu transparent. fillStyle und strokeStyle akzeptieren Farben, Gradients oder Patterns. lineWidth beeinflusst die Strichdicke, zentriert auf der Pfadkante.

html5
<script>
  const ctx = canvas.getContext('2d');
  // Filled rectangle
  ctx.fillStyle = '#3498db';
  ctx.fillRect(10, 10, 100, 50);
  // Outlined rectangle
  ctx.strokeStyle = '#e74c3c';
  ctx.lineWidth = 3;
  ctx.strokeRect(130, 10, 100, 50);
  // Clear a rectangle (erase)
  ctx.clearRect(50, 20, 40, 30);
</script>

Pfade & Linien

beginPath startet einen neuen Pfad. moveTo setzt die Stiftposition ohne zu zeichnen; lineTo ergänzt ein Liniensegment. closePath verbindet den letzten Punkt mit dem Anfang. fill() und/oder stroke() aufrufen, um zu rendern. Bögen (arc), Kurven (quadraticCurveTo, bezierCurveTo) und rects lassen sich ebenfalls in einen Pfad aufnehmen.

html5
<script>
  const ctx = canvas.getContext('2d');
  ctx.beginPath();
  ctx.moveTo(20, 20);          // starting point
  ctx.lineTo(180, 20);         // top edge
  ctx.lineTo(100, 140);        // bottom corner
  ctx.closePath();             // back to start
  ctx.fillStyle = 'rgba(46,204,113,0.6)';
  ctx.fill();
  ctx.stroke();
</script>

Text zeichnen

font nutzt dieselbe Kurzform wie CSS font. textAlign (start, end, left, right, center) und textBaseline (top, middle, alphabetic, bottom) steuern die Ausrichtung. fillText zeichnet gefüllten Text; strokeText nur den Umriss. measureText('foo').width liefert die gerenderte Breite.

html5
<script>
  const ctx = canvas.getContext('2d');
  ctx.font = '600 24px system-ui, sans-serif';
  ctx.textAlign = 'center';
  ctx.textBaseline = 'middle';
  ctx.fillStyle = '#2c3e50';
  ctx.fillText('Hello Canvas', 200, 150);
  ctx.lineWidth = 1;
  ctx.strokeStyle = '#bdc3c7';
  ctx.strokeText('Outlined', 200, 200);
</script>

Bilder zeichnen

drawImage kann ein img-, canvas- oder video-Element nehmen. Mit 3 Argumenten zeichnet es in natürlicher Größe; mit 5 skaliert es auf w/h; mit 9 sind die ersten vier das Quell-Rechteck (crop) und die letzten vier das Ziel-Rechteck. Vor dem Zeichnen auf onload warten, sonst erscheint das Bild evtl. nicht.

html5
<script>
  const img = new Image();
  img.src = 'pic.jpg';
  img.onload = () => {
    ctx.drawImage(img, 0, 0);                      // full size
    ctx.drawImage(img, 0, 0, 100, 75);             // scaled
    // Source crop -> destination
    ctx.drawImage(img, 32, 32, 64, 64, 200, 0, 64, 64);
  };
</script>

Gradients

createLinearGradient(x0, y0, x1, y1) und createRadialGradient(x0, y0, r0, x1, y1, r1) definieren Gradients. addColorStop(offset, color) ergänzt Farbstufen mit offset von 0 bis 1. Immer standardkonforme Farb-Strings übergeben; misspasste Formate (hex und rgba gemischt) können die Interpolation brechen. Den Gradient an fillStyle oder strokeStyle zuweisen.

html5
<script>
  // Linear gradient
  const lg = ctx.createLinearGradient(0, 0, 200, 0);
  lg.addColorStop(0, '#1e90ff');
  lg.addColorStop(1, '#ffffff');
  ctx.fillStyle = lg;
  ctx.fillRect(0, 0, 200, 80);

  // Radial gradient
  const rg = ctx.createRadialGradient(100, 180, 5, 100, 180, 80);
  rg.addColorStop(0, 'rgba(255,200,0,1)');
  rg.addColorStop(1, 'rgba(255,200,0,0)');
  ctx.fillStyle = rg;
  ctx.fillRect(0, 100, 200, 160);
</script>
05

Inline-SVG

SVG-Element-Grundlagen

Inline-SVG nutzt das svg-Element mit width/height für die Anzeigegröße und viewBox für das Koordinatensystem. xmlns ist Pflicht, wenn das SVG eigenständig genutzt wird, inline optional. SVG ist vektorbasiert: es skaliert in jeder Größe knackig und ist durchsuchbar und per CSS stylbar wie normales HTML.

html5
<svg width="200" height="120" viewBox="0 0 200 120"
     xmlns="http://www.w3.org/2000/svg">
  <rect x="10" y="10" width="180" height="100"
        fill="#3498db" rx="8" />
  <text x="100" y="65" text-anchor="middle"
        fill="white" font-size="18">SVG</text>
</svg>

Grundformen

SVG-Primitiva sind rect, circle, ellipse, line, polyline (offen) und polygon (geschlossen). cx/cy sind Zentrums-Koordinaten; r der Radius. fill ist die Innenfarbe, stroke der Umriss. stroke-width setzt die Umrissdicke. Alle Attribute lassen sich auch per CSS setzen.

html5
<svg width="240" height="120" viewBox="0 0 240 120">
  <rect x="10" y="10" width="80" height="80" fill="#e74c3c" />
  <circle cx="150" cy="50" r="40" fill="#2ecc71" />
  <ellipse cx="200" cy="60" rx="30" ry="18" fill="#f1c40f" />
  <line x1="10" y1="110" x2="230" y2="110" stroke="#333" stroke-width="2" />
  <polyline points="10,100 60,70 110,100 160,70"
            fill="none" stroke="#9b59b6" stroke-width="3" />
</svg>

Pfade

path ist das mächtigste SVG-Element und zeichnet über ein d-Attribut voller Befehle. M = moveTo, L = lineTo, H/V = horizontale/vertikale Linien, C = kubische Bezier, Q = quadratische Bezier, A = Bogen, Z = Pfad schließen. Kleinbuchstaben nutzen relative Koordinaten. Die meisten Editor-Exporte nutzen paths.

html5
<svg width="200" height="120" viewBox="0 0 200 120">
  <!-- M=moveTo, L=lineTo, C=cubicBezier, Z=closePath -->
  <path d="M 10 80
           C 40 10, 90 10, 120 80
           L 180 80 Z"
        fill="none" stroke="#3498db" stroke-width="3" />
  <!-- A=arc -->
  <path d="M 10 100 A 90 90 0 0 1 190 100"
        fill="none" stroke="#e74c3c" stroke-width="2" />
</svg>

Text in SVG

text rendert skalierbaren, selektierbaren Text. x/y positionieren die Baseline. text-anchor (start/middle/end) und dominant-baseline steuern die Ausrichtung. tspan erlaubt Styling, Positionierung und Umbrüche pro Segment. SVG-Text bleibt bei jedem Zoom knackig und ist zugänglich, anders als auf canvas gezeichneter Text.

html5
<svg width="300" height="100" viewBox="0 0 300 100">
  <text x="20" y="40" font-family="system-ui" font-size="20"
        fill="#2c3e50">Plain text</text>
  <text x="20" y="75" font-size="20" fill="#e74c3c"
        text-decoration="underline">Underlined</text>
  <text x="180" y="50">
    <tspan fill="#3498db">Blue</tspan>
    <tspan fill="#27ae60">Green</tspan>
  </text>
</svg>

Gradients & Patterns

Gradients leben innerhalb von defs und werden per id über fill='url(#id)' referenziert. linearGradient nutzt x1/y1/x2/y2 (objectBoundingBox als Default, 0-1). radialGradient defaultet auf einen zentrierten Kreis. stop-Elemente definieren Farbstufen. defs hält auch patterns, clip paths und wiederverwendbare symbols.

html5
<svg width="220" height="120" viewBox="0 0 220 120">
  <defs>
    <linearGradient id="g1" x1="0" y1="0" x2="1" y2="0">
      <stop offset="0%" stop-color="#1e90ff" />
      <stop offset="100%" stop-color="#ffffff" />
    </linearGradient>
    <radialGradient id="g2">
      <stop offset="0%" stop-color="#f1c40f" />
      <stop offset="100%" stop-color="#e67e22" />
    </radialGradient>
  </defs>
  <rect x="10" y="10" width="90" height="90" fill="url(#g1)" />
  <circle cx="160" cy="55" r="45" fill="url(#g2)" />
</svg>

Inline-SVG vs. Canvas

SVG ist auflösungsunabhängig, jede Form ist ein DOM-Knoten, den man stylen und mit Events versehen kann — ideal für Icons, Diagramme mit wenigen Elementen und zugängliche Grafiken. Canvas ist eine einzelne Bitmap, schneller bei Tausenden Objekten oder Pixelmanipulation (Spiele, Bildverarbeitung), aber nicht skalierbar und nicht DOM-zugänglich.

html5
<!-- SVG: vector, DOM-accessible, scalable -->
<svg width="100" height="100" viewBox="0 0 100 100">
  <circle id="c" cx="50" cy="50" r="40" fill="#3498db" />
</svg>
<button onclick="document.getElementById('c')
  .setAttribute('r','20')">Shrink</button>

<!-- Canvas: bitmap, pixel-based, faster for many objects -->
<canvas id="cv" width="100" height="100"></canvas>
06

Audio & Video

Video-Element

video bettet Video ohne Plugins ein. controls zeigt die native UI; poster ist das Thumbnail vor der Wiedergabe. Mehrere source-Elemente lassen den Browser den ersten unterstützten Codec wählen. Fallback-Text zwischen den Tags erscheint auf nicht unterstützenden Browsern. width/height immer mitgeben, um Layout-Verschiebung zu vermeiden.

html5
<video controls width="640" poster="cover.jpg">
  <source src="movie.mp4" type="video/mp4">
  <source src="movie.webm" type="video/webm">
  Your browser does not support the video tag.
</video>

Audio-Element

audio funktioniert wie video, ohne visuelle Dimensionen. controls ergänzt play/pause/seek/volume-UI. Ohne controls ist das Element unsichtbar und muss per JS gesteuert werden. Mehrere Quellen (mp3, ogg) für browserübergreifenden Support liefern. autoplay kann von Browsern blockiert werden, außer muted ist gesetzt.

html5
<audio controls>
  <source src="song.mp3" type="audio/mpeg">
  <source src="song.ogg" type="audio/ogg">
  Your browser does not support audio.
</audio>

<!-- Simple single-source -->
<audio src="beep.mp3" autoplay></audio>

Mehrere Quellen

Browser wählen die erste Quelle, deren type sie spielen können. Der codecs-Parameter hilft ihnen zu entscheiden, ohne herunterzuladen. Moderne Formate (webm/av1) zuerst listen wegen kleinerer Payloads, mp4 als universeller Fallback. Ein Download-Link innerhalb der Tags ist ein graceful Fallback.

html5
<video controls>
  <source src="clip.webm" type='video/webm; codecs="vp9, opus"'>
  <source src="clip.mp4"  type='video/mp4; codecs="hvc1"'>
  <source src="clip.ogv"  type="video/ogg">
  <p>Download <a href="clip.mp4">clip.mp4</a></p>
</video>

Track-Element (Untertitel)

track ergänzt zeitgesteuerte Text-Spuren über WebVTT (.vtt)-Dateien. kind kann subtitles, captions, descriptions, chapters oder metadata sein. srclang deklariert die Sprache, label erscheint im Menü, und default wählt die anfängliche Spur. Untertitel sind Pflicht für Barrierefreiheit und verbessern SEO.

html5
<video controls>
  <source src="talk.mp4" type="video/mp4">
  <track kind="subtitles" src="talk.en.vtt"
         srclang="en" label="English" default>
  <track kind="captions" src="talk.en.cc.vtt"
         srclang="en" label="English CC">
  <track kind="chapters" src="talk.chapters.vtt"
         srclang="en" label="Chapters">
</video>

Media-Attribute

autoplay startet die Wiedergabe automatisch, wird aber blockiert, außer muted ist ebenfalls gesetzt. loop wiederholt endlos. playsinline verhindert erzwungenen Vollbildmodus auf iOS (Pflicht für Inline-Hintergründe). preload kann none, metadata (nur Dauer/Dimensionen) oder auto (ganze Datei puffern) sein. autoplay+preload=auto zusammen vermeiden, um Bandbreite zu sparen.

html5
<video src="bg.mp4"
       autoplay muted loop
       playsinline
       preload="auto"
       width="1280" height="720">
</video>

<video src="preview.mp4"
       controls
       preload="metadata"
       poster="preview.jpg">
</video>

Media-API

Die HTMLMediaElement-API exponiert play(), pause(), load(), currentTime, duration, volume, muted, playbackRate und readyState. Events sind play, pause, timeupdate, ended, volumechange, loadedmetadata und waiting. Eigene Player bauen, indem man controls versteckt und Buttons mit diesen Methoden verdrahtet.

html5
<video id="v" src="movie.mp4"></video>
<button onclick="v.play()">Play</button>
<button onclick="v.pause()">Pause</button>
<input type="range" min="0" max="100" oninput="v.volume = this.value/100">

<script>
  const v = document.getElementById('v');
  v.addEventListener('timeupdate', () => {
    console.log(v.currentTime, '/', v.duration);
  });
  v.addEventListener('ended', () => alert('Done!'));
  // Jump 10s forward
  function skip() { v.currentTime += 10; }
</script>
07

Geolocation

getCurrentPosition

getCurrentPosition nimmt einen success- und einen optionalen error-Callback plus ein options-Objekt. Das position-Objekt exponiert coords.latitude, longitude, accuracy und — wenn verfügbar — altitude, heading und speed. Geolocation funktioniert nur auf HTTPS (oder localhost) und fragt den Nutzer um Erlaubnis.

html5
<script>
  if ('geolocation' in navigator) {
    navigator.geolocation.getCurrentPosition(
      (pos) => {
        console.log('Latitude:', pos.coords.latitude);
        console.log('Longitude:', pos.coords.longitude);
        console.log('Accuracy:', pos.coords.accuracy, 'meters');
      },
      (err) => console.error(err.message),
      { enableHighAccuracy: true, timeout: 10000 }
    );
  }
</script>

Position-Optionen

enableHighAccuracy verlangt das präziseste Ergebnis (GPS) auf Kosten von Zeit und Akku. timeout begrenzt die Wartezeit; bei Überschreitung ist error.code TIMEOUT (3). maximumAge lässt den Browser eine gecachte Position zurückgeben, solange sie jünger ist als die angegebenen Millisekunden, und vermeidet wiederholte GPS-Aufrufe.

html5
<script>
  navigator.geolocation.getCurrentPosition(success, error, {
    enableHighAccuracy: true,  // use GPS, slower
    timeout: 5000,             // max wait in ms
    maximumAge: 60000          // accept cached fix up to 60s old
  });

  function success(pos) { /* ... */ }
  function error(err) { /* ... */ }
</script>

watchPosition

watchPosition ruft den success-Callback bei jeder Positionsänderung auf und gibt eine ID zurück. Diese ID an clearWatch übergeben, um Updates zu stoppen. Pflicht für Navigations-Apps. Akku beachten — eine vernünftige Update-Intervall nutzen und das Beobachten stoppen, wenn es nicht gebraucht wird.

html5
<script>
  const watchId = navigator.geolocation.watchPosition(
    (pos) => updateMap(pos.coords),
    (err) => console.warn(err.message),
    { enableHighAccuracy: true }
  );

  // Stop tracking
  document.getElementById('stop').onclick = () => {
    navigator.geolocation.clearWatch(watchId);
  };
</script>

Fehlerbehandlung

Der error-Callback erhält ein GeolocationPositionError mit code und message. PERMISSION_DENIED (1) heißt, der Nutzer hat abgelehnt oder der Browser blockiert. POSITION_UNAVAILABLE (2) heißt, das Gerät konnte keinen Fix bestimmen. TIMEOUT (3) heißt, die Anfrage dauerte länger als die timeout-Option. Alle drei Fälle immer graceful behandeln.

html5
<script>
  navigator.geolocation.getCurrentPosition(
    (pos) => console.log(pos),
    (err) => {
      switch (err.code) {
        case err.PERMISSION_DENIED:  // 1
          console.log('User denied permission'); break;
        case err.POSITION_UNAVAILABLE: // 2
          console.log('Position unavailable'); break;
        case err.TIMEOUT:              // 3
          console.log('Timed out'); break;
      }
      console.log(err.message);
    }
  );
</script>

Permissions-API

Die Permissions-API erlaubt das Prüfen eines Berechtigungs-Zustands ohne einen Prompt zu triggern. query({ name: 'geolocation' }) liefert einen PermissionStatus, dessen state granted, denied oder prompt ist. Auf onchange lauschen, um zu reagieren, wenn der Nutzer anderswo die Erlaubnis gibt oder entzieht. Unterstützt für geolocation, notifications, camera, microphone und weitere.

html5
<script>
  navigator.permissions
    .query({ name: 'geolocation' })
    .then((result) => {
      // result.state: 'granted' | 'denied' | 'prompt'
      if (result.state === 'granted') {
        startTracking();
      } else if (result.state === 'prompt') {
        showEnableButton();
      } else {
        showInstructions();
      }
      result.onchange = () => console.log(result.state);
    });
</script>
08

Web Storage

localStorage-Grundlagen

localStorage speichert String-Key/Value-Paare ohne Ablauf; Daten überdauern Tabs und Sessions. Werte sind Strings, also werden Zahlen und Booleans automatisch konvertiert. Das Limit ist ~5MB pro Origin. Storage ist synchron und blockiert den Haupt-Thread, also große Schreibvorgänge vermeiden. Im privaten Modus kann der Zugriff werfen — try/catch drumherum.

html5
<script>
  // Store a value (strings only)
  localStorage.setItem('theme', 'dark');
  // Read a value
  const theme = localStorage.getItem('theme'); // 'dark'
  // Remove one key
  localStorage.removeItem('theme');
  // Remove everything
  localStorage.clear();

  // Number of stored keys
  console.log(localStorage.length);
</script>

sessionStorage

sessionStorage hat dieselbe API wie localStorage, ist aber auf einen Tab begrenzt und wird beim Schließen des Tabs geleert. Nützlich für flüchtige Daten wie einen Mehrschritt-Formular-Entwurf, einen temporären Warenkorb oder CSRF-Tokens. Daten werden nicht zwischen Tabs geteilt, auch nicht auf demselben Origin.

html5
<script>
  // sessionStorage works like localStorage but per-tab
  sessionStorage.setItem('cart', '3 items');
  console.log(sessionStorage.getItem('cart'));
  sessionStorage.removeItem('cart');

  // Survives a page reload but not a tab close
  // Also isolated per tab (not shared)
</script>

JSON-Daten speichern

Da Web Storage nur Strings speichert, JSON.stringify und JSON.parse für Objekte und Arrays nutzen. parse immer in try/catch wickeln, weil korrupte oder manuell bearbeitete Daten werfen. Bei komplexen Daten den Key versionieren (z. B. 'settings.v2'), damit Schema-Änderungen alte Daten nicht brechen.

html5
<script>
  const settings = { theme: 'dark', fontSize: 16, lang: 'en' };

  // Serialize before saving
  localStorage.setItem('settings', JSON.stringify(settings));

  // Parse when reading
  try {
    const saved = JSON.parse(localStorage.getItem('settings'));
    console.log(saved.theme); // 'dark'
  } catch (e) {
    console.warn('Corrupted data', e);
  }
</script>

Storage-Events

Das storage-Ereignis feuert in jedem anderen Tab desselben Origins, wenn sich localStorage oder sessionStorage ändert — aber NICHT im Tab, der die Änderung vornahm. Es ist der einfachste Cross-Tab-Kommunikationskanal. Das event-Objekt trägt key, oldValue, newValue, url und storageArea. Damit Logout, Theme-Wechsel oder Live-Updates über Tabs hinweg synchronisieren.

html5
<script>
  // Listen in OTHER tabs (same origin) for changes
  window.addEventListener('storage', (e) => {
    console.log('Key changed:', e.key);
    console.log('Old value:', e.oldValue);
    console.log('New value:', e.newValue);
    console.log('URL:', e.url);
  });

  // The tab that calls setItem does NOT receive the event
  localStorage.setItem('count', '42');
</script>

Storage leeren

clear() entfernt jeden Key des Origins — sparsam einsetzen und den Nutzer bestätigen lassen. key(n) gibt den Key-Namen am Index n zurück oder null, wenn außerhalb. Die Iterationsreihenfolge ist implementierungsdefiniert, also nicht darauf verlassen. Für Teilaufräumen Keys mit einem Präfix listen (z. B. 'cache:') und in einer Schleife removeItem aufrufen.

html5
<script>
  // Remove a single key
  localStorage.removeItem('temp');

  // Wipe all keys for this origin
  localStorage.clear();

  // Iterate keys
  const keys = [];
  for (let i = 0; i < localStorage.length; i++) {
    keys.push(localStorage.key(i));
  }
  console.log(keys);

  // Indexed access (order is not guaranteed)
  localStorage.key(0);
</script>
09

IndexedDB

Datenbank öffnen

indexedDB.open(name, version) öffnet oder erzeugt eine Datenbank. onupgradeneeded feuert, wenn die Version steigt oder die DB erstmals entsteht — der EINZIGE Ort, an dem object stores und indexes erzeugt oder geändert werden können. Die Versionsnummer bei jeder Schema-Änderung erhöhen. Stores brauchen einen keyPath (die als Key genutzte Eigenschaft) oder einen auto-incrementing Key.

html5
<script>
  const request = indexedDB.open('MyDB', 1);

  request.onupgradeneeded = (e) => {
    const db = e.target.result;
    if (!db.objectStoreNames.contains('users')) {
      const store = db.createObjectStore('users', { keyPath: 'id' });
      store.createIndex('email', 'email', { unique: true });
    }
  };

  request.onsuccess = (e) => {
    const db = e.target.result;
    console.log('DB ready:', db.name, db.version);
  };

  request.onerror = (e) => console.error(e.target.error);
</script>

Object Stores

Ein object store ist wie eine Tabelle; jeder Datensatz hat einen Key und einen Wert (jedes structured-clone-fähige Objekt). keyPath sagt dem Store, welche Eigenschaft den Key hält. autoIncrement vergibt sequenzielle Integer-Keys. Indexes erlauben Abfragen nach einem Nicht-Key-Feld; unique: true erzwingt keine Duplikate auf dem Feld.

html5
<script>
  request.onupgradeneeded = (e) => {
    const db = e.target.result;

    // With a key path
    const users = db.createObjectStore('users', { keyPath: 'id' });

    // Auto-incrementing integer key
    const logs = db.createObjectStore('logs', { autoIncrement: true });

    // Indexes for fast lookups
    users.createIndex('name', 'name', { unique: false });
    users.createIndex('email', 'email', { unique: true });
  };
</script>

Daten ergänzen

Alle Operationen passieren innerhalb einer Transaktion, erzeugt mit db.transaction(storeName, mode). Der mode ist 'readonly' (Default) oder 'readwrite'. add() lehnt Duplikate ab; put() upsertet. Die Transaktion committet automatisch, wenn alle Requests fertig sind; auf oncomplete lauschen. Transaktionen kurz halten — sie blockieren andere Transaktionen auf denselben Stores.

html5
<script>
  function addUser(db, user) {
    const tx = db.transaction('users', 'readwrite');
    const store = tx.objectStore('users');
    store.add(user);          // throws on duplicate key
    // store.put(user);       // inserts OR overwrites

    tx.oncomplete = () => console.log('Saved');
    tx.onerror = () => console.error(tx.error);
  }

  addUser(db, { id: 1, name: 'Ada', email: '[email protected]' });
</script>

Daten lesen

get(key) liest einen einzelnen Datensatz per primary key; getAll() gibt alle Datensätze als Array. Um nach einem Nicht-Key-Feld zu suchen, den index mit store.index(name) öffnen und darauf get/getAll aufrufen. Jeder Request hat onsuccess und onerror. Ergebnisse liegen in event.target.result bzw. request.result.

html5
<script>
  const tx = db.transaction('users', 'readonly');
  const store = tx.objectStore('users');

  // By primary key
  const req = store.get(1);
  req.onsuccess = () => console.log(req.result);

  // By index
  const byEmail = store.index('email');
  byEmail.get('[email protected]').onsuccess = (e) => {
    console.log(e.target.result);
  };

  // All records
  store.getAll().onsuccess = (e) => {
    console.log(e.target.result); // array
  };
</script>

Cursors & Indexes

openCursor() erlaubt das Iterieren von Datensätzen einzeln — ideal für große Datensätze, die nicht in den Speicher passen. cursor.continue() zum Weiterschalten. cursor.update(value) verändert den aktuellen Datensatz; cursor.delete() entfernt ihn. IDBKeyRange (bound, only, lowerBound, upperBound) begrenzt Index-Queries — praktisch für Präfix- oder Bereichssuchen.

html5
<script>
  const tx = db.transaction('users', 'readwrite');
  const store = tx.objectStore('users');

  // Iterate and modify
  const req = store.openCursor();
  req.onsuccess = (e) => {
    const cursor = e.target.result;
    if (cursor) {
      if (cursor.value.name === 'Ada') {
        cursor.value.role = 'admin';
        cursor.update(cursor.value);
      }
      cursor.continue();
    }
  };

  // Range query on an index
  const range = IDBKeyRange.bound('A', 'M');
  store.index('name').openCursor(range).onsuccess = (e) => { /* ... */ };
</script>
10

Drag-and-Drop-API

Elemente draggable machen

draggable='true' auf einem Element setzen, um es ziehbar zu machen. Das dragstart-Ereignis feuert beim Start; mit dataTransfer.setData Daten für das drop-Ziel verpacken. effectAllowed (copy, move, link, all, none) deutet die beabsichtigte Operation an. dragend feuert beim Ende des Ziehvorgangs, egal ob ein Drop erfolgte.

html5
<div id="card" draggable="true">
  Drag me!
</div>

<script>
  const card = document.getElementById('card');
  card.addEventListener('dragstart', (e) => {
    e.dataTransfer.setData('text/plain', card.id);
    e.dataTransfer.effectAllowed = 'move';
    card.classList.add('dragging');
  });
  card.addEventListener('dragend', () => {
    card.classList.remove('dragging');
  });
</script>

Drag-Events

Um einen Drop zu akzeptieren, MUSS preventDefault() sowohl auf dragover als auch auf drop aufgerufen werden — sonst tut der Browser nichts. dragenter/dragleave feuern, wenn der Zeiger das Ziel betritt/verlässt. dropEffect (copy, move, link, none) steuert den Cursor. Das drag-Ereignis feuert kontinuierlich auf der Quelle während des Ziehens.

html5
<script>
  // Events on the SOURCE element:
  //   dragstart, drag, dragend

  // Events on the TARGET element:
  //   dragenter, dragover, dragleave, drop

  const drop = document.getElementById('drop');
  drop.addEventListener('dragover', (e) => {
    e.preventDefault();                 // REQUIRED to allow drop
    e.dataTransfer.dropEffect = 'move';
  });
  drop.addEventListener('drop', (e) => {
    e.preventDefault();
    const id = e.dataTransfer.getData('text/plain');
    drop.appendChild(document.getElementById(id));
  });
</script>

DataTransfer

dataTransfer trägt Daten zwischen Zieh-Quelle und Drop-Ziel. setData(format, data) speichert einen String; getData(format) liest ihn. Standardformate sind text/plain, text/uri-list, text/html und files. Auch eigene MIME-Typen sind registrierbar. Manche Browser beschränken getData aus Sicherheitsgründen auf drop-Events.

html5
<script>
  card.addEventListener('dragstart', (e) => {
    // Multiple data types
    e.dataTransfer.setData('text/plain', 'Hello');
    e.dataTransfer.setData('text/uri-list', 'https://example.com');
    e.dataTransfer.setData('application/json', JSON.stringify({ a: 1 }));

    // Read in the drop handler
    // e.dataTransfer.getData('text/plain')
  });
</script>

Drop-Zone

Ein verbreitetes Muster: die drop-Zone bei dragenter/dragover hervorheben, bei dragleave/drop zurücksetzen. dataTransfer.files liefert eine FileList, wenn Dateien aus dem OS gezogen werden — das ermöglicht Drag-and-Drop-Uploads. Auf dragover immer preventDefault, sonst feuert das drop-Ereignis nicht. Bei verschachtelten Elementen dragenter/leave-Zähler nutzen.

html5
<style>
  .dropzone { border: 2px dashed #bbb; padding: 24px; }
  .dropzone.over { background: #eaf6ff; border-color: #3498db; }
</style>

<div class="dropzone" id="dz">Drop files here</div>

<script>
  const dz = document.getElementById('dz');
  dz.addEventListener('dragenter', () => dz.classList.add('over'));
  dz.addEventListener('dragover',  (e) => e.preventDefault());
  dz.addEventListener('dragleave', () => dz.classList.remove('over'));
  dz.addEventListener('drop', (e) => {
    e.preventDefault();
    dz.classList.remove('over');
    const files = e.dataTransfer.files;   // FileList
    for (const f of files) console.log(f.name, f.size);
  });
</script>

Drag-Image

setDragImage(element, offsetX, offsetY) ersetzt den Standard-Drag-Geist durch ein eigenes Element. Das Element muss im DOM sein und gerendert, also erzeugen, anhängen und nach dragstart entfernen. Die Offsets positionieren den Cursor relativ zur oberen linken Ecke des Bildes. Ohne Bild macht der Browser einen Screenshot des gezogenen Elements.

html5
<script>
  card.addEventListener('dragstart', (e) => {
    const ghost = document.createElement('div');
    ghost.textContent = 'Dragging card';
    ghost.style.cssText = 'position:absolute;top:-999px;' +
                          'padding:8px;background:#3498db;color:#fff;';
    document.body.appendChild(ghost);
    e.dataTransfer.setDragImage(ghost, 20, 20);
    setTimeout(() => document.body.removeChild(ghost), 0);
  });
</script>
11

Web Workers

Worker-Grundlagen

new Worker(url) erzeugt einen Hintergrund-Thread, der die Skript-Datei ausführt. Kommunikation läuft über postMessage und onmessage, mit Datenkopie (structured clone) zwischen den Threads. Workers dürfen das DOM, window oder document nicht anfassen — aber sie können fetch, IndexedDB und setTimeout nutzen. Für schwere Berechnungen einsetzen, damit die UI reaktionsfähig bleibt.

html5
<!-- main.js -->
<script>
  const worker = new Worker('worker.js');

  worker.postMessage({ cmd: 'sum', nums: [1, 2, 3] });

  worker.onmessage = (e) => {
    console.log('Result:', e.data);   // 6
  };

  worker.onerror = (e) => {
    console.error(e.message, e.filename, e.lineno);
  };
</script>

Worker-Skript

Innerhalb eines Workers ist self (oder this) der globale Scope — postMessage und onmessage hängen daran. Es gibt kein window oder document. Workers können fetch, importScripts(), setTimeout/setInterval und IndexedDB nutzen. importScripts('a.js','b.js') lädt synchron weitere Skripte in den Worker. Jeder Worker läuft in seinem eigenen Isolate.

html5
// worker.js
self.onmessage = (e) => {
  const { cmd, nums } = e.data;
  if (cmd === 'sum') {
    let total = 0;
    for (const n of nums) total += n;
    self.postMessage(total);
  } else if (cmd === 'heavy') {
    const result = doExpensiveWork();
    self.postMessage(result);
  }
};

function doExpensiveWork() {
  // ... long-running computation
  return 'done';
}

Nachrichten senden

postMessage(data, transferables) sendet Daten und kopiert sie via structured clone. Im zweiten Argument ein Array von ArrayBuffer, MessagePort oder ImageBitmap übergeben, um die Eigentümerschaft zu ÜBERTRAGEN statt zu kopieren — viel schneller bei großen Buffers, aber das Original wird im sendenden Thread unbrauchbar.

html5
<script>
  const w = new Worker('worker.js');

  // Plain object
  w.postMessage({ type: 'start' });

  // Transferable: zero-copy move of a buffer
  const buffer = new ArrayBuffer(1024);
  w.postMessage(buffer, [buffer]);
  // buffer is now "neutered" in main thread

  // Two-way communication
  w.onmessage = (e) => console.log('Worker said:', e.data);
</script>

Transferable-Objekte

Transferable-Objekte (ArrayBuffer, MessagePort, ImageBitmap, OffscreenCanvas) wandern ohne Kopie zwischen Threads. transferControlToOffscreen überträgt ein canvas an einen Worker, der dann unabhängig darauf rendern kann — großartig für geschmeidige Animationen, während der Haupt-Thread beschäftigt ist. Der Haupt-Thread verliert den Zugriff auf das übertragene Objekt.

html5
<script>
  // Send a canvas ImageBitmap to a worker for processing
  const offscreen = canvas.transferControlToOffscreen();
  const worker = new Worker('paint.js');
  worker.postMessage({ canvas: offscreen }, [offscreen]);

  // Now the worker draws directly to the canvas
  // without round-trips to the main thread.
</script>

<!-- paint.js -->
self.onmessage = (e) => {
  const ctx = e.data.canvas.getContext('2d');
  ctx.fillStyle = '#3498db';
  ctx.fillRect(0, 0, 100, 100);
};

Shared Workers

Ein SharedWorker ist ein einzelner Worker, den mehrere Tabs desselben Origins teilen. Jede Verbindung bekommt über das connect-Ereignis einen MessagePort. Für Cross-Tab-Zustand nutzen (Live-Zähler, geteilte Caches) oder ein einzelnes WebSocket-Fan-out. SharedWorkers werden von Safari auf iOS nicht unterstützt und haben Eigenheiten — vor dem Verlassen testen.

html5
<!-- main.js -->
<script>
  const sw = new SharedWorker('shared.js');
  sw.port.onmessage = (e) => console.log('Broadcast:', e.data);
  sw.port.start();
  sw.port.postMessage({ from: 'tab-A' });
</script>

<!-- shared.js -->
const ports = new Set();
self.onconnect = (e) => {
  const port = e.ports[0];
  ports.add(port);
  port.onmessage = (ev) => {
    // Broadcast to every connected tab
    for (const p of ports) p.postMessage(ev.data);
  };
  port.start();
};
12

WebSockets

Verbindung öffnen

new WebSocket(url) öffnet eine persistente, bidirektionale Verbindung. In Produktion wss:// (TLS) nutzen — ws:// ist Klartext und auf HTTPS-Seiten blockiert. Der readyState wandert von CONNECTING (0) zu OPEN (1) zu CLOSING (2) zu CLOSED (3). Auf open, message, error und close lauschen.

html5
<script>
  const ws = new WebSocket('wss://echo.example.com/chat');

  ws.addEventListener('open', () => {
    console.log('Connected');
    ws.send('Hello server!');
  });

  ws.addEventListener('message', (e) => {
    console.log('Received:', e.data);
  });

  ws.addEventListener('close', (e) => {
    console.log('Closed', e.code, e.reason);
  });
</script>

Nachrichten senden

send() akzeptiert Strings, Blobs, ArrayBuffers und ArrayBufferViews. Für strukturierte Daten zuerst JSON.stringify und auf der Gegenseite parsen. Vor open gesendete Nachrichten werden eingereiht, aber zur Sicherheit readyState === OPEN prüfen. Das Protokoll ist Vollduplex — beide Seiten können jederzeit senden.

html5
<script>
  // Strings
  ws.send('plain text');

  // JSON
  ws.send(JSON.stringify({ type: 'chat', text: 'hi' }));

  // Binary
  const blob = new Blob([new Uint8Array([1,2,3])]);
  ws.send(blob);
  ws.send(new ArrayBuffer(8));

  // Check state before sending
  if (ws.readyState === WebSocket.OPEN) ws.send(data);
</script>

Nachrichten empfangen

message-Events liefern e.data als String (text), Blob (Binär-Default) oder ArrayBuffer (ws.binaryType = 'arraybuffer' setzen). Für Text-Protokolle ist JSON die häufigste Kodierung. Für Binärdaten Blob für Dateien/Bilder und ArrayBuffer für numerisches Parsen wählen. Ein Nachrichten-Schema definieren, damit beide Seiten dieselbe Form annehmen.

html5
<script>
  ws.addEventListener('message', (e) => {
    // Text messages: e.data is a string
    if (typeof e.data === 'string') {
      const msg = JSON.parse(e.data);
      console.log(msg.type, msg.text);
    }
    // Binary: e.data is a Blob or ArrayBuffer
    else {
      e.data.arrayBuffer().then((buf) => {
        const view = new DataView(buf);
        console.log(view.getInt32(0));
      });
    }
  });

  // Force binary type
  ws.binaryType = 'arraybuffer';
</script>

Fehler & Schließen

error-Events tragen aus Sicherheitsgründen wenig Detail; danach das close-Ereignis prüfen. close(code, reason) leitet ein sauberes Herunterfahren ein; Code 1000 ist normal closure, 1006 bedeutet, die Verbindung brach ohne close frame (Netzwerkproblem). Codes 4000-4999 sind für die Anwendung reserviert. wasClean ist nur true, wenn beide Seiten den Handshake abgeschlossen haben.

html5
<script>
  ws.addEventListener('error', (e) => {
    console.error('Socket error', e);
  });

  ws.addEventListener('close', (e) => {
    console.log('code:', e.code, 'reason:', e.reason, 'clean:', e.wasClean);
  });

  // Close gracefully (1000 = normal closure)
  ws.close(1000, 'goodbye');

  // Common codes:
  //   1000 normal, 1001 going away, 1006 abnormal (no close frame)
  //   4000-4999 app-defined
</script>

Reconnection

Browser reconnecten nicht automatisch, also selbst implementieren mit exponentiellem Backoff (delay = min(base * 2^retry, max)). Periodische Pings senden, damit tote Sockets erkannt und geschlossen werden. Bei close reconnecten, aber das Retry-Intervall begrenzen, um den Server nicht zu bombardieren. Den Retry-Zähler nach erfolgreichem Verbindungsaufbau zurücksetzen.

html5
<script>
  let ws;
  let retry = 0;

  function connect() {
    ws = new WebSocket('wss://example.com/live');
    ws.onopen = () => { retry = 0; console.log('open'); };
    ws.onmessage = (e) => console.log(e.data);
    ws.onclose = () => {
      const delay = Math.min(1000 * 2 ** retry, 30000);
      retry++;
      setTimeout(connect, delay);
    };
  }
  connect();

  // Heartbeat to detect dead connections
  setInterval(() => {
    if (ws.readyState === WebSocket.OPEN) ws.send('ping');
  }, 30000);
</script>
13

History-API

pushState

pushState(state, title, url) ergänzt einen neuen Eintrag in die Session-History und aktualisiert die Adressleiste ohne Neuladen der Seite — der Kern clientseitigen Routings. Die URL muss same-origin sein, sonst wirft pushState. Das title-Argument wird von Browsern derzeit ignoriert. Das state-Objekt ist serialisierbar und über history.state abrufbar.

html5
<script>
  // Add a new entry WITHOUT reloading
  history.pushState(
    { page: 'about' },      // state object
    'About',                // title (ignored by most browsers)
    '/about'                // URL
  );

  console.log(history.length);     // entries count
  console.log(history.state);      // { page: 'about' }
</script>

replaceState

replaceState(state, title, url) wirkt wie pushState, ersetzt aber den aktuellen Eintrag, statt einen neuen zu ergänzen — zurück/vorwärts überspringen also das Original. Damit URL oder Zustand aktualisieren, ohne die History zu verschmutzen, z. B. nach einem Filter, durch den der Nutzer nicht 'zurück' gehen soll.

html5
<script>
  // Replace the CURRENT entry (no new history item)
  history.replaceState(
    { page: 'home', tab: 'featured' },
    '',
    '/home?tab=featured'
  );

  // Useful for: cleaning up redirects, updating URL after
  // AJAX filter changes, or normalizing the entry URL.
</script>

popstate-Event

popstate feuert, wenn der Nutzer auf zurück/vorwärts klickt oder history.go/back/forward aufgerufen wird — nicht bei pushState/replaceState. event.state ist das state-Objekt des Eintrags, zu dem navigiert wird. Die meisten SPA-Router rufen die Render-Funktion sowohl in navigate() als auch im popstate-Handler auf, damit alle Navigationen die View aktualisieren.

html5
<script>
  window.addEventListener('popstate', (e) => {
    console.log('Location:', location.pathname);
    console.log('State:', e.state);
    renderRoute(location.pathname);
  });

  function navigate(path) {
    history.pushState({ path }, '', path);
    renderRoute(path);
  }

  // NOTE: pushState/replaceState do NOT fire popstate.
  // Only back/forward (and history.go) do.
</script>

Navigations-Methoden

back(), forward() und go(delta) bewegen sich durch die Session-History; go(0) lädt neu. history.length ist die Zahl der Einträge der aktuellen Session, vom Browser begrenzt. Diese Methoden sind asynchron — popstate feuert, sobald die Navigation abgeschlossen ist. go außerhalb der Grenzen tut nichts.

html5
<script>
  history.back();              // go back one entry
  history.forward();           // go forward one entry
  history.go(-2);              // go back two entries
  history.go(2);               // go forward two entries
  history.go(0);               // reload current page

  if (history.length === 1) {
    console.log('First page in this tab');
  }
</script>

SPA-Routing

Ein minimaler SPA-Router: interne Link-Klicks abfangen, pushState zur URL-Aktualisierung, und die neue View rendern. popstate behandeln, damit zurück/vorwärts funktioniert. data-link oder eine Klasse nutzen, um interne Links zu markieren, und externe oder target=_blank-Links überspringen. Echte Frameworks ergänzen verschachtelte Routen, params, Guards und Scroll-Wiederherstellung.

html5
<script>
  document.body.addEventListener('click', (e) => {
    const a = e.target.closest('a');
    if (!a || !a.matches('[data-link]')) return;
    if (a.origin !== location.origin) return;

    e.preventDefault();
    history.pushState({ path: a.pathname }, '', a.pathname);
    render(a.pathname);
  });

  window.addEventListener('popstate', () => render(location.pathname));

  function render(path) {
    fetch(path, { headers: { 'X-Ajax': '1' } })
      .then((r) => r.text())
      .then((html) => {
        document.querySelector('#app').innerHTML = html;
      });
  }
</script>
14

Inline-semantische Elemente

time-Element

time repräsentiert ein konkretes Datum, eine Zeit oder eine Dauer. Der maschinenlesbare Wert steht im datetime-Attribut (YYYY-MM-DD, HH:MM oder vollständiges ISO 8601 mit Zeitzone); der menschenlesbare Text ist der Inhalt. Suchmaschinen und Kalender-Apps nutzen datetime zum Extrahieren von Ereignissen. Ohne datetime muss der Inhalt selbst ein gültiger Datums-String sein.

html5
<p>
  Published on
  <time datetime="2024-07-04">July 4, 2024</time>.
</p>
<p>
  Event starts at
  <time datetime="2024-07-04T19:00-05:00">7 PM EST</time>.
</p>
<p>
  Open
  <time datetime="09:00">9:00 AM</time>-
  <time datetime="17:00">5:00 PM</time> daily.
</p>

mark-Element

mark hebt Text als relevant für den aktuellen Kontext des Nutzers hervor, etwa Suchtreffer oder Notizen, die der Nutzer ergänzt hat. Anders als strong oder em trägt es keine semantische Betonung — nur visuelle Hervorhebung. Der Default-Stil ist gelber Hintergrund. Auch innerhalb von Blockquotes nützlich, um Text zu markieren, auf den der Zitierende aufmerksam machen will.

html5
<p>
  The function <code>querySelector()</code> returns the
  first match, while <mark>querySelectorAll()</mark>
  returns a static NodeList.
</p>

<p>
  Search results: <mark>HTML5</mark> is the latest
  version of the Hypertext Markup Language.
</p>

details & summary

details erzeugt ein Disclosure-Widget, das Nutzer auf- und zuklappen können — ganz ohne JS. summary ist das immer sichtbare Label; ein Klick togglet. Das open-Attribut ergänzen, um per Default aufgeklappt zu sein. Das toggle-Ereignis feuert beim Öffnen und Schließen. Ideal für FAQs, erweiterte Einstellungen und progressive Enthüllung von Inhalt.

html5
<details>
  <summary>What is HTML5?</summary>
  <p>HTML5 is the fifth major revision of the HTML standard,
  introducing semantic elements, new form controls, and APIs
  for graphics, media, and offline apps.</p>
</details>

<details open>
  <summary>System requirements</summary>
  <ul>
    <li>Modern browser (Chrome, Firefox, Safari, Edge)</li>
    <li>JavaScript enabled</li>
  </ul>
</details>

dialog-Element

dialog repräsentiert einen modalen oder nicht-modalen Kasten. show() öffnet nicht-modal; showModal() modal mit Backdrop und inertem Rest der Seite. method='dialog' auf einem Formular schließt den Dialog und setzt returnValue auf den Wert des geklickten Buttons. Das close-Ereignis feuert nach dem Schließen. ::backdrop stylt die Abdeckung.

html5
<button onclick="dlg.showModal()">Open dialog</button>

<dialog id="dlg">
  <form method="dialog">
    <p>Are you sure?</p>
    <menu>
      <button value="cancel">Cancel</button>
      <button value="confirm">OK</button>
    </menu>
  </form>
</dialog>

<script>
  const dlg = document.getElementById('dlg');
  dlg.addEventListener('close', () => {
    console.log('User chose:', dlg.returnValue);
  });
</script>

abbr, cite & q

abbr erweitert Abkürzungen über title (Hover-Tooltip) und hilft Screenreadern. cite markiert den Titel eines Werks (Buch, Artikel, Film) — nicht den Autor. q ist ein Inline-Zitat (Browser ergänzen Anführungszeichen); blockquote ist für Block-Ebene. dfn markiert die definierende Instanz eines Begriffs; spätere Verwendungen können mit a darauf verlinken.

html5
<p>
  <abbr title="World Health Organization">WHO</abbr>
  was founded in 1948.
</p>

<p>
  As <cite>MDN Web Docs</cite> notes,
  <q>HTML is the standard markup language.</q>
</p>

<p>
  Use <dfn>semantics</dfn> to describe the meaning of
  content, then refer to it normally.
</p>
15

Responsives Design

Meta-Viewport

Das viewport-meta-Tag sagt mobilen Browsern, die Gerätebreite als Layout-Viewport zu nutzen und bei Skalierung 1 zu starten. Ohne es geben sich Phones als 980px breit aus. initial-scale=1 verhindert Zoom beim Laden. viewport-fit=cover erlaubt die Nutzung der Notch-Fläche mit env(safe-area-inset-*). user-scalable=no vermeiden — es bricht Barrierefreiheit.

html5
<head>
  <meta name="viewport"
        content="width=device-width, initial-scale=1, viewport-fit=cover">
</head>

<!-- Without this tag, mobile browsers render the page at a
     ~980px "desktop" width and shrink it down, making text
     unreadable. -->

<!-- viewport-fit=cover lets content extend into the notch
     area on iPhone X+. -->

Picture-Element

picture erlaubt die Auslieferung unterschiedlicher Bilder je nach Medienbedingung (art direction). Der Browser wählt die erste source, deren media passt, und ignoriert den Rest. Das img ist als Fallback Pflicht und liefert den alt-Text. Nutzen, wenn je Breakpoint ein komplett anderes Bild oder ein Zuschnitt nötig ist, nicht bloß eine Größenänderung.

html5
<picture>
  <!-- Art direction: different image per viewport -->
  <source media="(min-width: 800px)" srcset="wide.jpg">
  <source media="(orientation: portrait)" srcset="tall.jpg">
  <img src="default.jpg" alt="A responsive photo">
</picture>

<!-- Browser picks the first matching <source>,
     falling back to the <img>. -->

srcset & sizes

srcset listet Bildkandidaten mit ihrer intrinsischen Breite (480w = 480px breit). sizes sagt dem Browser, wie breit das Bild je Breakpoint angezeigt wird. Der Browser wählt dann den besten Kandidaten anhand von Viewport und device pixel ratio — ganz ohne JS. Nutzen, wenn dasselbe Bild nur verschiedene Auflösungen braucht.

html5
<img src="small.jpg"
     srcset="small.jpg 480w,
             medium.jpg 800w,
             large.jpg  1200w"
     sizes="(max-width: 600px) 100vw,
            (max-width: 1200px) 50vw,
            33vw"
     alt="A responsive photo">

Viewport-Einheiten

vw und vh sind Prozentanteile der Viewport-Breite/-Höhe. Auf Mobile kann 100vh die URL-Leiste einschließen und Sprungigkeit verursachen — lieber dvh (dynamisch), svh (klein) oder lvh (groß). clamp(min, preferred, max) ist der sauberste Weg zu flüssiger Typografie, die weder zu klein noch zu groß wird. vmin/vmax nutzen die kleinere/größere Dimension.

html5
<style>
  .hero { height: 100vh; }           /* full viewport height */
  .half { width: 50vw; }             /* half the viewport width */

  /* Responsive typography */
  h1 {
    font-size: clamp(1.5rem, 4vw + 1rem, 3rem);
  }

  /* Use dvh/svh/lvh to handle mobile browser UI bars */
  .hero { height: 100dvh; }
</style>

Picture mit Typ

source mit type erlaubt die Auslieferung moderner Bildformate mit einem JPEG/PNG-Fallback. Der Browser wählt den ersten unterstützten Typ und ignoriert den Rest. AVIF und WebP bieten 30-50% kleinere Dateien als JPEG bei gleicher Qualität. Kombiniert mit loading='lazy' auf dem img der effizienteste Weg zur Bildauslieferung.

html5
<picture>
  <!-- Modern format first, smaller file size -->
  <source type="image/avif" srcset="photo.avif">
  <source type="image/webp" srcset="photo.webp">
  <img src="photo.jpg" alt="Optimized photo" loading="lazy">
</picture>

<!-- Browser picks the first type it supports.
     AVIF and WebP are ~30-50% smaller than JPEG/PNG. -->
16

Barrierefreiheit (ARIA)

ARIA-Rollen

ARIA-Rollen sagen assistiver Technik, was ein Element tut, aber die erste ARIA-Regel lautet: nutze sie nicht, wenn es ein natives HTML-Element gibt. header, nav, main, article, footer exponieren bereits die Rollen banner, navigation, main, article, contentinfo. ARIA für eigene Widgets (tab, dialog, slider, menu) ohne natives Pendant, und Rollen mit Tastatur-Support paaren.

html5
<div role="banner">           <!-- like <header> -->
  <h1>Site title</h1>
</div>

<div role="navigation">       <!-- like <nav> -->
  <a href="/">Home</a>
</div>

<div role="main">             <!-- like <main> -->
  <div role="article">        <!-- like <article> -->
    <p>Content</p>
  </div>
</div>

<button role="button" aria-pressed="false">Toggle</button>

aria-label & aria-labelledby

aria-label liefert einen zugänglichen Namen, wenn kein sichtbarer Text existiert (Icon-only-Buttons usw.). aria-labelledby referenziert die id sichtbaren Texts als Namen — nützlich, wenn eine Überschrift einen Abschnitt schon beschriftet. Für Formularfelder ein sichtbares <label for> bevorzugen. aria-describedby zeigt auf Hinweistext, der nach dem Label vorgelesen wird.

html5
<button aria-label="Close menu">×</button>

<nav aria-labelledby="main-nav-heading">
  <h2 id="main-nav-heading" class="sr-only">Main navigation</h2>
  <ul>...</ul>
</nav>

<input id="email" type="email">
<label id="email-label" for="email">Email address</label>
<!-- aria-labelledby="email-label" would also work -->

aria-hidden

aria-hidden='true' entfernt ein Element aus dem accessibility tree — für rein dekorative Icons, doppelten Text oder Off-Screen-Inhalt, der nicht angekündigt werden soll. Niemals fokussierbare Elemente verbergen. Das .sr-only-Muster versteckt Text visuell und hält ihn für Screenreader — Pflicht für Labels, die gesprochen, aber nicht gesehen werden sollen.

html5
<!-- Decorative icon: hide from screen readers -->
<svg aria-hidden="true" focusable="false">
  <use href="#icon-check"></use>
</svg>

<!-- Visually hidden but still announced -->
<span class="sr-only">3 new messages</span>

<style>
  .sr-only {
    position: absolute;
    width: 1px; height: 1px;
    padding: 0; margin: -1px;
    overflow: hidden;
    clip: rect(0, 0, 0, 0);
    white-space: nowrap; border: 0;
  }
</style>

aria-live-Regionen

aria-live markiert Regionen, deren Updates automatisch angekündigt werden sollen. polite wartet auf eine Pause; assertive unterbricht. role='alert' impliziert assertive und ist der Standard für Fehlermeldungen. aria-atomic='true' kündigt bei Änderung die ganze Region; aria-relevant steuert, welche Änderungen gesprochen werden. Sparsam einsetzen — Übergebrauch macht Interfaces laut.

html5
<!-- Polite: announce when screen reader is idle -->
<div aria-live="polite" id="status">Saving...</div>

<!-- Assertive: announce immediately, may interrupt -->
<div aria-live="assertive" role="alert" id="error"></div>

<script>
  function show(msg) {
    document.getElementById('status').textContent = msg;
  }
  function fail(msg) {
    document.getElementById('error').textContent = msg;
  }
</script>

Focus-Management

Tastaturnutzer navigieren via Tab; der Fokus muss immer sichtbar und logisch sein. :focus-visible stylt den Fokus nur für Tastatur, nicht Maus. Beim Öffnen eines Modals den Fokus hineinbewegen; beim Schließen zum Auslöser zurück. Tab innerhalb des Modals einfangen, damit der Fokus nicht zu verstecktem Inhalt entkommt. Niemals tabindex > 0; 0 macht Elemente fokussierbar, -1 programmatisch fokussierbar.

html5
<style>
  :focus-visible {
    outline: 3px solid #3498db;
    outline-offset: 2px;
  }
</style>

<script>
  // Move focus into a modal
  function openModal(dlg) {
    dlg.showModal();
    dlg.querySelector('input, button').focus();
  }
  // Trap focus inside the modal (simplified)
  // Restore focus to the trigger on close
  const trigger = document.activeElement;
  dlg.addEventListener('close', () => trigger.focus());
</script>

Skip-Links

Ein skip link ist das erste fokussierbare Element der Seite und lässt Tastaturnutzer die repetitive Navigation überspringen, direkt zum Hauptinhalt. Visuell versteckt, bis er fokussiert wird. Pflicht für Barrierefreiheit — WCAG 2.1 Erfolgskriterium 2.4.1. Mit einem <main id='main'>-Landmark paaren, damit das Ziel klar ist.

html5
<body>
  <a href="#main" class="skip-link">Skip to main content</a>
  <header>...nav with 30 links...</header>
  <main id="main">...</main>
</body>

<style>
  .skip-link {
    position: absolute;
    left: -999px;
    top: 0;
    background: #000; color: #fff;
    padding: 8px 16px;
    z-index: 1000;
  }
  .skip-link:focus {
    left: 0;
  }
</style>
17

Web Components

Custom Elements

customElements.define(name, class) registriert ein custom element. Der Name muss einen Bindestrich enthalten. Für autonome Elemente HTMLElement ableiten, oder eine konkrete Klasse wie HTMLButtonElement (mit is='name'), um ein Built-in zu erweitern. Custom elements sind die Grundlage von web components — wiederverwendbare, framework-agnostische UI.

html5
<script>
  class MyButton extends HTMLElement {
    constructor() {
      super();
      this.addEventListener('click', () => {
        console.log('Custom button clicked');
      });
    }
  }
  customElements.define('my-button', MyButton);

  // Autonomous element: extends HTMLElement
  // Customized built-in: extends HTMLButtonElement
  //   <button is="my-button">
</script>

<my-button>Click me</my-button>

Shadow DOM

attachShadow({ mode: 'open' }) erzeugt einen gekapselten DOM-Baum am Element. Styles und ids im shadow tree leaken nicht nach außen, und Seiten-Styles nicht hinein (außer vererbbare Eigenschaften). :host zielt auf das Host-Element; ::slotted() stylt slot-ted Kinder. mode: 'closed' blockiert den externen Zugriff auf shadowRoot — selten nötig.

html5
<script>
  class FancyCard extends HTMLElement {
    constructor() {
      super();
      const shadow = this.attachShadow({ mode: 'open' });
      shadow.innerHTML = `
        <style>
          :host { display: block; padding: 16px;
                  background: #f4f4f4; border-radius: 8px; }
          ::slotted(*) { color: #333; }
        </style>
        <div class="card">
          <slot></slot>
        </div>
      `;
    }
  }
  customElements.define('fancy-card', FancyCard);
</script>

HTML-Templates

Das template-Element hält inertes HTML, das geparst, aber erst beim Klonen gerendert wird. Zugriff über template.content, dann cloneNode(true) und append. Templates sind perfekt für wiederholte Strukturen und bilden die Markup-Seite von web components. Anders als innerHTML dürfen templates <tr>, <td>, <option> und andere Elemente mit Parsing-Eigenheiten enthalten.

html5
<template id="row-template">
  <tr>
    <td class="name"></td>
    <td class="age"></td>
  </tr>
</template>

<script>
  const tpl = document.getElementById('row-template');
  const tbody = document.querySelector('tbody');

  function addRow(name, age) {
    const clone = tpl.content.cloneNode(true);
    clone.querySelector('.name').textContent = name;
    clone.querySelector('.age').textContent = age;
    tbody.appendChild(clone);
  }
  addRow('Ada', 36);
</script>

Slots

Slots lassen Konsumenten light-DOM-Kinder an konkrete Stellen im shadow tree durchreichen. Ein <slot name='x'> empfängt Kinder mit slot='x'; ein unbenannter <slot> den Rest. Die slot-ted Kinder bleiben im light DOM — der slot ist nur ein Einfügepunkt. Auf slotchange am slot lauschen, um auf veränderte slot-ted Knoten zu reagieren.

html5
<fancy-card>
  <h2 slot="title">Card Title</h2>
  <p>Body text goes here.</p>
</fancy-card>

<!-- Inside the shadow DOM of <fancy-card>: -->
<template>
  <div class="card">
    <slot name="title"></slot>
    <div class="body"><slot></slot></div>
  </div>
</template>

Lifecycle-Callbacks

Custom elements haben Lifecycle-Callbacks: connectedCallback (in das DOM eingefügt), disconnectedCallback (entfernt), attributeChangedCallback (nur für Attribute in observedAttributes) und adoptedCallback (in ein neues Dokument verschoben). Der Konstruktor läuft bei Erzeugung — schlank halten. Setup in connectedCallback, Aufräumen in disconnectedCallback. Upgrade passiert automatisch für Elemente, die schon im DOM sind, wenn define() aufgerufen wird.

html5
<script>
  class Observed extends HTMLElement {
    static get observedAttributes() {
      return ['count', 'label'];
    }
    constructor() { super(); }
    connectedCallback() {
      console.log('Added to DOM');
    }
    disconnectedCallback() {
      console.log('Removed from DOM');
    }
    attributeChangedCallback(name, oldVal, newVal) {
      console.log(name, 'changed', oldVal, '->', newVal);
    }
  }
  customElements.define('observed-el', Observed);
</script>
18

Offline-Anwendungen

Service-Worker-Registrierung

Ein service worker ist ein Skript, das der Browser im Hintergrund ausführt, getrennt von einer Seite, und das Offline-Support, Push-Benachrichtigungen und Background Sync ermöglicht. Aus einem Seiten-Skript registrieren; die SW-Datei muss über HTTPS (oder localhost) ausgeliefert werden, ihr scope ist per Default ihr Verzeichnis. Nach der Installation steuert sie Seitenaufrufe über fetch-Events.

html5
<script>
  if ('serviceWorker' in navigator) {
    window.addEventListener('load', () => {
      navigator.serviceWorker
        .register('/sw.js', { scope: '/' })
        .then((reg) => console.log('SW registered', reg.scope))
        .catch((err) => console.error('SW failed', err));
    });
  }
</script>

Cache-API

Die Cache-API speichert Request/Response-Paare, persistiert über Sessions. Im install-Event kritische Assets vorab cachen. Im fetch-Event zuerst aus dem Cache antworten und auf das Netz ausweichen (cache-first-Strategie). Weitere Strategien: network-first, stale-while-revalidate, cache-only, network-only. Den Cache-Namen erhöhen, um alte Einträge zu invalidieren.

html5
// sw.js
const CACHE = 'app-v1';
const ASSETS = ['/', '/styles.css', '/app.js', '/offline.html'];

self.addEventListener('install', (e) => {
  e.waitUntil(
    caches.open(CACHE).then((c) => c.addAll(ASSETS))
  );
});

self.addEventListener('fetch', (e) => {
  e.respondWith(
    caches.match(e.request).then((r) => r || fetch(e.request))
  );
});

Offline-Fallback

Eine network-first-Strategie mit Offline-Fallback probiert das Netz, dann den Cache, dann eine generische Offline-Seite. Das activate-Event läuft nach abgeschlossenem install und ist der richtige Ort, um alte Caches zu löschen — sonst stapeln sie sich. Mit self.clients.claim() innerhalb von activate übernehmen Clients bestehende Tabs sofort.

html5
// sw.js
self.addEventListener('fetch', (e) => {
  e.respondWith(
    fetch(e.request).catch(() =>
      caches.match(e.request).then((r) =>
        r || caches.match('/offline.html')
      )
    )
  );
});

// Activate event: clean up old caches
self.addEventListener('activate', (e) => {
  e.waitUntil(
    caches.keys().then((keys) =>
      Promise.all(
        keys.filter((k) => k !== 'app-v1')
            .map((k) => caches.delete(k))
      )
    )
  );
});

Web-App-Manifest

Ein web app manifest ist eine JSON-Datei, die beschreibt, wie die App nach der Installation auf dem Home-Screen aussieht. name/short_name, icons, start_url und display (standalone, fullscreen, minimal-ui, browser) sind die Kernfelder. Kombiniert mit einem service worker macht das Manifest die App installierbar (PWA). theme_color beeinflusst das OS-UI-Chrome.

html5
<!-- index.html -->
<link rel="manifest" href="manifest.json">

<!-- manifest.json -->
{
  "name": "My App",
  "short_name": "App",
  "start_url": "/",
  "display": "standalone",
  "background_color": "#ffffff",
  "theme_color": "#3498db",
  "icons": [
    { "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" },
    { "src": "/icon-512.png", "sizes": "512x512", "type": "image/png" }
  ]
}

Background Sync

Background Sync (registriert über navigator.serviceWorker.ready.then(r => r.sync.register('tag'))) schiebt Arbeit auf, bis der Nutzer Konnektivität hat. Der Browser feuert ein sync-Event im service worker, wenn das Netz zurückkehrt — selbst wenn die Seite geschlossen ist. Damit wartende Formular-Einreichungen, Nachrichten oder Analytics senden. Das tag identifiziert den Sync; Duplikate werden verschmolzen.

html5
// sw.js
self.addEventListener('sync', (e) => {
  if (e.tag === 'send-messages') {
    e.waitUntil(sendQueuedMessages());
  }
});

async function sendQueuedMessages() {
  const queue = await getQueue();
  for (const msg of queue) {
    try { await fetch('/api/send', { method: 'POST', body: msg }); }
    catch (e) { throw e; }   // retry later
  }
}
19

SEO-Best-Practices

Title & Meta-Description

Der title (unter ~60 Zeichen) ist das wichtigste On-Page-SEO-Signal und erscheint als Schlagzeile des Suchergebnisses. Die meta description (unter ~160 Zeichen) ist der Snippet-Text — sie beeinflusst das Ranking nicht, aber die Klickrate. Einen Titel pro Seite, das Haupt-Keyword einschließen und überzeugend formulieren. canonical verhindert duplicate-content-Probleme.

html5
<head>
  <title>HTML5 Cheatsheet - Semantic Elements & APIs</title>
  <meta name="description"
        content="A quick reference to HTML5 semantic elements,
                 form types, and browser APIs with examples.">
  <meta name="robots" content="index, follow">
  <link rel="canonical" href="https://example.com/html5">
</head>

Open Graph & Twitter Cards

Open Graph-Tags steuern, wie die Seite bei einem Share auf Facebook, LinkedIn, Slack und den meisten sozialen Plattformen aussieht. og:image sollte 1200x630px sein. Twitter Cards nutzen ein ähnliches Set mit twitter:-Präfixen (oder fallen auf OG zurück). Ohne diese bekommen Shares ein zufälliges oder gar kein Vorschau-Bild — die Klickrate sinkt drastisch.

html5
<head>
  <!-- Open Graph (Facebook, LinkedIn, etc.) -->
  <meta property="og:title" content="HTML5 Cheatsheet">
  <meta property="og:description" content="Quick HTML5 reference.">
  <meta property="og:image" content="https://example.com/og.png">
  <meta property="og:url" content="https://example.com/html5">
  <meta property="og:type" content="article">

  <!-- Twitter Card -->
  <meta name="twitter:card" content="summary_large_image">
  <meta name="twitter:site" content="@example">
</head>

Canonical & hreflang

rel='canonical' sagt Suchmaschinen, welche URL die maßgebliche Version ist, wenn mehrere URLs ähnlichen Inhalt haben (print, sort, Query-Params) — verhindert duplicate-content-Strafen. hreflang zeigt auf übersetzte oder regionale Versionen, damit Google die richtige ausliefert. Immer ein x-default für unpassende Locales aufnehmen. Beide müssen absolute URLs sein.

html5
<head>
  <!-- Canonical: the master URL for duplicate content -->
  <link rel="canonical" href="https://example.com/article">

  <!-- hreflang: language/region alternatives -->
  <link rel="alternate" hreflang="en" href="https://example.com/en/article">
  <link rel="alternate" hreflang="es" href="https://example.com/es/article">
  <link rel="alternate" hreflang="x-default" href="https://example.com/article">
</head>

Strukturierte Daten (JSON-LD)

JSON-LD-strukturierte Daten beschreiben die Seite in einem maschinenlesbaren Format (schema.org-Vokabular) und ermöglichen Rich Results in der Suche: Artikel-Karussells, Breadcrumbs, FAQs, Bewertungen, Ereignisse, Produkte. In ein <script type='application/ld+json'> einbetten. Mit Googles Rich Results Test validieren. Das Ranking steigt nicht direkt, aber die Ergebnisse sehen besser aus.

html5
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "HTML5 Cheatsheet",
  "author": { "@type": "Person", "name": "Ada" },
  "datePublished": "2024-07-04",
  "image": "https://example.com/cover.png",
  "publisher": {
    "@type": "Organization",
    "name": "Example"
  }
}
</script>

Semantische Überschriften

Suchmaschinen und Screenreader nutzen Überschriften, um die Seitenstruktur zu verstehen. Ein h1 (der Seitentitel), dann h2 für große Abschnitte, h3 für Unterabschnitte — niemals Ebenen überspringen (nicht von h2 direkt zu h4). Keine Überschrift nach ihrer Größe wählen; Styling macht CSS. Eine logische Überschrift-Hierarchie verbessert SEO wie Barrierefreiheit.

html5
<article>
  <h1>Article Title (only one h1 per page)</h1>
  <p>Intro paragraph.</p>

  <section>
    <h2>First major section</h2>
    <p>Content...</p>
    <h3>Subsection</h3>
    <p>Detail...</p>
  </section>

  <section>
    <h2>Second major section</h2>
    <p>Content...</p>
  </section>
</article>
20

Performance-Optimierung

preload

rel='preload' sagt dem Browser, eine hochpriorisierte Ressource zu laden, die die aktuelle Seite braucht, bevor sie normalerweise entdeckt würde. Immer as angeben (font, style, script, image, fetch usw.), damit der Browser die richtigen Prioritäten und CSP anwendet. Fonts brauchen crossorigin. preload nur für wirklich kritische Ressourcen — Übergebrauch verschwendet Bandbreite.

html5
<head>
  <!-- Preload critical resources for the current page -->
  <link rel="preload" href="/fonts/main.woff2"
        as="font" type="font/woff2" crossorigin>
  <link rel="preload" href="/css/critical.css" as="style">
  <link rel="preload" href="/js/app.js" as="script">

  <!-- Preload a hero image -->
  <link rel="preload" href="/hero.webp" as="image">
</head>

prefetch & preconnect

preconnect schließt DNS, TCP und TLS zu einem Origin früh ab und spart ~100-300ms, wenn die echte Anfrage kommt — für kritische Drittanbieter-Domains nutzen. dns-prefetch ist die leichtere Version (nur DNS). prefetch lädt eine niederpriorisierte Ressource für eine wahrscheinliche nächste Navigation. Sparsam: zu viele preconnects verschwenden Sockets, und vorgeladene Ressourcen können ungenutzt bleiben.

html5
<head>
  <!-- preconnect: early handshake to a third-party origin -->
  <link rel="preconnect" href="https://cdn.example.com">
  <link rel="preconnect" href="https://api.example.com" crossorigin>

  <!-- dns-prefetch: just DNS lookup, lighter -->
  <link rel="dns-prefetch" href="https://cdn.example.com">

  <!-- prefetch: fetch a resource for the NEXT navigation -->
  <link rel="prefetch" href="/next-page.html">
</head>

lazy loading

loading='lazy' auf img und iframe schiebt das Laden auf, bis das Element sich dem Viewport nähert — spart Bandbreite und CPU beim ersten Rendern. decoding='async' verhindert, dass Bild-Dekodierung den Haupt-Thread blockiert. width/height immer setzen, um Layout-Verschiebung zu vermeiden. loading='eager' (Default) und fetchpriority='high' nur für Above-the-Fold-Hero-Bilder. In allen modernen Browsern unterstützt.

html5
<!-- Native lazy loading (no JS needed) -->
<img src="photo.jpg" loading="lazy" decoding="async" alt="...">
<iframe src="embed.html" loading="lazy"></iframe>

<!-- Eager (default) loads immediately -->
<img src="hero.jpg" loading="eager" fetchpriority="high" alt="Hero">

<!-- Defer non-critical images until they near the viewport -->
<img src="below-fold.jpg" loading="lazy" width="800" height="600" alt="">

defer & async

Ein schlichtes <script> blockiert das HTML-Parsing beim Download und der Ausführung. async lädt parallel und läuft, sobald es bereit ist — für unabhängige Skripte (Analytics, Ads), bei denen die Reihenfolge egal ist. defer lädt parallel, wartet aber und läuft geordnet nach dem Parsen des Dokuments — für App-Hauptskripte, die vom DOM abhängen. defer-Skripte laufen vor DOMContentLoaded.

html5
<head>
  <!-- async: download in parallel, run ASAP (order not guaranteed) -->
  <script src="analytics.js" async></script>

  <!-- defer: download in parallel, run after parse, in order -->
  <script src="app.js" defer></script>
  <script src="page.js" defer></script>

  <!-- Classic: block parsing to download and run -->
  <script src="blocking.js"></script>
</head>

Resource Hints Überblick

preload (aktuelle Seite), prefetch (nächste Seite), preconnect (Origin-Handshake) und dns-prefetch (nur DNS) sind die Kern-Resource-Hints. prerender ist zugunsten der Speculation Rules API deprecated, die Seiten vollständig vorrendern kann für sofortige Navigation. Hints nach echtem Nutzerverhalten anwenden — Über-Hinting verschwendet Daten und kann die Performance schädigen.

html5
<head>
  <link rel="preload"    href="/critical.woff2" as="font" crossorigin>
  <link rel="preconnect" href="https://cdn.example.com">
  <link rel="dns-prefetch" href="https://cdn.example.com">
  <link rel="prefetch"   href="/next-page.html">

  <!-- Speculation Rules API (Chrome) -->
  <script type="speculationrules">
  { "prerender": [{ "where": { "href_matches": "/next/*" } }] }
  </script>
</head>

Kritisches Rendering

Kritisches CSS für Above-the-Fold-Inhalt inlining entfernt die render-blockierende Anfrage und verbessert den First Contentful Paint. Den Rest über preload+swap laden. content-visibility: auto lässt den Browser das Rendern außerhalb des Bildschirms liegender Abschnitte überspringen und verbessert die Scroll-Performance langer Seiten drastisch — mit contain-intrinsic-size paaren, um Platz zu reservieren und Scrollbar-Sprünge zu vermeiden.

html5
<head>
  <!-- Inline critical CSS for above-the-fold -->
  <style>
    body { margin: 0; font: system-ui; }
    .hero { height: 60vh; background: #3498db; }
  </style>

  <!-- Load the rest asynchronously -->
  <link rel="preload" href="/full.css" as="style" onload="this.rel='stylesheet'">
  <noscript><link rel="stylesheet" href="/full.css"></noscript>
</head>
<body>
  <!-- Use content-visibility to skip off-screen rendering -->
  <section style="content-visibility: auto; contain-intrinsic-size: 500px;">
    Heavy content here
  </section>
</body>

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.