Einstieg
Setup & erstes Chart
Chart.js rendert auf einem canvas-Element. Die type-Eigenschaft setzt den Chart-Typ. data enthält labels und datasets mit Werten und Styling.
<!-- include Chart.js -->
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<canvas id="myChart" width="400" height="400"></canvas>
<script>
const ctx = document.getElementById('myChart').getContext('2d');
new Chart(ctx, {
type: 'bar',
data: {
labels: ['Red', 'Blue', 'Green'],
datasets: [{
label: 'Votes',
data: [12, 19, 3],
backgroundColor: ['red', 'blue', 'green']
}]
}
});
</script>npm-Install & ES-Modul-Import
'chart.js/auto' für die simpelste Einrichtung — es importiert Chart.js plus alle controllers/elements und registriert sie automatisch. Für kleinere Produktions-Bundles tree-shaking bevorzugen: aus 'chart.js' importieren und nur die genutzten Teile registrieren.
# install
npm install chart.js
// import the auto-bundled build (registers everything)
import Chart from 'chart.js/auto';
const ctx = document.getElementById('myChart');
const chart = new Chart(ctx, {
type: 'line',
data: { /* ... */ },
options: { responsive: true }
});Canvas & 2D-Kontext
Chart.js nimmt entweder das <canvas>-Element oder seinen 2d-Rendering-Kontext. Bei responsive true wird das canvas auf die Container-Größe skaliert, die width/height-HTML-Attribute sind also nur Fallbacks. Jedes canvas kann genau eine Chart-Instanz halten.
// Chart.js accepts a canvas element OR a 2D context
const canvas = document.getElementById('myChart');
const chart = new Chart(canvas, { type: 'bar', data: {...} });
// equivalent: pass the 2d context
const ctx = canvas.getContext('2d');
const chart2 = new Chart(ctx, { type: 'bar', data: {...} });
// one chart per canvas; the canvas size is controlled by
// responsive options, NOT the width/height attributesVerfügbare Chart-Typen
Chart.js bringt acht Chart-Typen mit. Bar, line, scatter und bubble nutzen kartesische Achsen; pie, doughnut und polarArea sind kreisförmig; radar hat eine eigene radiale Achse. Das 'type'-Feld auf top-level wählt den controller für alle datasets, außer ein dataset überschreibt ihn mit eigenem type.
// the 8 built-in chart types
const types = ['bar', 'line', 'pie', 'doughnut',
'radar', 'polarArea', 'bubble', 'scatter'];
// each type maps to a controller:
// bar/line -> Cartesian controllers
// pie/doughnut/polarArea -> circular controllers
// radar -> radar controller
// bubble/scatter -> cartesian with point parsing
new Chart(ctx, { type: 'polarArea', data: {...} });Tree-Shaking & register
Beim Import aus 'chart.js' (nicht /auto) ist nichts registriert, also müssen controllers, elements, scales und plugins selbst registriert werden. Dieser tree-shakeable-Ansatz kann die Bundle-Größe deutlich senken. Ein nicht registriertes Bauteil ist die häufigste Ursache des Fehlers 'scale is not a registered scale'.
import {
Chart,
BarController,
BarElement,
CategoryScale,
LinearScale,
Legend,
Title,
Tooltip,
} from 'chart.js';
// register ONLY what you use -> smaller bundle
Chart.register(
BarController, BarElement,
CategoryScale, LinearScale,
Legend, Title, Tooltip,
);
new Chart(ctx, {
type: 'bar',
data: { labels: ['A', 'B'], datasets: [{ data: [1, 2] }] },
});destroy & Lebenszyklus
Jede Chart-Instanz besitzt ihr canvas und ihre event listener. destroy() räumt alles ab, sodass das canvas wiederverwendbar ist — Pflicht in SPAs und React/Vue-Effekten. Ein zweites Chart auf einem aktiven canvas leakst Speicher und erzeugt doppelt gerenderte Grafiken.
const chart = new Chart(ctx, config);
// ...later, to re-render with new config:
chart.destroy(); // cleans up listeners and canvas
const fresh = new Chart(ctx, newConfig);
// never create two Chart instances on the same canvas;
// always destroy() the old one first.Balkendiagramme
Einfaches Balkendiagramm
Ein Balkendiagramm mappt jedes Label auf einen Balken, dessen Höhe dem Datenwert entspricht. backgroundColor setzt die Balkenfüllung, borderColor/borderWidth den Umriss. y.beginAtZero setzen, damit Balken immer bei null starten — ohne das skaliert Chart.js das Achsenminimum evtl. automatisch und verzerrt die Unterschiede visuell.
new Chart(ctx, {
type: 'bar',
data: {
labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
datasets: [{
label: 'Revenue',
data: [12, 19, 7, 15, 22],
backgroundColor: 'rgba(54, 162, 235, 0.6)',
borderColor: 'rgba(54, 162, 235, 1)',
borderWidth: 1
}]
},
options: { scales: { y: { beginAtZero: true } } }
});Horizontaler Balken (indexAxis)
In Chart.js v3+ entstehen horizontale Balken mit indexAxis: 'y' auf einem 'bar'-Typ — der alte 'horizontalBar'-Typ wurde entfernt. Die x-Scale wird zur value-Achse. Horizontale Balken ideal für lange Kategorien-Labels, die sich vertikal überlappen würden.
new Chart(ctx, {
type: 'bar',
data: {
labels: ['Task A', 'Task B', 'Task C'],
datasets: [{ label: 'Hours', data: [5, 8, 3] }]
},
options: {
indexAxis: 'y', // horizontal bars (v3+ syntax)
scales: { x: { beginAtZero: true } }
}
});Gruppierte Balken (mehrere datasets)
Mehrere datasets in einem Balkendiagramm stehen per Default nebeneinander (gruppiert). Chart.js vergibt Farben nur automatisch, wenn backgroundColor fehlt — also explizite Farben pro dataset setzen für vorhersagbare Ausgabe. Jedes dataset teilt dasselbe labels-Array auf der x-Achse.
new Chart(ctx, {
type: 'bar',
data: {
labels: ['Q1', 'Q2', 'Q3', 'Q4'],
datasets: [
{ label: '2023', data: [20, 35, 30, 35],
backgroundColor: 'rgba(255,99,132,0.6)' },
{ label: '2024', data: [25, 32, 34, 40],
backgroundColor: 'rgba(54,162,235,0.6)' }
]
},
options: { scales: { y: { beginAtZero: true } } }
});Gestapelte Balken
Gestapelte Balken verlangen stacked: true auf BEIDEN Skalen, x und y. Die Balken jedes datasets werden auf den vorigen gezeichnet und summieren sich zur Summe. Stapeln zeigt Zusammensetzung, macht aber obere series schwerer vergleichbar als gruppierte Balken.
new Chart(ctx, {
type: 'bar',
data: {
labels: ['A', 'B', 'C'],
datasets: [
{ label: 'Men', data: [20, 35, 30], backgroundColor: '#36A2EB' },
{ label: 'Women', data: [25, 32, 34], backgroundColor: '#FF6384' }
]
},
options: {
scales: {
x: { stacked: true },
y: { stacked: true, beginAtZero: true }
}
}
});Balken-Styling
borderRadius rundet Balkenecken (eine Zahl gilt für alle Ecken; ein Objekt wie {topLeft:8} zielt auf konkrete Ecken). borderSkipped defaultet auf 'start' und lässt einen Rand weg — false setzen, um alle vier zu zeichnen. barPercentage und categoryPercentage steuern zusammen Balkendicke und Abstand.
new Chart(ctx, {
type: 'bar',
data: {
labels: ['A', 'B', 'C'],
datasets: [{
data: [10, 20, 15],
backgroundColor: '#FF6384',
borderColor: '#fff',
borderWidth: 2,
borderRadius: 8, // rounded corners (px or %)
borderSkipped: false, // draw border on all sides
barPercentage: 0.8, // bar width within category
categoryPercentage: 0.7 // category width
}]
}
});Schwebende Balken ([min, max])
[min, max]-Paare als Datenwerte erzeugen schwebende Balken, die nicht bei null starten — perfekt für Bereiche wie Tages-Tief-/Höchsttemperatur, open-close oder Konfidenzintervalle. Die y-Achse sollte NICHT bei null beginnen. Funktioniert auch auf horizontalen Balken.
new Chart(ctx, {
type: 'bar',
data: {
labels: ['Mon', 'Tue', 'Wed'],
datasets: [{
label: 'Low-High temp',
// each value is [min, max] -> a floating bar
data: [[10, 18], [12, 20], [8, 15]],
backgroundColor: 'rgba(75,192,192,0.6)'
}]
},
options: { scales: { y: { beginAtZero: false } } }
});Liniendiagramme
Einfaches Liniendiagramm
Ein Liniendiagramm verbindet Datenpunkte der Reihe nach. borderColor ist die Linienfarbe; backgroundColor dient der Füllung (wenn fill aktiv ist). tension (0-1) steuert die Kurvenweichheit — 0 sind gerade Segmente, ~0.3-0.4 liefert sanfte Bezier-Kurven. Für präzise Daten wie Finanzkurse 0 nutzen.
new Chart(ctx, {
type: 'line',
data: {
labels: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
datasets: [{
label: 'Visitors',
data: [30, 45, 28, 60, 52],
borderColor: 'rgba(75,192,192,1)',
backgroundColor: 'rgba(75,192,192,0.2)',
tension: 0.3
}]
},
options: { scales: { y: { beginAtZero: true } } }
});Mehrere Linien
Jedes dataset in einem Liniendiagramm wird zur eigenen Linie, automatisch mit einer Farbe aus der Default-Palette versehen (per borderColor überschreibbar). Linien werden in dataset-Reihenfolge gezeichnet, das letzte dataset also oben. Jedes dataset mit label versehen, damit die legend sie unterscheiden kann.
new Chart(ctx, {
type: 'line',
data: {
labels: ['Jan', 'Feb', 'Mar', 'Apr'],
datasets: [
{ label: 'Plan', data: [10, 20, 25, 30], borderColor: 'red' },
{ label: 'Actual', data: [8, 22, 24, 33], borderColor: 'blue' }
]
},
options: {
scales: { y: { beginAtZero: true } },
plugins: { legend: { position: 'top' } }
}
});line tension & Interpolation
tension ergänzt Bezier-Glättung, kann aber Datenpunkte überschießen (Vertiefungen unter das Minimum). cubicInterpolationMode: 'monotone' glättet ohne Überschießen — bevorzugt bei monotonen Daten wie Aktienkursen. borderDash ist ein [dash, gap]-Muster für gestrichelte/gepunktete Linien.
datasets: [{
data: [1, 5, 2, 6, 3],
tension: 0, // straight lines
// tension: 0.4, // smooth bezier
cubicInterpolationMode: 'monotone', // no overshoot
borderDash: [5, 5], // dashed line
borderWidth: 2,
borderColor: 'purple'
}]Gefüllte Linien (fill)
fill steuert die Fläche unter der Linie. true/'origin' füllt bis zur x-Achse. Eine Zahl (1, -1, +1) füllt in Richtung eines anderen dataset per Index — nützlich für band charts. Eine negative Zahl füllt zum vorigen dataset. backgroundColor mit alpha setzen, damit die Linie durch die Füllung sichtbar bleibt.
datasets: [
{ label: 'A', data: [3,5,4,6], fill: true, backgroundColor: 'rgba(255,99,132,0.3)' },
{ label: 'B', data: [1,2,3,2], fill: 'origin', backgroundColor: 'rgba(54,162,235,0.3)' },
{ label: 'C', data: [2,4,3,5], fill: 1, backgroundColor: 'rgba(75,192,192,0.3)' }
]
// fill values: false | true/'origin' | 1/-1/+1 | '-1' | {target:...}Punkt-Styling
Punkt-Eigenschaften akzeptieren einen einzelnen Wert oder ein Array (einen pro Datenpunkt). pointStyle unterstützt viele Formen ('circle', 'rect', 'rectRot', 'triangle', 'star', 'cross', 'crossRot'). pointRadius: 0 verbirgt Punkte komplett (praktisch bei dichten Liniendiagrammen), pointHoverRadius größer für interaktiven pop-Effekt.
datasets: [{
data: [4, 6, 5, 7],
showLine: true,
pointRadius: 5, // point size (0 hides points)
pointHoverRadius: 9,
pointBackgroundColor: 'white',
pointBorderColor: 'black',
pointBorderWidth: 2,
pointStyle: 'rectRot', // 'circle','rect','triangle','star','cross'...
// per-point arrays also work:
// pointRadius: [0, 0, 6, 0],
}]Lücken überspannen & fehlende Daten
null, undefined und NaN stehen für fehlende Daten und unterbrechen die Linie per Default. spanGaps: true verbindet die Punkte beidseits einer Lücke mit einem einzigen Segment. NaN (fehlend) von 0 (echte Null) unterscheiden — die Verwechslung ist eine häufige Quelle irreführender Charts.
datasets: [{
data: [5, null, 7, NaN, 9, undefined, 11],
spanGaps: true, // connect across null/NaN gaps
// spanGaps: false -> the line breaks at missing points
}]
// also skip points entirely by setting them to NaN
// NaN is "no data"; 0 is a legitimate zero valueKreis- & Doughnut-Diagramme
Einfaches Kreisdiagramm
Ein Kreisdiagramm zeigt Teile eines Ganzen: jeder Wert wird zu einem Sektor, dessen Winkel seinem Anteil entspricht. Pro Sektion ein backgroundColor liefern (als Array), sonst zykliert Chart.js eine Default-Palette. Kreisdiagramme funktionieren am besten mit 3-6 Kategorien — mehr wird unlesbar.
new Chart(ctx, {
type: 'pie',
data: {
labels: ['Rent', 'Food', 'Fun', 'Save'],
datasets: [{
data: [1200, 600, 400, 800],
backgroundColor: ['#FF6384', '#36A2EB', '#FFCE56', '#4BC0C0']
}]
}
});Einfaches Doughnut
Ein doughnut ist ein Kreis mit Loch in der Mitte. cutout (Prozent-String oder Pixelzahl) steuert die Lochgröße — '50%' ist der klassische Doughnut-Look. Das Zentrum kann per plugin ein summary label tragen, und die Ringlänge kodiert Werte etwas besser als der Sektorwinkel.
new Chart(ctx, {
type: 'doughnut',
data: {
labels: ['A', 'B', 'C'],
datasets: [{
data: [40, 35, 25],
backgroundColor: ['#FF6384', '#36A2EB', '#FFCE56'],
cutout: '50%' // size of the inner hole
}]
}
});cutout, rotation & circumference
rotation setzt den Startwinkel in Grad (Default 0 = rechts; -90 = oben). circumference steuert, wie viel vom Kreis gezeichnet wird — 180 ergibt einen halben Doughnut, nützlich für gauge-artige Charts. Beide liegen unter options (nicht am dataset), in v3+; cutout kann in beidem erscheinen.
new Chart(ctx, {
type: 'doughnut',
data: { labels: ['A','B','C'], datasets: [{ data: [30,40,30], backgroundColor: ['#f00','#0f0','#00f'] }] },
options: {
cutout: '60%',
rotation: -90, // start at top (degrees)
circumference: 360 // full circle; 180 = half doughnut
}
});border & offset
borderColor mit borderWidth trennt Sektoren visuell (weiße Ränder wirken sauber segmentiert). hoverOffset schiebt eine Sektion nach außen, wenn der Nutzer sie hovert — klare interaktive Rückmeldung. offset ist ein Array (eins pro Sektion), um konkrete Sektoren dauerhaft 'explodieren' zu lassen.
datasets: [{
data: [30, 40, 30],
backgroundColor: ['#FF6384', '#36A2EB', '#FFCE56'],
borderColor: 'white',
borderWidth: 3,
hoverOffset: 16, // pop slice out on hover
offset: [0, 20, 0] // permanently offset 2nd slice
}]Halber Doughnut (Gauge)
Ein halber doughnut (rotation: -90, circumference: 180) liest sich als gauge/progress meter. Mit einem center-text-plugin paaren, um den Prozentwert zu zeigen, und die legend für einen sauberen KPI-Look abschalten. Die 'remaining'-Sektion in neutralem Grau übermittelt den offenen Anteil.
new Chart(ctx, {
type: 'doughnut',
data: {
labels: ['Done', 'Remaining'],
datasets: [{
data: [72, 28],
backgroundColor: ['#4BC0C0', '#E0E0E0']
}]
},
options: {
rotation: -90,
circumference: 180,
plugins: { legend: { display: false } }
}
});Tooltip-Prozent-Callback
Pie/doughnut-tooltips zeigen per Default rohe Werte. Über tooltip callbacks.label stattdessen Prozentwerte berechnen und anzeigen — ctx.parsed ist der Sektionswert, ctx.dataset.data hält alle Werte für die Summe. Template literals in callbacks müssen Backticks und ${} escapen, wenn sie in den Code-String dieses Cheatsheets eingebettet sind.
options: {
plugins: {
tooltip: {
callbacks: {
label: (ctx) => {
const total = ctx.dataset.data.reduce((a, b) => a + b, 0);
const pct = (ctx.parsed / total * 100).toFixed(1);
return `${ctx.label}: ${ctx.parsed} (${pct}%)`;
}
}
}
}
}Radar-Charts
Einfaches Radar
Ein radar-Chart plottet jedes Label als vertex eines Polygons und verbindet sie zu einer geschlossenen Form. fill: true schattiert das Innere. Die radiale scale wird unter scales.r konfiguriert (nicht x/y). Radars vergleichen multivariate Profile, können aber bei zu vielen Achsen oder unvergleichbaren Einheiten irreführen.
new Chart(ctx, {
type: 'radar',
data: {
labels: ['Speed', 'Power', 'Range', 'Comfort', 'Price'],
datasets: [{
label: 'Model X',
data: [8, 7, 6, 9, 5],
borderColor: 'rgba(255,99,132,1)',
backgroundColor: 'rgba(255,99,132,0.2)',
fill: true
}]
},
options: { scales: { r: { beginAtZero: true } } }
});Radar-Styling
Radar-datasets akzeptieren dasselbe Styling wie Liniendiagramme: borderColor, fill, punkt-Styling, tension. Kleine tension (0.1) rundet die vertex leicht für weicheren Look; 0 hält gerade spikes. Durchscheinendes backgroundColor nutzen, damit sich überlappende radar-Formen weiterhin erkennen lassen.
datasets: [{
data: [7, 8, 6, 9, 5],
borderColor: 'blue',
backgroundColor: 'rgba(0,0,255,0.2)',
borderWidth: 2,
pointRadius: 4,
pointBackgroundColor: 'blue',
fill: true,
tension: 0.1 // slight curve between vertices
}]Radar-scale (r) Einstellungen
Die radiale scale r steuert Ringe und Labels. min/max fixieren den Wertebereich über alle Achsen (Pflicht beim Vergleichen von datasets). ticks.stepSize setzt die Ringabstände; pointLabels stylt die Kategorienamen am Umfang. ticks.backdropColor transparent setzen, damit Ringzahlen die gridlines nicht verdecken.
options: {
scales: {
r: {
min: 0,
max: 10,
ticks: { stepSize: 2, backdropColor: 'transparent' },
pointLabels: { font: { size: 13 }, color: '#333' },
grid: { color: '#ccc' },
angleLines: { color: '#ccc' }
}
}
}Radar mit mehreren datasets
Mehrere datasets überlagern sich als konzentrische Polygone — ideal für before/after- oder Konkurrenzvergleiche. Immer dasselbe min/max an r setzen, damit die Formen vergleichbar sind, und durchscheinende fills nutzen, damit beide Profile an Überlappungen sichtbar bleiben.
new Chart(ctx, {
type: 'radar',
data: {
labels: ['A', 'B', 'C', 'D', 'E'],
datasets: [
{ label: 'Before', data: [5,6,4,7,5], borderColor: 'red', backgroundColor: 'rgba(255,0,0,0.15)', fill: true },
{ label: 'After', data: [7,8,6,9,7], borderColor: 'blue', backgroundColor: 'rgba(0,0,255,0.15)', fill: true }
]
}
});Radar angle lines & grid
angleLines sind die Speichen vom Zentrum zu jedem vertex; grid sind die konzentrischen Polygonringe. Ticks verbergen (display:false) entfernt die numerischen Ring-Labels für einen saubereren Look, lässt die Ringe aber stehen. pointLabels steuert nur den Kategorietext an jedem vertex.
options: {
scales: {
r: {
angleLines: { display: true, color: 'rgba(0,0,0,0.2)', lineWidth: 1 },
grid: { display: true, color: 'rgba(0,0,0,0.1)' },
pointLabels: { display: true, color: '#000', font: { weight: 'bold' } },
ticks: { display: false } // hide numeric ring labels for a cleaner look
}
}
}Polar Area Charts
Einfaches polar area chart
Ein polar area chart zeichnet jeden Wert als Sektor mit gleichem Winkel (je 360/N), wobei der Radius den Wert kodiert. Anders als beim pie (Winkel = Wert) gilt hier Radius = Wert, alle Sektoren haben also gleiche Winkelbreite, aber verschiedene Längen.
new Chart(ctx, {
type: 'polarArea',
data: {
labels: ['North', 'South', 'East', 'West'],
datasets: [{
data: [11, 16, 7, 14],
backgroundColor: ['#FF6384', '#4BC0C0', '#FFCE56', '#36A2EB']
}]
},
options: { scales: { r: { beginAtZero: true } } }
});Polar area vs. pie
Der Kernunterschied: beim pie ist der Winkel jeder Sektion zum Wert proportional; beim polar area ist der Radius zum Wert proportional bei gleichen Winkeln. Polar area nutzen, wenn jede Kategorie gleich sichtbar sein, aber nach Größenordnung dimensioniert werden soll.
// PIE: angle = value, radius = constant
new Chart(ctx, { type: 'pie', data: { datasets: [{ data: [10, 20, 30] }] } });
// POLAR: angle = constant, radius = value
new Chart(ctx, { type: 'polarArea', data: { datasets: [{ data: [10, 20, 30] }] } });
// polar area is better when values differ widely AND
// you want every category to occupy an equal angular sharePolar scale (r)
Polar area nutzt eine einzige radiale scale r, die sich alle Sektoren teilen — alle Werte werden also gegen denselben Maximalradius gemessen. Ein explizites max macht das Chart ehrlich bezüglich Skala; ohne skaliert Chart.js automatisch auf den größten Wert, was kleine Unterschiede überzeichnen kann.
options: {
scales: {
r: {
min: 0,
max: 20,
ticks: { stepSize: 5 },
grid: { color: 'rgba(0,0,0,0.15)' },
angleLines: { color: 'rgba(0,0,0,0.15)' }
}
}
}Polar border styling
Polar-area-Sektoren akzeptieren dasselbe border/fill-Styling wie pie/doughnut. Weiße Ränder trennen benachbarte Sektoren klar. hoverBackgroundColor ändert die Füllung einer Sektion beim Hover für interaktive Rückmeldung. Anders als der doughnut gibt es kein cutout — die Sektoren treffen sich im Zentrum.
datasets: [{
data: [11, 16, 7, 14],
backgroundColor: ['#FF6384', '#4BC0C0', '#FFCE56', '#36A2EB'],
borderColor: 'white',
borderWidth: 2,
hoverBackgroundColor: '#333'
}]Polar mit hover offset
Polar area unterstützt hoverBackgroundColor und hoverBorderColor, aber NICHT hoverOffset / offset so wie doughnut, weil sich Sektoren eine radiale scale teilen. Wenn 'herausspringende' Sektionen essenziell sind, lieber doughnut wählen. Für Polar-Interaktivität Farbe und tooltip-Änderungen nutzen.
datasets: [{
data: [11, 16, 7, 14],
backgroundColor: ['#FF6384', '#4BC0C0', '#FFCE56', '#36A2EB'],
hoverOffset: 12 // not supported on polarArea the same way as doughnut;
// use hoverBackgroundColor + tooltips for interactivity
}]
// for true "pop out" use 'doughnut' insteadBlasendiagramme
Einfaches bubble chart
bubble-Datenpunkte sind Objekte {x, y, r}, wobei x und y Koordinaten sind und r der Blasen-RADIUS in Pixeln. Anders als beim scatter kodiert die Blasengröße eine dritte Variable. r ist ein Radius (keine Fläche), also ist ein doppelt so großer Wert visuell viermal die Fläche — size-Daten ggf. per sqrt skalieren.
new Chart(ctx, {
type: 'bubble',
data: {
datasets: [{
label: 'Products',
data: [
{ x: 10, y: 20, r: 15 },
{ x: 15, y: 10, r: 10 },
{ x: 7, y: 25, r: 8 }
],
backgroundColor: 'rgba(255,99,132,0.6)'
}]
},
options: { scales: { y: { beginAtZero: true } } }
});Blasengröße mappen
Da Menschen Blasen-FLÄCHE statt Radius wahrnehmen, den Wert vor der Zuweisung an r durch Math.sqrt führen, sodass Verdoppeln des Werts die sichtbare Fläche verdoppelt. Einen Divisor wählen, der verhindert, dass die größte Blase zu viele Nachbarn überdeckt. So wird das chart wahrnehmungsehrlich.
const raw = [{x:1,y:2,pop:1000}, {x:2,y:3,pop:5000}, {x:3,y:1,pop:20000}];
// map a real-world value to a pixel radius with sqrt scaling
// so bubble AREA (not radius) is proportional to the value
const data = raw.map(d => ({
x: d.x,
y: d.y,
r: Math.sqrt(d.pop) / 10 // tune the divisor for your dataset
}));
new Chart(ctx, { type: 'bubble', data: { datasets: [{ data }] } });Blasenfarben pro Punkt
Wie andere Chart.js-datasets akzeptieren bubble-Styling-Eigenschaften Arrays, um jede Blase einzeln zu stylen. Damit Blasen nach Kategorie farblich kodieren, während die Größe einen separaten numerischen Wert kodiert — ergibt ein 4-dimensionales chart (x, y, size, color).
datasets: [{
data: [
{ x: 10, y: 20, r: 15 },
{ x: 15, y: 10, r: 10 }
],
// arrays give per-point styling
backgroundColor: ['rgba(255,99,132,0.6)', 'rgba(54,162,235,0.6)'],
borderColor: ['rgba(255,99,132,1)', 'rgba(54,162,235,1)'],
borderWidth: 2
}]Mehrere bubble-datasets
Mehrere datasets rendern als unterschiedlich gefärbte bubble-Gruppen, je eine in der legend. Bei überlagerten Gruppen Blasenradien mäßig halten, damit sich Blasen nicht völlig verdecken. Alpha-transparente fills (0.5-0.6) helfen, überlappende Blasen lesbar zu halten.
new Chart(ctx, {
type: 'bubble',
data: {
datasets: [
{ label: 'Asia', data: [{x:1,y:2,r:10},{x:3,y:4,r:8}], backgroundColor: 'rgba(255,99,132,0.6)' },
{ label: 'Europe', data: [{x:2,y:5,r:12},{x:4,y:2,r:7}], backgroundColor: 'rgba(54,162,235,0.6)' }
]
}
});bubble hover styling
Hover-Eigenschaften (hoverBackgroundColor, hoverBorderColor, hoverBorderWidth, hoverRadius) gelten nur für die Blase unter dem pointer. hoverRadius ergänzt beim Hover Pixel zum Radius — die anvisierte Blase springt sichtbar hervor. Mit tooltips kombiniert ergibt das klaren interaktiven Fokus.
datasets: [{
data: [{x:1,y:2,r:10}],
backgroundColor: 'rgba(75,192,192,0.5)',
hoverBackgroundColor: 'rgba(75,192,192,0.9)',
hoverBorderColor: 'black',
hoverBorderWidth: 3,
hoverRadius: 2 // EXTRA radius added on hover (v3+ uses hoverRadius)
}]Punktdiagramme
Einfaches scatter chart
scatter-Datenpunkte sind {x, y}-Objekte (kein radius nötig). Die x-scale sollte type: 'linear' sein (NICHT category), damit numerische x-Werte an echte Positionen mappen. Scatter ist der Standardchart für Korrelation zwischen zwei kontinuierlichen Variablen.
new Chart(ctx, {
type: 'scatter',
data: {
datasets: [{
label: 'Observations',
data: [
{ x: 1.2, y: 2.3 },
{ x: 1.8, y: 3.1 },
{ x: 2.5, y: 4.0 },
{ x: 3.1, y: 4.8 }
],
backgroundColor: 'rgba(75,192,192,0.7)'
}]
},
options: { scales: { x: { type: 'linear', position: 'bottom' } } }
});Scatter mit vielen Punkten
Bei Tausenden Punkten pointRadius verkleinern (1-2px) und durchscheinendes backgroundColor nutzen (alpha 0.2-0.4), sodass überlappende Punkte Dichte über dunklere Regionen offenbaren. Punkt-hover bei sehr großen datasets abschalten (pointHitRadius: 0), damit Interaktion responsiv bleibt.
const n = 2000;
const data = Array.from({ length: n }, () => ({
x: Math.random() * 100,
y: Math.random() * 100
}));
new Chart(ctx, {
type: 'scatter',
data: { datasets: [{ data, pointRadius: 1.5, backgroundColor: 'rgba(0,0,0,0.3)' }] }
});scatter punkt styling
pointStyle unterstützt viele Formen neben dem Default-Kreis: 'rect', 'rectRot', 'triangle', 'star', 'cross', 'crossRot', 'dash'. pointRotation rotiert nicht-kreisförmige Formen. Alle point*-Eigenschaften akzeptieren Arrays für punktweises Styling — praktisch, um konkrete Beobachtungen hervorzuheben.
datasets: [{
data: [{x:1,y:2},{x:2,y:3}],
pointRadius: 8,
pointHoverRadius: 12,
pointStyle: 'triangle', // 'circle','rect','star','cross',...
pointBackgroundColor: 'red',
pointBorderColor: 'darkred',
pointBorderWidth: 2,
pointRotation: 45 // rotation in degrees (for shapes)
}]scatter mit trend line
Chart.js hat keine eingebaute trend line, also eine Regression berechnen (hier least-squares) und ein 'line'-dataset mit zwei Endpunkten und pointRadius:0 ergänzen. Der type des line-datasets überschreibt den chart-Typ je dataset — so funktionieren auch mixed charts. fill:false hält es als reine Linie.
// simple least-squares fit
const pts = [{x:1,y:2},{x:2,y:3.5},{x:3,y:4.2},{x:4,y:5.1}];
const n = pts.length;
const mX = pts.reduce((s,p)=>s+p.x,0)/n;
const mY = pts.reduce((s,p)=>s+p.y,0)/n;
const slope = pts.reduce((s,p)=>s+(p.x-mX)*(p.y-mY),0) / pts.reduce((s,p)=>s+(p.x-mX)**2,0);
const intercept = mY - slope*mX;
new Chart(ctx, {
type: 'scatter',
data: { datasets: [
{ data: pts, backgroundColor: 'blue' },
{ type: 'line', data: [{x:0,y:intercept},{x:5,y:slope*5+intercept}],
borderColor: 'red', pointRadius: 0, fill: false }
]}
});scatter zu line (showLine)
showLine: true auf einem scatter-dataset verbindet die Punkte mit einer Linie und macht aus dem scatter effektiv ein Liniendiagramm mit numerischen x-Koordinaten. Die richtige Wahl, wenn x-Werte echte Zahlen sind (keine Kategorie-Labels), aber verbindende Segmente gewünscht sind — z. B. Zeitreihen mit unregelmäßigen Abständen.
new Chart(ctx, {
type: 'scatter',
data: { datasets: [{
data: [{x:1,y:2},{x:2,y:3},{x:3,y:5}],
showLine: true, // connect points with a line
borderColor: 'green',
backgroundColor: 'green',
pointRadius: 4
}]}
});Daten — datasets
datasets-Struktur
data hält labels (über alle datasets geteilt) und datasets (ein Array von series). Jedes dataset hat ein label (erscheint in legend/tooltips), ein data-Array passend zu labels, und styling-Eigenschaften. Auf dem dataset gesetzte Eigenschaften gelten für jeden Punkt, außer ein Array übersteuert sie.
data: {
labels: ['A', 'B', 'C'], // shared category labels
datasets: [
{
label: 'Series 1', // legend + tooltip label
data: [10, 20, 30], // values (one per label)
backgroundColor: 'rgba(0,0,255,0.5)',
borderColor: 'blue',
borderWidth: 1,
// ... type-specific styling
}
]
}labels & data Ausrichtung
Das data-Array jedes datasets ist positionell mit dem geteilten labels-Array ausgerichtet — data[i] ist der Wert für labels[i]. Ein kürzeres data-Array erzeugt undefined-Werte für den fehlenden Schwanz, die Liniendiagramme als Lücken behandeln. labels und data immer gleich lang halten, um überraschende Lücken zu vermeiden.
data: {
labels: ['Jan', 'Feb', 'Mar'],
datasets: [
{ data: [10, 20, 30] }, // Jan=10, Feb=20, Mar=30
{ data: [5, 15] } // Jan=5, Feb=15, Mar=undefined
]
}
// data[i] always corresponds to labels[i]; a shorter data array
// leaves the remaining positions as undefined (missing data)Mehrere datasets
Mehrere datasets rendern als parallele series (gruppierte Balken, mehrere Linien, überlappende radars). Sie teilen ein labels-Array. Unterschiedliche Farben pro dataset setzen — Chart.js färbt nur automatisch, wenn backgroundColor fehlt, und selbst dann sind explizite Farben über Versionen hinweg vorhersagbarer.
data: {
labels: ['Q1','Q2','Q3','Q4'],
datasets: [
{ label: '2023', data: [20,35,30,35], backgroundColor: 'rgba(255,99,132,0.6)' },
{ label: '2024', data: [25,32,34,40], backgroundColor: 'rgba(54,162,235,0.6)' },
{ label: '2025', data: [28,38,36,45], backgroundColor: 'rgba(75,192,192,0.6)' }
]
}Styling auf dataset-Ebene
dataset-Ebene-Stil gilt für jeden Punkt dieses datasets. hover*-Varianten aktivieren sich beim Hover. hidden:true startet das dataset versteckt (der legend-toggle kann es wieder zeigen). order steuert die z-order — niedrigere Zahlen zeichnen später (oben) — praktisch in gemischten/überlappenden charts.
datasets: [{
label: 'Revenue',
data: [10, 20, 30],
backgroundColor: 'rgba(54,162,235,0.6)',
borderColor: 'rgba(54,162,235,1)',
borderWidth: 2,
hoverBackgroundColor: 'rgba(54,162,235,0.9)',
hidden: false, // set true to hide from view + legend toggle
order: 0 // lower order draws on top
}]Objektdaten parsen
Ist das Datenmaterial ein Array von Objekten, über parsing: {xAxisKey, yAxisKey} mitteilen, welche Felder die Achsenwerte halten. So entfällt das manuelle Mapping auf {x, y}-Paare. Die keys defaulten auf 'x' und 'y', also funktionieren {x, y}-Objekte ohne parsing-Konfiguration.
new Chart(ctx, {
type: 'bar',
data: {
datasets: [{
data: [
{ name: 'Red', votes: 12 },
{ name: 'Blue', votes: 19 }
],
parsing: { xAxisKey: 'name', yAxisKey: 'votes' }
}]
}
});Styling-Arrays pro Punkt
Jede styling-Eigenschaft kann ein einzelner Wert (gilt für alle Punkte) oder ein Array (einer pro Punkt) sein. Damit lassen sich konkrete Punkte hervorheben — etwa den meisten backgroundColor auf grau setzen und einen auf rot, um Aufmerksamkeit zu ziehen. Die Array-Länge sollte zur Datenlänge passen; kürzere Arrays zyklieren.
datasets: [{
data: [10, 20, 30, 40],
// every styling property accepts an array (one value per point)
backgroundColor: ['red', 'green', 'blue', 'orange'],
borderColor: ['darkred', 'darkgreen', 'darkblue', 'darkorange'],
borderWidth: [1, 2, 3, 4],
pointRadius: [3, 6, 9, 12] // (line/scatter only)
}]Optionen — responsiv & scales
options-Struktur
options ist das top-level-Konfigurationsobjekt. Es gruppiert Belange: plugins (legend/title/tooltip), scales (x/y/r), layout (padding), animation, interaction (hover mode) und events. Fast jedes Chart.js-Verhalten wird hier abgestimmt, nicht an einzelnen datasets.
new Chart(ctx, {
type: 'bar',
data: { /* ... */ },
options: {
responsive: true,
maintainAspectRatio: true,
plugins: { legend: {}, title: {}, tooltip: {} },
scales: { x: {}, y: {} },
layout: { padding: 10 },
animation: { duration: 800 },
interaction: { mode: 'nearest', intersect: false },
events: ['mousemove', 'click', 'touchstart']
}
});responsive & maintainAspectRatio
responsive:true lässt das chart die Container-Breite füllen und beim resize neu rendern. maintainAspectRatio:false gibt die Höhe frei, sodass die CSS-Höhe des Containers gilt — beides setzen und das canvas in ein dimensioniertes <div> wickeln. Mit maintainAspectRatio:true (Default) hält das chart ein festes width/height-Verhältnis.
<div style="width:100%; height:400px;">
<canvas id="c"></canvas>
</div>
<script>
new Chart(document.getElementById('c'), {
type: 'line',
data: { /* ... */ },
options: {
responsive: true, // resize with container
maintainAspectRatio: false // let the container control height
}
});
</script>scales Überblick
scales konfiguriert jede Achse. Die id (x, y, r) ist der scale-Schlüssel; type wählt die scale-Klasse. Häufige Typen: 'category' (Text-Labels), 'linear' (Zahlen), 'logarithmic', 'time' (braucht einen date adapter), 'radialLinear' (radar/polar). title.display + text ergänzt ein Achsen-Label.
options: {
scales: {
x: { type: 'category', title: { display: true, text: 'Month' } },
y: { type: 'linear', title: { display: true, text: 'Value' },
beginAtZero: true },
r: { type: 'radialLinear' } // for radar/polarArea
}
}
// built-in scale types: category, linear, logarithmic, time,
// timeseries, radialLinearplugins Überblick
plugins gruppiert die eingebauten title-, legend- und tooltip-plugins plus die Optionen registrierter eigener plugins nach deren id. title ergänzt einen chart-Titel über dem canvas. legend steuert den dataset-Schlüssel. tooltip steuert hover-Popups. Eigene plugins lesen ihre Optionen aus demselben plugins-Objekt.
options: {
plugins: {
title: { display: true, text: 'My Chart', font: { size: 18 } },
legend: { display: true, position: 'top' },
tooltip: { enabled: true, mode: 'index', intersect: false },
// a custom inline plugin:
myPlugin: { prop: 'value' }
}
}layout (padding)
layout.padding ergänzt Platz innerhalb des canvas zwischen chart area und canvas-Kante — nützlich, wenn Titel, Achsen-Labels oder große tooltips sonst abgeschnitten würden. Eine einzelne Zahl padded alle Seiten gleich; die Objektform erlaubt Werte je Seite.
options: {
layout: {
padding: {
top: 10, right: 20, bottom: 10, left: 20
}
}
}
// or a single number for all four sides:
// layout: { padding: 15 }Globale defaults (Chart.defaults)
Chart.defaults hält die globale Default-Konfiguration — Werte einmal beim App-Start setzen und jedes chart erbt sie. Der richtige Ort fürs Branding (font family, Grundfarbe, Default-Animation). Chart-spezifische Optionen übersteuern die defaults immer, also bleiben individuelle charts anpassbar.
// set once, applies to every chart created afterwards
Chart.defaults.font.family = "'Segoe UI', sans-serif";
Chart.defaults.font.size = 13;
Chart.defaults.color = '#333';
Chart.defaults.borderColor = '#ddd';
Chart.defaults.plugins.legend.labels.color = '#333';
Chart.defaults.animation.duration = 600;
// per-chart override still wins:
new Chart(ctx, { options: { font: { size: 16 } } });Achsen — X & Y
lineare Achse
Eine lineare Achse mappt Zahlen anteilig. beginAtZero erzwingt den Achsenstart bei 0 (empfohlen für Balkendiagramme). min/max setzen harte Grenzen; suggestedMin/suggestedMax sind weiche Hinweise, die Chart.js zur Tickanpassung erweitern darf. ticks.callback passt den Labeltext an (z. B. Einheit anhängen).
options: {
scales: {
y: {
type: 'linear',
beginAtZero: true,
min: 0, max: 100, // hard limits
ticks: { stepSize: 10, callback: (v) => v + '%' }
}
}
}category-Achse
Eine category-Achse zeigt Text-Labels an festen Positionen. Sie ist die default-x-Achse für bar/line-charts. ticks.autoSkip:false zwingt jedes Label zur Anzeige (sonst verwirft Chart.js überlappende). maxRotation kippt Labels, um bei vielen Kategorien Überlappung zu verhindern.
options: {
scales: {
x: {
type: 'category',
labels: ['Mon','Tue','Wed'], // optional; usually from data.labels
ticks: { autoSkip: false, maxRotation: 45, minRotation: 0 }
}
}
}time-Achse
Eine time-Achse plottet Date-Objekte oder ISO-Strings anteilig zur Zeit, mit Lücken, wo keine Daten sind. Sie braucht ein date adapter package (chartjs-adapter-date-fns, -luxon, -dayjs). time.unit fixiert die Tick-Granularität ('day','month','year'); ohne wählt Chart.js automatisch eine Einheit.
# install a date adapter
npm install chart.js date-fns date-fns-tz
import 'chartjs-adapter-date-fns';
new Chart(ctx, {
type: 'line',
data: { datasets: [{ data: [
{x: new Date('2024-01-01'), y: 10},
{x: new Date('2024-02-01'), y: 20},
{x: new Date('2024-04-01'), y: 15}
]}]},
options: { scales: { x: { type: 'time', time: { unit: 'month' } } } }
});logarithmische Achse
Eine logarithmische Achse staffelt ticks in Zehnerpotenzen — Pflicht für Daten über Größenordnungen hinweg (Bevölkerung, Preise, Frequenzen). Sie kann 0 oder negative Werte nicht anzeigen. ticks.callback erlaubt, die Zehnerpotenz-Labels kompakt zu formatieren (z. B. wissenschaftliche Notation).
new Chart(ctx, {
type: 'line',
data: { datasets: [{ data: [1, 10, 100, 1000, 10000] }] },
options: {
scales: {
y: { type: 'logarithmic',
ticks: { callback: (v) => v >= 1 ? v.toExponential(0) : v } }
}
}
});Achsen-Titel & ticks callback
title.display + title.text ergänzen ein Achsen-Label (per Default aus — display:true setzen). ticks.callback erhält jeden tick-Wert und gibt den Anzeige-String zurück, sodass sich Zahlen als Währung, Prozent, k/M-Abkürzungen oder eigener Text formatieren lassen, ohne die zugrunde liegenden Daten zu ändern.
options: {
scales: {
y: {
title: { display: true, text: 'Revenue (USD)', color: '#333', font: { size: 14, weight: 'bold' } },
ticks: {
callback: function(value) {
if (value >= 1000) return (value/1000) + 'k';
return value;
}
}
}
}
}min/max vs. suggestedMin/Max
min/max sind HARTGrenzen: die Achse bleibt darin, auch wenn Daten den Bereich überschreiten (Daten werden abgeschnitten). suggestedMin/suggestedMax sind WEICHE Hinweise: Chart.js nutzt sie als Basis, darf aber erweitern, um runde tick-Werte zu erzeugen. suggested* bevorzugen, wenn schöne runde Zahlen gewünscht sind; harte min/max für fixe Skalen wie Prozent.
options: {
scales: {
y: {
// hard limits — chart never goes outside this range
min: 0, max: 100,
// OR soft hints — Chart.js may expand to fit nice ticks:
// suggestedMin: 0, suggestedMax: 100,
ticks: { stepSize: 20 }
}
}
}Legend
legend-Grundlagen
Die legend listet das label jedes datasets mit Farbchip. display:true zeigt sie (Default), display:false verbirgt sie. position akzeptiert 'top', 'bottom', 'left', 'right' oder 'center' (chartArea). Ein Klick auf ein legend-Item togglest per Default die Sichtbarkeit dieses datasets — eine eingebaute Filterinteraktion.
new Chart(ctx, {
type: 'bar',
data: { labels: ['A','B'], datasets: [{ label: 'Sales', data: [10,20] }] },
options: {
plugins: {
legend: { display: true, position: 'top' }
}
}
});legend position & align
position legt die legend-Seite fest; align steuert die Platzierung entlang dieser Seite ('start'/'center'/'end'). labels konfiguriert den chip (boxWidth/boxHeight) und den Textstil. maxWidth begrenzt den legend-Bereich, sodass sehr lange legends umbrechen statt das chart zur Seite zu drücken.
plugins: {
legend: {
position: 'bottom',
align: 'center', // 'start' | 'center' | 'end'
maxWidth: 300,
labels: {
boxWidth: 20,
boxHeight: 20,
padding: 15,
color: '#333',
font: { size: 12 }
}
}
}legend onClick (eigener toggle)
legend.onClick überschreiben, um das Klickverhalten anzupassen. Der Default togglest die dataset-Sichtbarkeit. Die Signatur ist (event, legendItem, legend). Nach Zustandsänderung chart.update() aufrufen — dann rendert er neu. Damit vorher bestätigen, mit externer UI synchronisieren oder single-select-(radio-)Verhalten implementieren.
plugins: {
legend: {
onClick(e, item, legend) {
const chart = legend.chart;
const dataset = chart.data.datasets[item.datasetIndex];
// custom: toggle visibility AND log the action
dataset.hidden = !dataset.hidden;
console.log('Toggled', dataset.label, '->', dataset.hidden);
chart.update();
}
}
}legend labels callback
generateLabels gibt ein Array von label-Objekten zurück, das vollständig steuert, was in der legend erscheint. text, chip-Farben und hidden-Zustand jedes Items sind anpassbar — nützlich, um Zählungen oder Einheiten zu ergänzen oder eine legend aus Nicht-dataset-Daten abzuleiten. Der hidden-Flag und datasetIndex verknüpfen Klicks mit dem richtigen dataset.
plugins: {
legend: {
labels: {
generateLabels(chart) {
return chart.data.datasets.map((ds, i) => ({
text: `${ds.label} (${ds.data.length} pts)`,
fillStyle: ds.backgroundColor,
strokeStyle: ds.borderColor,
lineWidth: ds.borderWidth,
hidden: ds.hidden,
datasetIndex: i
}));
}
}
}
}legend verbergen & externe legend
Für volle Stil-Kontrolle die eingebaute legend abschalten (display:false) und eine eigene HTML-legend rendern. Über chart.data.datasets iterieren, buttons/swatches rendern und bei Klick dataset.hidden + chart.update() togglest. Üblich, wenn ein design system eine default-canvas-legend nicht zulässt.
// hide the built-in legend entirely
options: { plugins: { legend: { display: false } } }
// build your own external legend HTML, then wire it to the chart:
const chart = new Chart(ctx, { /* ... */, options: { plugins: { legend: { display: false } } } });
chart.data.datasets.forEach((ds, i) => {
const btn = document.createElement('button');
btn.textContent = ds.label;
btn.onclick = () => { ds.hidden = !ds.hidden; chart.update(); };
document.getElementById('legend').appendChild(btn);
});Tooltips
tooltip-Grundlagen
Tooltips erscheinen beim Hover und zeigen dataset-label und Wert. enabled:true per Default. Styling-Eigenschaften (backgroundColor, titleColor, bodyColor, padding, cornerRadius) steuern den Look. displayColors togglest die kleinen Farbchips neben jedem Item — praktisch, wenn viele datasets überlappen.
options: {
plugins: {
tooltip: {
enabled: true, // show tooltips
backgroundColor: 'rgba(0,0,0,0.8)',
titleColor: 'white',
bodyColor: 'white',
borderColor: 'gray',
borderWidth: 1,
padding: 10,
cornerRadius: 4,
displayColors: true // show color boxes
}
}
}tooltip label callback
callbacks.label liefert den Text jeder tooltip-Zeile. ctx.dataset.label ist der series-Name, ctx.parsed.y hält den Wert (für pie/radar ctx.parsed nutzen). Hier Währung formatieren, Einheiten anhängen oder Summen berechnen. Der zurückgegebene String (oder String-Array) wird zum tooltip-Body.
plugins: {
tooltip: {
callbacks: {
label: (ctx) => {
const label = ctx.dataset.label || '';
const value = ctx.parsed.y ?? ctx.parsed;
return `${label}: $${value}`;
}
}
}
}tooltip title callback
callbacks.title steuert den tooltip-Header (Default: das x-Achsen-Label). Die Funktion erhält ein Array von tooltip-Items (nützlich, wenn mode:'index' mehrere datasets gruppiert). Ein leerer String '' unterdrückt den Titel komplett. title- und label-callbacks kombinieren für voll eigenen tooltip-Inhalt.
plugins: {
tooltip: {
callbacks: {
title: (items) => {
// items[0].label is the x-axis label / category
return 'Period: ' + items[0].label;
},
label: (ctx) => ctx.dataset.label + ': ' + ctx.formattedValue
}
}
}Externer HTML-tooltip
external erlaubt das Rendern des tooltips als echtes HTML — für reichhaltiges Styling, Bilder oder links, die auf canvas unmöglich sind. enabled:false setzen, damit der default-tooltip nicht doppelt rendert. Der callback erhält einen context mit einem tooltip-Objekt, das caretX/caretY (Position) und body-Zeilen hält. Das HTML-Element an diesen Koordinaten positionieren.
plugins: {
tooltip: {
enabled: false, // disable default canvas tooltip
external(context) {
const { tooltip } = context;
let el = document.getElementById('tt');
if (!el) { el = document.createElement('div'); el.id = 'tt'; document.body.appendChild(el); }
if (tooltip.opacity === 0) { el.style.opacity = 0; return; }
el.innerHTML = tooltip.body.map(b => b.lines.join('')).join('<br>');
el.style.position = 'fixed';
el.style.left = tooltip.caretX + 'px';
el.style.top = tooltip.caretY + 'px';
el.style.opacity = 1;
}
}
}tooltip mode (interaction)
interaction.mode steuert, was der tooltip zielt. 'point' zeigt nur den hovered Punkt; 'index' alle datasets am selben x (super für gruppierte Balken/Linien); 'nearest' findet den nächsten einzelnen Punkt. intersect:false triggert den tooltip, wenn der pointer irgendwo in der Spalte steht, nicht nur auf einem Punkt — meist das, was Nutzer erwarten.
options: {
interaction: {
mode: 'index', // 'point' | 'nearest' | 'index' | 'x' | 'y' | 'dataset'
intersect: false // trigger even when not directly over a point
},
plugins: { tooltip: { mode: 'index', intersect: false } }
}tooltip styling & filter
filter überspringt tooltip-Zeilen, die eine Bedingung nicht erfüllen (z. B. null/leere Werte verbergen). callbacks.footer ergänzt eine summary-Zeile nach allen Items — perfekt für eine Summe. bodyFont/titleFont stylen den Text; caretSize und caretPadding steuern den kleinen pointer-Pfeil.
plugins: {
tooltip: {
filter: (item) => item.parsed.y !== 0, // hide zero values
callbacks: { footer: (items) => 'Total: ' + items.reduce((s,i)=>s+i.parsed.y,0) },
bodyFont: { size: 13, weight: 'bold' },
titleFont: { size: 14 },
caretSize: 6,
caretPadding: 8
}
}Animation
Animationsdauer
animation.duration setzt die Gesamtlänge der Animation in Millisekunden (Default 1000). easing steuert die Beschleunigungskurve — 'easeOutQuart' (der Default) startet schnell und verzögert, was reaktionsschnell wirkt. Dauer verkürzen (200-400ms) für datengetriebene Dashboards mit häufigen Updates.
options: {
animation: {
duration: 1000, // total duration in ms
easing: 'easeOutQuart'
}
}
// easing options: 'linear','easeInQuad','easeOutQuad','easeInOutQuad',
// 'easeInCubic','easeOutCubic','easeInOutCubic','easeOutBounce',...Animation abschalten
animation:false schaltet alle Animationen komplett ab — ideal für performance-kritische Dashboards oder rasche Updates. animation:{duration:0} hält das Animationssystem aktiv, aber instant (hover funktioniert weiter). Das pluralische animations-Objekt erlaubt, konkrete Eigenschaften wie y zu deaktivieren, während andere animieren.
// disable ALL animations
options: { animation: false }
// disable only the initial draw, keep hover animations:
options: { animation: { duration: 0 } }
// per-property: animate everything except the y axis
options: {
animations: {
y: { duration: 0 }
}
}Easing-Funktionen
Easing verändert, wie eine Animation über die Zeit fortschreitet, und prägt das Gefühl stark. 'easeOutQuart' (Default) wirkt professionell und reaktionsschnell. 'easeOutBounce' oder 'easeInOutBack' sind verspielt, können auf Datencharts aber albern wirken. Easing an die übergreifende Bewegungssprache der App anpassen.
options: {
animation: {
duration: 1200,
easing: 'easeInOutBack' // slight overshoot for a playful feel
}
}
// common easings:
// 'linear' constant speed (mechanical)
// 'easeOutQuart' default; snappy start, smooth end
// 'easeInOutCubic' symmetric in/out
// 'easeOutBounce' bouncy landing
// 'easeInOutBack' overshoots at both endsanimation onComplete
onComplete feuert, wenn eine Animation endet — nützlich, um Aktionen zu verketten, etwa einen Export-Button zu aktivieren oder ein Folge-Rendering auszulösen. onProgress feuert in jedem Animationsframe mit der step count. Schwere Arbeit in onProgress vermeiden — er läuft 60x/Sekunde.
options: {
animation: {
onComplete: function() {
console.log('Animation finished');
// e.g. enable a "download PNG" button now that the chart is stable
document.getElementById('downloadBtn').disabled = false;
},
onProgress: function(ctx) {
// fired each frame; ctx.currentStep / ctx.numSteps
}
}
}Animations-Objekt je Eigenschaft (animations)
Das pluralische animations-Objekt konfiguriert einzelne Eigenschaften unabhängig. Jeder Eintrag kann from/to (oder eine Funktion des parsing-context) angeben, dazu duration, easing und loop. tension von 1 nach 0.3 zu animieren erzeugt einen 'settle'-Effekt; y von der Achsenbasis nach oben ergibt einen 'grow'-Effekt.
options: {
animations: {
tension: {
duration: 1500,
easing: 'easeOutBounce',
from: 1, // start very curved
to: 0.3, // settle at a gentle curve
loop: false
},
colors: { duration: 800 },
y: { from: ctx => ctx.chart.scales.y.getPixelForValue(0) }
}
}Events & Klicks
onClick-Handler
options.onClick feuert, wenn der Nutzer irgendwo auf das chart klickt. Das elements-Argument ist ein Array der geklickten chart-Elemente (balken/punkte), jeweils mit .datasetIndex und .index. Ist elements leer, traf der Klick leeres canvas. Der Standardweg, charts interaktiv zu machen (drill-down, Auswahl).
new Chart(ctx, {
type: 'bar',
data: { labels: ['A','B','C'], datasets: [{ data: [10,20,30] }] },
options: {
onClick(event, elements, chart) {
if (elements.length > 0) {
const el = elements[0];
const label = chart.data.labels[el.index];
const value = chart.data.datasets[el.datasetIndex].data[el.index];
alert(`Clicked ${label} = ${value}`);
}
}
}
});getElementsAtEventForMode
getElementsAtEventForMode findet die chart-Elemente unter einem nativen mouse event, mit denselben mode-Optionen wie interaction ('nearest', 'index', 'x' usw.). Das 4. Argument useFinalPosition sollte für hit-testing der finalen gerenderten Positionen true sein. Nutzen, wenn Element-Lookups außerhalb von options.onClick nötig sind.
const chart = new Chart(ctx, { /* ... */ });
canvas.addEventListener('click', (e) => {
const points = chart.getElementsAtEventForMode(
e, 'nearest', { intersect: true }, true // (event, mode, options, useFinalPosition)
);
if (points.length) {
const p = points[0];
console.log('dataset', p.datasetIndex, 'index', p.index);
}
});onHover
options.onHover feuert bei jeder Mausbewegung über dem chart. Für günstige UI-Rückmeldung nutzen, etwa cursor-Änderung (wie gezeigt) oder das Hervorheben verwandter externer Elemente. Teure Operationen vermeiden — er feuert sehr häufig. Für schwerere Logik onClick nutzen oder den handler debouncen.
options: {
onHover(event, elements, chart) {
// change cursor to a pointer when hovering a bar
event.native.target.style.cursor =
elements.length ? 'pointer' : 'default';
}
}hover & aktive Elemente
Die hover-Konfiguration steuert, wie das chart Elemente unter dem pointer hervorhebt. mode:'nearest' + intersect:true hebt den nächsten einzelnen Punkt hervor. animationDuration glättet den highlight-Übergang. chart.setActiveElements triggert den hover-Zustand programmatisch — praktisch, um chart-highlights mit externer UI zu synchronisieren.
options: {
hover: {
mode: 'nearest',
intersect: true,
animationDuration: 200 // smooth transition when hover target changes
}
}
// programmatically set the hovered element:
chart.setActiveElements([{ datasetIndex: 0, index: 2 }]);
chart.update();Events-Liste
events begrenzt, welche DOM-Events das chart lauscht. Die Liste zu verkleinern (z. B. nur 'click') schaltet hover-Effekte ab für statisches Gefühl und verbessert die Performance von Dashboards. In Touch-only-Kontexten touchstart/touchmove aufnehmen. Ein leeres Array deaktiviert jede Interaktion.
options: {
events: ['mousemove', 'mouseout', 'click', 'touchstart', 'touchmove']
// restrict to just click for a non-interactive "static" feel:
// events: ['click']
}
// supported events: mousemove, mouseout, click, touchstart, touchmove,
// touchend, pointer events (Chart.js v3.4+)Drill-down-Beispiel
Ein verbreitetes Muster: ein Klick auf einen Balken tauscht das dataset zu einer detaillierteren Sicht (drill-down). Den geklickten index erfassen, chart.data.labels und chart.data.datasets[...].data ersetzen, dann chart.update() aufrufen — der Übergang animiert. Für einen zurück-Button einen Stack der views halten.
const monthly = { labels: ['Jan','Feb','Mar'], data: [100,120,90] };
const daily = { labels: Array.from({length:28},(_,i)=>'D'+(i+1)),
data: Array.from({length:28},()=>Math.random()*50) };
const chart = new Chart(ctx, {
type: 'bar',
data: { labels: monthly.labels, datasets: [{ data: monthly.data }] },
options: { onClick(evt, els) {
if (!els.length) return;
const idx = els[0].index;
chart.data.labels = daily.labels;
chart.data.datasets[0].data = daily.data;
chart.update();
}}
});Mixed Charts
Balken + Linie gemischt
Chart-Typen mischen, indem type an einzelnen datasets gesetzt wird — er übersteuert den chart-Ebene-Typ für diese series. Balken + Linie ist der häufigste Mix (z. B. Umsatz als Balken, Wachstumsrate als Linie). Bei verschiedenen Einheiten oder Skalen eine zweite y-Achse (y1) nutzen.
new Chart(ctx, {
type: 'bar', // default type for all datasets
data: {
labels: ['Jan','Feb','Mar','Apr'],
datasets: [
{ type: 'bar', label: 'Revenue', data: [20,35,30,40], backgroundColor: '#36A2EB', yAxisID: 'y' },
{ type: 'line', label: 'Growth', data: [5,8,6,12], borderColor: '#FF6384', yAxisID: 'y1', fill: false }
]
},
options: { scales: { y: { position: 'left' }, y1: { position: 'right', grid: { drawOnChartArea: false } } } }
});dataset type override
Jedes dataset kann den chart-Ebene-Typ übersteuern und so bar, line und scatter in einem chart kombinieren. datasets ohne expliziten type erben den chart-Typ. Auf die z-order achten: datasets werden in Array-Reihenfolge gezeichnet, also background-series (balken) vor foreground-series (linien) platzieren.
new Chart(ctx, {
type: 'line', // chart-level default
data: {
labels: ['A','B','C'],
datasets: [
{ data: [1,2,3] }, // inherits 'line'
{ type: 'bar', data: [3,2,1] }, // becomes a bar
{ type: 'scatter', data: [{x:0,y:2},{x:2,y:3}], pointRadius: 5 } // scatter points
]
}
});Mehrere Y-Achsen (y, y1, y2)
Mehrere y-Achsen mit eigenen ids definieren (y, y1, y2) und datasets via yAxisID zuweisen. grid.drawOnChartArea:false verhindert, dass die zweite Achse gridlines über die erste zeichnet. position:'right' stapelt rechts; einer dritten Achse offset:true geben, damit sie die zweite nicht überlappt. Jede Achse passend zu ihrer series einfärben.
options: {
scales: {
y: { type: 'linear', position: 'left', title: { display: true, text: 'Price ($)' } },
y1: { type: 'linear', position: 'right', title: { display: true, text: 'Volume' }, grid: { drawOnChartArea: false } },
y2: { type: 'linear', position: 'right', offset: true, title: { display: true, text: '%' } }
}
}
// assign each dataset: yAxisID: 'y' | 'y1' | 'y2'Gemischte Daten mit verschiedenen Formen
Mixed charts können eine value-series (balken) mit Referenzlinien kombinieren (konstantes Ziel, trend). Auf den line-datasets pointRadius:0 und fill:false setzen, damit sie als reine Linien ohne Marker oder fills rendern. Dieses Muster ist bei performance-dashboards üblich (ist vs. soll).
new Chart(ctx, {
type: 'bar',
data: {
labels: ['Mon','Tue','Wed','Thu','Fri'],
datasets: [
{ type:'bar', label:'Tasks', data:[8,6,7,9,5], backgroundColor:'rgba(54,162,235,0.6)' },
{ type:'line', label:'Target',data:[7,7,7,7,7], borderColor:'red', borderWidth:2, pointRadius:0, fill:false },
{ type:'line', label:'Trend', data:[6,6.5,7,8,8.5], borderColor:'green', borderDash:[5,5], pointRadius:0, fill:false }
]
}
});Mixed-Styling-Tipps
In mixed charts dataset.order setzen, damit die Linie über den Balken zeichnet (niedrigere order = oben). ticks und title jeder Achse passend zu ihrer series einfärben, damit Leser wissen, welche scale zu welcher Linie gehört. Das grid der zweiten Achse abschalten (drawOnChartArea:false), um doppelte gridlines zu vermeiden.
// 1. assign order so lines draw on top of bars
datasets: [
{ type:'bar', data:[...], order: 2 },
{ type:'line', data:[...], order: 1 } // lower order draws later (on top)
]
// 2. give each axis a matching color
options: { scales: {
y: { ticks: { color: '#36A2EB' }, title: { text: 'Revenue', color: '#36A2EB' } },
y1: { ticks: { color: '#FF6384' }, title: { text: 'Growth', color: '#FF6384' }, position: 'right', grid: { drawOnChartArea: false } }
}}Plugins
Eingebaute plugins
Chart.js bringt drei eingebaute plugins mit: title (chart-Titel über dem canvas), legend (der dataset-Schlüssel) und tooltip (hover-Popups). Sie werden unter options.plugins nach ihrer id konfiguriert und sind per Default aktiviert (außer title, das display:true braucht, um seinen Text zu zeigen).
// three built-in plugins (always available):
// Legend -> options.plugins.legend
// Title -> options.plugins.title
// Tooltip -> options.plugins.tooltip
new Chart(ctx, {
type: 'line',
data: { /* ... */ },
options: {
plugins: {
title: { display: true, text: 'Sales 2024', font: { size: 18 } },
legend: { position: 'bottom' },
tooltip:{ mode: 'index', intersect: false }
}
}
});Eigenes inline-plugin
Ein Array von plugin-Objekten an ein einzelnes chart über die plugins-Option übergeben. Jedes plugin hat eine id und hook-Funktionen (beforeInit, afterInit, beforeDraw, afterDraw, beforeUpdate usw.). Inline-plugins gelten nur für diese chart-Instanz. ctx.save()/restore() um jede vorgenommene canvas-Zustandsänderung legen.
new Chart(ctx, {
type: 'line',
data: { /* ... */ },
options: { /* ... */ },
plugins: [{
id: 'centerText',
afterDraw(chart) {
const { ctx, chartArea } = chart;
ctx.save();
ctx.font = 'bold 24px Arial';
ctx.fillStyle = 'black';
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
ctx.fillText('Hello', (chartArea.left+chartArea.right)/2,
(chartArea.top+chartArea.bottom)/2);
ctx.restore();
}
}]
});plugin hooks (lifecycle)
Plugin-hooks laufen in jeder Phase des chart-Lebenszyklus: init, update, render, draw, resize, destroy. before*-hooks können eine Aktion durch Rückgabe von false abbrechen. Für eigenes Zeichnen am häufigsten afterDraw (über dem chart) oder beforeDraw (hinter den Daten). Jeder hook erhält die chart-Instanz.
const plugin = {
id: 'myHook',
beforeInit(chart) { console.log('before init'); },
afterInit(chart) { console.log('chart ready'); },
beforeUpdate(chart){ console.log('about to update'); },
beforeDraw(chart) { console.log('before draw'); },
afterDraw(chart) { console.log('after draw'); },
beforeRender(chart){ console.log('before first render'); },
resize(chart, size){ console.log('resized', size); },
destroy(chart) { console.log('destroyed'); }
};plugin: vertikale Linie am Index
Ein übliches eigenes plugin zeichnet eine vertikale Führungslinie an der tooltip-Position (wie der default-crosshair). afterDraw liest die x-Koordinate des aktiven tooltip-Elements und stroke't eine gestrichelte Linie von oben nach unten durch die chart area. Den canvas-Zustand in save()/restore() wickeln, damit der gestrichelte Stil nicht leakte.
const verticalLine = {
id: 'verticalLine',
afterDraw(chart) {
if (chart.tooltip?._active?.length) {
const x = chart.tooltip._active[0].element.x;
const { top, bottom } = chart.chartArea;
const ctx = chart.ctx;
ctx.save();
ctx.beginPath();
ctx.moveTo(x, top);
ctx.lineTo(x, bottom);
ctx.lineWidth = 1;
ctx.strokeStyle = 'gray';
ctx.setLineDash([4, 4]);
ctx.stroke();
ctx.restore();
}
}
};plugin: zentrierter Text für doughnut
Zentrierten summary text zu zeichnen ist der klassische Anwendungsfall eines doughnut-plugins. afterDatasetsDraw läuft nach den Sektoren, sodass der Text oben sitzt. Die Summe (oder jede summary) berechnen und im geometrischen Zentrum der chartArea rendern. So wird der doughnut zu einem informativen KPI-widget.
const centerText = {
id: 'centerText',
afterDatasetsDraw(chart) {
const { ctx, data } = chart;
const total = data.datasets[0].data.reduce((a,b)=>a+b, 0);
ctx.save();
ctx.font = 'bold 28px Arial';
ctx.fillStyle = '#333';
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
const { left, right, top, bottom } = chart.chartArea;
ctx.fillText(total, (left+right)/2, (top+bottom)/2);
ctx.restore();
}
};
new Chart(ctx, { type:'doughnut', data:{...}, plugins:[centerText] });plugin global registrieren
Chart.register(plugin) lässt ein plugin auf jedes danach erzeugte chart wirken — ideal für app-weite plugins wie watermarks, branding oder analytics. Für ein Einmal-chart stattdessen das inline-plugins-Array nutzen. Chart.unregister entfernt es. Registrierte plugins lesen ihre config aus options.plugins[id].
import { Chart } from 'chart.js';
const myPlugin = { id: 'watermark', afterDraw(chart) { /* ... */ } };
// register once -> applies to EVERY chart
Chart.register(myPlugin);
// or unregister later
Chart.unregister(myPlugin);
// per-chart-only: skip Chart.register and pass via options.plugins insteadupdate & destroy
chart.update()
Nach dem Verändern von chart.data oder chart.options chart.update() aufrufen, um neu zu rendern. Per Default animiert die Änderung vom vorigen Zustand. 'none' als mode übergeben, um die Animation zu überspringen (praktisch bei hochfrequenten Updates). Verändern und dann updaten ist deutlich billiger als destroy und Neuerzeugung des charts.
const chart = new Chart(ctx, config);
// mutate the data/config, then update:
chart.data.labels.push('Jun');
chart.data.datasets[0].data.push(28);
chart.options.scales.y.max = 50;
chart.update(); // animate to the new state
// chart.update('none'); // skip animationupdate modes
update(mode) nimmt einen mode-String, der das Verhalten steuert. 'none' schaltet die Animation ab für ein stilles refresh. 'reset' zurück zum vor-animierten Wert, dann erneut animieren (gut, um den Eingang zu wiederholen). 'active' aktualisiert nur hovered Elemente für günstige hover-Re-Renders. Der default (ohne Argument) animiert normal.
chart.update(); // default: animates the change
chart.update('none'); // no animation
chart.update('reset'); // reset to pre-animation state, then animate
chart.update('resize'); // re-compute layout (call after container resize)
chart.update('show'); // show currently-hidden dataset animations
chart.update('hide'); // hide dataset animations
chart.update('active'); // update only the active (hovered) elementsDaten & labels updaten
data/labels ganzheitlich ersetzen oder in place verändern (push/shift). Bei live-streaming charts (etwa einem 60-Sekunden-Fenster) den neuen Wert anhängen, den ältesten entfernen und update('none') für geschmeidiges nicht-animiertes refresh aufrufen — der default-animierte update bei jedem tick verursacht ruckelndes Nachziehen.
// replace the entire data array
chart.data.datasets[0].data = [5, 10, 15, 20];
chart.data.labels = ['A','B','C','D'];
chart.update();
// or append streaming data (and trim the oldest):
const arr = chart.data.datasets[0].data;
arr.push(newValue);
if (arr.length > 60) arr.shift();
chart.update('none'); // instant update for live datachart.destroy()
destroy() räumt das chart ab: es entfernt event listeners, bricht Animationen ab, leert das canvas und gibt Speicher frei. destroy immer aufrufen, wenn der container eines charts entfernt wird (React useEffect cleanup, routenwechsel). Fehlendes destroy leakst Speicher und kann beim Wiederverwenden eines canvas 'Canvas is already in use' werfen.
const chart = new Chart(ctx, config);
// when done (route change, component unmount, etc.):
chart.destroy();
// after destroy the canvas is free; a new Chart can reuse it:
const fresh = new Chart(ctx, newConfig);
// destroy also removes event listeners and frees memorychart.resize() & clear()
chart.resize() berechnet die chart-Größe neu — bei responsive:true passiert das automatisch beim window resize, manuelle Aufrufe sind also selten. chart.clear() leert das canvas, ohne das chart zu zerstören (das nächste update zeichnet neu). chart.resize(width, height) erzwingt konkrete Pixelmaße und übersteuert responsive sizing.
const chart = new Chart(ctx, config);
// manually trigger a resize (rarely needed; responsive:true auto-resizes)
chart.resize();
// clear the canvas (chart stays alive, just blank until next render):
chart.clear();
chart.draw(); // re-draw without recomputing layout
// resize the canvas to explicit dimensions:
chart.resize(800, 400);responsiv & devicePixelRatio
responsiver container
Für ein responsives chart das canvas in einen positionierten container mit expliziter width/height wickeln und responsive:true + maintainAspectRatio:false setzen. Das canvas füllt den container und rendert beim window resize neu. Ohne maintainAspectRatio:false hält das chart ein festes Seitenverhältnis und ignoriert die container-Höhe.
<!-- container controls the size -->
<div style="position: relative; width: 100%; height: 400px;">
<canvas id="c"></canvas>
</div>
<script>
new Chart(document.getElementById('c'), {
type: 'line',
data: { /* ... */ },
options: { responsive: true, maintainAspectRatio: false }
});
</script>maintainAspectRatio
maintainAspectRatio:true (Default) hält das canvas auf dem festen width/height-Verhältnis aus aspectRatio (Default 2 = 2:1). maintainAspectRatio:false gibt die Höhe an den container frei. pie/doughnut defaulten auf aspectRatio:1 (quadratisch), weil Kreise in einem breiten Rechteck falsch wirken.
// default: chart keeps a 2:1 (width:height) aspect ratio
options: { responsive: true, maintainAspectRatio: true, aspectRatio: 2 }
// let the container control height:
options: { responsive: true, maintainAspectRatio: false }
// square charts:
options: { responsive: true, maintainAspectRatio: true, aspectRatio: 1 }aspectRatio
aspectRatio = width / height. Bei maintainAspectRatio:true folgen die canvas-Maße diesem Verhältnis. Höheres Verhältnis (3-4) für breite dashboard-kacheln, niedrigeres (1-1.5) für hohe panels. pie/doughnut defaulten auf 1, weil Kreise ein quadratisches canvas brauchen, um nicht als Ellipsen zu wirken.
new Chart(ctx, {
type: 'bar',
data: { /* ... */ },
options: {
responsive: true,
maintainAspectRatio: true,
aspectRatio: 3 // width:height = 3:1 (wide, short chart)
}
});
// common ratios:
// 2 -> default for bar/line
// 1 -> pie/doughnut (square)
// 3 -> wide dashboards
// 16/9 -> video-likechart.resize() Methode
Chart.js lauscht bei responsive:true automatisch auf window resize events, aber layout-Änderungen aus CSS transitions, sidebar-toggles oder tab-wechseln feuern ggf. kein window resize. In diesen Fällen chart.resize() manuell aufrufen, nachdem sich die container-Größe stabilisiert hat (etwa in einem setTimeout oder transitionend handler).
const chart = new Chart(ctx, { /* responsive: true */ });
// manually trigger a re-layout (e.g. after a sidebar collapses)
window.dispatchEvent(new Event('resize'));
// or:
chart.resize();
// explicit size:
chart.resize(600, 300);devicePixelRatio (scharfes rendering)
devicePixelRatio skaliert den canvas-backing store, damit Linien auf high-DPI/retina displays scharf bleiben (default nutzt window.devicePixelRatio, meist 2 oder 3). Eine Obergrenze von 2 hält Text knackig und begrenzt die Pixel-Arbeit auf 3x-phones. 1 erzeugt unscharfe Ausgabe auf retina, maximiert aber die render-Geschwindigkeit.
// let Chart.js use the screen's full pixel density (default):
new Chart(ctx, { options: { devicePixelRatio: window.devicePixelRatio } });
// cap DPR for performance on retina displays (fewer pixels to render):
options: { devicePixelRatio: 2 }
// ignore DPR (renders at 1x — blurry on retina but fastest):
options: { devicePixelRatio: 1 }ResizeObserver-Muster
Ein ResizeObserver am chart-container erfasst Größenänderungen aus CSS flexbox/grid, einklappbaren sidebars und tab-wechseln, die window resize verpasst. Den observer disconnecten und im teardown chart.destroy() aufrufen, um Leaks zu verhindern. Das robusteste responsive Muster für komplexe layouts.
const canvas = document.getElementById('c');
const chart = new Chart(canvas, config);
// observe the CONTAINER, not the canvas:
const ro = new ResizeObserver(() => chart.resize());
ro.observe(canvas.parentElement);
// cleanup on destroy:
function teardown() {
ro.disconnect();
chart.destroy();
}Verwandte Chart.js-Snippets
Copy-paste ready code for common tasks.
Bar Chart
Vertical bar chart with custom colors and rounded corners.
Line Chart
Smooth line chart with fill, tension, and hover styling.
Pie Chart
Pie chart with per-slice colors and legend positioning.
Doughnut Chart
Doughnut chart with cutout control and centered title.
Radar Chart
Multi-series radar chart for comparing entities across dimensions.
Responsive Chart
Chart that fills its container with maintainAspectRatio disabled.
Options Configuration
Title, legend, axis formatting, animations, and live updates.
Tooltips
Custom-styled tooltips with title, label, and footer callbacks.
Was this helpful?