Skip to content

Chart.js Шпаргалка

Простая, но гибкая JavaScript-библиотека для построения графиков.

01

Начало работы

Настройка и первый график

Chart.js рендерит на элементе canvas. Свойство type задаёт тип графика. data содержит labels и datasets со значениями и стилями.

chartjs
<!-- include Chart.js -->
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>

<canvas id="myChart" width="400" height="400"></canvas>

<script>
const ctx = document.getElementById('myChart').getContext('2d');
new Chart(ctx, {
  type: 'bar',
  data: {
    labels: ['Red', 'Blue', 'Green'],
    datasets: [{
      label: 'Votes',
      data: [12, 19, 3],
      backgroundColor: ['red', 'blue', 'green']
    }]
  }
});
</script>

Установка через npm и импорт ES-модуля

Используйте 'chart.js/auto' для простейшей настройки — он импортирует Chart.js вместе со всеми контроллерами/элементами и регистрирует их автоматически. Для меньших продакшен-бандлов предпочитайте tree-shaking: импортируйте из 'chart.js' и регистрируйте только используемое.

chartjs
# install
npm install chart.js

// import the auto-bundled build (registers everything)
import Chart from 'chart.js/auto';

const ctx = document.getElementById('myChart');
const chart = new Chart(ctx, {
  type: 'line',
  data: { /* ... */ },
  options: { responsive: true }
});

Canvas и 2D-контекст

Chart.js принимает как сам элемент <canvas>, так и его 2d-контекст рендеринга. При responsive: true canvas растягивается под контейнер, поэтому HTML-атрибуты width/height — лишь запасные варианты. Каждому canvas принадлежит ровно один экземпляр Chart.

chartjs
// Chart.js accepts a canvas element OR a 2D context
const canvas = document.getElementById('myChart');
const chart = new Chart(canvas, { type: 'bar', data: {...} });

// equivalent: pass the 2d context
const ctx = canvas.getContext('2d');
const chart2 = new Chart(ctx, { type: 'bar', data: {...} });

// one chart per canvas; the canvas size is controlled by
// responsive options, NOT the width/height attributes

Доступные типы графиков

Chart.js поставляется с восемью типами графиков. Bar, line, scatter и bubble используют декартовы оси; pie, doughnut и polarArea — круговые; radar имеет собственную радиальную ось. Поле 'type' верхнего уровня выбирает контроллер для всех dataset, если конкретный dataset не переопределяет его своим type.

chartjs
// the 8 built-in chart types
const types = ['bar', 'line', 'pie', 'doughnut',
               'radar', 'polarArea', 'bubble', 'scatter'];

// each type maps to a controller:
//   bar/line    -> Cartesian controllers
//   pie/doughnut/polarArea -> circular controllers
//   radar       -> radar controller
//   bubble/scatter -> cartesian with point parsing

new Chart(ctx, { type: 'polarArea', data: {...} });

Tree-shaking и регистрация

При импорте из 'chart.js' (не /auto) ничего не регистрируется — придётся самому регистрировать контроллеры, элементы, шкалы и плагины. Такой tree-shakeable подход может заметно уменьшить размер бандла. Забытая регистрация компонента — самая частая причина ошибки «scale is not a registered scale».

chartjs
import {
  Chart,
  BarController,
  BarElement,
  CategoryScale,
  LinearScale,
  Legend,
  Title,
  Tooltip,
} from 'chart.js';

// register ONLY what you use -> smaller bundle
Chart.register(
  BarController, BarElement,
  CategoryScale, LinearScale,
  Legend, Title, Tooltip,
);

new Chart(ctx, {
  type: 'bar',
  data: { labels: ['A', 'B'], datasets: [{ data: [1, 2] }] },
});

Уничтожение и жизненный цикл

Каждый экземпляр Chart владеет своим canvas и привязанными слушателями событий. Вызов destroy() разбирает всё, и canvas можно использовать снова — обязательно в SPA и эффектах React/Vue. Второй график на активном canvas даёт утечку памяти и двойной рендер графики.

chartjs
const chart = new Chart(ctx, config);

// ...later, to re-render with new config:
chart.destroy();        // cleans up listeners and canvas
const fresh = new Chart(ctx, newConfig);

// never create two Chart instances on the same canvas;
// always destroy() the old one first.
02

Столбчатые диаграммы (Bar)

Базовая bar-диаграмма

Bar-диаграмма сопоставляет каждой метке столбец, высота которого равна значению данных. backgroundColor задаёт заливку столбца, borderColor/borderWidth — контур. Установите y.beginAtZero, чтобы столбцы всегда начинались с нуля — иначе Chart.js может автоматически подстроить минимум оси и визуально исказить различия.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: {
    labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
    datasets: [{
      label: 'Revenue',
      data: [12, 19, 7, 15, 22],
      backgroundColor: 'rgba(54, 162, 235, 0.6)',
      borderColor: 'rgba(54, 162, 235, 1)',
      borderWidth: 1
    }]
  },
  options: { scales: { y: { beginAtZero: true } } }
});

Горизонтальные столбцы (indexAxis)

В Chart.js v3+ горизонтальные столбцы создаются через indexAxis: 'y' для типа 'bar' — старый тип 'horizontalBar' удалён. Шкала x становится осью значений. Горизонтальные столбцы идеальны для длинных подписей категорий, которые перекрывались бы на вертикальной диаграмме.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: {
    labels: ['Task A', 'Task B', 'Task C'],
    datasets: [{ label: 'Hours', data: [5, 8, 3] }]
  },
  options: {
    indexAxis: 'y',   // horizontal bars (v3+ syntax)
    scales: { x: { beginAtZero: true } }
  }
});

Группированные столбцы (несколько dataset)

Несколько dataset в bar-диаграмме по умолчанию ставятся рядом (группами). Chart.js назначает цвета автоматически, только если опустить backgroundColor, поэтому задавайте явные цвета для предсказуемого результата. Все dataset делят один массив labels на оси x.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: {
    labels: ['Q1', 'Q2', 'Q3', 'Q4'],
    datasets: [
      { label: '2023', data: [20, 35, 30, 35],
        backgroundColor: 'rgba(255,99,132,0.6)' },
      { label: '2024', data: [25, 32, 34, 40],
        backgroundColor: 'rgba(54,162,235,0.6)' }
    ]
  },
  options: { scales: { y: { beginAtZero: true } } }
});

Стековые столбцы

Стековым столбцам требуется stacked: true ОДНОВРЕМЕННО на шкалах x и y. Столбцы каждого dataset рисуются поверх предыдущего, суммируясь в общий итог. Стек показывает состав, но верхние ряды труднее сравнивать между категориями, чем в группированных столбцах.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: {
    labels: ['A', 'B', 'C'],
    datasets: [
      { label: 'Men',   data: [20, 35, 30], backgroundColor: '#36A2EB' },
      { label: 'Women', data: [25, 32, 34], backgroundColor: '#FF6384' }
    ]
  },
  options: {
    scales: {
      x: { stacked: true },
      y: { stacked: true, beginAtZero: true }
    }
  }
});

Стилизация столбцов

borderRadius скругляет углы столбцов (одно число — все углы; объект вида {topLeft:8} — конкретные). borderSkipped по умолчанию 'start' и опускает одну сторону — задайте false, чтобы рисовать все четыре. barPercentage и categoryPercentage вместе управляют толщиной столбцов и промежутками.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: {
    labels: ['A', 'B', 'C'],
    datasets: [{
      data: [10, 20, 15],
      backgroundColor: '#FF6384',
      borderColor: '#fff',
      borderWidth: 2,
      borderRadius: 8,           // rounded corners (px or %)
      borderSkipped: false,      // draw border on all sides
      barPercentage: 0.8,        // bar width within category
      categoryPercentage: 0.7    // category width
    }]
  }
});

Плавающие столбцы ([min, max])

Пары [min, max] в качестве значений данных дают плавающие столбцы, не начинающиеся с нуля — идеально для диапазонов: минимум-максимум температуры за день, open-close, доверительные интервалы. Ось y НЕ должна начинаться с нуля для столбцов-диапазонов. Работает и с горизонтальными столбцами.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: {
    labels: ['Mon', 'Tue', 'Wed'],
    datasets: [{
      label: 'Low-High temp',
      // each value is [min, max] -> a floating bar
      data: [[10, 18], [12, 20], [8, 15]],
      backgroundColor: 'rgba(75,192,192,0.6)'
    }]
  },
  options: { scales: { y: { beginAtZero: false } } }
});
03

Линейные графики (Line)

Базовый линейный график

Линейный график соединяет точки данных по порядку. borderColor — цвет линии; backgroundColor используется для заливки (если fill включён). tension (0-1) управляет плавностью кривой — 0 даёт прямые сегменты, ~0.3-0.4 — мягкие кривые Безье. Для точных данных вроде финансовых цен используйте 0.

chartjs
new Chart(ctx, {
  type: 'line',
  data: {
    labels: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
    datasets: [{
      label: 'Visitors',
      data: [30, 45, 28, 60, 52],
      borderColor: 'rgba(75,192,192,1)',
      backgroundColor: 'rgba(75,192,192,0.2)',
      tension: 0.3
    }]
  },
  options: { scales: { y: { beginAtZero: true } } }
});

Несколько линий

Каждый dataset линейного графика становится своей линией и автоматически получает цвет из палитры по умолчанию (переопределяется borderColor). Линии рисуются в порядке dataset, поэтому последний dataset рендерится сверху. Передайте label каждому dataset, чтобы легенда могла их различать.

