Skip to content

ECharts Hoja de referencia

Potente librería de gráficos y visualización de Apache.

01

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.

echarts
<!-- include ECharts -->
<script src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js"></script>

<div id="chart" style="width: 600px; height: 400px;"></div>

<script>
const chart = echarts.init(document.getElementById('chart'));
chart.setOption({
  title: { text: 'Sales' },
  xAxis: { data: ['Q1', 'Q2', 'Q3', 'Q4'] },
  yAxis: {},
  series: [{
    type: 'bar',
    data: [100, 200, 150, 300]
  }]
});
</script>

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

echarts
// register a theme (defined elsewhere or imported)
echarts.registerTheme('myTheme', {
  color: ['#5470c6', '#91cc75'],
  backgroundColor: '#f5f5f5'
});

// renderer: 'canvas' (default, faster) or 'svg' (sharper, lighter)
const chart = echarts.init(document.getElementById('chart'), 'myTheme', {
  renderer: 'svg',
  devicePixelRatio: 2,
  width: 800,
  height: 600,
  locale: 'EN'
});

// detached from DOM later
chart.dispose();

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.

echarts
const chart = echarts.init(document.getElementById('chart'));
chart.setOption({ /* ... */ });

// resize when window changes
window.addEventListener('resize', () => chart.resize());

// or observe the container
const ro = new ResizeObserver(() => chart.resize());
ro.observe(document.getElementById('chart'));

// resize with explicit size
chart.resize({ width: 500, height: 300, silent: false });

// cleanup
window.addEventListener('unload', () => chart.dispose());

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.

echarts
const chart = echarts.init(document.getElementById('chart'));

// merge (default): deep-merges with existing option
chart.setOption({ xAxis: { data: ['A', 'B'] } });

// notMerge: replace entire option (old config discarded)
chart.setOption({ xAxis: { data: ['X', 'Y'] } }, { notMerge: true });

// replaceMerge: replace specific component types only
chart.setOption(
  { series: [{ type: 'bar', data: [5, 6] }] },
  { replaceMerge: ['series'] }
);

// lazyUpdate: batch updates, apply on next frame
chart.setOption({ series: [{ data: [1, 2] }] }, { lazyUpdate: true });

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.

echarts
function mountChart(dom) {
  // avoid double-init on the same DOM node
  const existing = echarts.getInstanceByDom(dom);
  if (existing) return existing;

  const chart = echarts.init(dom);
  chart.setOption({ /* ... */ });
  return chart;
}

// in a framework cleanup (React useEffect / Vue onUnmounted):
function unmount(dom) {
  const chart = echarts.getInstanceByDom(dom);
  if (chart) chart.dispose();  // free memory + remove DOM
}

// dispose all charts on a page
echarts.disposeAll?.();  // not built-in; iterate manually
Array.from(document.querySelectorAll('[_echarts_instance_]'))
  .forEach(dom => echarts.dispose(dom));
02

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.

echarts
chart.setOption({
  xAxis: {
    type: 'category',
    data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri']
  },
  yAxis: { type: 'value' },
  series: [{
    type: 'bar',
    data: [120, 200, 150, 80, 70],
    itemStyle: { color: '#5470c6' }
  }]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'category', data: ['Q1', 'Q2', 'Q3', 'Q4'] },
  yAxis: { type: 'value' },
  // GROUPED: multiple series render side by side
  series: [
    { type: 'bar', name: 'A', data: [10, 20, 30, 40] },
    { type: 'bar', name: 'B', data: [15, 25, 35, 45] }
  ]
});

// STACKED: add stack with same name to each series
chart.setOption({
  series: [
    { type: 'bar', name: 'A', stack: 'total', data: [10, 20, 30, 40] },
    { type: 'bar', name: 'B', stack: 'total', data: [15, 25, 35, 45] }
  ]
});

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.

echarts
chart.setOption({
  // swap: category axis becomes yAxis
  yAxis: {
    type: 'category',
    data: ['Apple', 'Banana', 'Cherry', 'Date']
  },
  xAxis: { type: 'value' },
  series: [{
    type: 'bar',
    data: [120, 200, 150, 80],
    label: {
      show: true,
      position: 'right'  // label at end of bar
    }
  }]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'category', data: ['A', 'B', 'C', 'D'] },
  yAxis: { type: 'value' },
  series: [{
    type: 'bar',
    data: [50, 80, 60, 90],
    showBackground: true,
    backgroundStyle: {
      color: 'rgba(180, 180, 180, 0.2)',
      borderRadius: [4, 4, 0, 0]
    },
    itemStyle: {
      borderRadius: [8, 8, 0, 0]  // round top corners
    }
  }]
});

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.

echarts
const data = [
  { name: 'A', value: 10 },
  { name: 'B', value: 20 }
];

chart.setOption({
  xAxis: { type: 'value', max: 100 },
  yAxis: { type: 'category', inverse: true },
  series: [{
    type: 'bar',
    data: data.map(d => ({ value: d.value, name: d.name })),
    label: { show: true, position: 'right' },
    // sort bars by value on each update
    animationDuration: 500,
    animationDurationUpdate: 500
  }]
});

// update data on interval
setInterval(() => {
  data.forEach(d => d.value += Math.random() * 10);
  data.sort((a, b) => b.value - a.value);
  chart.setOption({
    yAxis: { data: data.map(d => d.name) },
    series: [{ data: data.map(d => d.value) }]
  });
}, 1000);

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.

echarts
chart.setOption({
  xAxis: { type: 'category', data: ['A', 'B', 'C', 'D'] },
  yAxis: { type: 'value' },
  series: [{
    type: 'bar',
    data: [50, 80, 60, 90],
    barWidth: '40%',          // width of each bar
    barGap: '20%',            // gap between bars in same group
    barCategoryGap: '40%',    // gap between category groups
    // fixed pixel width also works:
    // barWidth: 30
  }]
});
03

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

echarts
chart.setOption({
  xAxis: { type: 'category', data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'] },
  yAxis: { type: 'value' },
  series: [{
    type: 'line',
    data: [120, 200, 150, 80, 70],
    symbol: 'circle',      // point marker
    symbolSize: 8
  }]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'category', boundaryGap: false, data: ['Mon','Tue','Wed','Thu','Fri'] },
  yAxis: { type: 'value' },
  series: [{
    type: 'line',
    data: [120, 200, 150, 80, 70],
    smooth: true,           // curved line
    areaStyle: {            // fill under line
      color: {
        type: 'linear',
        x: 0, y: 0, x2: 0, y2: 1,
        colorStops: [
          { offset: 0, color: 'rgba(84,112,198,0.5)' },
          { offset: 1, color: 'rgba(84,112,198,0.05)' }
        ]
      }
    }
  }]
});

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.

