Einstieg
Setup & erstes Chart
ECharts wird auf einem DOM-Element mit expliziter width/height initialisiert. setOption konfiguriert das gesamte Chart. Apache ECharts (ehemals Baidu ECharts) ist eine der mächtigsten JS-Charting-Bibliotheken.
<!-- include ECharts -->
<script src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js"></script>
<div id="chart" style="width: 600px; height: 400px;"></div>
<script>
const chart = echarts.init(document.getElementById('chart'));
chart.setOption({
title: { text: 'Sales' },
xAxis: { data: ['Q1', 'Q2', 'Q3', 'Q4'] },
yAxis: {},
series: [{
type: 'bar',
data: [100, 200, 150, 300]
}]
});
</script>Init mit Theme & Renderer
init nimmt (dom, theme, opts). Der 'svg'-Renderer ist bei jedem Zoom schärfer und erzeugt für einfache Charts ein kleineres DOM, während 'canvas' bei großen Datensätzen schneller ist. devicePixelRatio steuert die Schärfe auf Retina. Beim Entfernen eines Charts immer dispose() aufrufen, um Speicher freizugeben.
// register a theme (defined elsewhere or imported)
echarts.registerTheme('myTheme', {
color: ['#5470c6', '#91cc75'],
backgroundColor: '#f5f5f5'
});
// renderer: 'canvas' (default, faster) or 'svg' (sharper, lighter)
const chart = echarts.init(document.getElementById('chart'), 'myTheme', {
renderer: 'svg',
devicePixelRatio: 2,
width: 800,
height: 600,
locale: 'EN'
});
// detached from DOM later
chart.dispose();Responsives Resize
ECharts skaliert nicht automatisch, wenn sich sein Container ändert — chart.resize() muss aufgerufen werden. ResizeObserver ist der moderne Weg, die Container-Größe zu beobachten (besser als window resize bei layout-getriebenen Änderungen). Beim Abbauen immer dispose(), um Leaks in SPAs zu verhindern.
const chart = echarts.init(document.getElementById('chart'));
chart.setOption({ /* ... */ });
// resize when window changes
window.addEventListener('resize', () => chart.resize());
// or observe the container
const ro = new ResizeObserver(() => chart.resize());
ro.observe(document.getElementById('chart'));
// resize with explicit size
chart.resize({ width: 500, height: 300, silent: false });
// cleanup
window.addEventListener('unload', () => chart.dispose());setOption-Merge-Modi
Standardmäßig mergt setOption neue Optionen tief in bestehende — einzelne Teile lassen sich also aktualisieren. notMerge: true ersetzt die ganze Option (praktisch, wenn sich die series-Zahl ändert). replaceMerge zielt auf konkrete Komponententypen (series, xAxis) für partielle Ersetzung. lazyUpdate batcht mehrere setOption-Aufrufe zu einem Rendervorgang.
const chart = echarts.init(document.getElementById('chart'));
// merge (default): deep-merges with existing option
chart.setOption({ xAxis: { data: ['A', 'B'] } });
// notMerge: replace entire option (old config discarded)
chart.setOption({ xAxis: { data: ['X', 'Y'] } }, { notMerge: true });
// replaceMerge: replace specific component types only
chart.setOption(
{ series: [{ type: 'bar', data: [5, 6] }] },
{ replaceMerge: ['series'] }
);
// lazyUpdate: batch updates, apply on next frame
chart.setOption({ series: [{ data: [1, 2] }] }, { lazyUpdate: true });Lebenszyklus: getInstanceByDom & dispose
init auf einem DOM, das schon ein Chart hat, wirft. Vorher mit getInstanceByDom prüfen. dispose() gibt Speicher frei und entfernt das Chart; das DOM-Element bleibt. Das Attribut _echarts_instance_ markiert Chart-Container — danach suchen, um verwaiste Charts zu finden und aufzuräumen. In Framework-unmount-Hooks immer disposen.
function mountChart(dom) {
// avoid double-init on the same DOM node
const existing = echarts.getInstanceByDom(dom);
if (existing) return existing;
const chart = echarts.init(dom);
chart.setOption({ /* ... */ });
return chart;
}
// in a framework cleanup (React useEffect / Vue onUnmounted):
function unmount(dom) {
const chart = echarts.getInstanceByDom(dom);
if (chart) chart.dispose(); // free memory + remove DOM
}
// dispose all charts on a page
echarts.disposeAll?.(); // not built-in; iterate manually
Array.from(document.querySelectorAll('[_echarts_instance_]'))
.forEach(dom => echarts.dispose(dom));Balkendiagramme
Einfacher Balken
Ein Balkendiagramm braucht eine category-xAxis und eine value-yAxis. Jeder series.data-Wert mappt auf eine Kategorie. itemStyle steuert das Balken-Aussehen. Vertikale Balken: category-Achse auf x; horizontale Balken: x- und y-Achsentypen tauschen.
chart.setOption({
xAxis: {
type: 'category',
data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri']
},
yAxis: { type: 'value' },
series: [{
type: 'bar',
data: [120, 200, 150, 80, 70],
itemStyle: { color: '#5470c6' }
}]
});Gruppierte & gestapelte Balken
Mehrere bar-series mit derselben xAxis sind per Default gruppiert. Zum Stapeln bekommt jede series denselben stack-Namen. Stapeln akkumuliert Werte pro Kategorie. stack: 'total' auf allen series setzen, die zusammenstapeln sollen — series ohne stack-Namen gruppieren weiter.
chart.setOption({
xAxis: { type: 'category', data: ['Q1', 'Q2', 'Q3', 'Q4'] },
yAxis: { type: 'value' },
// GROUPED: multiple series render side by side
series: [
{ type: 'bar', name: 'A', data: [10, 20, 30, 40] },
{ type: 'bar', name: 'B', data: [15, 25, 35, 45] }
]
});
// STACKED: add stack with same name to each series
chart.setOption({
series: [
{ type: 'bar', name: 'A', stack: 'total', data: [10, 20, 30, 40] },
{ type: 'bar', name: 'B', stack: 'total', data: [15, 25, 35, 45] }
]
});Horizontaler Balken
Ein horizontaler Balken ist einfach ein Balkendiagramm mit category-Achse auf yAxis und value-Achse auf xAxis. Labels mit position: 'right' sitzen am Balkenende. Horizontale Balken sind besser bei langen Kategorienamen oder vielen Kategorien — sie vermeiden gedrehte Labels.
chart.setOption({
// swap: category axis becomes yAxis
yAxis: {
type: 'category',
data: ['Apple', 'Banana', 'Cherry', 'Date']
},
xAxis: { type: 'value' },
series: [{
type: 'bar',
data: [120, 200, 150, 80],
label: {
show: true,
position: 'right' // label at end of bar
}
}]
});Balken mit Hintergrund & runden Ecken
showBackground zeichnet eine Spur hinter jedem Balken (Fortschrittsbalken-Stil). itemStyle.borderRadius rundet Balkenecken — für vertikale Balken [topLeft, topRight, bottomRight, bottomLeft]; horizontal in umgekehrter Reihenfolge. borderRadius kann eine Zahl (alle Ecken) oder ein Array sein.
chart.setOption({
xAxis: { type: 'category', data: ['A', 'B', 'C', 'D'] },
yAxis: { type: 'value' },
series: [{
type: 'bar',
data: [50, 80, 60, 90],
showBackground: true,
backgroundStyle: {
color: 'rgba(180, 180, 180, 0.2)',
borderRadius: [4, 4, 0, 0]
},
itemStyle: {
borderRadius: [8, 8, 0, 0] // round top corners
}
}]
});Balken-Race (dynamisch)
Ein bar race animiert das Umordnen. Das Daten-Array sortieren, dann yAxis-Kategorien und series-Daten aktualisieren. animationDurationUpdate steuert die Übergangs-Smoothness. yAxis.inverse: true setzt den größten Wert nach oben. Beliebt für animierte Data-Stories.
const data = [
{ name: 'A', value: 10 },
{ name: 'B', value: 20 }
];
chart.setOption({
xAxis: { type: 'value', max: 100 },
yAxis: { type: 'category', inverse: true },
series: [{
type: 'bar',
data: data.map(d => ({ value: d.value, name: d.name })),
label: { show: true, position: 'right' },
// sort bars by value on each update
animationDuration: 500,
animationDurationUpdate: 500
}]
});
// update data on interval
setInterval(() => {
data.forEach(d => d.value += Math.random() * 10);
data.sort((a, b) => b.value - a.value);
chart.setOption({
yAxis: { data: data.map(d => d.name) },
series: [{ data: data.map(d => d.value) }]
});
}, 1000);Balkenbreite & Abstand
barWidth akzeptiert Pixel oder Prozent der category band. barGap ist der Abstand zwischen Balken innerhalb einer Gruppe (zählt nur bei mehreren series). barCategoryGap ist der Abstand zwischen Gruppen. Prozentangaben beziehen sich auf die category band und bleiben daher beim Resize proportional.
chart.setOption({
xAxis: { type: 'category', data: ['A', 'B', 'C', 'D'] },
yAxis: { type: 'value' },
series: [{
type: 'bar',
data: [50, 80, 60, 90],
barWidth: '40%', // width of each bar
barGap: '20%', // gap between bars in same group
barCategoryGap: '40%', // gap between category groups
// fixed pixel width also works:
// barWidth: 30
}]
});Liniendiagramme
Einfache Linie
Ein Liniendiagramm nutzt type: 'line'. Punkte erscheinen per Default mit symbol-Markern; symbol: 'none' versteckt sie. Die Linie verbindet Punkte in Datenreihenfolge. Für Zeitreihen type: 'time' auf der xAxis mit [timestamp, value]-Paaren nutzen.
chart.setOption({
xAxis: { type: 'category', data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'] },
yAxis: { type: 'value' },
series: [{
type: 'line',
data: [120, 200, 150, 80, 70],
symbol: 'circle', // point marker
symbolSize: 8
}]
});Glatte Linie & Fläche
smooth: true krümmt die Linie (Catmull-Rom-Interpolation). areaStyle füllt die Fläche unter der Linie; ein Gradient (lineare Farbstufen) verleiht einen ausklingenden Look. boundaryGap: false auf der category-Achse startet die Linie an der y-Achsen-Kante statt Lücke zu lassen.
chart.setOption({
xAxis: { type: 'category', boundaryGap: false, data: ['Mon','Tue','Wed','Thu','Fri'] },
yAxis: { type: 'value' },
series: [{
type: 'line',
data: [120, 200, 150, 80, 70],
smooth: true, // curved line
areaStyle: { // fill under line
color: {
type: 'linear',
x: 0, y: 0, x2: 0, y2: 1,
colorStops: [
{ offset: 0, color: 'rgba(84,112,198,0.5)' },
{ offset: 1, color: 'rgba(84,112,198,0.05)' }
]
}
}
}]
});Multi-Series-Linie
Mehrere series rendern als getrennte Linien, unterscheidbar per Farbe. Die legend togglet die Sichtbarkeit. lineStyle.type akzeptiert 'solid', 'dashed', 'dotted'. Jede series kann ihren eigenen Stil haben. Der legend-Name muss series.name entsprechen.
chart.setOption({
legend: { data: ['Email', 'Search'] },
xAxis: { type: 'category', data: ['Mon','Tue','Wed','Thu','Fri'] },
yAxis: { type: 'value' },
series: [
{
type: 'line',
name: 'Email',
data: [120, 132, 101, 134, 90],
lineStyle: { width: 3, type: 'solid' }
},
{
type: 'line',
name: 'Search',
data: [220, 182, 191, 234, 290],
lineStyle: { width: 2, type: 'dashed' }
}
]
});Gestapelte Fläche
Gestapelte Flächendiagramme nutzen type: 'line' mit gleichem stack-Namen und einem areaStyle. Jede series stapelt auf der vorigen. emphasis.focus: 'series' hebt die ganze series beim Hover hervor. Nützlich, um Zusammensetzung über Zeit zu zeigen (z. B. Traffic nach Quelle).
chart.setOption({
xAxis: { type: 'category', boundaryGap: false, data: ['Mon','Tue','Wed','Thu','Fri'] },
yAxis: { type: 'value' },
series: [
{
type: 'line',
name: 'A',
stack: 'total',
areaStyle: {},
data: [120, 132, 101, 134, 90],
emphasis: { focus: 'series' }
},
{
type: 'line',
name: 'B',
stack: 'total',
areaStyle: {},
data: [220, 182, 191, 234, 290]
}
]
});Stufenlinie
step macht aus einer Linie eine Treppe. 'start' stuft vor dem Punkt, 'middle' (symmetrisch) am Punkt, 'end' danach. Stufendiagramme passen zu diskret ändernden Werten (Lagerbestände, Serverstatus) statt kontinuierlichen.
chart.setOption({
xAxis: { type: 'category', data: ['Mon','Tue','Wed','Thu','Fri'] },
yAxis: { type: 'value' },
series: [{
type: 'line',
data: [120, 200, 150, 80, 70],
step: 'middle', // 'start' | 'middle' | 'end'
symbol: 'none',
lineStyle: { width: 2 }
}]
});Linie mit Zeitachse
Mit type: 'time' formatiert die Achse Daten automatisch und behandelt unregelmäßige Intervalle. Datenpunkte sind [timestamp, value]-Paare. ECharts verteilt Punkte nach tatsächlicher Zeit, sodass Datenlücken korrekt erscheinen. Die richtige Wahl für Zeitreihen mit wechselnden Intervallen.
chart.setOption({
xAxis: { type: 'time' }, // auto-parses timestamps
yAxis: { type: 'value' },
series: [{
type: 'line',
data: [
[new Date('2024-01-01').getTime(), 100],
[new Date('2024-01-02').getTime(), 200],
[new Date('2024-01-05').getTime(), 150],
[new Date('2024-01-10').getTime(), 300]
],
smooth: true
}]
});Kreisdiagramme
Einfacher Kreis
Kreisdiagramme nutzen keine Achsen — series.data ist ein Array aus {value, name}. radius steuert die Kreisgröße als Prozent der kleineren Container-Dimension. emphasis-Stile greifen beim Hover. Die legend leitet Labels automatisch aus data.name ab.
chart.setOption({
series: [{
type: 'pie',
radius: '60%', // radius of pie
data: [
{ value: 1048, name: 'Search' },
{ value: 735, name: 'Direct' },
{ value: 580, name: 'Email' },
{ value: 484, name: 'Union' },
{ value: 300, name: 'Video' }
],
emphasis: {
itemStyle: {
shadowBlur: 10,
shadowOffsetX: 0,
shadowColor: 'rgba(0,0,0,0.5)'
}
}
}]
});Doughnut (Ring)
radius auf [inner, outer] setzt erzeugt einen Doughnut. Ein Zentrums-Label ist ein übliches Muster (Gesamtsumme oder KPI zeigen). avoidLabelOverlap: false lässt Labels, wo sie sind. Der innere Radius steuert die Ringdicke — [50%, 70%] ist ein dünner Ring; [0%, 70%] ein voller Kreis.
chart.setOption({
series: [{
type: 'pie',
radius: ['40%', '70%'], // [inner, outer] = ring
avoidLabelOverlap: false,
label: {
show: true,
position: 'center', // center label
formatter: 'Total\n{c}'
},
data: [
{ value: 1048, name: 'A' },
{ value: 735, name: 'B' },
{ value: 580, name: 'C' }
]
}]
});Rose (Nightingale)
roseType macht den Sektionsradius zum Wert proportional (Nightingale-Rose). 'area' nutzt sqrt(value) für den Radius (flächengerecht), 'radius' direkt den Wert. Jede Sektion hat denselben Winkel, aber anderen Radius. Gut, um Größenordnungen zu vergleichen, die per Winkel schwer zu beurteilen sind.
chart.setOption({
series: [{
type: 'pie',
radius: ['10%', '70%'],
roseType: 'area', // or 'radius'
data: [
{ value: 40, name: 'A' },
{ value: 38, name: 'B' },
{ value: 32, name: 'C' },
{ value: 30, name: 'D' },
{ value: 28, name: 'E' }
],
label: { show: true }
}]
});Kreis mit eigenen Labels
label.formatter unterstützt Template-Variablen: {a} (series-Name), {b} (Datenname), {c} (Wert), {d} (Prozent). labelLine steuert die Verbindungslinie. length ist das Segment nahe der Sektion, length2 das nahe dem Label. Eigene Labels machen Kreisdiagramme deutlich lesbarer.
chart.setOption({
series: [{
type: 'pie',
radius: '60%',
label: {
formatter: '{b}: {d}%', // name: percentage
color: '#333',
fontSize: 14
},
labelLine: {
show: true,
length: 15, // first segment
length2: 20, // second segment
smooth: true
},
data: [
{ value: 1048, name: 'Search' },
{ value: 735, name: 'Direct' }
]
}]
});Halbkreis-Diagramm
startAngle und endAngle kombiniert erzeugen Teil-Kreise (Halb-, Viertel-, gauge-artig). center positioniert den Kreis — ['50%','70%'] schiebt ihn nach unten, damit ein 180°-Kreis unten sitzt. Teil-Kreise dienen oft als Gauges oder stilisierte Dashboards.
chart.setOption({
series: [{
type: 'pie',
radius: ['40%', '70%'],
center: ['50%', '70%'], // move down
startAngle: 180, // start at left
endAngle: 360, // end at right -> semicircle
data: [
{ value: 60, name: 'A' },
{ value: 30, name: 'B' },
{ value: 10, name: 'C' }
]
}]
});Punktdiagramme
Einfaches Scatter
Scatter-Charts nutzen zwei value-Achsen; jeder Datenpunkt ist [x, y]. symbolSize steuert die Punktgröße (fix oder pro Punkt via Funktion). Scatter zeigt Korrelation zwischen zwei Variablen. Beide Achsen sind type: 'value' (numerisch), anders als bei kategoriebasierten bar/line.
chart.setOption({
xAxis: { type: 'value' },
yAxis: { type: 'value' },
series: [{
type: 'scatter',
symbolSize: 12,
data: [
[10, 20], [15, 25], [20, 30], [25, 35],
[30, 40], [35, 45], [40, 50], [45, 55]
],
itemStyle: { color: '#5470c6' }
}]
});Blasendiagramm (Größe nach Wert)
Ein bubble chart ist ein scatter, bei dem die Punktgröße eine dritte Dimension kodiert. Pro Punkt [x, y, size] übergeben und symbolSize auf eine Funktion setzen, die die Größe liefert. Die Funktion läuft pro Punkt, also skalieren Blasen unabhängig. Nützlich für 3-Variable-Daten ohne 3D-Chart.
chart.setOption({
xAxis: { type: 'value' },
yAxis: { type: 'value' },
series: [{
type: 'scatter',
// each point: [x, y, size]
data: [
[10, 20, 30],
[15, 25, 60],
[20, 30, 12],
[25, 35, 45]
],
symbolSize: function (data) {
return data[2]; // use 3rd element as size
}
}]
});Scatter mit visualMap (Farbe nach Wert)
visualMap mappt eine Daten-Dimension auf Farbe. dimension: 2 färbt nach dem 3. Element (Index 2) jedes Punkts. inRange.color definiert den Gradient. Das ergibt eine vierte Dimension (Farbe) im scatter. Die visualMap-Komponente zeigt die legende mit einem slider.
chart.setOption({
xAxis: { type: 'value' },
yAxis: { type: 'value' },
visualMap: {
min: 0,
max: 100,
dimension: 2, // map color to 3rd element
inRange: { color: ['#50a3ba', '#eac736', '#d94e5d'] },
right: 10,
top: 'center'
},
series: [{
type: 'scatter',
data: [[10,20,30], [15,25,60], [20,30,12]],
symbolSize: 15
}]
});effectScatter (animiert)
effectScatter ergänzt eine Ripple-Animation um jeden Punkt — großartig, um Schlüsseldatenpunkte hervorzuheben (alerts, Top-Städte). showEffectOn steuert, wann der Ripple spielt. brushType: 'stroke' ist leichter; 'fill' auffälliger. Sparsam einsetzen — zu viele Ripples lenken ab.
chart.setOption({
xAxis: { type: 'value' },
yAxis: { type: 'value' },
series: [{
type: 'effectScatter', // animated ripple
symbolSize: function (data) { return data[2]; },
data: [[10, 20, 30], [15, 25, 60]],
showEffectOn: 'render', // 'render' or 'emphasis'
rippleEffect: {
brushType: 'stroke', // 'stroke' or 'fill'
period: 4,
scale: 3
}
}]
});Großmaßstab-Scatter
Bei Tausenden Punkten progressives Rendering aktivieren — ECharts teilt Daten in chunks und rendert sie über Frames verteilt, um Einfrieren zu vermeiden. large: true nutzt einen einzigen optimierten draw call. Mit kleinem symbolSize und opacity kombinieren, um overplotting zu handhaben. So bleiben 50k+ Punkte geschmeidig.
// for thousands of points, use progressive rendering
chart.setOption({
xAxis: { type: 'value' },
yAxis: { type: 'value' },
series: [{
type: 'scatter',
data: largeDataArray, // 50k+ points
symbolSize: 3,
progressive: 2000, // chunk size for progressive render
progressiveThreshold: 5000, // enable above this count
large: true, // optimize for many points
largeThreshold: 2000,
itemStyle: { opacity: 0.6 }
}]
});Radar-Charts
Einfaches Radar
Radar-Charts brauchen ein radar.indicator-Array, das jede Achse definiert (name und max). Series-Daten sind ein Array von Werten passend zu den indicators. Radar vergleicht idealerweise mehrere Attribute weniger Items (Spielerstats, Produktvergleich). max setzt die Skala jeder Achse.
chart.setOption({
radar: {
indicator: [
{ name: 'Speed', max: 100 },
{ name: 'Power', max: 100 },
{ name: 'Range', max: 100 },
{ name: 'Comfort', max: 100 },
{ name: 'Price', max: 100 }
]
},
series: [{
type: 'radar',
data: [{ value: [85, 70, 90, 65, 80], name: 'Car A' }]
}]
});Multi-Series-Radar
Mehrere data-Einträge rendern überlappende Polygone — ideal für Vergleiche. Jeder Eintrag braucht einen einzigartigen name passend zur legende. Zu viele series (5+) machen Radar-Charts unlesbar — die Polygone verschmelzen zu einem Klecks. Für Klarheit bei 2-4 Items bleiben.
chart.setOption({
legend: { data: ['Car A', 'Car B'] },
radar: {
indicator: [
{ name: 'Speed', max: 100 },
{ name: 'Power', max: 100 },
{ name: 'Range', max: 100 }
]
},
series: [{
type: 'radar',
data: [
{ value: [85, 70, 90], name: 'Car A' },
{ value: [60, 95, 75], name: 'Car B' }
]
}]
});Radar mit Fläche
areaStyle füllt das radar-Polygon halbtransparent und macht die Form leichter lesbar. lineStyle betont den Umriss. areaStyle-Opacity niedrig halten (0.2-0.4), damit überlappende series sichtbar bleiben. Symbole markieren jeden vertex.
chart.setOption({
radar: {
indicator: [
{ name: 'A', max: 100 },
{ name: 'B', max: 100 },
{ name: 'C', max: 100 }
]
},
series: [{
type: 'radar',
data: [{ value: [85, 70, 90], name: 'Score' }],
areaStyle: { opacity: 0.3 },
lineStyle: { width: 2 },
symbol: 'circle',
symbolSize: 6
}]
});Radar-Form & Achse
shape: 'polygon' (Default) gibt eckige Achsen; 'circle' macht geschmeidige Ringe. splitNumber steuert die Gitterdichte. splitArea wechselt Farben für einen Zebra-Effekt. axisName stylt die Achsen-Labels. Diese Optionen steuern die visuelle Struktur, ohne Daten anzufassen.
chart.setOption({
radar: {
shape: 'polygon', // 'polygon' or 'circle'
radius: '65%',
splitNumber: 5, // grid ring count
axisName: {
color: '#333',
fontSize: 12
},
splitLine: { lineStyle: { color: '#ccc' } },
splitArea: {
areaStyle: { color: ['#fafafa', '#fff'] }
},
indicator: [
{ name: 'Speed', max: 100 },
{ name: 'Power', max: 100 }
]
},
series: [{ type: 'radar', data: [{ value: [80, 70] }] }]
});Radar polarer Radius
radius: [inner, outer] erzeugt ein ring-förmiges radar (wie ein doughnut). center positioniert das chart. min an einem indicator legt den Achsen-Start fest — nützlich, wenn alle Werte hoch sind (vermeidet ein winziges Polygon im Zentrum). center anpassen, um Raum für Achsen-Labels zu lassen.
chart.setOption({
radar: {
indicator: [
{ name: 'A', max: 100, min: 0 }, // min sets the inner bound
{ name: 'B', max: 100 },
{ name: 'C', max: 100 }
],
radius: ['20%', '70%'], // [inner, outer] for ring radar
center: ['50%', '55%']
},
series: [{
type: 'radar',
data: [{ value: [60, 70, 80] }]
}]
});Heatmaps
Kartesische Heatmap
Eine kartesische heatmap braucht eine visualMap zur Färbung der Zellen. Daten sind [x, y, value]. label: { show: true } druckt Werte in Zellen (nur für kleine Gitter gut). calculable: true ergänzt einen slider-Handle. Heatmaps offenbaren Dichtemuster (z. B. Aktivität je Stunde).
const hours = ['12a','1a','2a','3a','4a','5a','6a','7a','8a','9a','10a','11a'];
const days = ['Sat','Sun','Mon','Tue','Wed','Thu','Fri'];
// data: [x, y, value]
const data = [[0,0,5],[0,1,1],[1,0,8] /* ... */];
chart.setOption({
tooltip: {},
xAxis: { type: 'category', data: hours },
yAxis: { type: 'category', data: days },
visualMap: {
min: 0, max: 10,
calculable: true,
orient: 'horizontal',
left: 'center', bottom: '5%'
},
series: [{
type: 'heatmap',
data: data,
label: { show: true }
}]
});Kalender-Heatmap
Kalender-Heatmaps zeigen Tageswerte über ein Jahr (GitHub-artiger Beitragsgraph). calendar.range setzt das Jahr oder den Datumsbereich. Datenpunkte sind [dateString, value]. Der visualMap-Gradient definiert Farbstufen. cellSize steuert die Quadratgröße — 'auto' füllt den Container.
const data = [];
// generate one year of data
for (let i = 0; i < 365; i++) {
const date = new Date(2024, 0, 1);
date.setDate(date.getDate() + i);
data.push([date.toISOString().slice(0,10), Math.floor(Math.random() * 100)]);
}
chart.setOption({
tooltip: {},
visualMap: {
min: 0, max: 100,
inRange: { color: ['#ebedf0', '#c6e48b', '#7bc96f', '#239a3b', '#196127'] }
},
calendar: {
range: '2024',
cellSize: ['auto', 13],
yearLabel: { show: true }
},
series: [{ type: 'heatmap', data: data }]
});Heatmap-Item-Stil
itemStyle.borderColor und borderWidth erzeugen einen Gittertrenner-Effekt (weiße Rahmen machen Zellen unterscheidbar). borderRadius rundet Zell-Ecken. emphasis-Stile greifen beim Hover. Eine versteckte visualMap (show: false) treibt weiterhin Farben, ohne die legende zu zeigen.
chart.setOption({
xAxis: { type: 'category', data: ['A','B','C','D'] },
yAxis: { type: 'category', data: ['X','Y','Z'] },
visualMap: { min: 0, max: 100, show: false },
series: [{
type: 'heatmap',
data: [[0,0,80],[0,1,30],[1,0,50]],
itemStyle: {
borderColor: '#fff', // white grid lines
borderWidth: 2,
borderRadius: 4
},
emphasis: {
itemStyle: { shadowBlur: 10 }
}
}]
});Punch-Card-Heatmap
Eine punch card ist eine 7x24-Heatmap, die Aktivität nach Wochentag und Stunde zeigt. Jede Zelle ist ein Zeitslot. Der abgerundete itemStyle lässt es wie Punkte aussehen. Punch cards offenbaren Wochenmuster (z. B. wann ein Server am beschäftigsten ist). Die Daten sind ein vollständiges 168-Zellen-Gitter.
const data = [];
for (let day = 0; day < 7; day++) {
for (let hour = 0; hour < 24; hour++) {
data.push([hour, day, Math.floor(Math.random() * 50) + 1]);
}
}
chart.setOption({
xAxis: { type: 'category', data: Array.from({length:24}, (_,i) => i + 'h') },
yAxis: { type: 'category', data: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'] },
visualMap: { max: 50, inRange: { color: ['#fff', '#5470c6'] } },
series: [{
type: 'heatmap',
data: data,
itemStyle: { borderRadius: 10, borderWidth: 2, borderColor: '#fff' }
}]
});Heatmap auf Geo-Karte
geo mit einer map-series kombiniert färbt Regionen nach Wert. visualMap treibt die Farbskala. Zuerst eine map via echarts.registerMap('china', geoJson) registrieren. roam: true aktiviert pan/zoom. So entstehen choropleth- (Farbe-je-Region-)Karten.
// requires a registered geo map (e.g. echarts.registerMap)
chart.setOption({
geo: { map: 'china', roam: true },
visualMap: {
min: 0, max: 1000,
inRange: { color: ['#e0ecf4', '#005824'] }
},
series: [{
type: 'map',
map: 'china',
data: [
{ name: 'Beijing', value: 800 },
{ name: 'Shanghai', value: 950 }
]
}]
});Baum-Charts
Einfacher Baum (vertikal)
Baum-Charts rendern hierarchische Daten. layout: 'orthogonal' mit orient: 'LR' macht einen links-nach-rechts-Baum. expandAndCollapse erlaubt Klick zum Auf-/Zuklappen von Teilbäumen. leaves konfiguriert den Stil von Blattknoten. Tree ist perfekt für Organigramme, Dateibäume und Taxonomien.
const data = {
name: 'Root',
children: [
{
name: 'Child A',
children: [{ name: 'A1' }, { name: 'A2' }]
},
{
name: 'Child B',
children: [{ name: 'B1' }]
}
]
};
chart.setOption({
series: [{
type: 'tree',
data: [data],
top: '5%', left: '10%', bottom: '5%', right: '20%',
layout: 'orthogonal', // 'orthogonal' or 'radial'
orient: 'LR', // 'LR','RL','TB','BT'
symbolSize: 10,
label: { position: 'left' },
leaves: { label: { position: 'right' } },
expandAndCollapse: true,
animationDuration: 550
}]
});Horizontaler Baum
orient: 'LR' erzeugt einen horizontalen Baum (Wurzel links, Blätter rechts). Interne Knoten-Labels stehen LINKS vom Knoten; Blatt-Label RECHTS — das verhindert Überlappung mit Ästen. curveness am lineStyle erzeugt geschwungene Verbindungen für weicheres Aussehen.
chart.setOption({
series: [{
type: 'tree',
data: [treeData],
layout: 'orthogonal',
orient: 'LR', // left to right
symbol: 'emptyCircle',
symbolSize: 7,
label: { position: 'left', verticalAlign: 'middle', align: 'right' },
leaves: { label: { position: 'right', align: 'left' } },
lineStyle: { color: '#999', width: 1, curveness: 0.5 }
}]
});Radialer Baum
layout: 'radial' legt die Wurzel ins Zentrum und strahlt Kinder kreisförmig nach außen. Gut für große Bäume, wo ein horizontales Layout zu breit wäre. emphasis.focus: 'descendant' hebt beim Hover alle Nachfahren hervor und hilft beim Verfolgen von Ästen.
chart.setOption({
series: [{
type: 'tree',
data: [treeData],
layout: 'radial', // circular layout
symbol: 'circle',
symbolSize: 8,
label: {
position: 'inside',
rotate: 0
},
leaves: { label: { position: 'right' } },
emphasis: { focus: 'descendant' },
lineStyle: { curveness: 0.5 }
}]
});Baum mit eigenen Symbolen
symbol und symbolSize akzeptieren Funktionen zur Knoten-Anpassung. Hier sind interne Knoten (mit Kindern) größere Rechtecke, Blätter kleine Kreise. So unterscheidet man Hierarchie-Ebenen visuell. Mit orient: 'TB' kombinieren für ein klassisches top-down-Organigramm.
const treeData = {
name: 'CEO',
value: 'Boss',
children: [
{ name: 'VP Engineering', children: [{ name: 'Eng Lead' }] },
{ name: 'VP Sales', children: [{ name: 'Sales Lead' }] }
]
};
chart.setOption({
series: [{
type: 'tree',
data: [treeData],
symbol: function (params) {
// custom symbol per node
return params.data.children ? 'rect' : 'circle';
},
symbolSize: function (params) {
return params.data.children ? 15 : 8;
},
orient: 'TB',
label: { position: 'top', distance: 8 }
}]
});Baum auf-/zuklappen steuern
initialTreeDepth steuert, wie viele Ebenen anfangs offen sind (null = alle, 0 = nur Wurzel). Ein Klick auf einen Knoten mit Kindern togglest seinen Teilbaum. Das click-Ereignis erlaubt Reaktion auf Knotenauswahl — nützlich für drill-down-UIs. animationDurationUpdate glättet expand/collapse.
chart.setOption({
series: [{
type: 'tree',
data: [treeData],
expandAndCollapse: true,
initialTreeDepth: 2, // expand first 2 levels
collapse: 'collapseBtn',
symbol: 'circle',
animationDurationUpdate: 750
}]
});
// programmatic control via API
chart.on('click', function (params) {
if (params.componentType === 'series') {
console.log('Node clicked:', params.data.name);
console.log('Collapsed:', params.data.collapsed);
}
});Sunburst-Charts
Einfaches Sunburst
Sunburst ist ein radialer Baum, bei dem jeder Ring eine Hierarchie-Ebene repräsentiert. Innen = Parent, außen = Kinder. Der Wert jedes Knotens treibt seine Winkelgröße. radius: [0, '90%'] macht eine volle Scheibe; [inner, outer] einen Ring-Sunburst. Ideal für hierarchische Proportionsvisualisierung.
const data = [{
name: 'Root',
children: [
{
name: 'A',
value: 15,
children: [{ name: 'A1', value: 5 }, { name: 'A2', value: 10 }]
},
{
name: 'B',
value: 20,
children: [{ name: 'B1', value: 20 }]
}
]
}];
chart.setOption({
series: [{
type: 'sunburst',
data: data,
radius: [0, '90%'],
label: { rotate: 'radial' }
}]
});Sunburst mit Levels
levels konfiguriert jeden Ring einzeln — der erste Eintrag ist die Wurzel, weitere mappen auf tiefere Ebenen. r0/r setzen inneren/äußeren Radius dieser Ebene. Verschiedene Label-Rotationen (radial, tangential, 0) halten Text in jeder Tiefe lesbar. So hat man feingranulare Stil-Kontrolle.
chart.setOption({
series: [{
type: 'sunburst',
data: sunburstData,
radius: ['15%', '90%'],
levels: [
{}, // root level (default)
{
r0: '15%',
r: '45%',
label: { rotate: 0, fontSize: 14 },
itemStyle: { borderWidth: 2 }
},
{
r0: '45%',
r: '70%',
label: { rotate: 'tangential', fontSize: 12 }
},
{
r0: '70%',
r: '90%',
label: { rotate: 'radial', fontSize: 10 }
}
]
}]
});Sunburst-Item-Stil & Highlight
emphasis.focus: 'ancestor' hebt den Pfad vom hovered Knoten zurück zur Wurzel hervor — Nutzer sehen, wo eine Scheibe in der Hierarchie sitzt. borderWidth trennt Scheiben visuell. Sunburst ist interaktiv: Klicken drillt meist nach unten. Ancestor-Highlighting nutzen, um bei tiefen Bäumen den Kontext zu halten.
chart.setOption({
series: [{
type: 'sunburst',
data: data,
itemStyle: {
borderColor: '#fff',
borderWidth: 1
},
emphasis: {
focus: 'ancestor' // highlight ancestors on hover
},
highlight: {
itemStyle: { color: '#ffb' }
}
}]
});Sunburst mit Wert & Sortierung
sort steuert die Scheiben-Reihenfolge innerhalb eines Parents. nodeClick: 'zoomToNode' lässt ein Klick in diesen Teilbaum zoomen (ideal zum Erkunden). minAngle verbirgt Labels auf Scheiben unter 5 Grad und vermeidet Clutter. Der Wert von Parent-Knoten wird bei Weglassen automatisch aus Kindern summiert.
chart.setOption({
series: [{
type: 'sunburst',
data: [{
name: 'Root',
children: [
{ name: 'A', value: 30, children: [/* ... */] },
{ name: 'B', value: 70, children: [/* ... */] }
]
}],
nodeClick: 'zoomToNode', // click to zoom into subtree
sort: 'desc', // or 'asc', null
label: { minAngle: 5 } // hide labels on tiny slices
}]
});Sunburst-Drill-down
Eigene click-Handler erlauben eine eigene drill-down-UX. Die Daten mit dem geklickten Knoten ersetzen, um hineinzuzoomen. Eine Referenz auf den Parent behalten, wenn ein 'zurück'-Button gewünscht ist. Sunburst-Drill-down eignet sich exzellent, um tiefe Hierarchien zu erkunden, ohne den Bildschirm zu überfordern.
const data = [/* full tree */];
let currentRoot = data[0];
chart.setOption({
series: [{
type: 'sunburst',
data: data,
nodeClick: false
}]
});
chart.on('click', function (params) {
if (params.componentType === 'series' && params.data.children) {
// manually drill down
currentRoot = params.data;
chart.setOption({
series: [{ data: [currentRoot] }]
}, { notMerge: true });
}
});Sankey-Diagramme
Einfaches Sankey
Sankey zeigt Fluss zwischen Knoten. data sind die Knoten (mit Namen); links der Fluss (source, target, value). Die Breite jedes Links ist zum Wert proportional. emphasis.focus: 'adjacency' hebt beim Hover verbundene Knoten hervor. Ideal für Energie-, Geld- oder Nutzerfluss-Visualisierung.
chart.setOption({
series: [{
type: 'sankey',
data: [
{ name: 'Source A' },
{ name: 'Source B' },
{ name: 'Mid C' },
{ name: 'Sink D' }
],
links: [
{ source: 'Source A', target: 'Mid C', value: 5 },
{ source: 'Source B', target: 'Mid C', value: 3 },
{ source: 'Mid C', target: 'Sink D', value: 8 }
],
emphasis: { focus: 'adjacency' },
lineStyle: { color: 'gradient', curveness: 0.5 }
}]
});Sankey-Knoten-Level
levels stylt Knoten nach Tiefe (Spalte). lineStyle.color: 'source' färbt links passend zum source-Knoten; 'target' passend zum target; 'gradient' mischt. nodeAlign positioniert Knoten vertikal innerhalb einer Spalte. depth explizit setzen erzwingt Spalten-Platzierung und überschreibt das auto-layout.
chart.setOption({
series: [{
type: 'sankey',
data: [
{ name: 'A', depth: 0 },
{ name: 'B', depth: 1 },
{ name: 'C', depth: 2 }
],
links: [
{ source: 'A', target: 'B', value: 10 },
{ source: 'B', target: 'C', value: 10 }
],
levels: [
{ depth: 0, itemStyle: { color: '#fbb' }, lineStyle: { color: 'source' } },
{ depth: 1, itemStyle: { color: '#bfb' }, lineStyle: { color: 'target' } },
{ depth: 2, itemStyle: { color: '#bbf' } }
],
nodeAlign: 'justify' // 'left','right','justify'
}]
});Sankey-Knoten-Stil & Abstand
nodeWidth legt die Dicke der Knotenrechtecke fest. nodeGap steuert den vertikalen Abstand. Kleinere Abstände zeigen mehr Knoten, können aber überlappen. lineStyle.opacity macht Flüsse dezent, sodass Knoten hervorstehen. label.position: 'right' setzt Labels neben Knoten — üblich bei links-nach-rechts-Flüssen.
chart.setOption({
series: [{
type: 'sankey',
data: nodes,
links: links,
nodeWidth: 20, // width of each node rectangle
nodeGap: 10, // vertical gap between nodes
nodeAlign: 'justify',
label: {
fontSize: 12,
color: '#333',
position: 'right'
},
lineStyle: { opacity: 0.4 },
itemStyle: { borderWidth: 0 }
}]
});Sankey mit Kreislauf (Drain)
Echte Zyklen lassen ECharts-Sankey scheitern. Der Ausweg: einen rücklaufenden Knoten in getrennte 'in'- und 'out'-Knoten splitten (z. B. 'Recycle'), sodass der Fluss azyklisch wird. Das stellt Feedback-Loops visuell dar. Flusserhaltung immer prüfen: die Eingangssumme eines Knotens sollte der Ausgangssumme entsprechen.
// Sankey normally forbids cycles, but you can show feedback loops
// by splitting a node into two (in & out) with the same name suffix
chart.setOption({
series: [{
type: 'sankey',
data: [
{ name: 'Input' },
{ name: 'Process' },
{ name: 'Output' },
{ name: 'Recycle' }
],
links: [
{ source: 'Input', target: 'Process', value: 100 },
{ source: 'Process', target: 'Output', value: 80 },
{ source: 'Process', target: 'Recycle', value: 20 },
{ source: 'Recycle', target: 'Process', value: 20 }
],
emphasis: { focus: 'adjacency' }
}]
});Sankey-Interaktion
Sankey-click-Events unterscheiden Knoten von Kanten über dataType. Damit Detail-Panels bauen, die Fluss-Details zeigen. label.formatter: '{b}: {c}' zeigt Name und Wert. Der adjacency-Fokus hebt den vollen Pfad durch einen hovered Knoten hervor und offenbart Ursache-Wirkung-Ketten.
chart.setOption({
series: [{
type: 'sankey',
data: nodes,
links: links,
emphasis: {
focus: 'adjacency',
lineStyle: { opacity: 0.8 }
},
label: { formatter: '{b}: {c}' },
tooltip: { trigger: 'item' }
}]
});
chart.on('click', function (params) {
if (params.dataType === 'edge') {
console.log('Flow from', params.data.source, 'to', params.data.target);
console.log('Value:', params.data.value);
} else if (params.dataType === 'node') {
console.log('Node:', params.data.name);
}
});Trichterdiagramme
Einfacher Trichter
Ein funnel zeigt Stufen eines Prozesses, wobei jede Stufe weniger Elemente hat. sort: 'descending' (Default) setzt die größte Stufe nach oben. Daten sollten der Prozessreihenfolge folgen. Funnels passen perfekt zu Sales-Pipelines, Konversionsanalyse und Onboarding-Schritten.
chart.setOption({
series: [{
type: 'funnel',
data: [
{ value: 100, name: 'Visit' },
{ value: 75, name: 'Sign Up' },
{ value: 50, name: 'Trial' },
{ value: 25, name: 'Purchase' }
],
sort: 'descending' // 'descending','ascending','none'
}]
});Trichter mit Sortierung & Abstand
sort: 'ascending' invertiert den Trichter (kleinste oben, wie ein Wachstumsdiagramm). gap trennt Scheiben zur Lesbarkeit. funnelAlign positioniert Scheiben horizontal. minSize/maxSize begrenzen die Scheibenbreiten als Prozent, damit winzige Stufen sichtbar bleiben.
chart.setOption({
series: [{
type: 'funnel',
data: data,
sort: 'ascending', // smallest at top
gap: 4, // pixel gap between slices
funnelAlign: 'center', // 'left','center','right'
width: '60%',
minSize: '20%',
maxSize: '100%'
}]
});Trichter-Labels
position: 'inside' legt Labels auf die Scheiben; 'left'/'right' setzt sie mit Verbindungslinien nach außen (labelLine). formatter: '{b}: {c}' zeigt Name und Wert. Außen-Labels nutzen, wenn Scheiben für innen liegenden Text zu dünn sind. emphasis vergrößert das Label beim Hover.
chart.setOption({
series: [{
type: 'funnel',
data: data,
label: {
show: true,
position: 'inside', // 'inside','left','right'
formatter: '{b}: {c}'
},
labelLine: {
show: true,
length: 20,
lineStyle: { width: 1, type: 'solid' }
},
emphasis: {
label: { fontSize: 16 }
}
}]
});Trichter-Item-Stil
Item-Stil pro Scheibe überschreibt den Default-Farbzyklus. borderColor trennt Scheiben visuell. Auch color an einzelnen data-Items setzen. Für poliertes Aussehen eine sequenzielle Farbpalette nutzen (heller für frühe Stufen, dunkler für konvertierte), um die Trichter-Metapher zu verstärken.
chart.setOption({
series: [{
type: 'funnel',
data: [
{ value: 100, name: 'A', itemStyle: { color: '#5470c6' } },
{ value: 75, name: 'B', itemStyle: { color: '#91cc75' } },
{ value: 50, name: 'C', itemStyle: { color: '#fac858' } }
],
itemStyle: {
borderColor: '#fff',
borderWidth: 2,
borderRadius: 0
}
}]
});Vergleichstrichter
Mehrere funnel-series können nebeneinander sitzen für Periodenvergleich. Jeder series eigenes left/width geben, um sie zu positionieren. Ideal für A/B-Test-Visualisierung oder Jahres-übergreifenden Konversionsvergleich. Kontrastierende Farben pro series zur Unterscheidung.
chart.setOption({
series: [
{
type: 'funnel',
name: '2023',
data: [{ value: 100, name: 'A' }, { value: 40, name: 'B' }],
sort: 'descending',
left: '5%', width: '40%',
label: { position: 'inside' }
},
{
type: 'funnel',
name: '2024',
data: [{ value: 120, name: 'A' }, { value: 60, name: 'B' }],
sort: 'descending',
left: '55%', width: '40%',
label: { position: 'inside' }
}
]
});Gauge-Charts
Einfacher Gauge
Ein gauge zeigt einen einzelnen Wert auf einem Bogen. min/max setzen die Skala. progress zeigt einen farbigen Bogen bis zum Wert (mit axisLine als Spur). detail rendert den Wertetext im Zentrum. valueAnimation transitioniert die Zahl geschmeidig. Ideal für KPIs und Ein-Metrik-Dashboards.
chart.setOption({
series: [{
type: 'gauge',
min: 0,
max: 100,
progress: { show: true, width: 18 },
axisLine: { lineStyle: { width: 18 } },
detail: {
valueAnimation: true,
formatter: '{value}%'
},
data: [{ value: 70, name: 'Score' }]
}]
});Gauge mit pointer
Der pointer-Stil ist der klassische Gauge-Look. anchor ist die Zentrum-Nadel. Negative distance-Werte schieben Ticks/Labels nach innen (zum Zentrum). radius skaliert den ganzen gauge. pointer mit splitLine kombinieren, um ein physisches Instrument zu imitieren. Nützlich für ein analoges Gefühl.
chart.setOption({
series: [{
type: 'gauge',
radius: '60%',
min: 0, max: 100,
pointer: { show: true, length: '60%', width: 5 },
anchor: { show: true, size: 12, itemStyle: { color: '#333' } },
axisTick: { distance: -15, length: 5 },
splitLine: { distance: -20, length: 10 },
axisLabel: { distance: -25 },
data: [{ value: 42 }]
}]
});Gauge mit Farbbändern
axisLine.lineStyle.color akzeptiert ein Array aus [threshold, color]-Paaren für farbige Zonen (z. B. rot/gelb/grün für Risikostufen). Thresholds sind Bruchteile (0-1). Der Standardweg, 'safe/warning/danger'-Bereiche auf einem gauge zu zeigen. pointer oder progress-Bogen markieren den aktuellen Wert innerhalb dieser Zonen.
chart.setOption({
series: [{
type: 'gauge',
min: 0, max: 100,
axisLine: {
lineStyle: {
width: 20,
color: [
[0.3, '#fd666d'], // 0-30% red
[0.7, '#37a2da'], // 30-70% blue
[1, '#91cc75'] // 70-100% green
]
}
},
data: [{ value: 85 }]
}]
});Gauge mit mehreren pointers
Mehrere data-Einträge erzeugen mehrere pointers auf demselben gauge. Nützlich, um verwandte Metriken zu vergleichen (CPU vs. Memory vs. Disk). Jeder Wert animiert unabhängig. Die Zahl niedrig halten (max. 3-5), sonst wird der gauge unübersichtlich. Namen erscheinen als Labels nahe jedem pointer.
chart.setOption({
series: [{
type: 'gauge',
min: 0, max: 100,
data: [
{ value: 60, name: 'CPU' },
{ value: 40, name: 'Memory' },
{ value: 80, name: 'Disk' }
],
detail: { formatter: '{value}%' },
title: { fontSize: 14 }
}]
});Eigener Gauge (Runder Fortschritt)
startAngle/endAngle auf 360° setzen erzeugt einen kreisförmigen Fortschrittsring (wie ein Apple-Watch-Ring). pointer/Ticks/Labels verbergen gibt einen minimalistischen Look. roundCap rundet die Fortschrittsenden. Dieser Stil ist bei modernen Dashboards beliebt — ein gauge als Ring verkleidet.
chart.setOption({
series: [{
type: 'gauge',
startAngle: 90,
endAngle: -270, // full circle
pointer: { show: false },
progress: {
show: true,
overlap: false,
roundCap: true,
clip: false
},
axisLine: { lineStyle: { width: 20, color: [[1, 'rgba(0,0,0,0.1)']] } },
splitLine: { show: false },
axisTick: { show: false },
axisLabel: { show: false },
detail: {
valueAnimation: true,
offsetCenter: ['0%', '0%'],
fontSize: 30,
formatter: '{value}%'
},
data: [{ value: 65 }]
}]
});Koordinatensysteme
Mehrere X-Achsen
xAxis ist ein Array — jeder Eintrag ist eine eigene Achse. Series binden via xAxisIndex (0-basiert) an eine Achse. So zeigt ein Chart zwei Metriken mit verschiedenen Skalen oder Einheiten. position platziert Achsen oben/unten. Üblich bei Aktiencharts (Kurs + Volumen) oder Wetter (Temperatur + Luftfeuchte).
chart.setOption({
xAxis: [
{ type: 'category', data: ['A','B','C'], position: 'bottom' },
{ type: 'category', data: ['A','B','C'], position: 'top', axisLine: { onZero: false } }
],
yAxis: { type: 'value' },
series: [
{ type: 'line', data: [10, 20, 30], xAxisIndex: 0 },
{ type: 'line', data: [50, 60, 70], xAxisIndex: 1 }
]
});Doppelte Y-Achsen
Zwei y-Achsen (links und rechts) erlauben series mit verschiedenen Einheiten (z. B. Umsatz in $ vs. verkaufte Stücke). Jede series bindet via yAxisIndex an eine Achse. Die rechte Achsenlinie farblich an ihre series koppeln, damit Nutzer wissen, welche Linie zu welcher Achse liest. 3+ Achsen vermeiden — verwirrend.
chart.setOption({
xAxis: { type: 'category', data: ['Mon','Tue','Wed','Thu'] },
yAxis: [
{ type: 'value', name: 'Sales', position: 'left' },
{ type: 'value', name: 'Orders', position: 'right', axisLine: { lineStyle: { color: '#ee6666' } } }
],
series: [
{ type: 'bar', data: [200, 180, 250, 210], yAxisIndex: 0 },
{ type: 'line', data: [40, 35, 50, 42], yAxisIndex: 1, smooth: true }
]
});Polarkoordinaten
Polarkoordinaten nutzen angleAxis (um den Kreis) und radiusAxis (nach außen vom Zentrum). Series setzen coordinateSystem: 'polar'. startAngle: 90 legt 0° nach oben (Norden). Polar passt zu Richtungsdaten (wind rose), zyklischen Mustern oder rose/nightingale-Varianten.
chart.setOption({
polar: {},
angleAxis: {
type: 'category',
data: ['N','NE','E','SE','S','SW','W','NW'],
startAngle: 90
},
radiusAxis: { type: 'value' },
series: [{
type: 'bar',
data: [1, 2, 3, 4, 5, 6, 7, 8],
coordinateSystem: 'polar'
}]
});Kalender-Koordinaten
Das calendar-Koordinatensystem mappt Daten auf Zellen. Series mit coordinateSystem: 'calendar' binden daran. cellSize kann Pixel oder 'auto' sein. orient: 'horizontal' ist das übliche Wochen-Zeilen-Layout. dayLabel/monthLabel nameMap lokalisiert die Labels. Mit heatmap kombinieren für contribution graphs.
chart.setOption({
calendar: {
range: ['2024-01-01', '2024-12-31'],
cellSize: ['auto', 15],
left: 50, right: 30,
orient: 'horizontal',
dayLabel: { nameMap: 'en' },
monthLabel: { nameMap: 'en' },
yearLabel: { show: false }
},
series: [{
type: 'heatmap',
coordinateSystem: 'calendar',
data: calendarData
}]
});Parallele Koordinaten
Parallele Koordinaten plotten multidimensionale Daten mit einer Achse je Dimension. Jede Datenzeile wird zu einer Polylinie, die alle Achsen kreuzt. Das offenbart Korrelationen und Cluster in hochdimensionalen Daten (z. B. Autos über Preis, Laufleistung, Jahr, Sicherheit). Praktisch für Datenexploration.
chart.setOption({
parallelAxis: [
{ dim: 0, name: 'Price' },
{ dim: 1, name: 'Mileage' },
{ dim: 2, name: 'Year' },
{ dim: 3, name: 'Safety', type: 'category', data: ['Low','Med','High'] }
],
parallel: {
parallelAxisDefault: {
axisLine: { lineStyle: { color: '#999' } },
nameTextStyle: { color: '#333' }
}
},
series: [{
type: 'parallel',
data: [[20000, 30, 2020, 'High'], [25000, 25, 2021, 'Med']]
}]
});Geo-Karten-Setup
registerMap bindet ein GeoJSON an einen Namen zur Nutzung in geo- und map-series. roam aktiviert Maus-pan/zoom. itemStyle.areaColor füllt Regionen; borderColor umrandet sie. emphasis-Stile greifen beim Hover. geo allein zeigt eine Karte; mit einer map-series paaren, um Regionen nach Wert zu färben (choropleth).
// load a map GeoJSON (must be registered before use)
fetch('https://geo.datav.aliyun.com/areas_v3/bound/100000_full.json')
.then(r => r.json())
.then(geoJson => {
echarts.registerMap('china', geoJson);
chart.setOption({
geo: {
map: 'china',
roam: true, // pan & zoom
zoom: 1.2,
label: { show: false },
itemStyle: {
areaColor: '#eee',
borderColor: '#fff'
},
emphasis: {
label: { show: true },
itemStyle: { areaColor: '#f5f5f5' }
}
}
});
});Dataset
Einfaches dataset
dataset trennt Daten von series-Konfiguration. Die source ist ein 2D-Array (Kopfzeile zuerst). seriesLayoutBy: 'column' lässt jede series eine Spalte nehmen. encode mappt dataset-Spalten auf x/y. So entkoppelt man Daten von Darstellung — nützlich, wenn Daten über mehrere Charts geteilt werden.
chart.setOption({
dataset: {
source: [
['product', '2023', '2024'],
['Apple', 41, 56],
['Banana', 67, 28],
['Cherry', 89, 76]
]
},
xAxis: { type: 'category' },
yAxis: {},
series: [
{ type: 'bar', seriesLayoutBy: 'column', encode: { x: 'product', y: '2023' } },
{ type: 'bar', seriesLayoutBy: 'column', encode: { x: 'product', y: '2024' } }
]
});Dataset mit Objektzeilen
Die dataset-source kann ein Array von Objekten sein (Key-Value-Zeilen). dimensions deklariert optional Spalten (nützlich, wenn Zeilen Keys vermissen lassen). encode nutzt dimensions-Namen statt Indizes — lesbarer. Objektzeilen sind einfacher von Hand zu schreiben und selbstdokumentierender.
chart.setOption({
dataset: {
dimensions: ['product', 'count', 'score'],
source: [
{ product: 'Apple', count: 41, score: 90 },
{ product: 'Banana', count: 67, score: 75 },
{ product: 'Cherry', count: 89, score: 88 }
]
},
xAxis: { type: 'category' },
yAxis: {},
series: [
{ type: 'bar', encode: { x: 'product', y: 'count' } },
{ type: 'bar', encode: { x: 'product', y: 'score' } }
]
});Dataset-Transform (Filter/Sort)
Transforms verketten datasets: filter entfernt Zeilen, sort ordnet sie. Jeder transform liest aus fromDatasetId und exponiert ein neues dataset. Series binden via datasetId. Transforms erlauben abgeleitete Sichten aus einer Quelle ohne Datenkopie. Unterstützte transforms: filter, sort und eigene via registerTransform.
chart.setOption({
dataset: [
{
id: 'raw',
source: [
{ product: 'A', sales: 100 },
{ product: 'B', sales: 50 },
{ product: 'C', sales: 200 }
]
},
{
id: 'filtered',
fromDatasetId: 'raw',
transform: {
type: 'filter',
config: { and: [{ gte: { sales: 80 } }] }
}
},
{
id: 'sorted',
fromDatasetId: 'filtered',
transform: { type: 'sort', config: { order: 'desc', main: 'sales' } }
}
],
xAxis: { type: 'category' },
yAxis: {},
series: [{ type: 'bar', datasetId: 'sorted', encode: { x: 'product', y: 'sales' } }]
});Dataset-encode & dimensions
encode mappt dataset-Spalten (per Index oder Name) auf chart-Dimensionen. encode.tooltip listet Spalten, die im tooltip erscheinen. Hier dienen Spalten 0/1 der Position, 2 der Größe, 3 der Farbe (via itemStyle). Encoding macht dasselbe dataset über verschiedene Chart-Typen hinweg wiederverwendbar.
chart.setOption({
dataset: {
source: [
[10, 20, 30, 'red'],
[15, 25, 35, 'blue'],
[20, 30, 40, 'green']
]
},
xAxis: { type: 'value' },
yAxis: { type: 'value' },
series: [{
type: 'scatter',
encode: {
x: 0, // first column -> x
y: 1, // second column -> y
tooltip: [0, 1, 2] // show these in tooltip
},
symbolSize: function (d) { return d[2]; }
}]
});Dataset mit pie
Pie-Charts brauchen itemName- und value-Mappings via encode. Dasselbe dataset könnte ein bar-chart speisen (encode x:name, y:value) und ein pie mit anderen encodings. Das ist die Stärke von dataset: eine Quelle, mehrere Sichten. Der Chart-Typwechsel ändert nur series-Typ und encode.
chart.setOption({
dataset: {
source: [
{ name: 'Search', value: 1048 },
{ name: 'Direct', value: 735 },
{ name: 'Email', value: 580 }
]
},
series: [{
type: 'pie',
radius: '60%',
encode: { itemName: 'name', value: 'value' }
}]
});VisualMap
Kontinuierliche visualMap
Die kontinuierliche visualMap mappt einen numerischen Bereich auf Farbe (und optional Größe). inRange.color ist der Gradient (interpoliert). calculable: true ergänzt ziehbare Handles zum Filtern. orient und left/top positionieren sie. Die visualMap treibt die series-Farben — itemStyle.color nicht manuell setzen.
chart.setOption({
visualMap: {
type: 'continuous',
min: 0,
max: 100,
inRange: {
color: ['#50a3ba', '#eac736', '#d94e5d'],
symbolSize: [10, 50]
},
calculable: true, // show slider handles
orient: 'vertical',
left: 'left', top: 'bottom'
},
series: [{
type: 'scatter',
data: [[10,20,30], [50,60,80], [80,90,95]]
}]
});Piecewise visualMap
Die piecewise visualMap binnt Werte in diskrete Bereiche, jeder mit eigener Farbe. pieces definiert die bins (min/max/label/color). Klarer als ein Gradient bei kategorialen Buckets (z. B. niedrig/mittel/hoch Risiko). Praktisch für choropleth-Karten und kategorisierte scatter-plots.
chart.setOption({
visualMap: {
type: 'piecewise',
pieces: [
{ min: 0, max: 30, label: 'Low', color: '#91cc75' },
{ min: 30, max: 70, label: 'Mid', color: '#fac858' },
{ min: 70, max: 100, label: 'High', color: '#ee6666' }
],
orient: 'horizontal',
left: 'center', bottom: 10
},
series: [{
type: 'scatter',
data: data
}]
});Kategoriale visualMap
Die kategoriale visualMap mappt String-Kategorien auf Farben. categories listet die Werte; inRange.color die passenden Farben in Ordnung. dimension wählt, welche Datenspalte das Mapping treibt (Default 0). Ideal, wenn Daten ein kategoriales Attribut haben (z. B. priority, status), das farblich kodiert werden soll.
chart.setOption({
visualMap: {
type: 'piecewise',
categories: ['Low', 'Medium', 'High'],
inRange: { color: ['#91cc75', '#fac858', '#ee6666'] },
dimension: 2 // which data column to map
},
series: [{
type: 'scatter',
data: [
[10, 20, 'Low'],
[50, 60, 'Medium'],
[80, 90, 'High']
]
}]
});VisualMap inline & außerhalb des Bereichs
outOfRange stylt Datenpunkte außerhalb des gewählten visualMap-Bereichs (z. B. ausgegraut beim Filtern). controller stylt den slider selbst. Zieht ein Nutzer den slider zum Filtern, verblassen außerhalb liegende Punkte zu outOfRange.color. So wird die visualMap zum interaktiven Filter, nicht nur eine legende.
chart.setOption({
visualMap: {
min: 0, max: 100,
inRange: { color: ['#5470c6', '#91cc75'] },
outOfRange: { color: '#ccc', symbolSize: 5 }, // filtered out style
controller: {
inRange: { color: ['#5470c6', '#91cc75'] }
},
right: 10, top: 'center'
},
series: [{
type: 'scatter',
data: data
}]
});VisualMap über mehrere series
Per Default wirkt die visualMap auf alle series. Mit seriesIndex (Zahl oder Array) konkrete series zielen. So lässt sich eine series farblich kodieren, während andere unverändert bleiben — nützlich beim Vergleich eines hervorgehobenen Datensatzes gegen eine Referenz. Ein Chart kann sogar mehrere visualMaps für verschiedene series haben.
chart.setOption({
visualMap: {
min: 0, max: 100,
inRange: { color: ['#5470c6', '#91cc75', '#fac858'] }
},
series: [
{ type: 'scatter', name: 'A', data: dataA },
{ type: 'scatter', name: 'B', data: dataB }
]
});
// bind visualMap to specific series only
chart.setOption({
visualMap: { seriesIndex: 1 } // only affects second series
});Legend
Einfache legend
Die legend listet series-Namen zum Umschalten der Sichtbarkeit. data muss series.name entsprechen (oder automatisch abgeleitet sein). icon stylt den marker. Ein Klick auf ein legend-Item togglest seine series. Die legend aktualisiert sich automatisch, wenn series per setOption ergänzt/entfernt werden.
chart.setOption({
legend: {
data: ['Email', 'Search', 'Direct'],
show: true,
icon: 'roundRect', // 'circle','rect','roundRect','triangle','diamond','pin','arrow'
itemWidth: 20,
itemHeight: 14,
textStyle: { color: '#333', fontSize: 12 }
},
series: [
{ type: 'line', name: 'Email', data: [120, 200, 150] },
{ type: 'line', name: 'Search', data: [220, 180, 90] }
]
});Legend-Position & Layout
orient und top/left positionieren die legend. Übliche Layouts: top-center (Default), bottom-center, right-vertical. itemGap steuert den Abstand zwischen legend-Items. Ein dezenter Hintergrund/Rahmen trennt die legend visuell vom chart. Die Position zählt — legends unten geben vertikalen Raum frei.
chart.setOption({
legend: {
orient: 'horizontal', // 'horizontal' or 'vertical'
top: 'top', // 'top','bottom','middle' or px
left: 'center', // 'left','center','right' or px
itemGap: 20, // gap between items
padding: 5,
backgroundColor: '#f5f5f5',
borderColor: '#ddd',
borderWidth: 1,
borderRadius: 4
},
series: [/* ... */]
});Legend-Auswahl & Default
selected steuert die anfängliche Sichtbarkeit. selectedMode: 'single' macht die legend zu radio buttons (nur eine series sichtbar). Das legendselectchanged-Ereignis feuert bei Nutzer-Toggles — praktisch, um Präferenzen zu persistieren oder mehrere charts zu synchronisieren. Default-Modus ist 'multiple'.
chart.setOption({
legend: {
selected: {
'Email': true, // visible by default
'Search': false, // hidden by default
'Direct': true
},
selectedMode: 'multiple' // 'single' or 'multiple'
},
series: [
{ type: 'line', name: 'Email', data: [120, 200, 150] },
{ type: 'line', name: 'Search', data: [220, 180, 90] },
{ type: 'line', name: 'Direct', data: [100, 90, 80] }
]
});
chart.on('legendselectchanged', function (params) {
console.log('Selected:', params.selected);
});Scrollbare legend
type: 'scroll' paginiert die legend bei zu vielen Items — page-Buttons erscheinen. Pflicht bei charts mit 10+ series, die sonst überlaufen würden. page-icon/text-Stile passen die Navigation an. Vertikale scroll-legends passen gut in den rechten Rand.
chart.setOption({
legend: {
type: 'scroll', // 'plain' (default) or 'scroll'
orient: 'vertical',
right: 10, top: 20, bottom: 20,
pageButtonItemStyle: { color: '#333' },
pageIconColor: '#5470c6',
pageIconInactiveColor: '#ccc',
pageTextStyle: { color: '#333' },
data: Array.from({length: 30}, (_, i) => 'Series ' + i)
},
series: [/* many series */]
});Legend-formatter & Rich Text
formatter passt legend-Labels an (z. B. Großbuchstaben, Zählungen ergänzen). Rich text erlaubt differentielles Styling von Label-Teilen — Stile in textStyle.rich definieren und im formatter mit {style|text}-Syntax referenzieren. So entstehen legends wie 'A {count|42}' mit gemischtem Styling.
chart.setOption({
legend: {
data: ['A', 'B'],
formatter: function (name) {
return name.toUpperCase();
},
textStyle: {
rich: {
a: { color: '#5470c6', fontSize: 14, fontWeight: 'bold' },
b: { color: '#91cc75', fontSize: 12 }
}
}
},
series: [/* ... */]
});
// legend can also show values via legendselectchanged + setOption
chart.on('legendselectchanged', () => {
// dynamic label updates
});Tooltip
Einfacher tooltip
trigger: 'item' zeigt den tooltip pro Datenpunkt (scatter, pie). 'axis' für die ganze Kategorie (bar, line). axisPointer zeichnet eine Führungslinie — 'shadow' ist ein durchscheinendes Band (gut für bars), 'line' eine dünne Linie (gut für Liniendiagramme), 'cross' zeigt beide, x- und y-Linien.
chart.setOption({
tooltip: {
trigger: 'axis', // 'item','axis','none'
show: true,
backgroundColor: 'rgba(50,50,50,0.9)',
borderColor: '#333',
borderWidth: 1,
padding: 10,
textStyle: { color: '#fff', fontSize: 13 },
axisPointer: { type: 'shadow' } // 'line','shadow','cross'
},
xAxis: { type: 'category', data: ['A','B','C'] },
yAxis: { type: 'value' },
series: [{ type: 'bar', data: [10, 20, 30] }]
});Tooltip-formatter
formatter passt den tooltip-Inhalt an. Eine Funktion erhält params (mit name, value, seriesName, color usw.) und gibt HTML zurück. String-Templates nutzen {a} (series-Name), {b} (Kategorie/x), {c} (Wert), {d} (pie-Prozent). Bei Multi-Series-Achsen-tooltips ist params ein Array — iterieren.
chart.setOption({
tooltip: {
trigger: 'item',
formatter: function (params) {
// params has: name, value, seriesName, color, dataIndex, ...
return '<b>' + params.name + '</b><br/>' +
'Value: ' + params.value + '<br/>' +
'Series: ' + params.seriesName;
}
},
series: [{ type: 'pie', data: [/* ... */] }]
});
// string template form (for axis trigger)
chart.setOption({
tooltip: {
trigger: 'axis',
formatter: '{a}: {b} = {c}' // a=series, b=category, c=value
}
});Tooltip-Crosshairs & axis pointer
Top-level axisPointer.link synchronisiert pointers über mehrere charts (multi-chart-dashboards) — xAxisIndex: 'all' übergeben. type: 'cross' zeigt ein volles crosshair mit x- und y-Werten in Labels. crossStyle/lineStyle passen die Führungslinien an. Synchronisierte pointers sind Pflicht, um Daten über gestapelte charts zu vergleichen.
chart.setOption({
tooltip: { trigger: 'axis' },
xAxis: { type: 'category', data: ['Mon','Tue','Wed','Thu'] },
yAxis: { type: 'value' },
axisPointer: {
link: [{ xAxisIndex: 'all' }], // sync pointers across charts
label: { backgroundColor: '#333' }
},
series: [{ type: 'line', data: [10, 20, 30, 40] }]
});
// per-axis pointer type
chart.setOption({
tooltip: {
axisPointer: {
type: 'cross',
crossStyle: { color: '#999' },
lineStyle: { color: '#999', type: 'dashed' }
}
}
});Tooltip trigger item
trigger: 'item' zeigt den tooltip beim Hover über einen einzelnen Datenpunkt (pie-Sektion, scatter-Punkt). Default für pie, scatter, radar. extraCssText ergänzt beliebiges CSS (Schatten, runde Ecken) für eigenes Styling. percent ist bei pie-charts verfügbar. Item-tooltips sind präzise pro Punkt.
chart.setOption({
tooltip: {
trigger: 'item', // per-point, not per-axis
formatter: function (p) {
return p.name + ': ' + p.value + ' (' + p.percent + '%)';
},
backgroundColor: 'rgba(255,255,255,0.95)',
borderColor: '#eee',
textStyle: { color: '#333' },
extraCssText: 'box-shadow: 0 2px 10px rgba(0,0,0,0.1);'
},
series: [{
type: 'pie',
data: [{ value: 60, name: 'A' }, { value: 40, name: 'B' }]
}]
});Tooltip mit reichhaltigem Inhalt
Bei Achsen-tooltips mit mehreren series ist params ein Array. Iterieren, um eine reichhaltige HTML-Tabelle mit Farbmarkern, Werten und Formatierung zu bauen. So entstehen professionelle tooltips mit Ausrichtung, Summen oder Einheiten. HTML zurückgeben gibt volle Stil-Kontrolle via inline CSS.
chart.setOption({
tooltip: {
trigger: 'axis',
axisPointer: { type: 'shadow' },
formatter: function (params) {
let html = '<div style="font-weight:bold;margin-bottom:4px;">'
+ params[0].name + '</div>';
params.forEach(p => {
html += '<div style="display:flex;align-items:center;">'
+ '<span style="display:inline-block;width:10px;height:10px;background:'
+ p.color + ';margin-right:6px;"></span>'
+ p.seriesName + ': ' + p.value
+ '</div>';
});
return html;
}
},
series: [
{ type: 'bar', name: 'A', data: [10, 20, 30] },
{ type: 'bar', name: 'B', data: [15, 25, 35] }
]
});Toolbox
Toolbox-Features
Die toolbox ergänzt Aktions-Icons (standardmäßig oben rechts). dataZoom erlaubt Ziehen-Auswählen zum Zoomen. dataView zeigt rohe Daten (editierbar bei readOnly: false). magicType wechselt den chart-Typ (line/bar). restore setzt zurück. saveAsImage exportiert PNG/SVG. Jedes Feature hat eine eigene config.
chart.setOption({
toolbox: {
show: true,
right: 10, top: 10,
feature: {
dataZoom: { yAxisIndex: 'none' },
dataView: { readOnly: false, title: 'Data', lang: ['Data','Close','Refresh'] },
magicType: { type: ['line','bar','stack','tiled'] },
restore: {},
saveAsImage: { pixelRatio: 2, name: 'chart', type: 'png' }
}
},
series: [{ type: 'bar', data: [10, 20, 30] }]
});dataZoom via Toolbox
Toolbox-dataZoom ergänzt 'zoom in/out'-Buttons für Ziehen-Auswählen. Mit dataZoom-Komponenten kombinieren: 'inside' (Maus-/Touch-Gesten) und 'slider' (eine ziehbare Leiste). yAxisIndex: 'none' begrenzt das Zoomen auf x. Bei Zeitreihen mit Tausenden Punkten ist dataZoom Pflicht zur Navigation.
chart.setOption({
toolbox: {
feature: {
dataZoom: {
yAxisIndex: 'none', // only zoom x axis
title: { zoom: 'Zoom In', back: 'Zoom Out' }
}
}
},
dataZoom: [
{ type: 'inside', xAxisIndex: 0 }, // mouse wheel
{ type: 'slider', xAxisIndex: 0 } // slider below chart
],
xAxis: { type: 'category', data: longData },
series: [{ type: 'line', data: longData }]
});Data View (rohe Daten bearbeiten)
dataView zeigt die dem chart zugrunde liegenden Daten. readOnly: false lässt Nutzer bearbeiten und neu rendern. optionToContent/contentToOption erlauben die vollständige Anpassung der Ansicht (z. B. eine HTML-Tabelle statt JSON). Nützlich zum Debuggen oder für fortgeschrittene Nutzer, die Daten verfeinern. Änderungen triggern ein Re-Rendering.
chart.setOption({
toolbox: {
feature: {
dataView: {
readOnly: false, // editable
title: 'View Data',
lang: ['Data View', 'Close', 'Refresh'],
optionToContent: function (opt) {
// custom HTML rendering instead of JSON
return '<div>Custom view</div>';
},
contentToOption: function (div) {
// parse edited content back to option
return opt;
}
}
}
}
});magicType & restore
magicType lässt Nutzer zur Laufzeit zwischen line/bar und gestapelten/tileierten Layouts wechseln — ECharts übernimmt die Konvertierung. restore dreht alle toolbox-Änderungen auf die Original-Option zurück. Das magicTypeChanged-Ereignis erlaubt Reaktion auf Typwechsel (z. B. Labels aktualisieren). Ideal zum Erkunden ohne Extra-Code.
chart.setOption({
toolbox: {
feature: {
magicType: {
type: ['line', 'bar', 'stack', 'tiled'],
title: { line: 'Line', bar: 'Bar', stack: 'Stack', tiled: 'Tile' }
},
restore: { title: 'Restore' }
}
},
series: [
{ type: 'bar', name: 'A', data: [10, 20, 30] },
{ type: 'bar', name: 'B', data: [15, 25, 35] }
]
});
chart.on('magicTypeChanged', function (params) {
console.log('Switched to', params.currentType);
});Als Bild speichern
saveAsImage exportiert das chart als PNG/JPG. pixelRatio: 2 verdoppelt die Auflösung für Retina. excludeComponents entfernt Elemente (wie die toolbox) aus dem Export. getDataURL gibt einen base64-String für programmgesteuerten Download oder Upload. Der SVG-Renderer exportiert bei type 'svg' sauberere Vektorbilder.
chart.setOption({
toolbox: {
feature: {
saveAsImage: {
type: 'png', // 'png' or 'jpg'
name: 'my-chart',
pixelRatio: 2, // higher = sharper
backgroundColor: '#fff',
excludeComponents: ['toolbox'],
title: 'Download'
}
}
}
});
// programmatic export
chart.getDataURL({
type: 'png',
pixelRatio: 2,
backgroundColor: '#fff'
});Marks (MarkPoint / MarkLine / MarkArea)
markPoint (Punkte hervorheben)
markPoint lenkt die Aufmerksamkeit auf konkrete Punkte. Eingebaute Typen: 'max', 'min', 'average'. Auch coord: [x, y] für eigene Punkte möglich. symbolSize skaliert den marker. markPoints schweben über der series — sie beeinflussen die Achsenskalierung nicht. Nützlich, um Extreme oder Ereignisse anzusprechen.
chart.setOption({
series: [{
type: 'line',
data: [10, 50, 30, 80, 20, 90],
markPoint: {
symbolSize: 50,
data: [
{ type: 'max', name: 'Peak' },
{ type: 'min', name: 'Low' },
{ type: 'average', name: 'Avg' }
],
label: { fontSize: 12 }
}
}]
});markLine (Referenzlinien)
markLine zeichnet Referenzlinien. type: 'average' zeichnet eine horizontale Linie am Mittel. { yAxis: 60 } zeichnet eine eigene horizontale Linie (Schwellen, Ziele). { xAxis: 'Wed' } zeichnet eine vertikale Linie (Ereignis-Marker). symbol: 'none' entfernt Endpfeile für einen saubereren Look.
chart.setOption({
series: [{
type: 'bar',
data: [10, 50, 30, 80, 20],
markLine: {
symbol: 'none', // no end arrows
lineStyle: { type: 'dashed', color: '#ee6666' },
data: [
{ type: 'average', name: 'Avg' },
{ yAxis: 60, name: 'Threshold' }, // horizontal line at y=60
{ xAxis: 'Wed', name: 'Event' } // vertical line at category
],
label: { formatter: '{b}: {c}' }
}
}]
});markArea (Regionen hervorheben)
markArea schattiert eine Region des charts. data ist ein Array aus [start, end]-Paaren — jedes Paar definiert ein Rechteck per coord (xAxis/yAxis-Werte). Nützlich, um Geschäftszeiten, Wochenenden, Rezessionen oder beliebige relevante Spannen hervorzuheben. silent: false lässt es auf Hover-Events reagieren.
chart.setOption({
series: [{
type: 'line',
data: [10, 20, 30, 40, 50, 60, 70],
markArea: {
silent: false,
itemStyle: { color: 'rgba(255, 200, 0, 0.2)' },
data: [
[
{ xAxis: 'Tue' }, // start
{ xAxis: 'Thu' } // end
],
[
{ xAxis: 'Fri' },
{ xAxis: 'Sat' }
]
],
label: { show: true, position: 'top' }
}
}]
});Marks kombiniert
markPoint, markLine und markArea auf einer series kombinieren. Ein typisches Analysechart hebt den peak hervor (markPoint), zeigt Mittel und Ziel (markLine) und schattiert eine bemerkenswerte Periode (markArea). Jedes mark hat eigenes Styling. Nicht übertreiben — zu viele marks überladen das chart.
chart.setOption({
series: [{
type: 'line',
data: [20, 50, 30, 80, 60, 90, 40],
markPoint: {
data: [{ type: 'max', name: 'Max' }]
},
markLine: {
data: [
{ type: 'average', name: 'Average' },
{ yAxis: 70, name: 'Target', lineStyle: { color: '#91cc75' } }
]
},
markArea: {
data: [[
{ xAxis: 'Wed' },
{ xAxis: 'Fri', itemStyle: { color: 'rgba(145,204,117,0.1)' } }
]]
}
}]
});Mark mit eigenen Koordinaten
Für eigene Positionen coord: [x, y] statt der eingebauten Typen nutzen. markLine mit eigenen coords nimmt ein Array aus zwei coord-Objekten (Start und Ende) — beliebige Linien zeichnen (Diagonalen, Trendlinien aus Regression). symbol: 'pin' ändert die markPoint-Form. So entstehen Annotationen an konkreten Datenpunkten.
chart.setOption({
series: [{
type: 'scatter',
data: [[10,20], [50,60], [80,90]],
markPoint: {
data: [
{ coord: [50, 60], name: 'Center', value: 'Origin' }
],
symbol: 'pin',
symbolSize: 40,
itemStyle: { color: '#ee6666' }
},
markLine: {
data: [
[{ coord: [0, 0] }, { coord: [100, 100] }] // diagonal line
]
}
}]
});Animation & Interaktion
Animations-Optionen
Animation global steuern. animationDuration ist die Länge der Eingangsanimation. Easing-Namen sind u. a. 'linear','cubicOut','elasticOut','bounceOut'. animationDelay als Funktion staffelt Items (idx * 100 lässt jeden Balken 100ms nach dem vorigen erscheinen). Bei großen Datensätzen deaktiviert animationThreshold die Animation automatisch für Performance.
chart.setOption({
animation: true,
animationThreshold: 2000, // disable above this data count
animationDuration: 2000, // entrance duration (ms)
animationEasing: 'cubicOut', // easing function
animationDelay: function (idx) { // stagger by index
return idx * 100;
},
animationDurationUpdate: 500, // update transition
animationEasingUpdate: 'cubicInOut',
animationDelayUpdate: 0,
series: [{ type: 'bar', data: [10, 20, 30, 40] }]
});Easing-Funktionen
ECharts unterstützt 30+ easing-Funktionen. 'cubicOut' (Default) ist eine natürliche Verzögerung. 'elasticOut' und 'bounceOut' ergänzen spielerisches Überschießen. 'sinusoidalInOut' ist geschmeidig und neutral. Für Data-viz dezente easings bevorzugen (cubic, sinusoidal) — springende Animationen lenken von den Daten ab. Easing an die Markenpersönlichkeit anpassen.
chart.setOption({
animationEasing: 'elasticOut',
// available easings:
// linear, quadraticIn, quadraticOut, quadraticInOut,
// cubicIn, cubicOut, cubicInOut,
// quarticIn, quarticOut, quarticInOut,
// quinticIn, quinticOut, quinticInOut,
// sinusoidalIn, sinusoidalOut, sinusoidalInOut,
// exponentialIn, exponentialOut, exponentialInOut,
// circularIn, circularOut, circularInOut,
// elasticIn, elasticOut, elasticInOut,
// backIn, backOut, backInOut,
// bounceIn, bounceOut, bounceInOut
series: [{ type: 'bar', data: [10, 20, 30] }]
});Ladeanimation
showLoading zeigt ein spinner-Overlay beim Laden der Daten. hideLoading aufrufen, sobald Daten bereit sind. Das Standardmuster für async-Daten — loading zeigen, laden, loading verbergen, setOption. Spinner-Farbe und Meldung an die App anpassen. Die Maske verhindert Nutzerinteraktion während des Ladens.
// show loading mask
chart.showLoading({
text: 'Loading data...',
color: '#5470c6',
textColor: '#333',
maskColor: 'rgba(255, 255, 255, 0.8)',
zlevel: 0,
fontSize: 14,
showSpinner: true,
spinnerRadius: 10,
lineWidth: 2
});
// hide after data loads
fetch('/api/data').then(r => r.json()).then(data => {
chart.hideLoading();
chart.setOption({ series: [{ type: 'bar', data: data }] });
});Events-API
chart.on bindet event handler. Häufige Events: click, dblclick, mouseover, legendselectchanged, datazoom, pieselectchanged. params trägt Komponenten-Infos. dispatchAction triggert Aktionen (highlight, showTip, dataZoom) — nützlich, um externe UI mit dem chart zu synchronisieren oder tooltips programmgesteuert zu zeigen.
chart.on('click', function (params) {
console.log('Clicked:', params.componentType, params.seriesType);
console.log('Series:', params.seriesName, 'Data:', params.name, params.value);
console.log(' dataIndex:', params.dataIndex);
});
chart.on('legendselectchanged', function (params) {
console.log('Legend toggled:', params.selected);
});
chart.on('datazoom', function (params) {
console.log('Zoom:', params.batch?.[0]?.start, params.batch?.[0]?.end);
});
// dispatch an action programmatically
chart.dispatchAction({
type: 'highlight',
seriesIndex: 0,
dataIndex: 2
});
chart.dispatchAction({ type: 'showTip', x: 100, y: 100 });Graphic-Elemente (eigene Formen)
graphic erlaubt das Überlagern eigener Formen (text, circles, rects, images) auf dem chart — nützlich für watermarks, empty-state-Meldungen oder Annotationen. Elemente unterstützen Positionierung (left/top/right/bottom als px oder %), Styling und Events. Sie rendern je nach z über oder unter dem chart. Die Notluke, wenn Standard-Optionen nicht reichen.
chart.setOption({
graphic: {
elements: [
{
type: 'text',
left: 'center', top: 'middle',
style: { text: 'No Data', fontSize: 24, fill: '#999' },
invisible: false
},
{
type: 'circle',
shape: { cx: 50, cy: 50, r: 20 },
style: { fill: '#5470c6' },
onclick: function () { console.log('clicked'); }
},
{
type: 'image',
style: { image: 'logo.png', width: 100, height: 40 },
left: 10, top: 10
}
]
}
});Verwandte ECharts-Snippets
Copy-paste ready code for common tasks.
Bar Chart
Category bar chart with axis tooltip and styled bars.
Line Chart
Smooth multi-series line chart with area fill.
Pie Chart
Donut-style pie with emphasis effect and percentage labels.
Scatter Plot
Scatter plot with point size encoded by a third dimension.
Radar Chart
Radar with multiple indicators and overlaid value series.
Options & Series
Dataset-driven multi-series chart with grid and legend config.
Tooltip
Custom HTML tooltip with crosshair axis pointer.
Responsive
Resize chart on window and container changes, with cleanup.
Was this helpful?