chartjs
new Chart(ctx, {
  type: 'line',
  data: {
    labels: ['Jan', 'Feb', 'Mar', 'Apr'],
    datasets: [
      { label: 'Plan',  data: [10, 20, 25, 30], borderColor: 'red' },
      { label: 'Actual', data: [8, 22, 24, 33], borderColor: 'blue' }
    ]
  },
  options: {
    scales: { y: { beginAtZero: true } },
    plugins: { legend: { position: 'top' } }
  }
});

Tension и интерполяция

tension добавляет сглаживание Безье, но может «перелетать» точки данных (создавая провалы ниже минимума). cubicInterpolationMode: 'monotone' сглаживает без перелётов — предпочтительно для монотонных данных вроде цен акций. borderDash — паттерн [штрих, пробел] для пунктирных/точечных линий.

chartjs
datasets: [{
  data: [1, 5, 2, 6, 3],
  tension: 0,                  // straight lines
  // tension: 0.4,             // smooth bezier
  cubicInterpolationMode: 'monotone',  // no overshoot
  borderDash: [5, 5],          // dashed line
  borderWidth: 2,
  borderColor: 'purple'
}]

Заливка линий (fill)

fill управляет областью под линией. true/'origin' заливает вниз до оси x. Число (1, -1, +1) заливает в сторону другого dataset по индексу — удобно для ленточных диаграмм. Отрицательное число заливает к предыдущему dataset. Задайте backgroundColor с альфой, чтобы линия оставалась видимой сквозь заливку.

chartjs
datasets: [
  { label: 'A', data: [3,5,4,6], fill: true,  backgroundColor: 'rgba(255,99,132,0.3)' },
  { label: 'B', data: [1,2,3,2], fill: 'origin', backgroundColor: 'rgba(54,162,235,0.3)' },
  { label: 'C', data: [2,4,3,5], fill: 1,       backgroundColor: 'rgba(75,192,192,0.3)' }
]
// fill values: false | true/'origin' | 1/-1/+1 | '-1' | {target:...}

Стилизация точек

Свойства точек принимают одно значение или массив (по одному на точку). pointStyle поддерживает множество форм ('circle', 'rect', 'rectRot', 'triangle', 'star', 'cross', 'crossRot'). pointRadius: 0 полностью скрывает точки (полезно для плотных графиков), а увеличенный pointHoverRadius даёт интерактивный эффект увеличения.

chartjs
datasets: [{
  data: [4, 6, 5, 7],
  showLine: true,
  pointRadius: 5,           // point size (0 hides points)
  pointHoverRadius: 9,
  pointBackgroundColor: 'white',
  pointBorderColor: 'black',
  pointBorderWidth: 2,
  pointStyle: 'rectRot',    // 'circle','rect','triangle','star','cross'...
  // per-point arrays also work:
  // pointRadius: [0, 0, 6, 0],
}]

spanGaps и пропущенные данные

null, undefined и NaN означают пропущенные данные и по умолчанию разрывают линию. spanGaps: true соединяет точки по обе стороны разрыва одним сегментом. Различайте NaN (пропуск) и 0 (настоящий ноль) — их путаница часто приводит к вводящим в заблуждение графикам.

chartjs
datasets: [{
  data: [5, null, 7, NaN, 9, undefined, 11],
  spanGaps: true,    // connect across null/NaN gaps
  // spanGaps: false -> the line breaks at missing points
}]

// also skip points entirely by setting them to NaN
// NaN is "no data"; 0 is a legitimate zero value
04

Pie и Doughnut

Базовая pie-диаграмма

Pie-диаграмма показывает части целого: каждое значение становится сектором, угол которого пропорционален его доле. Дайте по одному backgroundColor на сектор (массив), иначе Chart.js циклично применит палитру по умолчанию. Pie лучше всего работает с 3-6 категориями — больше становится нечитаемым.

chartjs
new Chart(ctx, {
  type: 'pie',
  data: {
    labels: ['Rent', 'Food', 'Fun', 'Save'],
    datasets: [{
      data: [1200, 600, 400, 800],
      backgroundColor: ['#FF6384', '#36A2EB', '#FFCE56', '#4BC0C0']
    }]
  }
});

Базовая doughnut-диаграмма

Doughnut — pie с отверстием в центре. Свойство cutout (строка-процент или число пикселей) задаёт размер отверстия — '50%' даёт классический вид «бублика». В центре через плагин можно разместить итоговую подпись, а длина кольца кодирует значение чуть точнее, чем угол сектора.

chartjs
new Chart(ctx, {
  type: 'doughnut',
  data: {
    labels: ['A', 'B', 'C'],
    datasets: [{
      data: [40, 35, 25],
      backgroundColor: ['#FF6384', '#36A2EB', '#FFCE56'],
      cutout: '50%'      // size of the inner hole
    }]
  }
});

Cutout, rotation и circumference

rotation задаёт начальный угол в градусах (по умолчанию 0 = вправо; -90 = вверх). circumference определяет, какая часть круга рисуется — 180 даёт половину doughnut, полезно для диаграмм-спидометров. Оба лежат в options (не в dataset) в v3+, хотя cutout может находиться в любом месте.

chartjs
new Chart(ctx, {
  type: 'doughnut',
  data: { labels: ['A','B','C'], datasets: [{ data: [30,40,30], backgroundColor: ['#f00','#0f0','#00f'] }] },
  options: {
    cutout: '60%',
    rotation: -90,        // start at top (degrees)
    circumference: 360    // full circle; 180 = half doughnut
  }
});

Граница и offset

borderColor с borderWidth визуально отделяет секторы (белые границы дают чистый сегментированный вид). hoverOffset выталкивает сектор наружу при наведении, давая чёткую интерактивную обратную связь. offset — массив (по одному на сектор) для постоянного «отрыва» нужных секторов.

chartjs
datasets: [{
  data: [30, 40, 30],
  backgroundColor: ['#FF6384', '#36A2EB', '#FFCE56'],
  borderColor: 'white',
  borderWidth: 3,
  hoverOffset: 16,        // pop slice out on hover
  offset: [0, 20, 0]      // permanently offset 2nd slice
}]

Половина doughnut (спидометр)

Половина doughnut (rotation: -90, circumference: 180) читается как спидометр/индикатор прогресса. Сочетайте с плагином текста в центре для показа процента и отключите легенду ради чистого KPI-вида. «Оставшийся» сектор нейтрально-серым передаёт незавершённую часть.

chartjs
new Chart(ctx, {
  type: 'doughnut',
  data: {
    labels: ['Done', 'Remaining'],
    datasets: [{
      data: [72, 28],
      backgroundColor: ['#4BC0C0', '#E0E0E0']
    }]
  },
  options: {
    rotation: -90,
    circumference: 180,
    plugins: { legend: { display: false } }
  }
});

Колбэк процентов в тултипе

Тултипы pie/doughnut по умолчанию показывают сырые значения. Используйте колбэк tooltip callbacks.label, чтобы вычислять и показывать проценты — ctx.parsed это значение сектора, а ctx.dataset.data содержит все значения для суммы. Шаблонные строки в колбэках должны экранировать бэктики и ${} внутри кодовой строки этого шпаргалки.

chartjs
options: {
  plugins: {
    tooltip: {
      callbacks: {
        label: (ctx) => {
          const total = ctx.dataset.data.reduce((a, b) => a + b, 0);
          const pct = (ctx.parsed / total * 100).toFixed(1);
          return `${ctx.label}: ${ctx.parsed} (${pct}%)`;
        }
      }
    }
  }
}
05

Радиальные графики (Radar)

Базовый radar

Radar-график наносит каждую метку как вершину полигона, соединяя их в замкнутую фигуру. fill: true закрашивает внутренность. Радиальная шкала настраивается в scales.r (не x/y). Radar сравнивает многомерные профили, но может вводить в заблуждение при слишком многих осях или несопоставимых единицах.

chartjs
new Chart(ctx, {
  type: 'radar',
  data: {
    labels: ['Speed', 'Power', 'Range', 'Comfort', 'Price'],
    datasets: [{
      label: 'Model X',
      data: [8, 7, 6, 9, 5],
      borderColor: 'rgba(255,99,132,1)',
      backgroundColor: 'rgba(255,99,132,0.2)',
      fill: true
    }]
  },
  options: { scales: { r: { beginAtZero: true } } }
});

Стилизация radar

Dataset radar принимает те же стили, что и line: borderColor, fill, стили точек, tension. Небольшой tension (0.1) слегка округляет вершины для мягкого вида; 0 сохраняет прямые «лучи». Используйте полупрозрачный backgroundColor, чтобы пересекающиеся фигуры radar оставались видимыми.

chartjs
datasets: [{
  data: [7, 8, 6, 9, 5],
  borderColor: 'blue',
  backgroundColor: 'rgba(0,0,255,0.2)',
  borderWidth: 2,
  pointRadius: 4,
  pointBackgroundColor: 'blue',
  fill: true,
  tension: 0.1            // slight curve between vertices
}]

Настройки шкалы r

Радиальная шкала r управляет кольцами и подписями. min/max фиксируют диапазон значений для всех осей (обязательно при сравнении dataset). ticks.stepSize задаёт шаг колец; pointLabels оформляет имена категорий по периметру. Сделайте ticks.backdropColor прозрачным, чтобы числа колец не перекрывали линии сетки.