echarts
chart.setOption({
  legend: { data: ['Email', 'Search'] },
  xAxis: { type: 'category', data: ['Mon','Tue','Wed','Thu','Fri'] },
  yAxis: { type: 'value' },
  series: [
    {
      type: 'line',
      name: 'Email',
      data: [120, 132, 101, 134, 90],
      lineStyle: { width: 3, type: 'solid' }
    },
    {
      type: 'line',
      name: 'Search',
      data: [220, 182, 191, 234, 290],
      lineStyle: { width: 2, type: 'dashed' }
    }
  ]
});

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

echarts
chart.setOption({
  xAxis: { type: 'category', boundaryGap: false, data: ['Mon','Tue','Wed','Thu','Fri'] },
  yAxis: { type: 'value' },
  series: [
    {
      type: 'line',
      name: 'A',
      stack: 'total',
      areaStyle: {},
      data: [120, 132, 101, 134, 90],
      emphasis: { focus: 'series' }
    },
    {
      type: 'line',
      name: 'B',
      stack: 'total',
      areaStyle: {},
      data: [220, 182, 191, 234, 290]
    }
  ]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'category', data: ['Mon','Tue','Wed','Thu','Fri'] },
  yAxis: { type: 'value' },
  series: [{
    type: 'line',
    data: [120, 200, 150, 80, 70],
    step: 'middle',          // 'start' | 'middle' | 'end'
    symbol: 'none',
    lineStyle: { width: 2 }
  }]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'time' },   // auto-parses timestamps
  yAxis: { type: 'value' },
  series: [{
    type: 'line',
    data: [
      [new Date('2024-01-01').getTime(), 100],
      [new Date('2024-01-02').getTime(), 200],
      [new Date('2024-01-05').getTime(), 150],
      [new Date('2024-01-10').getTime(), 300]
    ],
    smooth: true
  }]
});
04

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.

echarts
chart.setOption({
  series: [{
    type: 'pie',
    radius: '60%',          // radius of pie
    data: [
      { value: 1048, name: 'Search' },
      { value: 735, name: 'Direct' },
      { value: 580, name: 'Email' },
      { value: 484, name: 'Union' },
      { value: 300, name: 'Video' }
    ],
    emphasis: {
      itemStyle: {
        shadowBlur: 10,
        shadowOffsetX: 0,
        shadowColor: 'rgba(0,0,0,0.5)'
      }
    }
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'pie',
    radius: ['40%', '70%'],   // [inner, outer] = ring
    avoidLabelOverlap: false,
    label: {
      show: true,
      position: 'center',     // center label
      formatter: 'Total\n{c}'
    },
    data: [
      { value: 1048, name: 'A' },
      { value: 735, name: 'B' },
      { value: 580, name: 'C' }
    ]
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'pie',
    radius: ['10%', '70%'],
    roseType: 'area',         // or 'radius'
    data: [
      { value: 40, name: 'A' },
      { value: 38, name: 'B' },
      { value: 32, name: 'C' },
      { value: 30, name: 'D' },
      { value: 28, name: 'E' }
    ],
    label: { show: true }
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'pie',
    radius: '60%',
    label: {
      formatter: '{b}: {d}%',   // name: percentage
      color: '#333',
      fontSize: 14
    },
    labelLine: {
      show: true,
      length: 15,              // first segment
      length2: 20,             // second segment
      smooth: true
    },
    data: [
      { value: 1048, name: 'Search' },
      { value: 735, name: 'Direct' }
    ]
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'pie',
    radius: ['40%', '70%'],
    center: ['50%', '70%'],    // move down
    startAngle: 180,           // start at left
    endAngle: 360,             // end at right -> semicircle
    data: [
      { value: 60, name: 'A' },
      { value: 30, name: 'B' },
      { value: 10, name: 'C' }
    ]
  }]
});
05

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.

echarts
chart.setOption({
  xAxis: { type: 'value' },
  yAxis: { type: 'value' },
  series: [{
    type: 'scatter',
    symbolSize: 12,
    data: [
      [10, 20], [15, 25], [20, 30], [25, 35],
      [30, 40], [35, 45], [40, 50], [45, 55]
    ],
    itemStyle: { color: '#5470c6' }
  }]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'value' },
  yAxis: { type: 'value' },
  series: [{
    type: 'scatter',
    // each point: [x, y, size]
    data: [
      [10, 20, 30],
      [15, 25, 60],
      [20, 30, 12],
      [25, 35, 45]
    ],
    symbolSize: function (data) {
      return data[2];           // use 3rd element as size
    }
  }]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'value' },
  yAxis: { type: 'value' },
  visualMap: {
    min: 0,
    max: 100,
    dimension: 2,             // map color to 3rd element
    inRange: { color: ['#50a3ba', '#eac736', '#d94e5d'] },
    right: 10,
    top: 'center'
  },
  series: [{
    type: 'scatter',
    data: [[10,20,30], [15,25,60], [20,30,12]],
    symbolSize: 15
  }]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'value' },
  yAxis: { type: 'value' },
  series: [{
    type: 'effectScatter',    // animated ripple
    symbolSize: function (data) { return data[2]; },
    data: [[10, 20, 30], [15, 25, 60]],
    showEffectOn: 'render',   // 'render' or 'emphasis'
    rippleEffect: {
      brushType: 'stroke',    // 'stroke' or 'fill'
      period: 4,
      scale: 3
    }
  }]
});

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.

echarts
// for thousands of points, use progressive rendering
chart.setOption({
  xAxis: { type: 'value' },
  yAxis: { type: 'value' },
  series: [{
    type: 'scatter',
    data: largeDataArray,    // 50k+ points
    symbolSize: 3,
    progressive: 2000,        // chunk size for progressive render
    progressiveThreshold: 5000,  // enable above this count
    large: true,              // optimize for many points
    largeThreshold: 2000,
    itemStyle: { opacity: 0.6 }
  }]
});
06

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.

echarts
chart.setOption({
  radar: {
    indicator: [
      { name: 'Speed', max: 100 },
      { name: 'Power', max: 100 },
      { name: 'Range', max: 100 },
      { name: 'Comfort', max: 100 },
      { name: 'Price', max: 100 }
    ]
  },
  series: [{
    type: 'radar',
    data: [{ value: [85, 70, 90, 65, 80], name: 'Car A' }]
  }]
});

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.

