Démarrage
Installation et premier graphique
ECharts s'initialise sur un élément DOM avec largeur/hauteur explicites. setOption configure tout le graphique. Apache ECharts (ex-Baidu ECharts) est l'une des bibliothèques de graphiques JS les plus puissantes.
<!-- 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 avec thème et renderer
init prend (dom, theme, opts). Le renderer 'svg' est plus net à tout niveau de zoom et produit un DOM plus léger pour les graphiques simples, tandis que 'canvas' est plus rapide pour les gros volumes de données. devicePixelRatio contrôle la netteté sur retina. Appelez toujours dispose() en retirant un graphique pour libérer la mémoire.
// 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();Redimensionnement responsif
ECharts ne se redimensionne pas tout seul quand son conteneur change — vous devez appeler chart.resize(). ResizeObserver est la manière moderne de surveiller la taille du conteneur (mieux que le resize de fenêtre pour les changements liés à la mise en page). Appelez toujours dispose() au démontage pour éviter les fuites dans les SPA.
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());Modes de fusion de setOption
Par défaut, setOption fusionne en profondeur les nouvelles options avec les existantes, vous pouvez donc mettre à jour des éléments isolés. notMerge: true remplace toute l'option (utile quand le nombre de séries change). replaceMerge cible des types de composants précis (series, xAxis) pour un remplacement partiel. lazyUpdate regroupe plusieurs appels setOption en un seul rendu.
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 });Cycle de vie : getInstanceByDom et dispose
Appeler init sur un DOM qui a déjà un graphique lève une erreur. Utilisez getInstanceByDom pour vérifier. dispose() libère la mémoire et retire le graphique ; l'élément DOM reste. L'attribut _echarts_instance_ marque les conteneurs de graphiques — interrogez-le pour retrouver et nettoyer les graphiques orphelins. Disposez toujours dans les hooks de démontage du framework.
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));Graphiques en barres
Barres de base
Un graphique en barres exige un xAxis de catégorie et un yAxis de valeur. Chaque valeur de series.data correspond à une catégorie. itemStyle contrôle l'apparence des barres. Pour des barres verticales, l'axe de catégorie est x ; pour des barres horizontales, échangez les types des axes x et y.
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' }
}]
});Barres groupées et empilées
Plusieurs séries de barres sur le même xAxis sont groupées par défaut. Pour les empiler, donnez à chaque série le même nom de stack. L'empilement cumule les valeurs par catégorie. Utilisez stack: 'total' sur toutes les séries à empiler ensemble — les séries sans nom de stack restent groupées.
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] }
]
});Barres horizontales
Un graphique à barres horizontales est simplement un graphique en barres avec l'axe de catégorie sur yAxis et l'axe de valeur sur xAxis. Les labels avec position: 'right' se placent au bout des barres. Les barres horizontales sont mieux adaptées aux noms de catégories longs ou aux comparaisons de nombreuses catégories — elles évitent les labels inclinés.
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
}
}]
});Barres avec fond et coins arrondis
showBackground dessine une piste derrière chaque barre (style barre de progression). itemStyle.borderRadius arrondit les coins des barres — passez [hautGauche, hautDroite, basDroite, basGauche] pour des barres verticales ; ordre inverse pour l'horizontale. borderRadius peut être un nombre (tous les coins) ou un tableau.
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
}
}]
});Course de barres (dynamique)
Une course de barres anime le réordonnancement. Triez le tableau de données, puis mettez à jour à la fois les catégories du yAxis et les données des séries. animationDurationUpdate contrôle la fluidité de la transition. yAxis.inverse: true place la plus grande valeur en haut. Très populaire pour les histoires de données animées.
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);Largeur et espacement des barres
barWidth accepte des pixels ou un pourcentage de la bande de catégorie. barGap est l'espacement entre les barres d'un groupe (ne compte qu'avec plusieurs séries). barCategoryGap est l'espacement entre les groupes. Les pourcentages sont relatifs à la bande de catégorie, ils restent donc proportionnels au redimensionnement.
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
}]
});Graphiques en courbe
Courbe de base
Un graphique en courbe utilise type: 'line'. Les points sont affichés par défaut avec des marqueurs ; mettez symbol: 'none' pour les masquer. La ligne relie les points dans l'ordre des données. Pour des séries temporelles, utilisez type: 'time' sur xAxis avec des paires [timestamp, valeur].
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
}]
});Courbe lissée et aire
smooth: true courbe la ligne (interpolation Catmull-Rom). areaStyle remplit l'aire sous la ligne ; un dégradé (arrêts de couleur linéaires) donne un effet estompé. boundaryGap: false sur l'axe de catégorie fait démarrer la ligne au bord de l'axe y au lieu de laisser un espace.
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)' }
]
}
}
}]
});Courbes multi-séries
Plusieurs séries se tracent en lignes distinctes, différenciées par la couleur. La légende bascule la visibilité. lineStyle.type accepte 'solid', 'dashed', 'dotted'. Chaque série peut avoir son propre style. Le nom dans la légende doit correspondre à series.name.
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' }
}
]
});Aires empilées
Les aires empilées utilisent type: 'line' avec le même nom de stack et un areaStyle. Chaque série s'empile sur la précédente. emphasis.focus: 'series' met en surbrillance toute la série au survol. Utile pour montrer une composition dans le temps (ex. trafic par source).
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]
}
]
});Ligne en escalier
step transforme une ligne en escalier. 'start' monte avant le point, 'middle' (symétrique) sur le point, 'end' après. Les graphiques en escalier conviennent aux valeurs qui changent de façon discrète (niveaux de stock, état serveur) plutôt que continue.
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 }
}]
});Ligne avec axe temporel
Avec type: 'time', l'axe formate les dates automatiquement et gère les intervalles irréguliers. Les points de données sont des paires [timestamp, valeur]. ECharts espace les points selon leur temps réel, les trous dans les données apparaissent donc correctement. C'est le bon choix pour des séries temporelles à intervalles variables.
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
}]
});Graphiques circulaires
Camembert de base
Les camemberts n'utilisent pas d'axes — series.data est un tableau de {value, name}. radius contrôle la taille du camembert en pourcentage de la plus petite dimension du conteneur. Les styles emphasis s'appliquent au survol. La légende dérive automatiquement les libellés de data.name.
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)'
}
}
}]
});Anneau (doughnut)
Définir radius sur [intérieur, extérieur] crée un anneau. Un label central est un pattern courant (afficher le total ou un KPI). avoidLabelOverlap: false laisse les labels en place. Le rayon intérieur contrôle l'épaisseur de l'anneau — [50%, 70%] donne un anneau fin ; [0%, 70%] un camembert complet.
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 rend le rayon des parts proportionnel à la valeur (rose de Nightingale). 'area' utilise sqrt(valeur) pour le rayon (aire proportionnelle), 'radius' utilise la valeur directement. Chaque part a le même angle mais un rayon différent. Bien pour comparer des ordres de grandeur quand l'angle seul est difficile à juger.
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 }
}]
});Camembert avec labels personnalisés
label.formatter accepte les variables de template : {a} (nom de série), {b} (nom de donnée), {c} (valeur), {d} (pourcentage). labelLine contrôle la ligne de raccord. length est le segment près de la part, length2 celui près du label. Des labels personnalisés rendent les camemberts bien plus lisibles.
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' }
]
}]
});Camembert semi-circulaire
Combiner startAngle et endAngle crée des camemberts partiels (demi, quart, façon jauge). center positionne le camembert — ['50%','70%'] le pousse vers le bas pour qu'un camembert de 180° repose en bas. Les camemberts partiels servent souvent de jauges ou pour des dashboards stylisés.
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' }
]
}]
});Nuages de points
Nuage de points de base
Les nuages de points utilisent deux axes de valeur ; chaque point est [x, y]. symbolSize contrôle la taille des points (fixe ou par point via une fonction). Le nuage révèle la corrélation entre deux variables. Les deux axes sont de type 'value' (numérique), contrairement aux barres/courbes basées sur les catégories.
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' }
}]
});Graphique à bulles (taille par valeur)
Un graphique à bulles est un nuage de points où la taille du point encode une troisième dimension. Passez [x, y, taille] par point et définissez symbolSize comme fonction renvoyant la taille. La fonction s'exécute par point, chaque bulle s'échelle donc indépendamment. Utile pour des données à 3 variables sans graphique 3D.
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
}
}]
});Nuage avec visualMap (couleur par valeur)
visualMap associe une dimension de données à la couleur. dimension: 2 colore selon le 3e élément (index 2) de chaque point. inRange.color définit le dégradé. Cela ajoute une quatrième dimension (couleur) au nuage. Le composant visualMap affiche la légende avec un curseur.
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
}]
});Nuage à effets (animé)
effectScatter ajoute une animation d'ondulation autour de chaque point — parfait pour mettre en évidence des points clés (alertes, grandes villes). showEffectOn contrôle quand l'ondulation se joue. brushType: 'stroke' est plus léger ; 'fill' plus visible. À utiliser avec parcimonie — trop d'ondulations distraient.
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
}
}]
});Nuage à grande échelle
Pour des milliers de points, activez le rendu progressif — ECharts découpe les données en tranches et les rend sur plusieurs frames pour éviter le gel. large: true utilise un seul appel de dessin optimisé. Combinez avec un symbolSize réduit et de l'opacité pour gérer le sur-traçage. Cela garde 50 000+ points fluides.
// 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 }
}]
});Graphiques radar
Radar de base
Les radars exigent un tableau radar.indicator définissant chaque axe (name et max). Les données de série sont un tableau de valeurs correspondant aux indicateurs. Le radar est parfait pour comparer plusieurs attributs de quelques éléments (stats de joueur, comparaison de produits). max fixe l'échelle de chaque axe.
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' }]
}]
});Radar multi-s éries
Plusieurs entrées de données se tracent en polygones superposés, idéals pour comparer. Chaque entrée exige un nom unique correspondant à la légende. Trop de séries (5+) rend le radar illisible — les polygones se chevauchent en une tache. Restez à 2-4 éléments pour la clarté.
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 avec aire
areaStyle remplit le polygone radar d'une couleur semi-transparente, rendant la forme plus lisible. lineStyle met l'outline en valeur. Gardez l'opacité de areaStyle basse (0,2-0,4) pour que les séries qui se chevauchent restent visibles. Les symboles marquent chaque sommet.
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
}]
});Forme et axes du radar
shape: 'polygon' (défaut) donne des axes anguleux ; 'circle' des anneaux lisses. splitNumber contrôle la densité de grille. splitArea alterne les couleurs pour un effet zébré. axisName stylise les labels d'axes. Ces options contrôlent la structure visuelle sans toucher aux données.
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] }] }]
});Rayon polaire du radar
radius: [intérieur, extérieur] crée un radar en anneau (façon doughnut). center positionne le graphique. min sur un indicateur fixe le départ de l'axe — utile quand toutes les valeurs sont élevées (évite un minuscule polygone au centre). Ajustez center pour laisser la place aux labels d'axes.
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] }]
}]
});Cartes de chaleur
Carte de chaleur cartésienne
Une carte de chaleur cartésienne exige un visualMap pour colorer les cellules. Les données sont [x, y, valeur]. label: { show: true } imprime les valeurs dans les cellules (bien seulement pour les petites grilles). calculable: true ajoute une poignée de curseur. Les heatmaps révèlent des motifs de densité (ex. activité horaire).
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 }
}]
});Carte de chaleur calendaire
Les heatmaps calendaires montrent des valeurs quotidiennes sur un an (graphe de contributions à la GitHub). calendar.range fixe l'année ou la plage de dates. Les points sont des [dateString, valeur]. Le dégradé du visualMap définit les arrêts de couleur. cellSize contrôle la taille des cases — 'auto' épouse le conteneur.
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 }]
});Style des cellules de heatmap
itemStyle.borderColor et borderWidth créent un effet de séparateur de grille (des bordures blanches distinguent les cellules). borderRadius arrondit les coins des cellules. Les styles emphasis s'appliquent au survol. Un visualMap masqué (show: false) pilote quand même les couleurs sans afficher la légende.
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 }
}
}]
});Heatmap punch card
Une punch card est une heatmap 7x24 montrant l'activité par jour de la semaine et heure. Chaque cellule est un créneau horaire. Le itemStyle arrondi lui donne l'aspect de points. Les punch cards révèlent les patterns hebdomadaires (ex. quand un serveur est le plus sollicité). Les données forment une grille complète de 168 cellules.
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 sur carte géographique
Combiner geo avec une série map colore les régions selon la valeur. visualMap pilote l'échelle de couleurs. Vous devez d'abord enregistrer une carte via echarts.registerMap('china', geoJson). roam: true active le déplacement/zoom. C'est ainsi qu'on construit les cartes choroplèthes (couleur par région).
// 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 }
]
}]
});Graphiques arborescents
Arbre de base (vertical)
Les arbres tracent des données hiérarchiques. layout: 'orthogonal' avec orient: 'LR' donne un arbre de gauche à droite. expandAndCollapse permet de cliquer pour replier/déplier des sous-arbres. leaves configure le style des nœuds feuilles. L'arbre est parfait pour les organigrammes, arborescences de fichiers et taxonomies.
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
}]
});Arbre horizontal
orient: 'LR' produit un arbre horizontal (racine à gauche, feuilles à droite). Les labels des nœuds internes se placent à GAUCHE du nœud ; les labels des feuilles à DROITE — cela évite le chevauchement avec les branches. curveness sur lineStyle crée des raccords courbés pour un rendu plus doux.
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 }
}]
});Arbre radial
layout: 'radial' place la racine au centre et irradie les enfants en cercle. Cela convient aux grands arbres où une disposition horizontale serait trop large. emphasis.focus: 'descendant' met en évidence tous les descendants au survol, aidant à suivre les branches.
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 }
}]
});Arbre avec symboles personnalisés
symbol et symbolSize acceptent des fonctions pour une personnalisation par nœud. Ici, les nœuds internes (avec enfants) sont des rectangles plus grands tandis que les feuilles sont de petits cercles. Cela distingue visuellement les niveaux de hiérarchie. Combinez avec orient: 'TB' pour un organigramme classique descendant.
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 }
}]
});Contrôle déplier/replier de l'arbre
initialTreeDepth contrôle le nombre de niveaux ouverts au départ (null = tous, 0 = racine seule). Cliquer un nœud avec enfants bascule son sous-arbre. L'événement click permet de réagir à la sélection de nœud — utile pour des UI de drill-down. animationDurationUpdate lisse déplier/replier.
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);
}
});Graphiques sunburst
Sunburst de base
Le sunburst est un arbre radial où chaque anneau représente un niveau hiérarchique. Intérieur = parents, extérieur = enfants. La valeur de chaque nœud détermine sa taille angulaire. radius: [0, '90%'] donne un disque plein ; [intérieur, extérieur] crée un sunburst en anneau. Parfait pour visualiser des proportions hiérarchiques.
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 avec niveaux
levels configure chaque anneau séparément — la première entrée est la racine, les suivantes correspondent aux niveaux plus profonds. r0/r fixent les rayons intérieur/extérieur de ce niveau. Des rotations de labels différentes (radial, tangentiel, 0) gardent le texte lisible à chaque profondeur. Cela donne un contrôle stylistique fin.
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 }
}
]
}]
});Style et mise en évidence du sunburst
emphasis.focus: 'ancestor' met en évidence le chemin du nœud survolé jusqu'à la racine — on voit où une part se situe dans la hiérarchie. borderWidth sépare visuellement les parts. Le sunburst est interactif : un clic descend généralement d'un niveau. Utilisez la mise en évidence par ancêtres pour garder le contexte dans les arbres profonds.
chart.setOption({
series: [{
type: 'sunburst',
data: data,
itemStyle: {
borderColor: '#fff',
borderWidth: 1
},
emphasis: {
focus: 'ancestor' // highlight ancestors on hover
},
highlight: {
itemStyle: { color: '#ffb' }
}
}]
});Sunburst avec valeurs et tri
sort contrôle l'ordre des parts dans un parent. nodeClick: 'zoomToNode' fait qu'un clic zoome sur ce sous-arbre (parfait pour explorer). minAngle masque les labels des parts de moins de 5 degrés, évitant l'encombrement. La valeur des nœuds parents est sommée automatiquement depuis les enfants si elle est omise.
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
}]
});Drill-down sunburst
Des gestionnaires de clic personnalisés permettent de construire votre propre UX de drill-down. Remplacez les données par le nœud cliqué pour zoomer. Gardez une référence au parent si vous voulez un bouton « retour ». Le drill-down sunburst est excellent pour explorer des hiérarchies profondes sans surcharger l'écran.
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 });
}
});Diagrammes de Sankey
Sankey de base
Le Sankey montre des flux entre nœuds. data contient les nœuds (avec noms) ; links contient les flux (source, target, value). La largeur de chaque lien est proportionnelle à la valeur. emphasis.focus: 'adjacency' met en évidence les nœuds connectés au survol. Parfait pour visualiser des flux d'énergie, d'argent ou d'utilisateurs.
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 }
}]
});Niveaux des nœuds Sankey
levels stylise les nœuds par profondeur (colonne). lineStyle.color: 'source' colore les liens selon le nœud source ; 'target' selon la cible ; 'gradient' mélange. nodeAlign positionne les nœuds verticalement dans une colonne. Définir depth explicitement force la colonne, en l'emportant sur l'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'
}]
});Style et espacement des nœuds Sankey
nodeWidth fixe l'épaisseur de chaque rectangle de nœud. nodeGap contrôle l'espacement vertical. Des écarts plus petits montrent plus de nœuds mais peuvent se chevaucher. lineStyle.opacity rend les flux discrets pour que les nœuds ressortent. label.position: 'right' place les labels à côté des nœuds — courant pour les flux de gauche à droite.
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 avec cycle (drain)
De vrais cycles font échouer le Sankey d'ECharts. La parade consiste à scinder un nœud de recyclage en nœuds « entrée » et « sortie » distincts (ex. 'Recycle') pour que le flux reste acyclique. Cela représente visuellement les boucles de rétroaction. Vérifiez toujours la conservation : le total entrant d'un nœud doit égaler son total sortant.
// 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' }
}]
});Interaction Sankey
Les événements de clic Sankey distinguent nœuds et arêtes via dataType. Servez-vous en pour construire des panneaux de détails montrant les spécificités du flux. label.formatter: '{b}: {c}' affiche nom et valeur. La mise au focus adjacency met en évidence le chemin complet passant par un nœud survolé, révélant les chaînes de cause à effet.
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);
}
});Graphiques en entonnoir
Entonnoir de base
Un entonnoir montre les étapes d'un processus où chaque étape retient moins d'éléments. sort: 'descending' (défaut) place la plus grande étape en haut. Les données doivent être ordonnées selon le flux du processus. Les entonnoirs sont parfaits pour les pipelines de vente, l'analyse de conversion et les étapes d'onboarding.
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'
}]
});Entonnoir avec tri et écart
sort: 'ascending' inverse l'entonnoir (la plus petite en haut, comme un graphique de croissance). gap sépare les parts pour la lisibilité. funnelAlign positionne les parts horizontalement. minSize/maxSize bornent les largeurs de parts en pourcentages, garantissant que les petites étapes restent visibles.
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%'
}]
});Labels d'entonnoir
position: 'inside' superpose les labels sur les parts ; 'left'/'right' les place à l'extérieur avec des lignes de raccord (labelLine). formatter: '{b}: {c}' affiche nom et valeur. Utilisez les labels extérieurs quand les parts sont trop fines pour du texte intérieur. Emphasis agrandit le label au survol.
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 }
}
}]
});Style des parts d'entonnoir
Un itemStyle par part remplace le cycle de couleurs par défaut. borderColor sépare visuellement les parts. Vous pouvez aussi définir color sur chaque élément de données. Pour un rendu soigné, utilisez une palette séquentielle (plus clair pour les premières étapes, plus foncé pour les converties) afin de renforcer la métaphore de l'entonnoir.
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
}
}]
});Entonnoirs comparés
Plusieurs séries d'entonnoir peuvent se côte à côte pour comparer des périodes. Donnez à chaque série son propre left/width pour les positionner. Parfait pour visualiser un test A/B ou comparer les conversions d'une année sur l'autre. Utilisez des couleurs contrastées par série pour les distinguer.
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' }
}
]
});Jauges
Jauge de base
Une jauge montre une valeur unique sur un arc. min/max fixent l'échelle. progress affiche un arc coloré jusqu'à la valeur (avec axisLine comme piste). detail rend le texte de la valeur au centre. valueAnimation anime la transition du nombre. Parfait pour les KPI et dashboards à métrique unique.
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' }]
}]
});Jauge avec aiguille
Le style d'aiguille (pointer) est l'aspect classique d'une jauge. anchor est le pivot central. Des valeurs de distance négatives poussent graduations et labels vers l'intérieur (vers le centre). radius met à l'échelle toute la jauge. Combinez l'aiguille avec splitLine pour imiter un instrument physique. Utile pour un rendu analogique.
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 }]
}]
});Jauge à zones colorées
axisLine.lineStyle.color accepte un tableau de paires [seuil, couleur] pour créer des zones colorées (ex. rouge/jaune/vert pour des niveaux de risque). Les seuils sont des fractions (0-1). C'est la façon standard d'afficher des plages « sûr/avertissement/danger » sur une jauge. L'aiguille ou l'arc de progression indique la valeur courante dans ces zones.
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 }]
}]
});Jauge multi-aiguilles
Plusieurs entrées de données créent plusieurs aiguilles sur la même jauge. Utile pour comparer des métriques liées (CPU vs mémoire vs disque). Chaque valeur s'anime indépendamment. Limitez le nombre (3-5 au plus) sinon la jauge devient encombrée. Les noms apparaissent en labels près de chaque aiguille.
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 }
}]
});Jauge personnalisée (progression circulaire)
Régler startAngle/endAngle pour couvrir 360° crée un anneau de progression circulaire (comme un anneau d'Apple Watch). Masquer aiguille/graduations/labels donne un look minimaliste épuré. roundCap arrondit les extrémités de la progression. Ce style est populaire dans les dashboards modernes — une jauge déguisée en anneau.
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 }]
}]
});Systèmes de coordonnées
Axes X multiples
xAxis est un tableau — chaque entrée est un axe distinct. Les séries se lient à un axe via xAxisIndex (base 0). Cela permet à un graphique de montrer deux métriques d'échelles ou d'unités différentes. Utilisez position pour placer les axes en haut/en bas. Courant pour les graphiques boursiers (prix + volume) ou météo (température + humidité).
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 }
]
});Double axe Y
Deux axes y (gauche et droite) permettent de tracer des séries d'unités différentes (ex. revenus en $ vs unités vendues). Chaque série se lie à un axe via yAxisIndex. Codifiez par la couleur l'axe droit pour qu'il corresponde à sa série, afin que l'on sache quelle ligne se lit sur quel axe. Évitez 3 axes ou plus — cela embrouille.
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 }
]
});Coordonnées polaires
Les coordonnées polaires utilisent angleAxis (autour du cercle) et radiusAxis (du centre vers l'extérieur). Les séries définissent coordinateSystem: 'polar'. startAngle: 90 place le 0° en haut (nord). Le polaire convient aux données directionnelles (rose des vents), aux patterns cycliques ou aux variantes rose/nightingale.
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'
}]
});Coordonnées calendaires
Le système de coordonnées calendar associe des dates à des cellules. Les séries avec coordinateSystem: 'calendar' s'y lient. cellSize peut être en pixels ou 'auto'. orient: 'horizontal' est la disposition standard en lignes de semaines. dayLabel/monthLabel nameMap localise les labels. Combinez avec une heatmap pour les graphes de contributions.
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
}]
});Coordonnées parallèles
Les coordonnées parallèles tracent des données multidimensionnelles avec un axe par dimension. Chaque ligne de données devient une polyligne traversant tous les axes. Cela révèle corrélations et regroupements dans des données de grande dimension (ex. comparer des voitures par prix, kilométrage, année, sécurité). Utile pour l'exploration de données.
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']]
}]
});Configuration de carte géographique
registerMap lie un GeoJSON à un nom pour l'usage dans les séries geo et map. roam active le déplacement/zoom à la souris. itemStyle.areaColor remplit les régions ; borderColor les contourne. Les styles emphasis s'appliquent au survol. Geo seul montre une carte ; associez une série map pour colorer les régions selon la valeur (choroplèthe).
// 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
Dataset de base
Dataset sépare les données de la config des séries. La source est un tableau 2D (ligne d'en-tête d'abord). seriesLayoutBy: 'column' fait prendre une colonne par série. encode associe les colonnes du dataset à x/y. Cela découple données et présentation — utile quand les données sont partagées entre plusieurs graphiques.
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 avec lignes objets
La source du dataset peut être un tableau d'objets (lignes clé-valeur). dimensions déclare optionnellement les colonnes (utile si des lignes peuvent manquer des clés). encode utilise les noms de dimensions au lieu des indices, pour la lisibilité. Les lignes objets sont plus faciles à écrire à la main et plus auto-documentées.
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' } }
]
});Transform de dataset (filtre/tri)
Les transforms enchaînent les datasets : filter supprime des lignes, sort les ordonne. Chaque transform lit depuis fromDatasetId et expose un nouveau dataset. Les séries se lient via datasetId. Les transforms permettent de dériver des vues d'une même source sans copier les données. Transforms pris en charge : filter, sort, et personnalisé 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' } }]
});Encode et dimensions du dataset
encode associe les colonnes du dataset (par index ou nom) aux dimensions du graphique. encode.tooltip liste les colonnes à afficher dans l'info-bulle. Ici, colonnes 0/1 pour la position, 2 pour la taille, 3 pour la couleur (via itemStyle). L'encodage rend un même dataset réutilisable entre types de graphiques différents.
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 avec camembert
Les camemberts exigent des correspondances itemName et value via encode. Le même dataset pourrait alimenter un graphique en barres (encode x:name, y:value) et un camembert avec des encodages différents. C'est la force du dataset : une source, plusieurs vues. Changer de type de graphique ne touche que le type de série et l'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
VisualMap continue
Le visualMap continu associe une plage numérique à une couleur (et éventuellement une taille). inRange.color est le dégradé (interpolé). calculable: true ajoute des poignées déplaçables pour filtrer. orient et left/top le positionnent. Le visualMap pilote les couleurs des séries — vous ne définissez pas itemStyle.color à la main.
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]]
}]
});VisualMap par morceaux
Le visualMap par morceaux regroupe les valeurs en plages discrètes, chacune avec sa couleur. pieces définit les bins (min/max/label/couleur). C'est plus clair qu'un dégradé quand on veut des buckets catégoriels (ex. risque faible/moyen/élevé). Utile pour les cartes choroplèthes et les nuages de points catégorisés.
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
}]
});VisualMap catégoriel
Le visualMap catégoriel associe des catégories de chaînes à des couleurs. categories liste les valeurs ; inRange.color liste les couleurs correspondantes dans l'ordre. dimension choisit quelle colonne de données pilote la correspondance (défaut 0). Parfait quand vos données ont un attribut catégoriel (ex. priorité, statut) à coder par couleur.
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 et hors plage
outOfRange stylise les points en dehors de la plage sélectionnée du visualMap (ex. grisés lors d'un filtrage). controller stylise le curseur lui-même. Quand l'utilisateur déplace le curseur pour filtrer, les points hors plage s'estompent vers outOfRange.color. Le visualMap devient ainsi un filtre interactif, pas juste une légende.
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 sur plusieurs séries
Par défaut, le visualMap affecte toutes les séries. Utilisez seriesIndex (nombre ou tableau) pour cibler des séries précises. Cela permet de coder par couleur une série en laissant les autres inchangées — pratique pour comparer un jeu de données mis en évidence à une référence. Un même graphique peut même avoir plusieurs visualMaps pour des séries différentes.
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
});Légende
Légende de base
La légende liste les noms de séries pour basculer leur visibilité. data doit correspondre à series.name (ou être dérivée automatiquement). icon stylise le marqueur. Cliquer un élément de légende bascule sa série. La légende se met à jour automatiquement quand des séries sont ajoutées/retirées via setOption.
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] }
]
});Position et disposition de la légende
orient et top/left positionnent la légende. Dispositions courantes : haut-centre (défaut), bas-centre, verticale à droite. itemGap contrôle l'espacement entre les éléments. Un fond/bordure discret sépare visuellement la légende du graphique. La position compte — une légende en bas libère de l'espace vertical.
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: [/* ... */]
});Sélection et défaut de la légende
selected contrôle la visibilité initiale. selectedMode: 'single' fait agir la légende comme des boutons radio (une seule série visible). L'événement legendselectchanged se déclenche au basculement par l'utilisateur — utile pour persister des préférences ou synchroniser plusieurs graphiques. Le mode par défaut est '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);
});Légende défilable
type: 'scroll' pagine la légende quand il y a trop d'éléments — des boutons de page apparaissent. Essentiel pour les graphiques à 10+ séries qui sinon débordent. Les styles d'icône/texte de page personnalisent la navigation. Une légende verticale défilable s'intègre bien dans la marge droite.
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 */]
});Formatter de légende et texte riche
formatter personnalise les libellés de légende (ex. majuscules, ajouter des comptes). Le texte riche permet de styliser différemment des parties du label — définissez les styles dans textStyle.rich et référencez-les dans le formatter avec la syntaxe {style|texte}. Cela donne des légendes comme 'A {count|42}' aux styles mixtes.
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
});Info-bulle (Tooltip)
Tooltip de base
trigger: 'item' montre l'info-bulle par point de données (nuage, camembert). 'axis' la montre pour toute la catégorie (barres, courbe). axisPointer trace une ligne guide — 'shadow' est une bande translucide (bien pour les barres), 'line' une ligne fine (bien pour les courbes), 'cross' montre les lignes x et y.
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] }]
});Formatter du tooltip
formatter personnalise le contenu de l'info-bulle. Une fonction reçoit params (avec name, value, seriesName, color, etc.) et renvoie du HTML. Les templates de chaînes utilisent {a} (nom de série), {b} (catégorie/x), {c} (valeur), {d} (pourcentage camembert). Pour les tooltips d'axe multi-séries, params est un tableau — itérez-le.
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
}
});Réticules et axis pointer du tooltip
axisPointer.link au niveau racine synchronise les pointeurs entre plusieurs graphiques (dashboards multi-graphiques) — passez xAxisIndex: 'all'. type: 'cross' montre un réticule complet avec les valeurs x et y dans les labels. crossStyle/lineStyle personnalisent les lignes guides. Des pointeurs synchronisés sont essentiels pour comparer des données entre graphiques empilés.
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 déclenché par item
trigger: 'item' montre l'info-bulle au survol d'un point de données unique (part de camembert, point du nuage). C'est le défaut pour camembert, nuage, radar. extraCssText ajoute du CSS arbitraire (ombres, coins arrondis) pour un style personnalisé. percent est disponible pour les camemberts. Les tooltips par item sont précis, point par point.
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 au contenu riche
Pour les tooltips d'axe avec plusieurs séries, params est un tableau. Itérez-le pour construire un tableau HTML riche avec marqueurs colorés, valeurs et mise en forme. C'est ainsi qu'on construit des tooltips professionnels avec alignement, totaux ou unités. Renvoyer du HTML donne un contrôle stylistique complet via CSS inline.
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
Fonctionnalités de la toolbox
La toolbox ajoute des icônes d'action (en haut à droite par défaut). dataZoom permet de sélectionner par glisser pour zoomer. dataView montre les données brutes (éditables si readOnly: false). magicType change le type de graphique (ligne/barres). restore réinitialise. saveAsImage exporte en PNG/SVG. Chaque fonctionnalité a sa propre 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] }]
});Data zoom via la toolbox
Le dataZoom de la toolbox ajoute des boutons « zoom avant/arrière » pour la sélection par glisser. Combinez avec les composants dataZoom : 'inside' (gestes souris/tactile) et 'slider' (une barre déplaçable). yAxisIndex: 'none' restreint le zoom à x. Pour des séries temporelles à des milliers de points, le dataZoom est essentiel pour naviguer.
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 (éditer les données brutes)
dataView montre les données sous-jacentes du graphique. readOnly: false permet aux utilisateurs de modifier et re-rendre. optionToContent/contentToOption permettent de personnaliser entièrement la vue (ex. un tableau HTML au lieu de JSON). Utile pour déboguer ou laisser les utilisateurs avancés ajuster les données. Les modifications déclenchent un re-rendu.
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;
}
}
}
}
});Magic type et restore
magicType permet aux utilisateurs de basculer entre ligne/barres et dispositions empilée/carrelée à l'exécution — ECharts gère la conversion. restore ramène toutes les modifications de la toolbox à l'option d'origine. L'événement magicTypeChanged permet de réagir aux changements de type (ex. mettre à jour les labels). Parfait pour explorer sans code supplémentaire.
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);
});Enregistrer en image
saveAsImage exporte le graphique en PNG/JPG. pixelRatio: 2 double la résolution pour retina. excludeComponents retire des éléments (comme la toolbox) de l'export. getDataURL renvoie une chaîne base64 pour un téléchargement ou un envoi par programme. Le renderer SVG exporte des images vectorielles plus propres quand le type est 'svg'.
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'
});Marqueurs (MarkPoint / MarkLine / MarkArea)
MarkPoint (points en évidence)
markPoint attire l'attention sur des points précis. Types intégrés : 'max', 'min', 'average'. Vous pouvez aussi préciser coord: [x, y] pour des points personnalisés. symbolSize met à l'échelle le marqueur. Les MarkPoints flottent au-dessus des séries — ils n'affectent pas l'échelle des axes. Utile pour signaler des extrêmes ou des événements.
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 (lignes de référence)
markLine trace des lignes de référence. type: 'average' dessine une horizontale à la moyenne. { yAxis: 60 } trace une horizontale personnalisée (seuils, objectifs). { xAxis: 'Wed' } trace une verticale (marqueurs d'événements). symbol: 'none' retire les flèches d'extrémité pour un rendu plus épuré.
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 (régions en évidence)
markArea ombrage une région du graphique. data est un tableau de paires [début, fin] — chaque paire définit un rectangle par coordonnées (valeurs xAxis/yAxis). Utile pour surligner les heures ouvrées, les week-ends, les récessions ou toute période d'intérêt. silent: false le fait réagir aux événements de survol.
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' }
}
}]
});Marqueurs combinés
Combinez markPoint, markLine et markArea sur une même série. Un graphique d'analyse typique met en évidence le pic (markPoint), montre la moyenne et l'objectif (markLine) et ombrage une période notable (markArea). Chaque marqueur a son style indépendant. N'en abusez pas — trop de marqueurs encombrent le graphique.
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)' } }
]]
}
}]
});Marqueurs avec coordonnées personnalisées
Pour des positions personnalisées, utilisez coord: [x, y] au lieu des types intégrés. Un markLine avec coordonnées personnalisées prend un tableau de deux objets coord (début et fin) — vous pouvez tracer des lignes arbitraires (diagonales, droites de régression). symbol: 'pin' change la forme du markPoint. Cela permet d'annoter des points de données précis.
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 et interaction
Options d'animation
Contrôle global de l'animation. animationDuration est la durée de l'animation d'entrée. Les noms d'easing incluent 'linear','cubicOut','elasticOut','bounceOut'. animationDelay en fonction décale les éléments (idx * 100 fait apparaître chaque barre 100 ms après la précédente). Pour les gros jeux de données, animationThreshold désactive automatiquement l'animation pour rester performant.
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] }]
});Fonctions d'easing
ECharts propose plus de 30 fonctions d'easing. 'cubicOut' (défaut) est une décélération naturelle. 'elasticOut' et 'bounceOut' ajoutent un dépassement ludique. 'sinusoidalInOut' est fluide et neutre. Pour la data viz, préférez des easings discrets (cubic, sinusoidal) — les animations rebondissantes distraient des données. Accordez l'easing à la personnalité de votre marque.
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] }]
});Animation de chargement
showLoading affiche un spinner en surcoule pendant le chargement des données. Appelez hideLoading une fois les données prêtes. C'est le pattern standard des données asynchrones — montrer le chargement, récupérer, masquer, setOption. Personnalisez la couleur du spinner et le message pour coller à votre app. Le masque empêche l'interaction pendant le chargement.
// 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 }] });
});API d'événements
chart.on lie des gestionnaires d'événements. Événements courants : click, dblclick, mouseover, legendselectchanged, datazoom, pieselectchanged. params transporte les infos du composant. dispatchAction déclenche des actions (highlight, showTip, dataZoom) — utile pour synchroniser une UI externe avec le graphique ou montrer des tooltips par programme.
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 });Éléments graphiques (formes personnalisées)
graphic permet de superposer des formes personnalisées (texte, cercles, rects, images) au graphique — utile pour les filigranes, messages d'état vide ou annotations. Les éléments gèrent le positionnement (left/top/right/bottom en px ou %), le style et les événements. Ils se rendent au-dessus ou en dessous du graphique selon z. C'est l'échappatoire quand les options standard ne suffisent pas.
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
}
]
}
});Snippets ECharts associés
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?