chartjs
options: {
  scales: {
    r: {
      min: 0,
      max: 10,
      ticks: { stepSize: 2, backdropColor: 'transparent' },
      pointLabels: { font: { size: 13 }, color: '#333' },
      grid: { color: '#ccc' },
      angleLines: { color: '#ccc' }
    }
  }
}

Radar с несколькими dataset

Несколько dataset накладываются как концентрические полигоны — идеально для сравнения «до/после» или конкурентов. Всегда задавайте одинаковые min/max на r, чтобы фигуры были сопоставимы, и полупрозрачные заливки, чтобы оба профиля оставались видимыми в местах пересечения.

chartjs
new Chart(ctx, {
  type: 'radar',
  data: {
    labels: ['A', 'B', 'C', 'D', 'E'],
    datasets: [
      { label: 'Before', data: [5,6,4,7,5], borderColor: 'red',  backgroundColor: 'rgba(255,0,0,0.15)', fill: true },
      { label: 'After',  data: [7,8,6,9,7], borderColor: 'blue', backgroundColor: 'rgba(0,0,255,0.15)', fill: true }
    ]
  }
});

Линии углов и сетка radar

angleLines — лучи от центра к каждой вершине; grid — концентрические кольца полигона. Скрытие тиков (display:false) убирает числовые подписи колец ради более чистого вида, сохраняя сами кольца. pointLabels управляет только текстом категории у каждой вершины.

chartjs
options: {
  scales: {
    r: {
      angleLines: { display: true, color: 'rgba(0,0,0,0.2)', lineWidth: 1 },
      grid: { display: true, color: 'rgba(0,0,0,0.1)' },
      pointLabels: { display: true, color: '#000', font: { weight: 'bold' } },
      ticks: { display: false }   // hide numeric ring labels for a cleaner look
    }
  }
}
06

Polar Area

Базовый polar area

Polar area рисует каждое значение сектором одинакового угла (360/N каждому), а радиус кодирует значение. В отличие от pie (где угол = значение), здесь радиус = значение, поэтому все секторы имеют равную угловую ширину, но разную длину.

chartjs
new Chart(ctx, {
  type: 'polarArea',
  data: {
    labels: ['North', 'South', 'East', 'West'],
    datasets: [{
      data: [11, 16, 7, 14],
      backgroundColor: ['#FF6384', '#4BC0C0', '#FFCE56', '#36A2EB']
    }]
  },
  options: { scales: { r: { beginAtZero: true } } }
});

Polar area против pie

Ключевая разница: в pie УГОЛ каждого сектора пропорционален значению; в polar area РАДИУС пропорционален значению, а углы равны. Используйте polar area, когда нужно одинаково видимое присутствие всех категорий, но размером по величине.

chartjs
// PIE:    angle = value,  radius = constant
new Chart(ctx, { type: 'pie',     data: { datasets: [{ data: [10, 20, 30] }] } });

// POLAR:  angle = constant, radius = value
new Chart(ctx, { type: 'polarArea', data: { datasets: [{ data: [10, 20, 30] }] } });

// polar area is better when values differ widely AND
// you want every category to occupy an equal angular share

Полярная шкала r

Polar area использует одну радиальную шкалу r для всех секторов — все значения измеряются относительно одного максимального радиуса. Явный max делает шкалу честной; без него Chart.js подстроит масштаб под наибольшее значение, что может преувеличить небольшие различия.

chartjs
options: {
  scales: {
    r: {
      min: 0,
      max: 20,
      ticks: { stepSize: 5 },
      grid: { color: 'rgba(0,0,0,0.15)' },
      angleLines: { color: 'rgba(0,0,0,0.15)' }
    }
  }
}

Границы polar area

Секторы polar area принимают ту же стилизацию границы/заливки, что pie/doughnut. Белые границы чётко разделяют соседние секторы. hoverBackgroundColor меняет заливку сектора при наведении для интерактивной обратной связи. В отличие от doughnut, cutout нет — секторы сходятся в центре.

chartjs
datasets: [{
  data: [11, 16, 7, 14],
  backgroundColor: ['#FF6384', '#4BC0C0', '#FFCE56', '#36A2EB'],
  borderColor: 'white',
  borderWidth: 2,
  hoverBackgroundColor: '#333'
}]

Polar area с hover-offset

Polar area поддерживает hoverBackgroundColor и hoverBorderColor, но НЕ поддерживает hoverOffset / offset так, как doughnut, поскольку секторы делят радиальную шкалу. Если «выталкивание» сектора обязательно — выбирайте doughnut. Для интерактивности polar area используйте цвет и изменения тултипа.

chartjs
datasets: [{
  data: [11, 16, 7, 14],
  backgroundColor: ['#FF6384', '#4BC0C0', '#FFCE56', '#36A2EB'],
  hoverOffset: 12     // not supported on polarArea the same way as doughnut;
                      // use hoverBackgroundColor + tooltips for interactivity
}]
// for true "pop out" use 'doughnut' instead
07

Пузырьковые диаграммы (Bubble)

Базовый bubble

Точки данных bubble — объекты {x, y, r}, где x и y — координаты, а r — РАДИУС пузыря в пикселях. В отличие от scatter, размер пузыря кодирует третью переменную. Учтите: r — радиус (не площадь), поэтому значение в 2 раза больше выглядит как площадь в 4 раза больше — рассмотрите sqrt-масштабирование данных размера.

chartjs
new Chart(ctx, {
  type: 'bubble',
  data: {
    datasets: [{
      label: 'Products',
      data: [
        { x: 10, y: 20, r: 15 },
        { x: 15, y: 10, r: 10 },
        { x:  7, y: 25, r:  8 }
      ],
      backgroundColor: 'rgba(255,99,132,0.6)'
    }]
  },
  options: { scales: { y: { beginAtZero: true } } }
});

Маппинг размера пузыря

Человек воспринимает ПЛОЩАДЬ пузыря, а не радиус, поэтому прогоняйте значение через Math.sqrt перед присваиванием r — тогда удвоение значения удваивает видимую площадь. Подберите делитель, чтобы самый большой пузырь не перекрывал слишком многих соседей. Так диаграмма становится перцептивно честной.

chartjs
const raw = [{x:1,y:2,pop:1000}, {x:2,y:3,pop:5000}, {x:3,y:1,pop:20000}];

// map a real-world value to a pixel radius with sqrt scaling
// so bubble AREA (not radius) is proportional to the value
const data = raw.map(d => ({
  x: d.x,
  y: d.y,
  r: Math.sqrt(d.pop) / 10    // tune the divisor for your dataset
}));

new Chart(ctx, { type: 'bubble', data: { datasets: [{ data }] } });

Цвета пузырей по точкам

Как и у других dataset Chart.js, стилевые свойства bubble принимают массивы для индивидуальной стилизации каждого пузыря. Так можно кодировать цветом категорию, а размером — отдельное числовое значение, получая четырёхмерную диаграмму (x, y, размер, цвет).

chartjs
datasets: [{
  data: [
    { x: 10, y: 20, r: 15 },
    { x: 15, y: 10, r: 10 }
  ],
  // arrays give per-point styling
  backgroundColor: ['rgba(255,99,132,0.6)', 'rgba(54,162,235,0.6)'],
  borderColor:     ['rgba(255,99,132,1)',   'rgba(54,162,235,1)'],
  borderWidth: 2
}]

Несколько bubble-dataset

Несколько dataset рендерятся группами пузырей разных цветов, каждая — в легенде. Держите радиусы умеренными при наложении групп, чтобы пузыри не заслоняли друг друга полностью. Полупрозрачные заливки (альфа 0.5-0.6) помогают пересекающимся пузырям оставаться читаемыми.

chartjs
new Chart(ctx, {
  type: 'bubble',
  data: {
    datasets: [
      { label: 'Asia',   data: [{x:1,y:2,r:10},{x:3,y:4,r:8}],  backgroundColor: 'rgba(255,99,132,0.6)' },
      { label: 'Europe', data: [{x:2,y:5,r:12},{x:4,y:2,r:7}],  backgroundColor: 'rgba(54,162,235,0.6)' }
    ]
  }
});

Стили пузыря при наведении

Свойства hover (hoverBackgroundColor, hoverBorderColor, hoverBorderWidth, hoverRadius) применяются только к пузырю под указателем. hoverRadius добавляет пиксели к радиусу при наведении — целевой пузырь заметно «выпрыгивает». Вместе с тултипами это даёт чёткий интерактивный фокус.

chartjs
datasets: [{
  data: [{x:1,y:2,r:10}],
  backgroundColor: 'rgba(75,192,192,0.5)',
  hoverBackgroundColor: 'rgba(75,192,192,0.9)',
  hoverBorderColor: 'black',
  hoverBorderWidth: 3,
  hoverRadius: 2      // EXTRA radius added on hover (v3+ uses hoverRadius)
}]
08

Диаграммы рассеяния (Scatter)

Базовый scatter

Точки scatter — объекты {x, y} (радиус не нужен). Шкале x должен иметь type: 'linear' (НЕ category), чтобы числовые значения x отображались в реальные позиции. Scatter — стандартный график для демонстрации корреляции двух непрерывных переменных.

chartjs
new Chart(ctx, {
  type: 'scatter',
  data: {
    datasets: [{
      label: 'Observations',
      data: [
        { x: 1.2, y: 2.3 },
        { x: 1.8, y: 3.1 },
        { x: 2.5, y: 4.0 },
        { x: 3.1, y: 4.8 }
      ],
      backgroundColor: 'rgba(75,192,192,0.7)'
    }]
  },
  options: { scales: { x: { type: 'linear', position: 'bottom' } } }
});

