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.
<!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.
<header>
<h1>Site Title</h1>
<p>Tagline</p>
</header>
<footer>
<nav>
<a href="/about">About</a>
<a href="/contact">Contact</a>
</nav>
<small>© 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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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.
<!-- 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>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.
<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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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.
<!-- 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>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.
<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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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>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.
<!-- 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.
// 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.
<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.
<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.
<!-- 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();
};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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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. -->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.
<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.
<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.
<!-- 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.
<!-- 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.
<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.
<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>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.
<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.
<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.
<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.
<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.
<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>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.
<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.
// 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.
// 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.
<!-- 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.
// 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
}
}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.
<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.
<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.
<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.
<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.
<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>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.
<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.
<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.
<!-- 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.
<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.
<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.
<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>Verwandte HTML5-Snippets
Copy-paste ready code for common tasks.
Semantic Elements
Structure a page with header, nav, main, article, and footer.
Form Input Types
Use native HTML5 input types, validation, and datalist.
Canvas Basics
Draw shapes, lines, and text on a 2D canvas.
Video & Audio
Embed media with multiple sources and control playback.
Local & Session Storage
Persist data in the browser with the Web Storage API.
Geolocation
Get the user's position and watch for changes.
Drag and Drop
Accept dropped files with the Drag and Drop API.
Web Workers
Run heavy computation on a background thread.
Was this helpful?