Primeros pasos
Configuración y primer gráfico
ECharts se inicializa sobre un elemento del DOM con width/height explícitos. setOption configura el gráfico completo. Apache ECharts (antes Baidu ECharts) es una de las librerías de gráficos JS más potentes.
<!-- 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 con tema y renderer
init recibe (dom, theme, opts). El renderer 'svg' es más nítido a cualquier zoom y produce un DOM más pequeño en gráficos simples, mientras que 'canvas' es más rápido con grandes datasets. devicePixelRatio controla la nitidez en retina. Llama siempre a dispose() al eliminar un gráfico para liberar memoria.
// 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();Redimensionado responsivo
ECharts no se redimensiona solo cuando cambia su contenedor — debes llamar a chart.resize(). ResizeObserver es la forma moderna de vigilar el tamaño del contenedor (mejor que el resize de la ventana para cambios guiados por el layout). Llama siempre a dispose() al desmontar para evitar fugas en SPAs.
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());Modos de fusión de setOption
Por defecto setOption fusiona en profundidad las opciones nuevas con las existentes, así que puedes actualizar piezas individuales. notMerge: true reemplaza toda la opción (útil cuando cambia el número de series). replaceMerge apunta a tipos de componente concretos (series, xAxis) para reemplazo parcial. lazyUpdate agrupa varias llamadas setOption en un solo render.
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 });Ciclo de vida: getInstanceByDom y dispose
Llamar a init sobre un DOM que ya tiene un gráfico lanza un error. Usa getInstanceByDom para comprobarlo. dispose() libera memoria y elimina el gráfico; el elemento del DOM se mantiene. El atributo _echarts_instance_ marca los contenedores de gráficos — consúltalo para encontrar y limpiar gráficos sueltos. Haz siempre dispose en los hooks de desmontaje del 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));Gráficos de barras
Barras básicas
Un gráfico de barras necesita un xAxis de categoría y un yAxis de valor. Cada valor de series.data se mapea a una categoría. itemStyle controla la apariencia de las barras. Para barras verticales, el eje de categorías es x; para barras horizontales, intercambia los tipos de los ejes x e 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' }
}]
});Barras agrupadas y apiladas
Varias series de barras con el mismo xAxis se agrupan por defecto. Para apilarlas, dale a cada serie el mismo nombre de stack. El apilado acumula los valores por categoría. Usa stack: 'total' en todas las series que deban apilarse juntas — las series sin nombre de stack siguen agrupándose.
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] }
]
});Barras horizontales
Una barra horizontal es simplemente un gráfico de barras con el eje de categorías en yAxis y el de valores en xAxis. Las etiquetas con position: 'right' se sitúan al final de la barra. Las barras horizontales son mejores para nombres de categoría largos o al comparar muchas categorías — evitan las etiquetas rotadas.
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
}
}]
});Barras con fondo y esquinas redondeadas
showBackground dibuja una pista detrás de cada barra (estilo barra de progreso). itemStyle.borderRadius redondea las esquinas de las barras — pasa [topLeft, topRight, bottomRight, bottomLeft] para barras verticales; orden inverso para horizontales. borderRadius puede ser un número (todas las esquinas) o un array.
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
}
}]
});Carrera de barras (dinámica)
Una carrera de barras anima el reordenamiento. Ordena el array de datos y actualiza tanto las categorías del yAxis como los datos de las series. animationDurationUpdate controla la suavidad de la transición. yAxis.inverse: true pone el valor mayor arriba. Es popular para historias de datos animadas.
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);Ancho y hueco de las barras
barWidth acepta píxeles o porcentaje de la banda de categoría. barGap es el hueco entre barras dentro de un grupo (solo importa con varias series). barCategoryGap es el hueco entre grupos. Los porcentajes son relativos a la banda de categoría, así que se mantienen proporcionales al redimensionar.
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
}]
});Gráficos de líneas
Línea básica
Un gráfico de líneas usa type: 'line'. Los puntos se muestran por defecto con marcadores; fija symbol: 'none' para ocultarlos. La línea conecta los puntos en el orden de los datos. Para series temporales, usa type: 'time' en xAxis con pares [timestamp, valor].
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
}]
});Línea suave y área
smooth: true curva la línea (interpolación Catmull-Rom). areaStyle rellena el área bajo la línea; un degradado (paradas de color lineales) da un aspecto desvanecido. boundaryGap: false en el eje de categorías hace que la línea empiece en el borde del eje y en lugar de dejar un hueco.
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)' }
]
}
}
}]
});Línea multiserie
Varias series se renderizan como líneas separadas, distinguidas por color. La leyenda alterna la visibilidad. lineStyle.type acepta 'solid', 'dashed', 'dotted'. Cada serie puede tener su propio estilo. El nombre en la leyenda debe coincidir con 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' }
}
]
});Área apilada
Los gráficos de área apilada usan type: 'line' con el mismo nombre de stack y un areaStyle. Cada serie se apila sobre la anterior. emphasis.focus: 'series' resalta toda la serie al pasar el ratón. Útil para mostrar la composición a lo largo del tiempo (por ejemplo, tráfico por fuente).
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]
}
]
});Línea escalonada
step convierte una línea en una escalera. 'start' escala antes del punto, 'middle' (simétrico) en el punto, 'end' después. Los gráficos escalonados son geniales para valores que cambian de forma discreta (niveles de inventario, estado del servidor) en lugar de continua.
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 }
}]
});Línea con eje temporal
Con type: 'time', el eje formatea las fechas automáticamente y maneja intervalos irregulares. Los puntos de datos son pares [timestamp, valor]. ECharts espacia los puntos según su tiempo real, así que los huecos en los datos se muestran correctamente. Es la elección correcta para series temporales con intervalos 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
}]
});Gráficos de pie
Pie básico
Los gráficos de pie no usan ejes — series.data es un array de {value, name}. radius controla el tamaño del pie como porcentaje de la dimensión menor del contenedor. Los estilos emphasis se aplican al pasar el ratón. La leyenda deriva automáticamente las etiquetas 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)'
}
}
}]
});Pie tipo doughnut (anillo)
Fjar radius en [interior, exterior] crea un doughnut. Una etiqueta central es un patrón común (mostrar el total o un KPI). avoidLabelOverlap: false mantiene las etiquetas donde están. El radio interior controla el grosor del anillo — [50%, 70%] es un anillo fino; [0%, 70%] es un pie completo.
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' }
]
}]
});Gráfico de rosa (Nightingale)
roseType hace que el radio de cada sector sea proporcional al valor (rosa de Nightingale). 'area' usa sqrt(valor) para el radio (proporcional al área), 'radius' usa el valor directamente. Cada sector tiene el mismo ángulo pero distinto radio. Bueno para comparar magnitudes donde solo el ángulo es difícil de juzgar.
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 }
}]
});Pie con etiquetas personalizadas
label.formatter soporta variables de plantilla: {a} (nombre de serie), {b} (nombre del dato), {c} (valor), {d} (porcentaje). labelLine controla la línea conectora. length es el segmento cerca del sector, length2 el segmento cerca de la etiqueta. Las etiquetas personalizadas hacen los gráficos de pie mucho más legibles.
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' }
]
}]
});Pie semicircular
Combinar startAngle y endAngle crea pies parciales (medio, cuarto, tipo indicador). center posiciona el pie — ['50%','70%'] lo empuja hacia abajo para que un pie de 180° quede abajo. Los pies parciales suelen usarse como indicadores o en dashboards estilizados.
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' }
]
}]
});Gráficos de dispersión
Dispersión básica
Los gráficos de dispersión usan dos ejes de valor; cada punto de datos es [x, y]. symbolSize controla el tamaño del punto (fijo o por punto mediante una función). El scatter revela la correlación entre dos variables. Ambos ejes son type: 'value' (numéricos), a diferencia de bar/line basados en categorías.
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' }
}]
});Gráfico de burbujas (tamaño por valor)
Un gráfico de burbujas es un scatter donde el tamaño del punto codifica una tercera dimensión. Pasa [x, y, tamaño] por punto y fija symbolSize a una función que devuelva el tamaño. La función corre por punto, así que cada burbuja escala de forma independiente. Útil para datos de 3 variables sin un gráfico 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
}
}]
});Dispersión con visualMap (color por valor)
visualMap mapea una dimensión de datos a color. dimension: 2 colorea por el tercer elemento (índice 2) de cada punto. inRange.color define el degradado. Esto añade una cuarta dimensión (color) al scatter. El componente visualMap muestra la leyenda con un deslizador.
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
}]
});Efecto scatter (animado)
effectScatter añade una animación de onda alrededor de cada punto — genial para resaltar puntos clave (alertas, ciudades principales). showEffectOn controla cuándo se reproduce la onda. brushType: 'stroke' es más ligero; 'fill' es más prominente. Úsalo con moderación — demasiadas ondas distraen.
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
}
}]
});Dispersión a gran escala
Para miles de puntos, activa el renderizado progresivo — ECharts divide los datos en fragmentos y los renderiza a lo largo de varios fotogramas para evitar congelaciones. large: true usa una única llamada de dibujo optimizada. Combínalo con un symbolSize pequeño y opacidad para manejar el solapamiento. Esto mantiene suaves 50k+ puntos.
// 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 }
}]
});Gráficos de radar
Radar básico
Los gráficos de radar necesitan un array radar.indicator que defina cada eje (nombre y max). Los datos de la serie son un array de valores que coincide con los indicadores. El radar es genial para comparar varios atributos de pocos ítems (estadísticas de jugadores, comparación de productos). max fija la escala de cada eje.
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 multiserie
Varias entradas de datos se renderizan como polígonos superpuestos, ideal para comparar. Cada entrada necesita un nombre único que coincida con la leyenda. Demasiadas series (5+) hacen los gráficos de radar ilegibles — los polígonos se solapan en una mancha. Quédate con 2-4 ítems por claridad.
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 con área
areaStyle rellena el polígono del radar con un color semitransparente, haciendo la forma más fácil de leer. lineStyle enfatiza el contorno. Mantén la opacidad de areaStyle baja (0.2-0.4) para que las series superpuestas sigan siendo visibles. Los símbolos marcan cada vértice.
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
}]
});Forma y ejes del radar
shape: 'polygon' (por defecto) da ejes angulares; 'circle' hace anillos suaves. splitNumber controla la densidad de la cuadrícula. splitArea alterna colores para un efecto cebra. axisName estiliza las etiquetas de los ejes. Estas opciones controlan la estructura visual del gráfico sin tocar los datos.
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] }] }]
});Radio polar del radar
radius: [interior, exterior] crea un radar con forma de anillo (como un doughnut). center posiciona el gráfico. min en un indicador fija dónde empieza el eje — útil cuando los valores son consistentemente altos (evita un polígono minúsculo en el centro). Ajusta center para dejar sitio a las etiquetas de los ejes.
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] }]
}]
});Mapas de calor
Mapa de calor cartesiano
Un mapa de calor cartesiano necesita un visualMap para colorear las celdas. Los datos son [x, y, valor]. label: { show: true } imprime los valores en las celdas (solo bueno para cuadrículas pequeñas). calculable: true añade un tirador de deslizador. Los mapas de calor revelan patrones de densidad (por ejemplo, actividad por horas).
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 }
}]
});Mapa de calor de calendario
Los mapas de calor de calendario muestran valores diarios a lo largo de un año (gráfico de contribuciones estilo GitHub). calendar.range fija el año o rango de fechas. Los puntos de datos son [cadenaDeFecha, valor]. El degradado del visualMap define las paradas de color. cellSize controla el tamaño del cuadrado — 'auto' encaja con el contenedor.
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 }]
});Estilo de ítem del mapa de calor
itemStyle.borderColor y borderWidth crean un efecto de separación de cuadrícula (los bordes blancos distinguen las celdas). borderRadius redondea las esquinas de las celdas. Los estilos emphasis se aplican al pasar el ratón. Un visualMap oculto (show: false) sigue guiando los colores sin mostrar la leyenda.
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 }
}
}]
});Mapa de calor de punch card
Una punch card es un mapa de calor de 7x24 que muestra la actividad por día de la semana y hora. Cada celda es una franja horaria. El itemStyle redondeado hace que parezcan puntos. Las punch cards revelan patrones semanales (por ejemplo, cuándo está más ocupado un servidor). Los datos son una cuadrícula completa de 168 celdas.
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' }
}]
});Mapa de calor sobre mapa geográfico
Combinar geo con una serie de mapa colorea las regiones por valor. visualMap guía la escala de color. Debes registrar primero un mapa vía echarts.registerMap('china', geoJson). roam: true habilita desplazamiento/zoom. Así se construyen los mapas de coropletas (color por región).
// 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 }
]
}]
});Gráficos de árbol
Árbol básico (vertical)
Los gráficos de árbol renderizan datos jerárquicos. layout: 'orthogonal' con orient: 'LR' hace un árbol de izquierda a derecha. expandAndCollapse permite a los usuarios hacer clic para plegar/desplegar subárboles. leaves configura el estilo de los nodos hoja. El árbol es perfecto para organigramas, árboles de archivos y taxonomías.
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
}]
});Árbol horizontal
orient: 'LR' produce un árbol horizontal (raíz a la izquierda, hojas a la derecha). Las etiquetas de los nodos internos quedan a la IZQUIERDA del nodo; las de las hojas a la DERECHA — esto evita el solapamiento con las ramas. curveness en lineStyle crea conectores curvos para un aspecto más suave.
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 }
}]
});Árbol radial
layout: 'radial' coloca la raíz en el centro e irradia los hijos hacia afuera en círculo. Funciona bien para árboles grandes donde un layout horizontal sería demasiado ancho. emphasis.focus: 'descendant' resalta la descendencia completa al pasar el ratón, ayudando a seguir las ramas.
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 }
}]
});Árbol con símbolos personalizados
symbol y symbolSize aceptan funciones para personalizar por nodo. Aquí los nodos internos (con hijos) son rectángulos mayores mientras que las hojas son círculos pequeños. Esto distingue visualmente los niveles de jerarquía. Combínalo con orient: 'TB' para un organigrama clásico de arriba abajo.
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 }
}]
});Control de expansión/colapso del árbol
initialTreeDepth controla cuántos niveles hay abiertos al inicio (null = la profundidad completa, 0 = solo la raíz). Hacer clic en un nodo con hijos alterna su subárbol. El evento click te permite reaccionar a la selección de nodos — útil para interfaces de drill-down. animationDurationUpdate suaviza expandir/colapsar.
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);
}
});Gráficos de sunburst
Sunburst básico
Sunburst es un árbol radial donde cada anillo representa un nivel de jerarquía. Interior = padre, exterior = hijos. El valor de cada nodo determina su tamaño angular. radius: [0, '90%'] hace un disco completo; [interior, exterior] crea un sunburst anular. Genial para visualizar proporciones jerárquicas.
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 con niveles
levels configura cada anillo por separado — la primera entrada es la raíz, las siguientes se mapean a niveles más profundos. r0/r fijan el radio interior/exterior de ese nivel. Distintas rotaciones de etiqueta (radial, tangencial, 0) mantienen el texto legible en cada profundidad. Esto da un control de estilo muy fino.
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 }
}
]
}]
});Estilo y resaltado del sunburst
emphasis.focus: 'ancestor' resalta el camino desde el nodo bajo el cursor hasta la raíz — los usuarios ven dónde encaja un sector en la jerarquía. borderWidth separa visualmente los sectores. El sunburst es interactivo: hacer clic suele hacer drill-down. Usa el resaltado de ancestros para mantener el contexto en árboles profundos.
chart.setOption({
series: [{
type: 'sunburst',
data: data,
itemStyle: {
borderColor: '#fff',
borderWidth: 1
},
emphasis: {
focus: 'ancestor' // highlight ancestors on hover
},
highlight: {
itemStyle: { color: '#ffb' }
}
}]
});Sunburst con valor y ordenación
sort controla el orden de los sectores dentro de un padre. nodeClick: 'zoomToNode' hace que un clic haga zoom en ese subárbol (genial para explorar). minAngle oculta las etiquetas de sectores menores de 5 grados, evitando el desorden. El valor de los nodos padres se suma automáticamente de los hijos si se omite.
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 de sunburst
Los manejadores de clic personalizados te permiten construir tu propia UX de drill-down. Reemplaza los datos por el nodo clicado para hacer zoom. Guarda una referencia al padre si quieres un botón de 'volver'. El drill-down de sunburst es excelente para explorar jerarquías profundas sin saturar la pantalla.
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 });
}
});Diagramas de Sankey
Sankey básico
Sankey muestra flujos entre nodos. data son los nodos (con nombres); links son los flujos (source, target, value). El ancho de cada enlace es proporcional al valor. emphasis.focus: 'adjacency' resalta los nodos conectados al pasar el ratón. Genial para visualizar flujos de energía, dinero o usuarios.
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 }
}]
});Niveles de nodos del Sankey
levels estiliza los nodos por profundidad (columna). lineStyle.color: 'source' colorea los enlaces para que coincidan con el nodo origen; 'target' coincide con el destino; 'gradient' mezcla. nodeAlign posiciona los nodos verticalmente dentro de una columna. Fjar depth explícitamente fuerza la colocación en columna, anulando el layout automático.
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'
}]
});Estilo y hueco de los nodos del Sankey
nodeWidth fija cuán grueso es cada rectángulo de nodo. nodeGap controla el espaciado vertical. Huecos menores muestran más nodos pero pueden solaparse. lineStyle.opacity hace sutiles los flujos para que los nodos destaquen. label.position: 'right' pone las etiquetas junto a los nodos — común en flujos de izquierda a derecha.
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 con ciclo (drenaje)
Los ciclos verdaderos hacen fallar el Sankey de ECharts. La solución es dividir un nodo de recirculación en nodos 'entrada' y 'salida' separados (por ejemplo, 'Reciclar') para que el flujo sea acíclico. Esto representa visualmente los bucles de retroalimentación. Verifica siempre la conservación del flujo: el total de entrada de un nodo debería igualar al total de salida.
// 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' }
}]
});Interacción del Sankey
Los eventos de clic del Sankey distinguen nodos de aristas vía dataType. Úsalo para construir paneles de detalle que muestren las especificidades del flujo. label.formatter: '{b}: {c}' muestra nombre y valor. El foco de adyacencia resalta el camino completo a través de un nodo bajo el cursor, revelando cadenas de causa y efecto.
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);
}
});Gráficos de embudo
Embudo básico
Un embudo muestra las etapas de un proceso donde cada etapa tiene menos ítems. sort: 'descending' (por defecto) pone la etapa mayor arriba. Los datos deberían ordenarse según el flujo del proceso. Los embudos son perfectos para pipelines de ventas, análisis de conversión y pasos de 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'
}]
});Embudo con orden y hueco
sort: 'ascending' invierte el embudo (el menor arriba, como un gráfico de crecimiento). gap separa los sectores para legibilidad. funnelAlign posiciona los sectores horizontalmente. minSize/maxSize acotan los anchos de los sectores como porcentajes, asegurando que las etapas diminutas sigan siendo 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%'
}]
});Etiquetas del embudo
position: 'inside' superpone las etiquetas sobre los sectores; 'left'/'right' las coloca fuera con líneas conectoras (labelLine). formatter: '{b}: {c}' muestra nombre y valor. Usa etiquetas exteriores cuando los sectores son demasiado finos para texto interior. Emphasis agranda la etiqueta al pasar el ratón.
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 }
}
}]
});Estilo de ítem del embudo
El itemStyle por sector sobrescribe el ciclo de colores por defecto. borderColor separa visualmente los sectores. También puedes fijar color en los ítems de datos individuales. Para un aspecto pulido, usa una paleta de colores secuencial (más claro en las etapas iniciales, más oscuro en las convertidas) para reforzar la metáfora del embudo.
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
}
}]
});Embudo comparativo
Varias series de embudo pueden situarse lado a lado para comparar periodos. Dale a cada serie su propio left/width para posicionarlas. Es genial para visualizar tests A/B o comparar la conversión año contra año. Usa colores contrastantes por serie para distinguirlas.
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' }
}
]
});Gráficos de indicador (gauge)
Gauge básico
Un gauge muestra un único valor sobre un arco. min/max fijan la escala. progress muestra un arco de color hasta el valor (con axisLine como pista). detail renderiza el texto del valor en el centro. valueAnimation transiciona suavemente el número. Genial para KPIs y dashboards de una sola métrica.
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 con puntero
El estilo de puntero es el aspecto clásico del gauge. anchor es el pin central. Los valores negativos de distance empujan las marcas/etiquetas hacia adentro (hacia el centro). radius escala el gauge completo. Combina el puntero con splitLine para imitar un instrumento físico. Útil cuando quieres una sensación analógica.
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 con bandas de color
axisLine.lineStyle.color acepta un array de pares [umbral, color] para crear zonas de color (por ejemplo, rojo/amarillo/verde para niveles de riesgo). Los umbrales son fracciones (0-1). Es la forma estándar de mostrar rangos 'seguro/aviso/peligro' en un gauge. El puntero o el arco de progreso indica el valor actual dentro de estas zonas.
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 multipuntero
Varias entradas de datos crean varios punteros sobre el mismo gauge. Útil para comparar métricas relacionadas (CPU vs memoria vs disco). Cada valor se anima de forma independiente. Mantén la cuenta baja (3-5 como máximo) o el gauge se vuelve saturado. Los nombres aparecen como etiquetas junto a cada puntero.
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 }
}]
});Gauge personalizado (progreso circular)
Fjar startAngle/endAngle para abarcar 360° crea un anillo de progreso circular (como los anillos del Apple Watch). Ocultar puntero/marcas/etiquetas da un aspecto minimalista limpio. roundCap redondea los extremos del progreso. Este estilo es popular en dashboards modernos — es un gauge disfrazado de anillo.
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 }]
}]
});Sistemas de coordenadas
Múltiples ejes X
xAxis es un array — cada entrada es un eje independiente. Las series se enlazan a un eje vía xAxisIndex (base 0). Esto permite que un gráfico muestre dos métricas con escalas o unidades distintas. Usa position para colocar los ejes arriba/abajo. Común en gráficos de acciones (precio + volumen) o meteorología (temperatura + humedad).
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 }
]
});Doble eje Y
Dos ejes y (izquierda y derecha) permiten trazar series con unidades distintas (por ejemplo, ingresos en $ vs unidades vendidas). Cada serie se enlaza a un eje vía yAxisIndex. Codifica por color la línea del eje derecho para que coincida con su serie y los usuarios sepan qué línea se lee contra qué eje. Evita 3+ ejes — se vuelven confusos.
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 }
]
});Coordenadas polares
Las coordenadas polares usan angleAxis (alrededor del círculo) y radiusAxis (hacia afuera desde el centro). Las series fijan coordinateSystem: 'polar'. startAngle: 90 pone 0° arriba (norte). Polar es genial para datos direccionales (rosa de los vientos), patrones cíclicos o variantes rosa/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'
}]
});Coordenadas de calendario
El sistema de coordenadas de calendario mapea fechas a celdas. Las series con coordinateSystem: 'calendar' se enlazan a él. cellSize puede ser en píxeles o 'auto'. orient: 'horizontal' es el layout estándar de fila por semana. dayLabel/monthLabel nameMap localiza las etiquetas. Combínalo con heatmap para gráficos de contribuciones.
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
}]
});Coordenadas paralelas
Las coordenadas paralelas trazan datos multidimensionales con un eje por dimensión. Cada fila de datos se convierte en una polilínea que cruza cada eje. Esto revela correlaciones y grupos en datos de alta dimensión (por ejemplo, comparar coches por precio, kilometraje, año, seguridad). Útil para la exploración de datos.
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']]
}]
});Configuración del mapa geográfico
registerMap enlaza un GeoJSON a un nombre para usarlo en las series geo y map. roam habilita desplazamiento/zoom con el ratón. itemStyle.areaColor rellena las regiones; borderColor las delinea. Los estilos emphasis se aplican al pasar el ratón. Geo por sí solo muestra un mapa; emparéjalo con una serie de mapa para colorear regiones por valor (coropleta).
// 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 básico
Dataset separa los datos de la configuración de las series. El source es un array 2D (primero la fila de encabezados). seriesLayoutBy: 'column' hace que cada serie tome una columna. encode mapea las columnas del dataset a x/y. Esto desacopla los datos de la presentación — útil cuando los datos se comparten entre varios gráficos.
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 con filas de objetos
El source del dataset puede ser un array de objetos (filas clave-valor). dimensions declara opcionalmente las columnas (útil cuando a las filas les pueden faltar claves). encode usa nombres de dimensión en lugar de índices por legibilidad. Las filas de objetos son más fáciles de escribir a mano y más claras por sí solas.
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' } }
]
});Transformaciones del dataset (filter/sort)
Las transformaciones encadenan datasets: filter elimina filas, sort las ordena. Cada transformación lee de fromDatasetId y expone un dataset nuevo. Las series se enlazan vía datasetId. Las transformaciones te permiten derivar vistas de una sola fuente sin copiar datos. Transformaciones soportadas: filter, sort y personalizada vía 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 y dimensions del dataset
encode mapea las columnas del dataset (por índice o nombre) a las dimensiones del gráfico. encode.tooltip lista las columnas a mostrar en el tooltip. Aquí usamos las columnas 0/1 para posición, 2 para tamaño y 3 para color (vía itemStyle). La codificación hace que el mismo dataset sea reutilizable entre tipos de gráfico distintos.
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 con pie
Los gráficos de pie necesitan mapeos itemName y value vía encode. El mismo dataset podría alimentar un gráfico de barras (encode x:name, y:value) y un gráfico de pie con codificaciones distintas. Esta es la fortaleza del dataset: una fuente, múltiples vistas. Cambiar de tipo de gráfico solo altera el type de la serie y el 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 continuo
El visualMap continuo mapea un rango numérico a color (y opcionalmente a tamaño). inRange.color es el degradado (interpolado). calculable: true añade tiradores arrastrables para filtrar. orient y left/top lo posicionan. El visualMap guía los colores de las series — no fijas itemStyle.color manualmente.
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 por tramos
El visualMap por tramos agrupa los valores en rangos discretos, cada uno con su color. pieces define los tramos (min/max/label/color). Es más claro que un degradado cuando quieres cubos categóricos (por ejemplo, riesgo bajo/medio/alto). Útil para mapas de coropletas y scatter categorizados.
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 de categorías
El visualMap de categorías mapea categorías de cadena a colores. categories lista los valores; inRange.color lista los colores correspondientes en orden. dimension selecciona qué columna de datos guía el mapeo (0 por defecto). Genial cuando tus datos tienen un atributo categórico (por ejemplo, prioridad, estado) que quieras codificar por color.
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 en línea y fuera de rango
outOfRange estiliza los puntos de datos fuera del rango seleccionado del visualMap (por ejemplo, atenuados al filtrar). controller estiliza el propio deslizador. Cuando el usuario arrastra el deslizador para filtrar, los puntos fuera de rango se desvanecen a outOfRange.color. Esto convierte al visualMap en un filtro interactivo, no solo una leyenda.
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 en varias series
Por defecto el visualMap afecta a todas las series. Usa seriesIndex (número o array) para apuntar a series concretas. Esto te permite codificar por color una serie dejando las demás intactas — útil al comparar un dataset resaltado contra una referencia. Un solo gráfico puede incluso tener varios visualMaps para distintas series.
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
});Leyenda
Leyenda básica
La leyenda lista los nombres de las series para alternar su visibilidad. data debe coincidir con series.name (o derivarse automáticamente). icon estiliza el marcador. Hacer clic en un ítem de la leyenda alterna su serie. La leyenda se actualiza automáticamente al añadir/quitar series vía 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] }
]
});Posición y layout de la leyenda
orient y top/left posicionan la leyenda. Layouts comunes: arriba-centro (por defecto), abajo-centro, derecha-vertical. itemGap controla el espaciado entre ítems de la leyenda. Un fondo/borde sutil separa visualmente la leyenda del gráfico. La posición importa — las leyendas abajo liberan espacio 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: [/* ... */]
});Selección y valores por defecto de la leyenda
selected controla la visibilidad inicial. selectedMode: 'single' hace que la leyenda funcione como botones de radio (solo una serie visible). El evento legendselectchanged se dispara con las alternancias del usuario — útil para persistir preferencias o sincronizar varios gráficos. El modo por defecto es '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);
});Leyenda desplazable
type: 'scroll' pagina la leyenda cuando hay demasiados ítems — aparecen botones de página. Es esencial para gráficos con 10+ series que de otro modo desbordarían. Los estilos de icono/texto de página personalizan la navegación. Las leyendas con scroll vertical encajan bien en el margen derecho.
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 y texto enriquecido de la leyenda
formatter personaliza las etiquetas de la leyenda (por ejemplo, mayúsculas, añadir conteos). El texto enriquecido permite estilizar partes de la etiqueta de forma distinta — define estilos en textStyle.rich y refiérete a ellos en el formatter con la sintaxis {style|text}. Esto habilita leyendas como 'A {count|42}' con estilos mezclados.
chart.setOption({
legend: {
data: ['A', 'B'],
formatter: function (name) {
return name.toUpperCase();
},
textStyle: {
rich: {
a: { color: '#5470c6', fontSize: 14, fontWeight: 'bold' },
b: { color: '#91cc75', fontSize: 12 }
}
}
},
series: [/* ... */]
});
// legend can also show values via legendselectchanged + setOption
chart.on('legendselectchanged', () => {
// dynamic label updates
});Tooltip
Tooltip básico
trigger: 'item' muestra el tooltip por punto de datos (scatter, pie). 'axis' lo muestra para toda la categoría (bar, line). axisPointer dibuja una línea guía — 'shadow' es una banda translúcida (buena para barras), 'line' es una línea fina (buena para gráficos de líneas), 'cross' muestra las líneas x e 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 del tooltip
formatter personaliza el contenido del tooltip. Una función recibe params (con name, value, seriesName, color, etc.) y devuelve HTML. Las plantillas de cadena usan {a} (nombre de serie), {b} (categoría/x), {c} (valor), {d} (porcentaje de pie). Para tooltips de eje multiserie, params es un array — itéralo.
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
}
});Miras y axis pointer del tooltip
axisPointer.link de nivel superior sincroniza los punteros entre varios gráficos (dashboards multi-gráfico) — pasa xAxisIndex: 'all'. type: 'cross' muestra una mira completa con los valores x e y en las etiquetas. crossStyle/lineStyle personalizan las líneas guía. Los punteros sincronizados son esenciales para comparar datos en gráficos apilados.
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 con trigger item
trigger: 'item' muestra el tooltip al pasar sobre un único punto de datos (porción de pie, punto de scatter). Es el valor por defecto para pie, scatter y radar. extraCssText añade CSS arbitrario (sombras, esquinas redondeadas) para estilos personalizados. percent está disponible en los gráficos de pie. Los tooltips de ítem son precisos punto a punto.
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 con contenido enriquecido
Para tooltips de eje con varias series, params es un array. Itéralo para construir una tabla HTML rica con marcadores de color, valores y formato. Así construyes tooltips profesionales con alineación, totales o unidades. Devolver HTML da control total del estilo vía CSS en línea.
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
Funciones del toolbox
Toolbox añade iconos de acción (arriba a la derecha por defecto). dataZoom permite a los usuarios arrastrar-seleccionar para hacer zoom. dataView muestra los datos crudos (editables si readOnly: false). magicType cambia el tipo de gráfico (línea/barra). restore restablece. saveAsImage exporta PNG/SVG. Cada función tiene su propia configuración.
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 vía toolbox
El dataZoom del toolbox añade botones de 'acercar/alejar' para selección por arrastre. Combínalo con los componentes dataZoom: 'inside' (gestos de ratón/táctil) y 'slider' (una barra arrastrable). yAxisIndex: 'none' restringe el zoom al eje x. Para series temporales con miles de puntos, dataZoom es esencial para navegar.
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 (editar datos crudos)
dataView muestra los datos subyacentes del gráfico. readOnly: false permite a los usuarios editar y volver a renderizar. optionToContent/contentToOption te permiten personalizar por completo la vista (por ejemplo, una tabla HTML en lugar de JSON). Útil para depurar o dejar que usuarios avanzados ajusten los datos. Las ediciones disparan un re-render.
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 y restore
magicType permite a los usuarios cambiar entre layouts línea/barra y apilado/adosado en tiempo de ejecución — ECharts maneja la conversión. restore revierte los cambios del toolbox a la opción original. El evento magicTypeChanged te permite reaccionar a los cambios de tipo (por ejemplo, actualizar etiquetas). Genial para explorar sin código extra.
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);
});Guardar como imagen
saveAsImage exporta el gráfico como PNG/JPG. pixelRatio: 2 duplica la resolución para retina. excludeComponents elimina elementos (como el toolbox) de la exportación. getDataURL devuelve una cadena base64 para descarga o subida programática. El renderer SVG exporta imágenes vectoriales más limpias cuando el type es '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'
});Marcas (MarkPoint / MarkLine / MarkArea)
MarkPoint (resaltar puntos)
markPoint llama la atención sobre puntos concretos. Tipos integrados: 'max', 'min', 'average'. También puedes especificar coord: [x, y] para puntos personalizados. symbolSize escala el marcador. Los MarkPoints flotan sobre la serie — no afectan al escalado de los ejes. Útil para señalar extremos o eventos.
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 (líneas de referencia)
markLine dibuja líneas de referencia. type: 'average' dibuja una línea horizontal en la media. { yAxis: 60 } dibuja una línea horizontal personalizada (umbrales, objetivos). { xAxis: 'Wed' } dibuja una línea vertical (marcadores de eventos). symbol: 'none' elimina las flechas de los extremos para un aspecto más limpio.
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 (resaltar regiones)
markArea sombrea una región del gráfico. data es un array de pares [inicio, fin] — cada par define un rectángulo mediante coord (valores de xAxis/yAxis). Útil para resaltar horarios laborales, fines de semana, recesiones o cualquier lapso de interés. silent: false hace que responda a los eventos hover.
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' }
}
}]
});Marcas combinadas
Combina markPoint, markLine y markArea en una sola serie. Un gráfico de análisis típico resalta el pico (markPoint), muestra la media y el objetivo (markLine) y sombrea un periodo notable (markArea). Cada marca tiene estilo independiente. No exageres — demasiadas marcas saturan el gráfico.
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)' } }
]]
}
}]
});Marcas con coordenadas personalizadas
Para posiciones personalizadas, usa coord: [x, y] en lugar de los tipos integrados. Un markLine con coordenadas personalizadas toma un array de dos objetos coord (inicio y fin) — puedes dibujar líneas arbitrarias (diagonales, líneas de tendencia de una regresión). symbol: 'pin' cambia la forma del markPoint. Esto habilita anotaciones sobre puntos de datos concretos.
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
]
}
}]
});Animación e interacción
Opciones de animación
Controla la animación globalmente. animationDuration es la duración de la animación de entrada. Los nombres de easing incluyen 'linear','cubicOut','elasticOut','bounceOut'. animationDelay como función escalona los ítems (idx * 100 hace que cada barra aparezca 100ms después de la anterior). Para datasets grandes, animationThreshold desactiva la animación automáticamente para mantener el rendimiento.
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] }]
});Funciones de easing
ECharts soporta más de 30 funciones de easing. 'cubicOut' (por defecto) es una desaceleración natural. 'elasticOut' y 'bounceOut' añaden un sobrepaso juguetón. 'sinusoidalInOut' es suave y neutra. Para visualización de datos, prefiere easings sutiles (cubic, sinusoidal) — las animaciones con rebote distraen de los datos. Ajusta el easing a la personalidad de tu marca.
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] }]
});Animación de carga
showLoading muestra una capa con spinner mientras se obtienen los datos. Llama a hideLoading una vez listos los datos. Este es el patrón estándar de datos asíncronos — mostrar carga, obtener, ocultar carga, setOption. Personaliza el color del spinner y el mensaje para que coincidan con tu app. La máscara impide la interacción del usuario durante la carga.
// 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 de eventos
chart.on enlaza manejadores de eventos. Eventos comunes: click, dblclick, mouseover, legendselectchanged, datazoom, pieselectchanged. params lleva la información del componente. dispatchAction dispara acciones (highlight, showTip, dataZoom) — útil para sincronizar una UI externa con el gráfico o mostrar tooltips programáticamente.
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 });Elementos gráficos (formas personalizadas)
graphic te permite superponer formas personalizadas (texto, círculos, rectángulos, imágenes) sobre el gráfico — útil para marcas de agua, mensajes de estado vacío o anotaciones. Los elementos soportan posicionamiento (left/top/right/bottom en px o %), estilos y eventos. Se renderizan encima o debajo del gráfico según z. Es la vía de escape cuando las opciones estándar no bastan.
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
}
]
}
});Fragmentos de ECharts relacionados
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?