Scatter со множеством точек

Для тысяч точек уменьшите pointRadius (1-2px) и используйте полупрозрачный backgroundColor (альфа 0.2-0.4) — перекрывающиеся точки покажут плотность более тёмными областями. Для очень больших dataset отключите hover точек (pointHitRadius: 0), чтобы взаимодействие оставалось отзывчивым.

chartjs
const n = 2000;
const data = Array.from({ length: n }, () => ({
  x: Math.random() * 100,
  y: Math.random() * 100
}));

new Chart(ctx, {
  type: 'scatter',
  data: { datasets: [{ data, pointRadius: 1.5, backgroundColor: 'rgba(0,0,0,0.3)' }] }
});

Стилизация точек scatter

pointStyle поддерживает множество форм помимо круга по умолчанию: 'rect', 'rectRot', 'triangle', 'star', 'cross', 'crossRot', 'dash'. pointRotation вращает некруглые формы. Все свойства point* принимают массивы для стилизации по точке — удобно выделять конкретные наблюдения.

chartjs
datasets: [{
  data: [{x:1,y:2},{x:2,y:3}],
  pointRadius: 8,
  pointHoverRadius: 12,
  pointStyle: 'triangle',          // 'circle','rect','star','cross',...
  pointBackgroundColor: 'red',
  pointBorderColor: 'darkred',
  pointBorderWidth: 2,
  pointRotation: 45                // rotation in degrees (for shapes)
}]

Scatter с линией тренда

В Chart.js нет встроенной линии тренда — вычислите регрессию (здесь — метод наименьших квадратов) и добавьте dataset 'line' с двумя концами и pointRadius:0. Type у dataset переопределяет тип графика для конкретного ряда — так работают и смешанные графики. fill:false оставляет просто линией.

chartjs
// simple least-squares fit
const pts = [{x:1,y:2},{x:2,y:3.5},{x:3,y:4.2},{x:4,y:5.1}];
const n = pts.length;
const mX = pts.reduce((s,p)=>s+p.x,0)/n;
const mY = pts.reduce((s,p)=>s+p.y,0)/n;
const slope = pts.reduce((s,p)=>s+(p.x-mX)*(p.y-mY),0) / pts.reduce((s,p)=>s+(p.x-mX)**2,0);
const intercept = mY - slope*mX;

new Chart(ctx, {
  type: 'scatter',
  data: { datasets: [
    { data: pts, backgroundColor: 'blue' },
    { type: 'line', data: [{x:0,y:intercept},{x:5,y:slope*5+intercept}],
      borderColor: 'red', pointRadius: 0, fill: false }
  ]}
});

Scatter в line (showLine)

showLine: true у scatter-dataset соединяет точки линией, фактически превращая scatter в линейный график с числовыми координатами x. Правильный выбор, когда значения x — реальные числа (не метки категорий), но нужны соединяющие сегменты — например, временные ряды с неравномерными интервалами.

chartjs
new Chart(ctx, {
  type: 'scatter',
  data: { datasets: [{
    data: [{x:1,y:2},{x:2,y:3},{x:3,y:5}],
    showLine: true,            // connect points with a line
    borderColor: 'green',
    backgroundColor: 'green',
    pointRadius: 4
  }]}
});
09

Данные — Datasets

Структура datasets

data хранит labels (общие для всех dataset) и datasets (массив рядов). У каждого dataset есть label (показывается в легенде/тултипах), массив data, выровненный с labels, и стилевые свойства. Свойства dataset применяются ко всем точкам, если не переопределены массивом.

chartjs
data: {
  labels: ['A', 'B', 'C'],          // shared category labels
  datasets: [
    {
      label: 'Series 1',             // legend + tooltip label
      data: [10, 20, 30],            // values (one per label)
      backgroundColor: 'rgba(0,0,255,0.5)',
      borderColor: 'blue',
      borderWidth: 1,
      // ... type-specific styling
    }
  ]
}

Выравнивание labels и data

Массив data каждого dataset выровнен позиционно с общим массивом labels — data[i] это значение для labels[i]. Более короткий data даёт undefined для недостающего хвоста, что line-графики трактуют как разрывы. Держите labels и data одинаковой длины, чтобы избежать неожиданных разрывов.

chartjs
data: {
  labels: ['Jan', 'Feb', 'Mar'],
  datasets: [
    { data: [10, 20, 30] },          // Jan=10, Feb=20, Mar=30
    { data: [5, 15] }                // Jan=5, Feb=15, Mar=undefined
  ]
}
// data[i] always corresponds to labels[i]; a shorter data array
// leaves the remaining positions as undefined (missing data)

Несколько dataset

Несколько dataset рендерятся параллельными рядами (группы столбцов, несколько линий, наложенные radar). Они делят один массив labels. Задайте различающиеся цвета каждому dataset — Chart.js красит автоматически только при опущенном backgroundColor, а явные цвета предсказуемее между версиями.

chartjs
data: {
  labels: ['Q1','Q2','Q3','Q4'],
  datasets: [
    { label: '2023', data: [20,35,30,35], backgroundColor: 'rgba(255,99,132,0.6)' },
    { label: '2024', data: [25,32,34,40], backgroundColor: 'rgba(54,162,235,0.6)' },
    { label: '2025', data: [28,38,36,45], backgroundColor: 'rgba(75,192,192,0.6)' }
  ]
}

Стили уровня dataset

Стиль уровня dataset применяется ко всем точкам этого dataset. Варианты hover* активируются при наведении. hidden:true скрывает dataset изначально (переключатель легенды вернёт). order управляет z-порядком — меньшие числа рисуются позже (сверху) — полезно в смешанных/перекрывающихся графиках.

chartjs
datasets: [{
  label: 'Revenue',
  data: [10, 20, 30],
  backgroundColor: 'rgba(54,162,235,0.6)',
  borderColor: 'rgba(54,162,235,1)',
  borderWidth: 2,
  hoverBackgroundColor: 'rgba(54,162,235,0.9)',
  hidden: false,                  // set true to hide from view + legend toggle
  order: 0                        // lower order draws on top
}]

Разбор объектных данных

Когда данные — массив объектов, скажите Chart.js, какие поля содержат значения осей, через parsing: {xAxisKey, yAxisKey}. Это избавляет от ручного маппинга в пары {x, y}. Ключи по умолчанию 'x' и 'y', поэтому объекты {x, y} работают без конфигурации parsing.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: {
    datasets: [{
      data: [
        { name: 'Red', votes: 12 },
        { name: 'Blue', votes: 19 }
      ],
      parsing: { xAxisKey: 'name', yAxisKey: 'votes' }
    }]
  }
});

Массивы стилей по точкам

Любое стилевое свойство может быть одним значением (для всех точек) или массивом (по одному на точку). Это позволяет выделять конкретные точки — например, сделать почти весь backgroundColor серым, а один красным. Длина массива должна совпадать с длиной данных; более короткие массивы циклятся.

chartjs
datasets: [{
  data: [10, 20, 30, 40],
  // every styling property accepts an array (one value per point)
  backgroundColor: ['red', 'green', 'blue', 'orange'],
  borderColor:     ['darkred', 'darkgreen', 'darkblue', 'darkorange'],
  borderWidth: [1, 2, 3, 4],
  pointRadius: [3, 6, 9, 12]   // (line/scatter only)
}]
10

Опции — отзывчивость и шкалы

Структура options

options — объект конфигурации верхнего уровня. Он группирует аспекты: plugins (legend/title/tooltip), scales (x/y/r), layout (padding), animation, interaction (режим hover) и events. Почти всё поведение Chart.js настраивается здесь, а не на отдельных dataset.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: { /* ... */ },
  options: {
    responsive: true,
    maintainAspectRatio: true,
    plugins: { legend: {}, title: {}, tooltip: {} },
    scales:  { x: {}, y: {} },
    layout:  { padding: 10 },
    animation: { duration: 800 },
    interaction: { mode: 'nearest', intersect: false },
    events: ['mousemove', 'click', 'touchstart']
  }
});

Responsive и maintainAspectRatio

responsive:true заставляет график заполнять ширину контейнера и перерисовываться при изменении размера. maintainAspectRatio:false освобождает высоту, чтобы учитывалась CSS-высота контейнера — задайте оба и оберните canvas в div с размерами. При maintainAspectRatio:true (по умолчанию) график держит фиксированное соотношение сторон.

chartjs
<div style="width:100%; height:400px;">
  <canvas id="c"></canvas>
</div>

<script>
new Chart(document.getElementById('c'), {
  type: 'line',
  data: { /* ... */ },
  options: {
    responsive: true,           // resize with container
    maintainAspectRatio: false  // let the container control height
  }
});
</script>

Обзор шкал (scales)

scales настраивает каждую ось. Id (x, y, r) — ключ шкалы; type выбирает класс шкалы. Частые типы: 'category' (текстовые метки), 'linear' (числа), 'logarithmic', 'time' (нужен адаптер дат), 'radialLinear' (radar/polar). title.display + text добавляют подпись оси.

chartjs
options: {
  scales: {
    x: { type: 'category', title: { display: true, text: 'Month' } },
    y: { type: 'linear',   title: { display: true, text: 'Value' },
         beginAtZero: true },
    r: { type: 'radialLinear' }   // for radar/polarArea
  }
}
// built-in scale types: category, linear, logarithmic, time,
//                       timeseries, radialLinear

Обзор плагинов