echarts
chart.setOption({
  legend: { data: ['Car A', 'Car B'] },
  radar: {
    indicator: [
      { name: 'Speed', max: 100 },
      { name: 'Power', max: 100 },
      { name: 'Range', max: 100 }
    ]
  },
  series: [{
    type: 'radar',
    data: [
      { value: [85, 70, 90], name: 'Car A' },
      { value: [60, 95, 75], name: 'Car B' }
    ]
  }]
});

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

echarts
chart.setOption({
  radar: {
    indicator: [
      { name: 'A', max: 100 },
      { name: 'B', max: 100 },
      { name: 'C', max: 100 }
    ]
  },
  series: [{
    type: 'radar',
    data: [{ value: [85, 70, 90], name: 'Score' }],
    areaStyle: { opacity: 0.3 },
    lineStyle: { width: 2 },
    symbol: 'circle',
    symbolSize: 6
  }]
});

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.

echarts
chart.setOption({
  radar: {
    shape: 'polygon',          // 'polygon' or 'circle'
    radius: '65%',
    splitNumber: 5,            // grid ring count
    axisName: {
      color: '#333',
      fontSize: 12
    },
    splitLine: { lineStyle: { color: '#ccc' } },
    splitArea: {
      areaStyle: { color: ['#fafafa', '#fff'] }
    },
    indicator: [
      { name: 'Speed', max: 100 },
      { name: 'Power', max: 100 }
    ]
  },
  series: [{ type: 'radar', data: [{ value: [80, 70] }] }]
});

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.

echarts
chart.setOption({
  radar: {
    indicator: [
      { name: 'A', max: 100, min: 0 },   // min sets the inner bound
      { name: 'B', max: 100 },
      { name: 'C', max: 100 }
    ],
    radius: ['20%', '70%'],   // [inner, outer] for ring radar
    center: ['50%', '55%']
  },
  series: [{
    type: 'radar',
    data: [{ value: [60, 70, 80] }]
  }]
});
07

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

echarts
const hours = ['12a','1a','2a','3a','4a','5a','6a','7a','8a','9a','10a','11a'];
const days = ['Sat','Sun','Mon','Tue','Wed','Thu','Fri'];

// data: [x, y, value]
const data = [[0,0,5],[0,1,1],[1,0,8] /* ... */];

chart.setOption({
  tooltip: {},
  xAxis: { type: 'category', data: hours },
  yAxis: { type: 'category', data: days },
  visualMap: {
    min: 0, max: 10,
    calculable: true,
    orient: 'horizontal',
    left: 'center', bottom: '5%'
  },
  series: [{
    type: 'heatmap',
    data: data,
    label: { show: true }
  }]
});

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.

echarts
const data = [];
// generate one year of data
for (let i = 0; i < 365; i++) {
  const date = new Date(2024, 0, 1);
  date.setDate(date.getDate() + i);
  data.push([date.toISOString().slice(0,10), Math.floor(Math.random() * 100)]);
}

chart.setOption({
  tooltip: {},
  visualMap: {
    min: 0, max: 100,
    inRange: { color: ['#ebedf0', '#c6e48b', '#7bc96f', '#239a3b', '#196127'] }
  },
  calendar: {
    range: '2024',
    cellSize: ['auto', 13],
    yearLabel: { show: true }
  },
  series: [{ type: 'heatmap', data: data }]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'category', data: ['A','B','C','D'] },
  yAxis: { type: 'category', data: ['X','Y','Z'] },
  visualMap: { min: 0, max: 100, show: false },
  series: [{
    type: 'heatmap',
    data: [[0,0,80],[0,1,30],[1,0,50]],
    itemStyle: {
      borderColor: '#fff',       // white grid lines
      borderWidth: 2,
      borderRadius: 4
    },
    emphasis: {
      itemStyle: { shadowBlur: 10 }
    }
  }]
});

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.

echarts
const data = [];
for (let day = 0; day < 7; day++) {
  for (let hour = 0; hour < 24; hour++) {
    data.push([hour, day, Math.floor(Math.random() * 50) + 1]);
  }
}

