Skip to content

ECharts Spickzettel

Mächtige Charting- und Visualisierungsbibliothek von Apache.

01

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.

echarts
<!-- 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.

echarts
// 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.

echarts
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.

echarts
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.

echarts
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));
02

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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
  }]
});
03

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.

echarts
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.

echarts
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.

echarts
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).

echarts
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.

echarts
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.

echarts
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
  }]
});
04

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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' }
    ]
  }]
});
05

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
// 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 }
  }]
});
06

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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] }]
  }]
});
07

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).

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
// 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 }
    ]
  }]
});
08

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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);
  }
});
09

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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 });
  }
});
10

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.

echarts
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.

echarts
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.

echarts
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.

echarts
// 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.

echarts
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);
  }
});
11

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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' }
    }
  ]
});
12

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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 }]
  }]
});
13

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).

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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).

echarts
// 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' }
        }
      }
    });
  });
14

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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' }
  }]
});
15

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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
});
16

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.

echarts
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.

echarts
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'.

echarts
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.

echarts
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.

echarts
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
});
17

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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] }
  ]
});
18

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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'
});
19

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.

echarts
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.

echarts
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.

echarts
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.

echarts
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.

echarts
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
      ]
    }
  }]
});
20

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.

echarts
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.

echarts
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.

echarts
// 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.

echarts
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.

echarts
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
      }
    ]
  }
});

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.