plugins группирует встроенные плагины title, legend и tooltip плюс опции любых зарегистрированных кастомных плагинов по их id. title добавляет заголовок над canvas. legend управляет ключом dataset. tooltip управляет всплывающими подсказками. Кастомные плагины читают свои опции из того же объекта plugins.

chartjs
options: {
  plugins: {
    title:   { display: true, text: 'My Chart', font: { size: 18 } },
    legend:  { display: true, position: 'top' },
    tooltip: { enabled: true, mode: 'index', intersect: false },
    // a custom inline plugin:
    myPlugin: { prop: 'value' }
  }
}

Layout (padding)

layout.padding добавляет место внутри canvas между областью графика и краем canvas — полезно, когда заголовки, подписи осей или крупные тултипы иначе обрезались бы. Одно число задает одинаковый padding со всех сторон; объектная форма позволяет значения по сторонам.

chartjs
options: {
  layout: {
    padding: {
      top: 10, right: 20, bottom: 10, left: 20
    }
  }
}
// or a single number for all four sides:
// layout: { padding: 15 }

Глобальные значения по умолчанию (Chart.defaults)

Chart.defaults хранит глобальную конфигурацию по умолчанию — задайте значения один раз при старте приложения, и каждый график их унаследует. Правильное место для брендинга (семейство шрифтов, базовый цвет, анимация по умолчанию). Опции конкретного графика всегда переопределяют значения по умолчанию, так что отдельные графики всё равно можно кастомизировать.

chartjs
// set once, applies to every chart created afterwards
Chart.defaults.font.family = "'Segoe UI', sans-serif";
Chart.defaults.font.size = 13;
Chart.defaults.color = '#333';
Chart.defaults.borderColor = '#ddd';
Chart.defaults.plugins.legend.labels.color = '#333';
Chart.defaults.animation.duration = 600;

// per-chart override still wins:
new Chart(ctx, { options: { font: { size: 16 } } });
11

Оси — X и Y

Линейная ось

Линейная ось отображает числа пропорционально. beginAtZero заставляет ось начинаться с 0 (рекомендуется для bar). min/max задают жёсткие границы; suggestedMin/suggestedMax — мягкие подсказки, которые Chart.js может расширить для красивых тиков. ticks.callback кастомизирует текст подписи (например, добавить единицу измерения).

chartjs
options: {
  scales: {
    y: {
      type: 'linear',
      beginAtZero: true,
      min: 0, max: 100,        // hard limits
      ticks: { stepSize: 10, callback: (v) => v + '%' }
    }
  }
}

Категориальная ось

Категориальная ось показывает текстовые метки в фиксированных позициях. Это ось x по умолчанию для bar/line. ticks.autoSkip:false заставляет показывать каждую подпись (иначе Chart.js отбрасывает перекрывающиеся). maxRotation наклоняет подписи, предотвращая наложение при большом числе категорий.

chartjs
options: {
  scales: {
    x: {
      type: 'category',
      labels: ['Mon','Tue','Wed'],   // optional; usually from data.labels
      ticks: { autoSkip: false, maxRotation: 45, minRotation: 0 }
    }
  }
}

Ось времени

Ось time отображает объекты Date или ISO-строки пропорционально времени, с разрывами там, где данных нет. Требуется пакет адаптера дат (chartjs-adapter-date-fns, -luxon, -dayjs). time.unit фиксирует гранулярность тиков ('day','month','year'); без него Chart.js подберёт единицу сам.

chartjs
# install a date adapter
npm install chart.js date-fns date-fns-tz

import 'chartjs-adapter-date-fns';

new Chart(ctx, {
  type: 'line',
  data: { datasets: [{ data: [
    {x: new Date('2024-01-01'), y: 10},
    {x: new Date('2024-02-01'), y: 20},
    {x: new Date('2024-04-01'), y: 15}
  ]}]},
  options: { scales: { x: { type: 'time', time: { unit: 'month' } } } }
});

Логарифмическая ось

Логарифмическая ось размещает тики по степеням 10 — необходима для данных, охватывающих порядки величины (население, цены, частоты). Она не может показывать 0 и отрицательные значения. ticks.callback позволяет компактно форматировать подписи степеней (например, научная нотация).

chartjs
new Chart(ctx, {
  type: 'line',
  data: { datasets: [{ data: [1, 10, 100, 1000, 10000] }] },
  options: {
    scales: {
      y: { type: 'logarithmic',
           ticks: { callback: (v) => v >= 1 ? v.toExponential(0) : v } }
    }
  }
});

Заголовок оси и колбэк тиков

title.display + title.text добавляют подпись оси (по умолчанию всегда выключена — задайте display:true). ticks.callback получает значение каждого тика и возвращает строку для отображения: форматируйте числа как валюту, проценты, сокращения k/M или любой свой текст, не меняя исходные данные.

chartjs
options: {
  scales: {
    y: {
      title: { display: true, text: 'Revenue (USD)', color: '#333', font: { size: 14, weight: 'bold' } },
      ticks: {
        callback: function(value) {
          if (value >= 1000) return (value/1000) + 'k';
          return value;
        }
      }
    }
  }
}

Min/Max против suggestedMin/Max

min/max — ЖЁСТКИЕ границы: ось остаётся в них, даже если данные выходят за диапазон (данные обрезаются). suggestedMin/suggestedMax — МЯГКИЕ подсказки: Chart.js берёт их за основу, но может расширить ради круглых значений тиков. Предпочитайте suggested*, когда хочется красивых круглых чисел; жёсткие min/max — для фиксированных шкал вроде процентов.

chartjs
options: {
  scales: {
    y: {
      // hard limits — chart never goes outside this range
      min: 0, max: 100,
      // OR soft hints — Chart.js may expand to fit nice ticks:
      // suggestedMin: 0, suggestedMax: 100,
      ticks: { stepSize: 20 }
    }
  }
}
12

Легенда

Основы легенды

Легенда перечисляет label каждого dataset с цветным образцом. display:true показывает (по умолчанию), display:false скрывает. position принимает 'top', 'bottom', 'left', 'right' или 'center' (chartArea). Клик по пункту легенды по умолчанию переключает видимость этого dataset — встроенная фильтрация.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: { labels: ['A','B'], datasets: [{ label: 'Sales', data: [10,20] }] },
  options: {
    plugins: {
      legend: { display: true, position: 'top' }
    }
  }
});

Позиция и выравнивание легенды

position задаёт сторону легенды; align — размещение вдоль неё ('start'/'center'/'end'). labels настраивает образец (boxWidth/boxHeight) и стиль текста. maxWidth ограничивает область легенды, чтобы очень длинные легенды переносились, а не отталкивали график.

chartjs
plugins: {
  legend: {
    position: 'bottom',
    align: 'center',     // 'start' | 'center' | 'end'
    maxWidth: 300,
    labels: {
      boxWidth: 20,
      boxHeight: 20,
      padding: 15,
      color: '#333',
      font: { size: 12 }
    }
  }
}

Legend onClick (кастомное переключение)

Переопределите legend.onClick, чтобы настроить поведение по клику. По умолчанию переключается видимость dataset. Сигнатура: (event, legendItem, legend). После изменения состояния вызовите chart.update() для перерисовки. Применяйте для подтверждения перед скрытием, синхронизации с внешним UI или поведения «только один выбор» (radio).

chartjs
plugins: {
  legend: {
    onClick(e, item, legend) {
      const chart = legend.chart;
      const dataset = chart.data.datasets[item.datasetIndex];
      // custom: toggle visibility AND log the action
      dataset.hidden = !dataset.hidden;
      console.log('Toggled', dataset.label, '->', dataset.hidden);
      chart.update();
    }
  }
}

Колбэк подписей легенды

generateLabels возвращает массив объектов-подписей и полностью управляет тем, что показывается в легенде. Текст каждого пункта, цвета образцов и состояние hidden можно кастомизировать — полезно для добавления счётчиков, единиц или построения легенды из данных вне dataset. Флаг hidden и datasetIndex связывают клик с нужным dataset.

chartjs
plugins: {
  legend: {
    labels: {
      generateLabels(chart) {
        return chart.data.datasets.map((ds, i) => ({
          text: `${ds.label} (${ds.data.length} pts)`,
          fillStyle: ds.backgroundColor,
          strokeStyle: ds.borderColor,
          lineWidth: ds.borderWidth,
          hidden: ds.hidden,
          datasetIndex: i
        }));
      }
    }
  }
}

Скрытие легенды и внешняя легенда

Для полного контроля стиля отключите встроенную легенду (display:false) и нарисуйте свою HTML-легенду. Переберите chart.data.datasets, отрисуйте кнопки/образцы и по клику переключайте dataset.hidden + chart.update(). Часто нужно, когда вписаться в дизайн-систему не позволяет стандартная canvas-легенда.

chartjs
// hide the built-in legend entirely
options: { plugins: { legend: { display: false } } }

// build your own external legend HTML, then wire it to the chart:
const chart = new Chart(ctx, { /* ... */, options: { plugins: { legend: { display: false } } } });

chart.data.datasets.forEach((ds, i) => {
  const btn = document.createElement('button');
  btn.textContent = ds.label;
  btn.onclick = () => { ds.hidden = !ds.hidden; chart.update(); };
  document.getElementById('legend').appendChild(btn);
});
13

Тултипы

Основы тултипов