chart.setOption({
  xAxis: { type: 'category', data: Array.from({length:24}, (_,i) => i + 'h') },
  yAxis: { type: 'category', data: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'] },
  visualMap: { max: 50, inRange: { color: ['#fff', '#5470c6'] } },
  series: [{
    type: 'heatmap',
    data: data,
    itemStyle: { borderRadius: 10, borderWidth: 2, borderColor: '#fff' }
  }]
});

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

echarts
// requires a registered geo map (e.g. echarts.registerMap)
chart.setOption({
  geo: { map: 'china', roam: true },
  visualMap: {
    min: 0, max: 1000,
    inRange: { color: ['#e0ecf4', '#005824'] }
  },
  series: [{
    type: 'map',
    map: 'china',
    data: [
      { name: 'Beijing', value: 800 },
      { name: 'Shanghai', value: 950 }
    ]
  }]
});
08

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.

echarts
const data = {
  name: 'Root',
  children: [
    {
      name: 'Child A',
      children: [{ name: 'A1' }, { name: 'A2' }]
    },
    {
      name: 'Child B',
      children: [{ name: 'B1' }]
    }
  ]
};

chart.setOption({
  series: [{
    type: 'tree',
    data: [data],
    top: '5%', left: '10%', bottom: '5%', right: '20%',
    layout: 'orthogonal',       // 'orthogonal' or 'radial'
    orient: 'LR',               // 'LR','RL','TB','BT'
    symbolSize: 10,
    label: { position: 'left' },
    leaves: { label: { position: 'right' } },
    expandAndCollapse: true,
    animationDuration: 550
  }]
});

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

echarts
chart.setOption({
  series: [{
    type: 'tree',
    data: [treeData],
    layout: 'orthogonal',
    orient: 'LR',              // left to right
    symbol: 'emptyCircle',
    symbolSize: 7,
    label: { position: 'left', verticalAlign: 'middle', align: 'right' },
    leaves: { label: { position: 'right', align: 'left' } },
    lineStyle: { color: '#999', width: 1, curveness: 0.5 }
  }]
});

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

echarts
chart.setOption({
  series: [{
    type: 'tree',
    data: [treeData],
    layout: 'radial',          // circular layout
    symbol: 'circle',
    symbolSize: 8,
    label: {
      position: 'inside',
      rotate: 0
    },
    leaves: { label: { position: 'right' } },
    emphasis: { focus: 'descendant' },
    lineStyle: { curveness: 0.5 }
  }]
});

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

echarts
const treeData = {
  name: 'CEO',
  value: 'Boss',
  children: [
    { name: 'VP Engineering', children: [{ name: 'Eng Lead' }] },
    { name: 'VP Sales', children: [{ name: 'Sales Lead' }] }
  ]
};

chart.setOption({
  series: [{
    type: 'tree',
    data: [treeData],
    symbol: function (params) {
      // custom symbol per node
      return params.data.children ? 'rect' : 'circle';
    },
    symbolSize: function (params) {
      return params.data.children ? 15 : 8;
    },
    orient: 'TB',
    label: { position: 'top', distance: 8 }
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'tree',
    data: [treeData],
    expandAndCollapse: true,
    initialTreeDepth: 2,        // expand first 2 levels
    collapse: 'collapseBtn',
    symbol: 'circle',
    animationDurationUpdate: 750
  }]
});

// programmatic control via API
chart.on('click', function (params) {
  if (params.componentType === 'series') {
    console.log('Node clicked:', params.data.name);
    console.log('Collapsed:', params.data.collapsed);
  }
});
09

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.

echarts
const data = [{
  name: 'Root',
  children: [
    {
      name: 'A',
      value: 15,
      children: [{ name: 'A1', value: 5 }, { name: 'A2', value: 10 }]
    },
    {
      name: 'B',
      value: 20,
      children: [{ name: 'B1', value: 20 }]
    }
  ]
}];

chart.setOption({
  series: [{
    type: 'sunburst',
    data: data,
    radius: [0, '90%'],
    label: { rotate: 'radial' }
  }]
});

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

echarts
chart.setOption({
  series: [{
    type: 'sunburst',
    data: sunburstData,
    radius: ['15%', '90%'],
    levels: [
      {},  // root level (default)
      {
        r0: '15%',
        r: '45%',
        label: { rotate: 0, fontSize: 14 },
        itemStyle: { borderWidth: 2 }
      },
      {
        r0: '45%',
        r: '70%',
        label: { rotate: 'tangential', fontSize: 12 }
      },
      {
        r0: '70%',
        r: '90%',
        label: { rotate: 'radial', fontSize: 10 }
      }
    ]
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'sunburst',
    data: data,
    itemStyle: {
      borderColor: '#fff',
      borderWidth: 1
    },
    emphasis: {
      focus: 'ancestor'    // highlight ancestors on hover
    },
    highlight: {
      itemStyle: { color: '#ffb' }
    }
  }]
});

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

echarts
chart.setOption({
  series: [{
    type: 'sunburst',
    data: [{
      name: 'Root',
      children: [
        { name: 'A', value: 30, children: [/* ... */] },
        { name: 'B', value: 70, children: [/* ... */] }
      ]
    }],
    nodeClick: 'zoomToNode',   // click to zoom into subtree
    sort: 'desc',              // or 'asc', null
    label: { minAngle: 5 }     // hide labels on tiny slices
  }]
});

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.

echarts
const data = [/* full tree */];
let currentRoot = data[0];

chart.setOption({
  series: [{
    type: 'sunburst',
    data: data,
    nodeClick: false
  }]
});

chart.on('click', function (params) {
  if (params.componentType === 'series' && params.data.children) {
    // manually drill down
    currentRoot = params.data;
    chart.setOption({
      series: [{ data: [currentRoot] }]
    }, { notMerge: true });
  }
});
10

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.

echarts
chart.setOption({
  series: [{
    type: 'sankey',
    data: [
      { name: 'Source A' },
      { name: 'Source B' },
      { name: 'Mid C' },
      { name: 'Sink D' }
    ],
    links: [
      { source: 'Source A', target: 'Mid C', value: 5 },
      { source: 'Source B', target: 'Mid C', value: 3 },
      { source: 'Mid C', target: 'Sink D', value: 8 }
    ],
    emphasis: { focus: 'adjacency' },
    lineStyle: { color: 'gradient', curveness: 0.5 }
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'sankey',
    data: [
      { name: 'A', depth: 0 },
      { name: 'B', depth: 1 },
      { name: 'C', depth: 2 }
    ],
    links: [
      { source: 'A', target: 'B', value: 10 },
      { source: 'B', target: 'C', value: 10 }
    ],
    levels: [
      { depth: 0, itemStyle: { color: '#fbb' }, lineStyle: { color: 'source' } },
      { depth: 1, itemStyle: { color: '#bfb' }, lineStyle: { color: 'target' } },
      { depth: 2, itemStyle: { color: '#bbf' } }
    ],
    nodeAlign: 'justify'      // 'left','right','justify'
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'sankey',
    data: nodes,
    links: links,
    nodeWidth: 20,            // width of each node rectangle
    nodeGap: 10,              // vertical gap between nodes
    nodeAlign: 'justify',
    label: {
      fontSize: 12,
      color: '#333',
      position: 'right'
    },
    lineStyle: { opacity: 0.4 },
    itemStyle: { borderWidth: 0 }
  }]
});

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

echarts
// Sankey normally forbids cycles, but you can show feedback loops
// by splitting a node into two (in & out) with the same name suffix
chart.setOption({
  series: [{
    type: 'sankey',
    data: [
      { name: 'Input' },
      { name: 'Process' },
      { name: 'Output' },
      { name: 'Recycle' }
    ],
    links: [
      { source: 'Input', target: 'Process', value: 100 },
      { source: 'Process', target: 'Output', value: 80 },
      { source: 'Process', target: 'Recycle', value: 20 },
      { source: 'Recycle', target: 'Process', value: 20 }
    ],
    emphasis: { focus: 'adjacency' }
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'sankey',
    data: nodes,
    links: links,
    emphasis: {
      focus: 'adjacency',
      lineStyle: { opacity: 0.8 }
    },
    label: { formatter: '{b}: {c}' },
    tooltip: { trigger: 'item' }
  }]
});

chart.on('click', function (params) {
  if (params.dataType === 'edge') {
    console.log('Flow from', params.data.source, 'to', params.data.target);
    console.log('Value:', params.data.value);
  } else if (params.dataType === 'node') {
    console.log('Node:', params.data.name);
  }
});
11

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.

echarts
chart.setOption({
  series: [{
    type: 'funnel',
    data: [
      { value: 100, name: 'Visit' },
      { value: 75, name: 'Sign Up' },
      { value: 50, name: 'Trial' },
      { value: 25, name: 'Purchase' }
    ],
    sort: 'descending'      // 'descending','ascending','none'
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'funnel',
    data: data,
    sort: 'ascending',          // smallest at top
    gap: 4,                     // pixel gap between slices
    funnelAlign: 'center',      // 'left','center','right'
    width: '60%',
    minSize: '20%',
    maxSize: '100%'
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'funnel',
    data: data,
    label: {
      show: true,
      position: 'inside',      // 'inside','left','right'
      formatter: '{b}: {c}'
    },
    labelLine: {
      show: true,
      length: 20,
      lineStyle: { width: 1, type: 'solid' }
    },
    emphasis: {
      label: { fontSize: 16 }
    }
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'funnel',
    data: [
      { value: 100, name: 'A', itemStyle: { color: '#5470c6' } },
      { value: 75, name: 'B', itemStyle: { color: '#91cc75' } },
      { value: 50, name: 'C', itemStyle: { color: '#fac858' } }
    ],
    itemStyle: {
      borderColor: '#fff',
      borderWidth: 2,
      borderRadius: 0
    }
  }]
});

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.

echarts
chart.setOption({
  series: [
    {
      type: 'funnel',
      name: '2023',
      data: [{ value: 100, name: 'A' }, { value: 40, name: 'B' }],
      sort: 'descending',
      left: '5%', width: '40%',
      label: { position: 'inside' }
    },
    {
      type: 'funnel',
      name: '2024',
      data: [{ value: 120, name: 'A' }, { value: 60, name: 'B' }],
      sort: 'descending',
      left: '55%', width: '40%',
      label: { position: 'inside' }
    }
  ]
});
12

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.

echarts
chart.setOption({
  series: [{
    type: 'gauge',
    min: 0,
    max: 100,
    progress: { show: true, width: 18 },
    axisLine: { lineStyle: { width: 18 } },
    detail: {
      valueAnimation: true,
      formatter: '{value}%'
    },
    data: [{ value: 70, name: 'Score' }]
  }]
});

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

echarts
chart.setOption({
  series: [{
    type: 'gauge',
    radius: '60%',
    min: 0, max: 100,
    pointer: { show: true, length: '60%', width: 5 },
    anchor: { show: true, size: 12, itemStyle: { color: '#333' } },
    axisTick: { distance: -15, length: 5 },
    splitLine: { distance: -20, length: 10 },
    axisLabel: { distance: -25 },
    data: [{ value: 42 }]
  }]
});

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

echarts
chart.setOption({
  series: [{
    type: 'gauge',
    min: 0, max: 100,
    axisLine: {
      lineStyle: {
        width: 20,
        color: [
          [0.3, '#fd666d'],    // 0-30% red
          [0.7, '#37a2da'],    // 30-70% blue
          [1, '#91cc75']       // 70-100% green
        ]
      }
    },
    data: [{ value: 85 }]
  }]
});

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

echarts
chart.setOption({
  series: [{
    type: 'gauge',
    min: 0, max: 100,
    data: [
      { value: 60, name: 'CPU' },
      { value: 40, name: 'Memory' },
      { value: 80, name: 'Disk' }
    ],
    detail: { formatter: '{value}%' },
    title: { fontSize: 14 }
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'gauge',
    startAngle: 90,
    endAngle: -270,            // full circle
    pointer: { show: false },
    progress: {
      show: true,
      overlap: false,
      roundCap: true,
      clip: false
    },
    axisLine: { lineStyle: { width: 20, color: [[1, 'rgba(0,0,0,0.1)']] } },
    splitLine: { show: false },
    axisTick: { show: false },
    axisLabel: { show: false },
    detail: {
      valueAnimation: true,
      offsetCenter: ['0%', '0%'],
      fontSize: 30,
      formatter: '{value}%'
    },
    data: [{ value: 65 }]
  }]
});
13

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

echarts
chart.setOption({
  xAxis: [
    { type: 'category', data: ['A','B','C'], position: 'bottom' },
    { type: 'category', data: ['A','B','C'], position: 'top', axisLine: { onZero: false } }
  ],
  yAxis: { type: 'value' },
  series: [
    { type: 'line', data: [10, 20, 30], xAxisIndex: 0 },
    { type: 'line', data: [50, 60, 70], xAxisIndex: 1 }
  ]
});

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.

echarts
chart.setOption({
  xAxis: { type: 'category', data: ['Mon','Tue','Wed','Thu'] },
  yAxis: [
    { type: 'value', name: 'Sales', position: 'left' },
    { type: 'value', name: 'Orders', position: 'right', axisLine: { lineStyle: { color: '#ee6666' } } }
  ],
  series: [
    { type: 'bar', data: [200, 180, 250, 210], yAxisIndex: 0 },
    { type: 'line', data: [40, 35, 50, 42], yAxisIndex: 1, smooth: true }
  ]
});

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.

echarts
chart.setOption({
  polar: {},
  angleAxis: {
    type: 'category',
    data: ['N','NE','E','SE','S','SW','W','NW'],
    startAngle: 90
  },
  radiusAxis: { type: 'value' },
  series: [{
    type: 'bar',
    data: [1, 2, 3, 4, 5, 6, 7, 8],
    coordinateSystem: 'polar'
  }]
});

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.

echarts
chart.setOption({
  calendar: {
    range: ['2024-01-01', '2024-12-31'],
    cellSize: ['auto', 15],
    left: 50, right: 30,
    orient: 'horizontal',
    dayLabel: { nameMap: 'en' },
    monthLabel: { nameMap: 'en' },
    yearLabel: { show: false }
  },
  series: [{
    type: 'heatmap',
    coordinateSystem: 'calendar',
    data: calendarData
  }]
});

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.

echarts
chart.setOption({
  parallelAxis: [
    { dim: 0, name: 'Price' },
    { dim: 1, name: 'Mileage' },
    { dim: 2, name: 'Year' },
    { dim: 3, name: 'Safety', type: 'category', data: ['Low','Med','High'] }
  ],
  parallel: {
    parallelAxisDefault: {
      axisLine: { lineStyle: { color: '#999' } },
      nameTextStyle: { color: '#333' }
    }
  },
  series: [{
    type: 'parallel',
    data: [[20000, 30, 2020, 'High'], [25000, 25, 2021, 'Med']]
  }]
});

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

echarts
// load a map GeoJSON (must be registered before use)
fetch('https://geo.datav.aliyun.com/areas_v3/bound/100000_full.json')
  .then(r => r.json())
  .then(geoJson => {
    echarts.registerMap('china', geoJson);
    chart.setOption({
      geo: {
        map: 'china',
        roam: true,                  // pan & zoom
        zoom: 1.2,
        label: { show: false },
        itemStyle: {
          areaColor: '#eee',
          borderColor: '#fff'
        },
        emphasis: {
          label: { show: true },
          itemStyle: { areaColor: '#f5f5f5' }
        }
      }
    });
  });
14

Dataset

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.

echarts
chart.setOption({
  dataset: {
    source: [
      ['product', '2023', '2024'],
      ['Apple', 41, 56],
      ['Banana', 67, 28],
      ['Cherry', 89, 76]
    ]
  },
  xAxis: { type: 'category' },
  yAxis: {},
  series: [
    { type: 'bar', seriesLayoutBy: 'column', encode: { x: 'product', y: '2023' } },
    { type: 'bar', seriesLayoutBy: 'column', encode: { x: 'product', y: '2024' } }
  ]
});

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

echarts
chart.setOption({
  dataset: {
    dimensions: ['product', 'count', 'score'],
    source: [
      { product: 'Apple', count: 41, score: 90 },
      { product: 'Banana', count: 67, score: 75 },
      { product: 'Cherry', count: 89, score: 88 }
    ]
  },
  xAxis: { type: 'category' },
  yAxis: {},
  series: [
    { type: 'bar', encode: { x: 'product', y: 'count' } },
    { type: 'bar', encode: { x: 'product', y: 'score' } }
  ]
});

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.

echarts
chart.setOption({
  dataset: [
    {
      id: 'raw',
      source: [
        { product: 'A', sales: 100 },
        { product: 'B', sales: 50 },
        { product: 'C', sales: 200 }
      ]
    },
    {
      id: 'filtered',
      fromDatasetId: 'raw',
      transform: {
        type: 'filter',
        config: { and: [{ gte: { sales: 80 } }] }
      }
    },
    {
      id: 'sorted',
      fromDatasetId: 'filtered',
      transform: { type: 'sort', config: { order: 'desc', main: 'sales' } }
    }
  ],
  xAxis: { type: 'category' },
  yAxis: {},
  series: [{ type: 'bar', datasetId: 'sorted', encode: { x: 'product', y: 'sales' } }]
});

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.

echarts
chart.setOption({
  dataset: {
    source: [
      [10, 20, 30, 'red'],
      [15, 25, 35, 'blue'],
      [20, 30, 40, 'green']
    ]
  },
  xAxis: { type: 'value' },
  yAxis: { type: 'value' },
  series: [{
    type: 'scatter',
    encode: {
      x: 0,                  // first column -> x
      y: 1,                  // second column -> y
      tooltip: [0, 1, 2]     // show these in tooltip
    },
    symbolSize: function (d) { return d[2]; }
  }]
});

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

echarts
chart.setOption({
  dataset: {
    source: [
      { name: 'Search', value: 1048 },
      { name: 'Direct', value: 735 },
      { name: 'Email', value: 580 }
    ]
  },
  series: [{
    type: 'pie',
    radius: '60%',
    encode: { itemName: 'name', value: 'value' }
  }]
});
15

VisualMap

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.

echarts
chart.setOption({
  visualMap: {
    type: 'continuous',
    min: 0,
    max: 100,
    inRange: {
      color: ['#50a3ba', '#eac736', '#d94e5d'],
      symbolSize: [10, 50]
    },
    calculable: true,           // show slider handles
    orient: 'vertical',
    left: 'left', top: 'bottom'
  },
  series: [{
    type: 'scatter',
    data: [[10,20,30], [50,60,80], [80,90,95]]
  }]
});

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.

echarts
chart.setOption({
  visualMap: {
    type: 'piecewise',
    pieces: [
      { min: 0, max: 30, label: 'Low', color: '#91cc75' },
      { min: 30, max: 70, label: 'Mid', color: '#fac858' },
      { min: 70, max: 100, label: 'High', color: '#ee6666' }
    ],
    orient: 'horizontal',
    left: 'center', bottom: 10
  },
  series: [{
    type: 'scatter',
    data: data
  }]
});

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.

echarts
chart.setOption({
  visualMap: {
    type: 'piecewise',
    categories: ['Low', 'Medium', 'High'],
    inRange: { color: ['#91cc75', '#fac858', '#ee6666'] },
    dimension: 2                  // which data column to map
  },
  series: [{
    type: 'scatter',
    data: [
      [10, 20, 'Low'],
      [50, 60, 'Medium'],
      [80, 90, 'High']
    ]
  }]
});

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

echarts
chart.setOption({
  visualMap: {
    min: 0, max: 100,
    inRange: { color: ['#5470c6', '#91cc75'] },
    outOfRange: { color: '#ccc', symbolSize: 5 },  // filtered out style
    controller: {
      inRange: { color: ['#5470c6', '#91cc75'] }
    },
    right: 10, top: 'center'
  },
  series: [{
    type: 'scatter',
    data: data
  }]
});

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

echarts
chart.setOption({
  visualMap: {
    min: 0, max: 100,
    inRange: { color: ['#5470c6', '#91cc75', '#fac858'] }
  },
  series: [
    { type: 'scatter', name: 'A', data: dataA },
    { type: 'scatter', name: 'B', data: dataB }
  ]
});

// bind visualMap to specific series only
chart.setOption({
  visualMap: { seriesIndex: 1 }   // only affects second series
});
16

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.

echarts
chart.setOption({
  legend: {
    data: ['Email', 'Search', 'Direct'],
    show: true,
    icon: 'roundRect',        // 'circle','rect','roundRect','triangle','diamond','pin','arrow'
    itemWidth: 20,
    itemHeight: 14,
    textStyle: { color: '#333', fontSize: 12 }
  },
  series: [
    { type: 'line', name: 'Email', data: [120, 200, 150] },
    { type: 'line', name: 'Search', data: [220, 180, 90] }
  ]
});

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.

echarts
chart.setOption({
  legend: {
    orient: 'horizontal',          // 'horizontal' or 'vertical'
    top: 'top',                    // 'top','bottom','middle' or px
    left: 'center',                // 'left','center','right' or px
    itemGap: 20,                   // gap between items
    padding: 5,
    backgroundColor: '#f5f5f5',
    borderColor: '#ddd',
    borderWidth: 1,
    borderRadius: 4
  },
  series: [/* ... */]
});

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

echarts
chart.setOption({
  legend: {
    selected: {
      'Email': true,        // visible by default
      'Search': false,      // hidden by default
      'Direct': true
    },
    selectedMode: 'multiple'   // 'single' or 'multiple'
  },
  series: [
    { type: 'line', name: 'Email', data: [120, 200, 150] },
    { type: 'line', name: 'Search', data: [220, 180, 90] },
    { type: 'line', name: 'Direct', data: [100, 90, 80] }
  ]
});

chart.on('legendselectchanged', function (params) {
  console.log('Selected:', params.selected);
});

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.

echarts
chart.setOption({
  legend: {
    type: 'scroll',           // 'plain' (default) or 'scroll'
    orient: 'vertical',
    right: 10, top: 20, bottom: 20,
    pageButtonItemStyle: { color: '#333' },
    pageIconColor: '#5470c6',
    pageIconInactiveColor: '#ccc',
    pageTextStyle: { color: '#333' },
    data: Array.from({length: 30}, (_, i) => 'Series ' + i)
  },
  series: [/* many series */]
});

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.

echarts
chart.setOption({
  legend: {
    data: ['A', 'B'],
    formatter: function (name) {
      return name.toUpperCase();
    },
    textStyle: {
      rich: {
        a: { color: '#5470c6', fontSize: 14, fontWeight: 'bold' },
        b: { color: '#91cc75', fontSize: 12 }
      }
    }
  },
  series: [/* ... */]
});

// legend can also show values via legendselectchanged + setOption
chart.on('legendselectchanged', () => {
  // dynamic label updates
});
17

Tooltip

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.

echarts
chart.setOption({
  tooltip: {
    trigger: 'axis',           // 'item','axis','none'
    show: true,
    backgroundColor: 'rgba(50,50,50,0.9)',
    borderColor: '#333',
    borderWidth: 1,
    padding: 10,
    textStyle: { color: '#fff', fontSize: 13 },
    axisPointer: { type: 'shadow' }   // 'line','shadow','cross'
  },
  xAxis: { type: 'category', data: ['A','B','C'] },
  yAxis: { type: 'value' },
  series: [{ type: 'bar', data: [10, 20, 30] }]
});

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.

echarts
chart.setOption({
  tooltip: {
    trigger: 'item',
    formatter: function (params) {
      // params has: name, value, seriesName, color, dataIndex, ...
      return '<b>' + params.name + '</b><br/>' +
             'Value: ' + params.value + '<br/>' +
             'Series: ' + params.seriesName;
    }
  },
  series: [{ type: 'pie', data: [/* ... */] }]
});

// string template form (for axis trigger)
chart.setOption({
  tooltip: {
    trigger: 'axis',
    formatter: '{a}: {b} = {c}'   // a=series, b=category, c=value
  }
});

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.

echarts
chart.setOption({
  tooltip: { trigger: 'axis' },
  xAxis: { type: 'category', data: ['Mon','Tue','Wed','Thu'] },
  yAxis: { type: 'value' },
  axisPointer: {
    link: [{ xAxisIndex: 'all' }],   // sync pointers across charts
    label: { backgroundColor: '#333' }
  },
  series: [{ type: 'line', data: [10, 20, 30, 40] }]
});

// per-axis pointer type
chart.setOption({
  tooltip: {
    axisPointer: {
      type: 'cross',
      crossStyle: { color: '#999' },
      lineStyle: { color: '#999', type: 'dashed' }
    }
  }
});

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

echarts
chart.setOption({
  tooltip: {
    trigger: 'item',               // per-point, not per-axis
    formatter: function (p) {
      return p.name + ': ' + p.value + ' (' + p.percent + '%)';
    },
    backgroundColor: 'rgba(255,255,255,0.95)',
    borderColor: '#eee',
    textStyle: { color: '#333' },
    extraCssText: 'box-shadow: 0 2px 10px rgba(0,0,0,0.1);'
  },
  series: [{
    type: 'pie',
    data: [{ value: 60, name: 'A' }, { value: 40, name: 'B' }]
  }]
});

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

echarts
chart.setOption({
  tooltip: {
    trigger: 'axis',
    axisPointer: { type: 'shadow' },
    formatter: function (params) {
      let html = '<div style="font-weight:bold;margin-bottom:4px;">'
        + params[0].name + '</div>';
      params.forEach(p => {
        html += '<div style="display:flex;align-items:center;">'
          + '<span style="display:inline-block;width:10px;height:10px;background:'
          + p.color + ';margin-right:6px;"></span>'
          + p.seriesName + ': ' + p.value
          + '</div>';
      });
      return html;
    }
  },
  series: [
    { type: 'bar', name: 'A', data: [10, 20, 30] },
    { type: 'bar', name: 'B', data: [15, 25, 35] }
  ]
});
18

Toolbox

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.

echarts
chart.setOption({
  toolbox: {
    show: true,
    right: 10, top: 10,
    feature: {
      dataZoom: { yAxisIndex: 'none' },
      dataView: { readOnly: false, title: 'Data', lang: ['Data','Close','Refresh'] },
      magicType: { type: ['line','bar','stack','tiled'] },
      restore: {},
      saveAsImage: { pixelRatio: 2, name: 'chart', type: 'png' }
    }
  },
  series: [{ type: 'bar', data: [10, 20, 30] }]
});

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.

echarts
chart.setOption({
  toolbox: {
    feature: {
      dataZoom: {
        yAxisIndex: 'none',    // only zoom x axis
        title: { zoom: 'Zoom In', back: 'Zoom Out' }
      }
    }
  },
  dataZoom: [
    { type: 'inside', xAxisIndex: 0 },   // mouse wheel
    { type: 'slider', xAxisIndex: 0 }    // slider below chart
  ],
  xAxis: { type: 'category', data: longData },
  series: [{ type: 'line', data: longData }]
});

Data view (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.

echarts
chart.setOption({
  toolbox: {
    feature: {
      dataView: {
        readOnly: false,                  // editable
        title: 'View Data',
        lang: ['Data View', 'Close', 'Refresh'],
        optionToContent: function (opt) {
          // custom HTML rendering instead of JSON
          return '<div>Custom view</div>';
        },
        contentToOption: function (div) {
          // parse edited content back to option
          return opt;
        }
      }
    }
  }
});

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.

echarts
chart.setOption({
  toolbox: {
    feature: {
      magicType: {
        type: ['line', 'bar', 'stack', 'tiled'],
        title: { line: 'Line', bar: 'Bar', stack: 'Stack', tiled: 'Tile' }
      },
      restore: { title: 'Restore' }
    }
  },
  series: [
    { type: 'bar', name: 'A', data: [10, 20, 30] },
    { type: 'bar', name: 'B', data: [15, 25, 35] }
  ]
});

chart.on('magicTypeChanged', function (params) {
  console.log('Switched to', params.currentType);
});

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

echarts
chart.setOption({
  toolbox: {
    feature: {
      saveAsImage: {
        type: 'png',                  // 'png' or 'jpg'
        name: 'my-chart',
        pixelRatio: 2,                // higher = sharper
        backgroundColor: '#fff',
        excludeComponents: ['toolbox'],
        title: 'Download'
      }
    }
  }
});

// programmatic export
chart.getDataURL({
  type: 'png',
  pixelRatio: 2,
  backgroundColor: '#fff'
});
19

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.

echarts
chart.setOption({
  series: [{
    type: 'line',
    data: [10, 50, 30, 80, 20, 90],
    markPoint: {
      symbolSize: 50,
      data: [
        { type: 'max', name: 'Peak' },
        { type: 'min', name: 'Low' },
        { type: 'average', name: 'Avg' }
      ],
      label: { fontSize: 12 }
    }
  }]
});

MarkLine (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.

echarts
chart.setOption({
  series: [{
    type: 'bar',
    data: [10, 50, 30, 80, 20],
    markLine: {
      symbol: 'none',              // no end arrows
      lineStyle: { type: 'dashed', color: '#ee6666' },
      data: [
        { type: 'average', name: 'Avg' },
        { yAxis: 60, name: 'Threshold' },          // horizontal line at y=60
        { xAxis: 'Wed', name: 'Event' }            // vertical line at category
      ],
      label: { formatter: '{b}: {c}' }
    }
  }]
});

MarkArea (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.

echarts
chart.setOption({
  series: [{
    type: 'line',
    data: [10, 20, 30, 40, 50, 60, 70],
    markArea: {
      silent: false,
      itemStyle: { color: 'rgba(255, 200, 0, 0.2)' },
      data: [
        [
          { xAxis: 'Tue' },          // start
          { xAxis: 'Thu' }           // end
        ],
        [
          { xAxis: 'Fri' },
          { xAxis: 'Sat' }
        ]
      ],
      label: { show: true, position: 'top' }
    }
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'line',
    data: [20, 50, 30, 80, 60, 90, 40],
    markPoint: {
      data: [{ type: 'max', name: 'Max' }]
    },
    markLine: {
      data: [
        { type: 'average', name: 'Average' },
        { yAxis: 70, name: 'Target', lineStyle: { color: '#91cc75' } }
      ]
    },
    markArea: {
      data: [[
        { xAxis: 'Wed' },
        { xAxis: 'Fri', itemStyle: { color: 'rgba(145,204,117,0.1)' } }
      ]]
    }
  }]
});

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.

echarts
chart.setOption({
  series: [{
    type: 'scatter',
    data: [[10,20], [50,60], [80,90]],
    markPoint: {
      data: [
        { coord: [50, 60], name: 'Center', value: 'Origin' }
      ],
      symbol: 'pin',
      symbolSize: 40,
      itemStyle: { color: '#ee6666' }
    },
    markLine: {
      data: [
        [{ coord: [0, 0] }, { coord: [100, 100] }]  // diagonal line
      ]
    }
  }]
});
20

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.

echarts
chart.setOption({
  animation: true,
  animationThreshold: 2000,        // disable above this data count
  animationDuration: 2000,         // entrance duration (ms)
  animationEasing: 'cubicOut',     // easing function
  animationDelay: function (idx) { // stagger by index
    return idx * 100;
  },
  animationDurationUpdate: 500,    // update transition
  animationEasingUpdate: 'cubicInOut',
  animationDelayUpdate: 0,
  series: [{ type: 'bar', data: [10, 20, 30, 40] }]
});

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.

echarts
chart.setOption({
  animationEasing: 'elasticOut',
  // available easings:
  // linear, quadraticIn, quadraticOut, quadraticInOut,
  // cubicIn, cubicOut, cubicInOut,
  // quarticIn, quarticOut, quarticInOut,
  // quinticIn, quinticOut, quinticInOut,
  // sinusoidalIn, sinusoidalOut, sinusoidalInOut,
  // exponentialIn, exponentialOut, exponentialInOut,
  // circularIn, circularOut, circularInOut,
  // elasticIn, elasticOut, elasticInOut,
  // backIn, backOut, backInOut,
  // bounceIn, bounceOut, bounceInOut
  series: [{ type: 'bar', data: [10, 20, 30] }]
});

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.

echarts
// show loading mask
chart.showLoading({
  text: 'Loading data...',
  color: '#5470c6',
  textColor: '#333',
  maskColor: 'rgba(255, 255, 255, 0.8)',
  zlevel: 0,
  fontSize: 14,
  showSpinner: true,
  spinnerRadius: 10,
  lineWidth: 2
});

// hide after data loads
fetch('/api/data').then(r => r.json()).then(data => {
  chart.hideLoading();
  chart.setOption({ series: [{ type: 'bar', data: data }] });
});

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.

echarts
chart.on('click', function (params) {
  console.log('Clicked:', params.componentType, params.seriesType);
  console.log('Series:', params.seriesName, 'Data:', params.name, params.value);
  console.log(' dataIndex:', params.dataIndex);
});

chart.on('legendselectchanged', function (params) {
  console.log('Legend toggled:', params.selected);
});

chart.on('datazoom', function (params) {
  console.log('Zoom:', params.batch?.[0]?.start, params.batch?.[0]?.end);
});

// dispatch an action programmatically
chart.dispatchAction({
  type: 'highlight',
  seriesIndex: 0,
  dataIndex: 2
});

chart.dispatchAction({ type: 'showTip', x: 100, y: 100 });

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.

echarts
chart.setOption({
  graphic: {
    elements: [
      {
        type: 'text',
        left: 'center', top: 'middle',
        style: { text: 'No Data', fontSize: 24, fill: '#999' },
        invisible: false
      },
      {
        type: 'circle',
        shape: { cx: 50, cy: 50, r: 20 },
        style: { fill: '#5470c6' },
        onclick: function () { console.log('clicked'); }
      },
      {
        type: 'image',
        style: { image: 'logo.png', width: 100, height: 40 },
        left: 10, top: 10
      }
    ]
  }
});

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.