Тултипы появляются при наведении и показывают label и значение dataset. enabled:true по умолчанию. Стилевые свойства (backgroundColor, titleColor, bodyColor, padding, cornerRadius) управляют внешним видом. displayColors переключает маленькие цветные образцы рядом с каждым пунктом — полезно при многих пересекающихся dataset.

chartjs
options: {
  plugins: {
    tooltip: {
      enabled: true,           // show tooltips
      backgroundColor: 'rgba(0,0,0,0.8)',
      titleColor: 'white',
      bodyColor: 'white',
      borderColor: 'gray',
      borderWidth: 1,
      padding: 10,
      cornerRadius: 4,
      displayColors: true      // show color boxes
    }
  }
}

Колбэк label тултипа

callbacks.label возвращает текст каждой строки тултипа. ctx.dataset.label — имя ряда, ctx.parsed.y содержит значение (для pie/radar используйте ctx.parsed). Здесь форматируйте валюту, добавляйте единицы или вычисляйте итоги. Возвращённая строка (или массив строк) становится телом тултипа.

chartjs
plugins: {
  tooltip: {
    callbacks: {
      label: (ctx) => {
        const label = ctx.dataset.label || '';
        const value = ctx.parsed.y ?? ctx.parsed;
        return `${label}: $${value}`;
      }
    }
  }
}

Колбэк title тултипа

callbacks.title управляет заголовком тултипа (по умолчанию — метка оси x). Функция получает массив пунктов тултипа (актуально, когда mode:'index' группирует несколько dataset). Возврат пустой строки '' полностью подавляет заголовок. Сочетайте колбэки title и label для полностью кастомного содержимого тултипа.

chartjs
plugins: {
  tooltip: {
    callbacks: {
      title: (items) => {
        // items[0].label is the x-axis label / category
        return 'Period: ' + items[0].label;
      },
      label: (ctx) => ctx.dataset.label + ': ' + ctx.formattedValue
    }
  }
}

Внешний HTML-тултип

external позволяет рендерить тултип настоящим HTML — для насыщенных стилей, изображений или ссылок, невозможных на canvas. Задайте enabled:false, чтобы стандартный тултип не дублировал отрисовку. Колбэк получает контекст с объектом tooltip, содержащим caretX/caretY (позиция) и строки body. Позиционируйте HTML-элемент по этим координатам.

chartjs
plugins: {
  tooltip: {
    enabled: false,                  // disable default canvas tooltip
    external(context) {
      const { tooltip } = context;
      let el = document.getElementById('tt');
      if (!el) { el = document.createElement('div'); el.id = 'tt'; document.body.appendChild(el); }
      if (tooltip.opacity === 0) { el.style.opacity = 0; return; }
      el.innerHTML = tooltip.body.map(b => b.lines.join('')).join('<br>');
      el.style.position = 'fixed';
      el.style.left = tooltip.caretX + 'px';
      el.style.top  = tooltip.caretY + 'px';
      el.style.opacity = 1;
    }
  }
}

Режим тултипа (interaction)

interaction.mode определяет, на что нацелен тултип. 'point' показывает только точку под курсором; 'index' — все dataset на том же x (удобно для группированных bar/line); 'nearest' находит ближайшую точку. intersect:false вызывает тултип, когда указатель где угодно в колонке, а не только на точке — обычно именно этого ожидают пользователи.

chartjs
options: {
  interaction: {
    mode: 'index',     // 'point' | 'nearest' | 'index' | 'x' | 'y' | 'dataset'
    intersect: false   // trigger even when not directly over a point
  },
  plugins: { tooltip: { mode: 'index', intersect: false } }
}

Стили тултипа и фильтры

filter пропускает строки тултипа, не удовлетворяющие условию (например, скрыть нулевые/пустые значения). callbacks.footer добавляет итоговую строку после всех пунктов — идеально для суммы. bodyFont/titleFont оформляют текст; caretSize и caretPadding управляют стрелкой-указателем.

chartjs
plugins: {
  tooltip: {
    filter: (item) => item.parsed.y !== 0,   // hide zero values
    callbacks: { footer: (items) => 'Total: ' + items.reduce((s,i)=>s+i.parsed.y,0) },
    bodyFont: { size: 13, weight: 'bold' },
    titleFont: { size: 14 },
    caretSize: 6,
    caretPadding: 8
  }
}
14

Анимация

Длительность анимации

animation.duration задаёт общую длину анимации в миллисекундах (по умолчанию 1000). easing выбирает кривую ускорения — 'easeOutQuart' (по умолчанию) стартует быстро и замедляется, что ощущается отзывчивым. Уменьшайте duration (200-400 мс) для дашбордов с частыми обновлениями.

chartjs
options: {
  animation: {
    duration: 1000,      // total duration in ms
    easing: 'easeOutQuart'
  }
}
// easing options: 'linear','easeInQuad','easeOutQuad','easeInOutQuad',
// 'easeInCubic','easeOutCubic','easeInOutCubic','easeOutBounce',...

Отключение анимации

animation:false полностью отключает все анимации — лучший вариант для производительно-критичных дашбордов или потоковых обновлений. animation:{duration:0} оставляет систему анимации активной, но мгновенной (hover работает). Объект animations (множественное число) позволяет отключить конкретные свойства вроде y, анимируя остальные.

chartjs
// disable ALL animations
options: { animation: false }

// disable only the initial draw, keep hover animations:
options: { animation: { duration: 0 } }

// per-property: animate everything except the y axis
options: {
  animations: {
    y: { duration: 0 }
  }
}

Функции easing

Easing меняет, как анимация продвигается во времени, резко влияя на ощущение. 'easeOutQuart' (по умолчанию) ощущается профессионально и отзывчиво. 'easeOutBounce' или 'easeInOutBack' игривы, но на графиках данных могут смотреться наигранно. Согласуйте easing с общим языком движения приложения.

chartjs
options: {
  animation: {
    duration: 1200,
    easing: 'easeInOutBack'   // slight overshoot for a playful feel
  }
}
// common easings:
// 'linear'            constant speed (mechanical)
// 'easeOutQuart'      default; snappy start, smooth end
// 'easeInOutCubic'    symmetric in/out
// 'easeOutBounce'     bouncy landing
// 'easeInOutBack'     overshoots at both ends

Animation onComplete

onComplete срабатывает по завершении анимации — удобно для цепочек действий: включить кнопку экспорта или запустить следующий рендер. onProgress срабатывает на каждом кадре анимации со счётчиком шага. Избегайте тяжёлой работы в onProgress — он выполняется 60 раз в секунду.

chartjs
options: {
  animation: {
    onComplete: function() {
      console.log('Animation finished');
      // e.g. enable a "download PNG" button now that the chart is stable
      document.getElementById('downloadBtn').disabled = false;
    },
    onProgress: function(ctx) {
      // fired each frame; ctx.currentStep / ctx.numSteps
    }
  }
}

Анимация по свойствам (animations)

Объект animations (множественное число) настраивает отдельные свойства независимо. Каждый элемент может задать from/to (или функцию от контекста парсинга), duration, easing и loop. Анимация tension с 1 до 0.3 даёт эффект «линия успокаивается»; анимация y от базовой линии оси — эффект «вырастает вверх».

chartjs
options: {
  animations: {
    tension: {
      duration: 1500,
      easing: 'easeOutBounce',
      from: 1,           // start very curved
      to: 0.3,           // settle at a gentle curve
      loop: false
    },
    colors: { duration: 800 },
    y: { from: ctx => ctx.chart.scales.y.getPixelForValue(0) }
  }
}
15

События и клики

Обработчик onClick

options.onClick срабатывает при клике в любой точке графика. Аргумент elements — массив кликнутых элементов графика (столбцов/точек), у каждого есть .datasetIndex и .index. Пустой elements означает клик мимо всего. Это стандартный способ сделать графики интерактивными (drill-down, выбор).

chartjs
new Chart(ctx, {
  type: 'bar',
  data: { labels: ['A','B','C'], datasets: [{ data: [10,20,30] }] },
  options: {
    onClick(event, elements, chart) {
      if (elements.length > 0) {
        const el = elements[0];
        const label = chart.data.labels[el.index];
        const value = chart.data.datasets[el.datasetIndex].data[el.index];
        alert(`Clicked ${label} = ${value}`);
      }
    }
  }
});

getElementsAtEventForMode

getElementsAtEventForMode находит элементы графика под нативным событием мыши с теми же опциями mode, что у interaction ('nearest', 'index', 'x' и т. д.). Четвёртый аргумент useFinalPosition должен быть true для проверки попадания по финальным отрендеренным позициям. Применяйте, когда нужен поиск элементов вне options.onClick.

chartjs
const chart = new Chart(ctx, { /* ... */ });

canvas.addEventListener('click', (e) => {
  const points = chart.getElementsAtEventForMode(
    e, 'nearest', { intersect: true }, true   // (event, mode, options, useFinalPosition)
  );
  if (points.length) {
    const p = points[0];
    console.log('dataset', p.datasetIndex, 'index', p.index);
  }
});

onHover

options.onHover срабатывает при каждом движении мыши над графиком. Используйте для дешёвой обратной связи: сменить курсор (как в примере) или подсветить связанные внешние элементы. Избегайте дорогих операций — срабатывает очень часто. Для тяжёлой логики берите onClick или добавляйте debounce.

chartjs
options: {
  onHover(event, elements, chart) {
    // change cursor to a pointer when hovering a bar
    event.native.target.style.cursor =
      elements.length ? 'pointer' : 'default';
  }
}

Hover и активные элементы

Конфигурация hover управляет подсветкой элементов под указателем. mode:'nearest' + intersect:true подсвечивает единственную ближайшую точку. animationDuration сглаживает переход подсветки. chart.setActiveElements программно включает состояние hover — удобно синхронизировать подсветку графика с внешним UI.

chartjs
options: {
  hover: {
    mode: 'nearest',
    intersect: true,
    animationDuration: 200   // smooth transition when hover target changes
  }
}
// programmatically set the hovered element:
chart.setActiveElements([{ datasetIndex: 0, index: 2 }]);
chart.update();

Список событий

events ограничивает, какие DOM-события слушает график. Сокращение списка (например, только 'click') отключает эффекты наведения для статичного ощущения и повышает производительность дашбордов. Для чисто тач-контекста мобильных включите touchstart/touchmove. Пустой массив отключает всё взаимодействие.

chartjs
options: {
  events: ['mousemove', 'mouseout', 'click', 'touchstart', 'touchmove']
  // restrict to just click for a non-interactive "static" feel:
  // events: ['click']
}
// supported events: mousemove, mouseout, click, touchstart, touchmove,
//                   touchend, pointer events (Chart.js v3.4+)

Пример drill-down

Частый паттерн: клик по столбцу подменяет dataset детальным видом (drill-down). Сохраните кликнутый индекс, замените chart.data.labels и chart.data.datasets[...].data, затем вызовите chart.update() для анимированного перехода. Держите стек видов, если нужна кнопка «назад».

chartjs
const monthly = { labels: ['Jan','Feb','Mar'], data: [100,120,90] };
const daily = { labels: Array.from({length:28},(_,i)=>'D'+(i+1)),
                data: Array.from({length:28},()=>Math.random()*50) };

const chart = new Chart(ctx, {
  type: 'bar',
  data: { labels: monthly.labels, datasets: [{ data: monthly.data }] },
  options: { onClick(evt, els) {
    if (!els.length) return;
    const idx = els[0].index;
    chart.data.labels = daily.labels;
    chart.data.datasets[0].data = daily.data;
    chart.update();
  }}
});
16

Смешанные графики

Смешанный bar + line

Смешивайте типы, задавая type отдельным dataset — он переопределяет тип уровня графика для этого ряда. Комбинация bar + line — самая частая (например, выручка столбцами, темп роста линией). При разных единицах или масштабах используйте вторую ось y (y1).

chartjs
new Chart(ctx, {
  type: 'bar',                          // default type for all datasets
  data: {
    labels: ['Jan','Feb','Mar','Apr'],
    datasets: [
      { type: 'bar',  label: 'Revenue', data: [20,35,30,40], backgroundColor: '#36A2EB', yAxisID: 'y' },
      { type: 'line', label: 'Growth',  data: [5,8,6,12],    borderColor: '#FF6384', yAxisID: 'y1', fill: false }
    ]
  },
  options: { scales: { y: { position: 'left' }, y1: { position: 'right', grid: { drawOnChartArea: false } } } }
});

Переопределение type у dataset

Любой dataset может переопределить тип уровня графика, позволяя объединить bar, line и scatter в одном графике. Dataset без явного type наследует тип графика. Следите за z-порядком: dataset рисуются в порядке массива, поэтому фоновые ряды (столбцы) ставьте раньше передних (линии).

chartjs
new Chart(ctx, {
  type: 'line',                // chart-level default
  data: {
    labels: ['A','B','C'],
    datasets: [
      { data: [1,2,3] },                          // inherits 'line'
      { type: 'bar', data: [3,2,1] },              // becomes a bar
      { type: 'scatter', data: [{x:0,y:2},{x:2,y:3}], pointRadius: 5 }  // scatter points
    ]
  }
});

Несколько осей Y (y, y1, y2)

Определите несколько осей y с кастомными id (y, y1, y2) и привяжите dataset через yAxisID. grid.drawOnChartArea:false не даёт второй оси рисовать линии сетки поверх первой. position:'right' — справа; третьей оси добавьте offset:true, чтобы она не налезла на вторую. Окрасьте каждую ось в цвет её ряда.

chartjs
options: {
  scales: {
    y:  { type: 'linear', position: 'left',  title: { display: true, text: 'Price ($)' } },
    y1: { type: 'linear', position: 'right', title: { display: true, text: 'Volume' }, grid: { drawOnChartArea: false } },
    y2: { type: 'linear', position: 'right', offset: true, title: { display: true, text: '%' } }
  }
}
// assign each dataset: yAxisID: 'y' | 'y1' | 'y2'

Смешанные данные разных форм

Смешанные графики могут комбинировать ряд значений (столбцы) со справочными линиями (постоянная цель, тренд). Задайте pointRadius:0 и fill:false у line-dataset, чтобы они рендерились чистыми линиями без маркеров и заливки. Паттерн типичен для дашбордов производительности (факт против плана).

chartjs
new Chart(ctx, {
  type: 'bar',
  data: {
    labels: ['Mon','Tue','Wed','Thu','Fri'],
    datasets: [
      { type:'bar',  label:'Tasks', data:[8,6,7,9,5], backgroundColor:'rgba(54,162,235,0.6)' },
      { type:'line', label:'Target',data:[7,7,7,7,7], borderColor:'red', borderWidth:2, pointRadius:0, fill:false },
      { type:'line', label:'Trend', data:[6,6.5,7,8,8.5], borderColor:'green', borderDash:[5,5], pointRadius:0, fill:false }
    ]
  }
});

Советы по стилю смешанных графиков

В смешанных графиках задайте dataset.order, чтобы линия рисовалась выше столбцов (меньший order = сверху). Красьте тики и заголовок каждой оси в цвет её ряда, чтобы читатель понимал, какая шкала к какой линии. Отключите сетку второй оси (drawOnChartArea:false), чтобы не дублировать линии сетки.

chartjs
// 1. assign order so lines draw on top of bars
datasets: [
  { type:'bar',  data:[...], order: 2 },
  { type:'line', data:[...], order: 1 }   // lower order draws later (on top)
]
// 2. give each axis a matching color
options: { scales: {
  y:  { ticks: { color: '#36A2EB' }, title: { text: 'Revenue', color: '#36A2EB' } },
  y1: { ticks: { color: '#FF6384' }, title: { text: 'Growth',  color: '#FF6384' }, position: 'right', grid: { drawOnChartArea: false } }
}}
17

Плагины

Встроенные плагины

Chart.js поставляется с тремя встроенными плагинами: Title (заголовок над canvas), Legend (ключ dataset) и Tooltip (всплывающие подсказки). Они настраиваются в options.plugins по id и включены по умолчанию (кроме Title, которому нужно display:true для показа текста).

chartjs
// three built-in plugins (always available):
//   Legend   -> options.plugins.legend
//   Title    -> options.plugins.title
//   Tooltip  -> options.plugins.tooltip

new Chart(ctx, {
  type: 'line',
  data: { /* ... */ },
  options: {
    plugins: {
      title:  { display: true, text: 'Sales 2024', font: { size: 18 } },
      legend: { position: 'bottom' },
      tooltip:{ mode: 'index', intersect: false }
    }
  }
});

Кастомный инлайн-плагин

Передайте массив объектов-плагинов конкретному графику через опцию plugins. У каждого плагина id и функции-хуки (beforeInit, afterInit, beforeDraw, afterDraw, beforeUpdate и др.). Инлайн-плагины действуют только на этот экземпляр графика. ctx.save()/restore() обрамляйте любые изменения состояния canvas.

chartjs
new Chart(ctx, {
  type: 'line',
  data: { /* ... */ },
  options: { /* ... */ },
  plugins: [{
    id: 'centerText',
    afterDraw(chart) {
      const { ctx, chartArea } = chart;
      ctx.save();
      ctx.font = 'bold 24px Arial';
      ctx.fillStyle = 'black';
      ctx.textAlign = 'center';
      ctx.textBaseline = 'middle';
      ctx.fillText('Hello', (chartArea.left+chartArea.right)/2,
                            (chartArea.top+chartArea.bottom)/2);
      ctx.restore();
    }
  }]
});

Хуки плагинов (жизненный цикл)

Хуки плагинов выполняются на каждом этапе жизненного цикла графика: init, update, render, draw, resize, destroy. Хуки before* могут отменить действие, вернув false. Для кастомного рисования чаще всего используют afterDraw (рисовать поверх) или beforeDraw (рисовать позади данных). Каждый хук получает экземпляр графика.

chartjs
const plugin = {
  id: 'myHook',
  beforeInit(chart)  { console.log('before init'); },
  afterInit(chart)   { console.log('chart ready'); },
  beforeUpdate(chart){ console.log('about to update'); },
  beforeDraw(chart)  { console.log('before draw'); },
  afterDraw(chart)   { console.log('after draw'); },
  beforeRender(chart){ console.log('before first render'); },
  resize(chart, size){ console.log('resized', size); },
  destroy(chart)     { console.log('destroyed'); }
};

Плагин: вертикальная линия по индексу

Частый кастомный плагин рисует вертикальную направляющую в позиции тултипа (как встроенный перекрестие). afterDraw читает координату x активного элемента тултипа и рисует пунктирную линию сверху вниз области графика. Обрамляйте состояние canvas в save()/restore(), чтобы стиль пунктира не протекал.

chartjs
const verticalLine = {
  id: 'verticalLine',
  afterDraw(chart) {
    if (chart.tooltip?._active?.length) {
      const x = chart.tooltip._active[0].element.x;
      const { top, bottom } = chart.chartArea;
      const ctx = chart.ctx;
      ctx.save();
      ctx.beginPath();
      ctx.moveTo(x, top);
      ctx.lineTo(x, bottom);
      ctx.lineWidth = 1;
      ctx.strokeStyle = 'gray';
      ctx.setLineDash([4, 4]);
      ctx.stroke();
      ctx.restore();
    }
  }
};

Плагин: текст в центре doughnut

Рисование итогового текста в центре — классический сценарий плагина для doughnut. afterDatasetsDraw выполняется после секторов, поэтому текст ложится сверху. Вычислите итог (или любую сводку) и отрисуйте в геометрическом центре chartArea. Это превращает doughnut в информативный KPI-виджет.

chartjs
const centerText = {
  id: 'centerText',
  afterDatasetsDraw(chart) {
    const { ctx, data } = chart;
    const total = data.datasets[0].data.reduce((a,b)=>a+b, 0);
    ctx.save();
    ctx.font = 'bold 28px Arial';
    ctx.fillStyle = '#333';
    ctx.textAlign = 'center';
    ctx.textBaseline = 'middle';
    const { left, right, top, bottom } = chart.chartArea;
    ctx.fillText(total, (left+right)/2, (top+bottom)/2);
    ctx.restore();
  }
};
new Chart(ctx, { type:'doughnut', data:{...}, plugins:[centerText] });

Глобальная регистрация плагина

Chart.register(plugin) применяет плагин ко всем графикам, созданным после — идеально для плагинов уровня приложения: водяные знаки, брендинг, аналитика. Для разового графика используйте инлайн-массив plugins. Chart.unregister убирает плагин. Зарегистрированные плагины читают конфигурацию из options.plugins[id].

chartjs
import { Chart } from 'chart.js';

const myPlugin = { id: 'watermark', afterDraw(chart) { /* ... */ } };

// register once -> applies to EVERY chart
Chart.register(myPlugin);

// or unregister later
Chart.unregister(myPlugin);

// per-chart-only: skip Chart.register and pass via options.plugins instead
18

Обновление и уничтожение

chart.update()

После изменения chart.data или chart.options вызовите chart.update() для перерисовки. По умолчанию изменение анимируется от предыдущего состояния. Передайте 'none' как mode, чтобы пропустить анимацию (полезно при частых обновлениях). Мутация плюс обновление намного дешевле, чем уничтожение и пересоздание графика.

chartjs
const chart = new Chart(ctx, config);

// mutate the data/config, then update:
chart.data.labels.push('Jun');
chart.data.datasets[0].data.push(28);
chart.options.scales.y.max = 50;

chart.update();   // animate to the new state
// chart.update('none');   // skip animation

Режимы обновления

update(mode) принимает строку режима. 'none' отключает анимацию для тихого обновления. 'reset' откатывает к значениям до анимации и проигрывает её заново (удобно повторить вход). 'active' обновляет только элементы под наведением — дешёвая перерисовка hover. По умолчанию (без аргумента) анимируется как обычно.

chartjs
chart.update();             // default: animates the change
chart.update('none');       // no animation
chart.update('reset');      // reset to pre-animation state, then animate
chart.update('resize');     // re-compute layout (call after container resize)
chart.update('show');       // show currently-hidden dataset animations
chart.update('hide');       // hide dataset animations
chart.update('active');     // update only the active (hovered) elements

Обновление данных и подписей

Можно заменить data/labels целиком или мутировать на месте (push/shift). Для потоковых графиков (например, окно 60 секунд) добавляйте новое значение и сдвигайте старейшее, затем update('none') для плавного обновления без анимации — анимированный update на каждом тике вызывает дёрганое отставание.

chartjs
// replace the entire data array
chart.data.datasets[0].data = [5, 10, 15, 20];
chart.data.labels = ['A','B','C','D'];
chart.update();

// or append streaming data (and trim the oldest):
const arr = chart.data.datasets[0].data;
arr.push(newValue);
if (arr.length > 60) arr.shift();
chart.update('none');   // instant update for live data

chart.destroy()

destroy() разбирает график: удаляет слушателей событий, отменяет анимации, очищает canvas и освобождает память. Всегда вызывайте destroy, когда контейнер графика удаляется (cleanup в React useEffect, смена маршрута). Неуничтоженный график утечёт память и может выбросить ошибку «Canvas is already in use» при переиспользовании canvas.

chartjs
const chart = new Chart(ctx, config);

// when done (route change, component unmount, etc.):
chart.destroy();

// after destroy the canvas is free; a new Chart can reuse it:
const fresh = new Chart(ctx, newConfig);

// destroy also removes event listeners and frees memory

chart.resize() и clear()

chart.resize() пересчитывает размер графика — при responsive:true это происходит автоматически при изменении окна, поэтому ручные вызовы редки. chart.clear() очищает canvas без уничтожения графика (следующий update перерисует). chart.resize(width, height) принудительно задаёт пиксельные размеры, переопределяя адаптивные.

chartjs
const chart = new Chart(ctx, config);

// manually trigger a resize (rarely needed; responsive:true auto-resizes)
chart.resize();

// clear the canvas (chart stays alive, just blank until next render):
chart.clear();
chart.draw();   // re-draw without recomputing layout

// resize the canvas to explicit dimensions:
chart.resize(800, 400);
19

Отзывчивость и devicePixelRatio

Отзывчивый контейнер

Для отзывчивого графика оберните canvas в позиционированный контейнер с явными width/height и задайте responsive:true + maintainAspectRatio:false. Canvas заполнит контейнер и перерисуется при изменении окна. Без maintainAspectRatio:false график держит фиксированное соотношение сторон и игнорирует высоту контейнера.

chartjs
<!-- container controls the size -->
<div style="position: relative; width: 100%; height: 400px;">
  <canvas id="c"></canvas>
</div>

<script>
new Chart(document.getElementById('c'), {
  type: 'line',
  data: { /* ... */ },
  options: { responsive: true, maintainAspectRatio: false }
});
</script>

maintainAspectRatio

maintainAspectRatio:true (по умолчанию) держит canvas при фиксированном соотношении width/height, заданном aspectRatio (по умолчанию 2 = 2:1). maintainAspectRatio:false отдаёт высоту контейнеру. Pie/doughnut по умолчанию aspectRatio:1 (квадрат), потому что круги выглядят неправильно в вытянутом прямоугольнике.

chartjs
// default: chart keeps a 2:1 (width:height) aspect ratio
options: { responsive: true, maintainAspectRatio: true, aspectRatio: 2 }

// let the container control height:
options: { responsive: true, maintainAspectRatio: false }

// square charts:
options: { responsive: true, maintainAspectRatio: true, aspectRatio: 1 }

aspectRatio

aspectRatio = ширина / высота. При maintainAspectRatio:true размеры canvas следуют этому соотношению. Для широких плиток дашборда берите соотношение выше (3-4), для высоких панелей — ниже (1-1.5). Pie/doughnut по умолчанию 1, потому что кругам нужен квадратный canvas, чтобы не выглядеть эллипсами.

chartjs
new Chart(ctx, {
  type: 'bar',
  data: { /* ... */ },
  options: {
    responsive: true,
    maintainAspectRatio: true,
    aspectRatio: 3    // width:height = 3:1 (wide, short chart)
  }
});
// common ratios:
//   2  -> default for bar/line
//   1  -> pie/doughnut (square)
//   3  -> wide dashboards
//   16/9 -> video-like

Метод chart.resize()

Chart.js слушает события resize окна автоматически при responsive:true, но изменения раскладки из CSS-переходов, сворачивания сайдбара или переключения вкладок могут не вызвать resize окна. В таких случаях вызывайте chart.resize() вручную после стабилизации размера контейнера (например, в setTimeout или обработчике transitionend).

chartjs
const chart = new Chart(ctx, { /* responsive: true */ });

// manually trigger a re-layout (e.g. after a sidebar collapses)
window.dispatchEvent(new Event('resize'));
// or:
chart.resize();

// explicit size:
chart.resize(600, 300);

devicePixelRatio (чёткий рендеринг)

devicePixelRatio масштабирует backing store canvas, чтобы линии оставались чёткими на дисплеях высокой плотности/retina (по умолчанию берётся window.devicePixelRatio, обычно 2 или 3). Потолок 2 сохраняет чёткость текста, ограничивая пиксельную нагрузку на телефонах с 3x. Значение 1 даёт размытие на retina, но максимизирует скорость рендера.

chartjs
// let Chart.js use the screen's full pixel density (default):
new Chart(ctx, { options: { devicePixelRatio: window.devicePixelRatio } });

// cap DPR for performance on retina displays (fewer pixels to render):
options: { devicePixelRatio: 2 }

// ignore DPR (renders at 1x — blurry on retina but fastest):
options: { devicePixelRatio: 1 }

Паттерн ResizeObserver

ResizeObserver на контейнере графика ловит изменения размера от CSS flexbox/grid, сворачиваемых сайдбаров и переключения вкладок, которые пропускает resize окна. В teardown отключите наблюдателя и вызовите chart.destroy(), чтобы избежать утечек. Самый надёжный адаптивный паттерн для сложных раскладок.

chartjs
const canvas = document.getElementById('c');
const chart = new Chart(canvas, config);

// observe the CONTAINER, not the canvas:
const ro = new ResizeObserver(() => chart.resize());
ro.observe(canvas.parentElement);

// cleanup on destroy:
function teardown() {
  ro.disconnect();
  chart.destroy();
}

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.