Skip to content

SVG Шпаргалка

Масштабируемая векторная графика для изображений, независимых от разрешения.

01

Базовая структура

Скелет SVG-документа

Атрибут xmlns объявляет пространство имён SVG. width/height задают размер рендеринга в пикселях. viewBox определяет внутреннюю систему координат. SVG может быть отдельным .svg-файлом или встроен в HTML inline, где XML-декларация и xmlns необязательны.

svg
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg"
     width="200" height="200"
     viewBox="0 0 200 200">
  <!-- SVG content goes here -->
  <rect x="0" y="0" width="200" height="200" fill="#eee"/>
</svg>

Встраивание SVG в HTML

Inline SVG — самый гибкий вариант: его можно стилизовать CSS и управлять им через JS, как и HTML. <img> и background-image трактуют SVG как статичное изображение (без внутреннего CSS/JS). <object> загружает его как отдельный документ со своим DOM, допуская часть скриптования.

svg
<!-- 1. Inline (best for styling and scripting) -->
<svg width="100" height="100">
  <circle cx="50" cy="50" r="40" fill="red"/>
</svg>

<!-- 2. As an image (no CSS/JS interaction) -->
<img src="icon.svg" alt="Icon" width="100" height="100">

<!-- 3. As a background (limited styling) -->
<div style="background: url('icon.svg') no-repeat;"></div>

<!-- 4. Via object/embed (allows scripting) -->
<object data="icon.svg" type="image/svg+xml"></object>

Система координат

SVG использует левостороннюю систему координат: начало в левом верхнем углу, X вправо, Y вниз. Атрибут viewBox определяет внутреннее координатное пространство — SVG масштабирует содержимое под width/height элемента, поэтому viewBox 0 0 100 100 в элементе 200px отрисует всё в 2x.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <!-- Origin (0,0) is top-left, like Canvas -->
  <!-- X increases rightward, Y increases downward -->

  <!-- A point at (50, 25) -->
  <circle cx="50" cy="25" r="3" fill="black"/>

  <!-- The viewBox stretches content to fill width/height -->
  <!-- viewBox="minX minY width height" -->
</svg>

<!-- viewBox 0 0 100 100 in a 200x200 element = 2x zoom -->
<svg width="200" height="200" viewBox="0 0 100 100">
  <circle cx="50" cy="50" r="50" fill="blue"/>
</svg>

Ширина, высота и единицы

Пользовательские единицы (без суффикса) эквивалентны px. Проценты считаются от родителя. Для адаптивного SVG опустите width/height и задайте viewBox — SVG масштабируется под контейнер, сохраняя пропорции. 'auto' в height с viewBox сохраняет пропорции.

svg
<svg width="200" height="100">
  <!-- Default unit is the user unit (px equivalent) -->
</svg>

<!-- Common units: px, em, %, pt, cm, mm, in -->
<svg width="50%" height="auto" viewBox="0 0 100 100">
  <!-- % is relative to the parent element -->
</svg>

<!-- No width/height + viewBox = fully responsive -->
<svg viewBox="0 0 100 100" style="width:100%;height:auto;">
  <!-- Scales to container, preserves aspect ratio -->
</svg>

Пространства имён и xlink

SVG 2 ввёл прямую поддержку href в <use>, <image> и <a>, сделав xlink:href устаревшим. Современные браузеры поддерживают обычный href. Оставляйте пространство имён xlink только если нужно поддерживать очень старые браузеры. Inline SVG в HTML строго не требует атрибута xmlns.

svg
<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink">

  <!-- Modern SVG 2: use href directly -->
  <use href="#icon"/>

  <!-- Legacy SVG 1.1: use xlink:href -->
  <use xlink:href="#icon"/>
</svg>

<!-- In HTML5 inline SVG, the xmlns is optional -->
<!-- But xlink namespace is needed if you use xlink:href -->

Комментарии и метаданные

<title> и <desc> дают текст для доступности, который читают скринридеры, — всегда добавляйте их для осмысленных SVG. <metadata> хранит структурированные данные (RDF, Dublin Core) для инструментов. Комментарии используют тот же синтаксис <!-- -->, что и HTML.

svg
<svg width="100" height="100" viewBox="0 0 100 100">
  <!-- This is an XML comment (same as HTML) -->

  <!-- Metadata is hidden from rendering -->
  <metadata>
    <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
      <dc:title xmlns:dc="http://purl.org/dc/elements/1.1/">My Icon</dc:title>
    </rdf:RDF>
  </metadata>

  <!-- title and desc for accessibility -->
  <title>Shopping Cart Icon</title>
  <desc>A red shopping cart with 3 items</desc>

  <circle cx="50" cy="50" r="40" fill="red"/>
</svg>
02

Фигуры

Прямоугольник (rect)

rect требует x, y, width, height. rx/ry создают скруглённые углы (если задан только rx, ry по умолчанию равен rx). fill='none' делает внутреннюю часть прозрачной. stroke-width центрируется на крае, поэтому половина выходит за геометрию.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <!-- Basic rectangle -->
  <rect x="10" y="10" width="80" height="50" fill="steelblue"/>

  <!-- Rounded corners -->
  <rect x="110" y="10" width="80" height="50"
        rx="10" ry="10" fill="tomato"/>

  <!-- Stroked, no fill -->
  <rect x="10" y="70" width="80" height="20"
        fill="none" stroke="black" stroke-width="2"/>
</svg>

Circle и Ellipse

circle задаётся центром (cx, cy) и радиусом r. У ellipse отдельные rx и ry для растяжения. У обоих cx/cy по умолчанию 0, если опущены. В отличие от rect, у кругов и эллипсов не бывает скруглённых углов — они уже кривые.

svg
<svg width="200" height="120" viewBox="0 0 200 120">
  <!-- circle: cx, cy (center), r (radius) -->
  <circle cx="50" cy="60" r="40" fill="gold"/>

  <!-- ellipse: cx, cy, rx (x radius), ry (y radius) -->
  <ellipse cx="150" cy="60" rx="50" ry="30" fill="mediumpurple"/>

  <!-- Circle as an ellipse (rx == ry) -->
  <ellipse cx="100" cy="20" rx="15" ry="15" fill="black"/>
</svg>

Line

line соединяет две точки. У неё нет fill (только stroke). stroke-dasharray создаёт пунктир — шаблон 'длина штриха, длина пробела' повторяется. stroke-linecap (butt, round, square) управляет окончаниями.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <!-- line: x1,y1 (start) to x2,y2 (end) -->
  <line x1="10" y1="10" x2="190" y2="10" stroke="black" stroke-width="2"/>

  <!-- Diagonal line -->
  <line x1="10" y1="90" x2="190" y2="10" stroke="red" stroke-width="3"/>

  <!-- Dashed line -->
  <line x1="10" y1="50" x2="190" y2="50"
        stroke="blue" stroke-width="2" stroke-dasharray="10,5"/>
</svg>

Polyline и Polygon

polyline рисует связанные отрезки, не замыкая фигуру (fill применяется как к замкнутой, но stroke не соединяет концы). polygon замыкается автоматически, соединяя последнюю точку с первой. points — список пар x,y через пробел или запятую.

svg
<svg width="200" height="120" viewBox="0 0 200 120">
  <!-- polyline: open shape (no auto-close) -->
  <polyline points="10,10 50,90 100,10 150,90 190,10"
            fill="none" stroke="green" stroke-width="2"/>

  <!-- polygon: closed shape (auto-connects last to first) -->
  <polygon points="100,10 190,110 10,110"
           fill="lime" stroke="black" stroke-width="1"/>

  <!-- Star (polygon with 10 points) -->
  <polygon points="50,5 61,38 95,38 67,58 78,90 50,70 22,90 33,58 5,38 39,38"
           fill="gold" stroke="orange"/>
</svg>

Общие атрибуты фигур

fill и stroke — два основных свойства заливки. opacity влияет на элемент целиком; fill-opacity и stroke-opacity действуют независимо. stroke-linecap (butt/round/square) задаёт форму концов линий; stroke-linejoin (miter/round/bevel) — форму углов.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <rect x="10" y="10" width="80" height="80"
        fill="#3498db"
        fill-opacity="0.5"
        stroke="#2c3e50"
        stroke-width="3"
        stroke-opacity="0.8"
        stroke-dasharray="5,3"
        stroke-linecap="round"
        stroke-linejoin="round"
        opacity="0.9"/>

  <!-- opacity affects the whole element -->
  <!-- fill-opacity/stroke-opacity affect parts independently -->
</svg>

Правила заливки (evenodd)

fill-rule определяет, как заливаются перекрывающиеся области фигуры. 'nonzero' (по умолчанию) заливает по направлению обхода. 'evenodd' заливает области, окружённые нечётное число раз, — это создаёт классический эффект «дырки от бублика» для самопересекающихся путей и концентрических многоугольников.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <!-- Default fill-rule: nonzero -->
  <polygon points="50,10 90,90 10,90 50,30 80,80 20,80"
           fill="red" fill-rule="nonzero"/>

  <!-- fill-rule: evenodd creates holes in overlapping shapes -->
  <polygon points="150,10 190,90 110,90 150,30 180,80 120,80"
           fill="blue" fill-rule="evenodd"/>
</svg>
03

Path

Обзор команд path

Элемент <path> — самая мощная фигура SVG: его атрибут d хранит строку команд рисования. Команды в верхнем регистре используют абсолютные координаты; в нижнем — координаты относительно текущей позиции пера. M, L, C, Q, A, Z — базовые команды.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <!-- The d attribute contains all path commands -->
  <path d="M 10 10 L 190 10 L 100 90 Z" fill="none" stroke="black"/>

  <!-- Uppercase = absolute, lowercase = relative -->
  <!-- M = moveto (lift pen, move) -->
  <!-- L = lineto (draw straight line) -->
  <!-- H = horizontal lineto, V = vertical lineto -->
  <!-- C = cubic bezier, S = smooth cubic -->
  <!-- Q = quadratic bezier, T = smooth quadratic -->
  <!-- A = arc, Z = closepath -->
</svg>

M, L, H, V, Z (линии)

M перемещает перо без рисования. L рисует до точки. H/V рисуют горизонтальные и вертикальные линии (одна координата). Z замыкает путь к началу. Строчные версии (l, h, v, z) трактуют координаты как смещения от текущей позиции, делая подпути переиспользуемыми.

svg
<svg width="200" height="120" viewBox="0 0 200 120">
  <!-- M = moveto, L = lineto, Z = close path -->
  <path d="M 10 10 L 190 10 L 190 110 L 10 110 Z"
        fill="none" stroke="black"/>

  <!-- H = horizontal line, V = vertical line (one coord each) -->
  <path d="M 10 60 H 190" stroke="red"/>

  <!-- Relative commands (lowercase): coords are offsets -->
  <path d="M 10 80 l 30 -20 l 30 20 l 30 -20 l 30 20"
        fill="none" stroke="blue"/>

  <!-- Multiple M's create subpaths (disconnected segments) -->
  <path d="M 10 100 L 50 100 M 100 100 L 150 100" stroke="green"/>
</svg>

C и S (кубическая кривая Безье)

C рисует кубическую кривую Безье с двумя контрольными точками, которые притягивают кривую. Первая (x1,y1) влияет на касательную в начале; вторая (x2,y2) — на касательную в конце. S продолжает плавно, зеркаля вторую контрольную точку предыдущей кривой, — указывайте только новую вторую контрольную и конечную точку.

svg
<svg width="240" height="120" viewBox="0 0 240 120">
  <!-- C = cubic bezier: two control points + endpoint -->
  <!-- C x1 y1, x2 y2, x y -->
  <path d="M 10 60 C 60 10, 180 110, 230 60"
        fill="none" stroke="red" stroke-width="2"/>

  <!-- S = smooth cubic: control point mirrors the previous -->
  <!-- S x2 y2, x y (first control point is auto-mirrored) -->
  <path d="M 10 100 C 60 50, 100 50, 120 100 S 200 150, 230 100"
        fill="none" stroke="blue" stroke-width="2"/>

  <!-- Multiple cubics in one path -->
  <path d="M 10 20 C 40 0, 70 40, 100 20 C 130 0, 160 40, 190 20"
        fill="none" stroke="green"/>
</svg>

Q и T (квадратичная кривая Безье)

Q использует одну контрольную точку вместо двух — проще, но менее гибко, чем C. T продолжает Q плавно, зеркаля его контрольную точку, и требует только конечную точку. Квадратичные кривые часты в глифах шрифтов и простых иконках, где одной контрольной точки достаточно.

svg
<svg width="200" height="120" viewBox="0 0 200 120">
  <!-- Q = quadratic bezier: one control point + endpoint -->
  <!-- Q x1 y1, x y -->
  <path d="M 10 100 Q 100 0, 190 100"
        fill="none" stroke="purple" stroke-width="2"/>

  <!-- T = smooth quadratic: control point auto-mirrored -->
  <path d="M 10 60 Q 50 20, 90 60 T 170 60"
        fill="none" stroke="orange" stroke-width="2"/>

  <!-- Q is simpler than C but less precise — good for curves -->
  <!-- with a single bend, like basic arcs and waves -->
</svg>

A (дуга)

A рисует эллиптическую дугу. rx, ry — радиусы; x-rotation наклоняет эллипс. large-arc-flag (0/1) выбирает короткую или длинную дугу между точками. sweep-flag (0/1) выбирает против или по часовой стрелке. Дуги коварны — многие дизайнеры используют кривые C ради предсказуемости.

svg
<svg width="200" height="150" viewBox="0 0 200 150">
  <!-- A rx ry, x-rotation, large-arc-flag, sweep-flag, x y -->
  <path d="M 10 75 A 60 60, 0, 0, 1, 130 75"
        fill="none" stroke="red" stroke-width="2"/>

  <!-- large-arc-flag: 0 = small arc, 1 = large arc -->
  <!-- sweep-flag: 0 = counterclockwise, 1 = clockwise -->

  <!-- Large arc (the long way around) -->
  <path d="M 10 75 A 60 60, 0, 1, 1, 130 75"
        fill="none" stroke="blue" stroke-width="2"/>

  <!-- Elliptical arc (rx != ry) -->
  <path d="M 10 120 A 80 30, 0, 0, 0, 170 120"
        fill="none" stroke="green" stroke-width="2"/>
</svg>

Практические примеры path

Реальные иконки комбинируют M, L, C и Z для обводки фигур. Сердце использует кубические Безье для плавных изгибов. Галочка — просто три точки с круглыми концами линий. Облако реплики смешивает линии H/V для прямоугольника и команды L для хвоста. Начинайте просто, затем уточняйте контрольные точки.

svg
<svg width="200" height="120" viewBox="0 0 200 120">
  <!-- Heart shape -->
  <path d="M 100 30
           C 70 0, 20 20, 20 60
           C 20 90, 60 110, 100 120
           C 140 110, 180 90, 180 60
           C 180 20, 130 0, 100 30 Z"
        fill="red"/>

  <!-- Checkmark -->
  <path d="M 20 60 L 50 90 L 100 20"
        fill="none" stroke="green" stroke-width="6"
        stroke-linecap="round" stroke-linejoin="round"/>

  <!-- Speech bubble (combines lines and curves) -->
  <path d="M 20 20 H 180 V 80 H 60 L 40 100 L 45 80 H 20 Z"
        fill="lightblue" stroke="navy"/>
</svg>
04

Текст

Базовый текст

Координата y по умолчанию относится к базовой линии текста, а не к верху. text-anchor (start/middle/end) управляет горизонтальным выравниванием относительно x. dominant-baseline (auto/middle/hanging/...) управляет вертикальным выравниванием. Оба нужны для центрирования текста.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <text x="10" y="50" font-family="Arial" font-size="24"
        fill="black">Hello SVG!</text>

  <!-- x, y sets the baseline position (y is the text baseline) -->
  <!-- Use dominant-baseline to change the vertical anchor -->
  <text x="100" y="50" font-size="20" fill="blue"
        text-anchor="middle" dominant-baseline="middle">Centered</text>
</svg>

Стилизация текста

Текст SVG поддерживает большинство CSS-свойств шрифта как атрибуты. font-family принимает стандартные стеки шрифтов. stroke по тексту рисует контур — используйте небольшую stroke-width, чтобы не заслонить заливку. letter-spacing и word-spacing работают как в CSS.

svg
<svg width="300" height="120" viewBox="0 0 300 120">
  <text x="10" y="30"
        font-family="Georgia, serif"
        font-size="28"
        font-weight="bold"
        font-style="italic"
        fill="darkblue"
        stroke="navy"
        stroke-width="0.5"
        text-decoration="underline"
        letter-spacing="2">Styled Text</text>

  <!-- font-family uses CSS font stacks -->
  <!-- font-weight: normal, bold, 100-900 -->
  <!-- font-style: normal, italic, oblique -->
</svg>

tspan (часть текста)

<tspan> позволяет стилизовать или позиционировать части текста по-разному, как <span> в HTML. dx/dy смещают относительно предыдущего символа; абсолютные x/y прыгают на новую позицию (используйте x с исходным значением и dy для переноса строки). tspan — так строят многострочный текст в SVG.

svg
<svg width="300" height="100" viewBox="0 0 300 100">
  <text x="10" y="50" font-size="20" fill="black">
    <tspan font-weight="bold" fill="red">Bold red</tspan>
    <tspan dx="10" font-style="italic">italic</tspan>
    <tspan x="10" dy="30">New line via dy</tspan>
    <tspan dx="10" font-size="14">smaller</tspan>
  </text>

  <!-- dx/dy: relative offset from previous position -->
  <!-- x/y: absolute position (useful for line breaks) -->
</svg>

Текст по пути

<textPath> отрисовывает текст вдоль любого элемента path. Ссылайтесь на путь по id через href (современно) или xlink:href (устаревший вариант). startOffset (длина или процент) позиционирует текст вдоль пути. Это стандартная техника для изогнутых подписей на дугах, окружностях и произвольных фигурах.

svg
<svg width="300" height="150" viewBox="0 0 300 150">
  <!-- Define a path (can be invisible) -->
  <defs>
    <path id="curve" d="M 20 100 Q 150 0, 280 100" fill="none"/>
  </defs>

  <!-- Text follows the path via xlink:href / href -->
  <text font-size="20" fill="purple">
    <textPath href="#curve">Text along a curved path!</textPath>
  </text>

  <!-- startOffset shifts where the text begins on the path -->
  <text font-size="14" fill="gray">
    <textPath href="#curve" startOffset="50%" text-anchor="middle">
      Centered on path
    </textPath>
  </text>
</svg>

Writing mode и направление

writing-mode='tb' заставляет текст течь сверху вниз (часто в восточноазиатской типографике). direction='rtl' меняет порядок символов для письма справа налево. Для произвольного поворота используйте атрибут transform — rotate(angle, cx, cy) вращает вокруг точки (cx, cy).

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <!-- Vertical text (top-to-bottom) -->
  <text x="50" y="20" writing-mode="tb" font-size="20">Vertical</text>

  <!-- Right-to-left text -->
  <text x="190" y="100" direction="rtl" font-size="20"
        text-anchor="end">RTL text</text>

  <!-- Rotated text (via transform) -->
  <text x="100" y="100" font-size="20"
        transform="rotate(45, 100, 100)">Rotated 45°</text>
</svg>

Доступность текста

Текст SVG по умолчанию выделяется и доступен, но декоративный SVG должен иметь <title> и <desc>. Для inline SVG, используемого как элемент интерфейса, добавляйте role='img' и aria-label, чтобы скринридеры сообщали смысл. Не помещайте важную информацию только в текст SVG — HTML-текст доступнее.

svg
<svg width="200" height="80" viewBox="0 0 200 80">
  <title>Error Icon</title>
  <desc>A red circle with a white exclamation mark</desc>

  <!-- role and aria-label for screen readers -->
  <text role="img" aria-label="Error: 3 items need attention"
        x="100" y="45" text-anchor="middle"
        font-size="24" fill="red">! Error</text>
</svg>
05

Градиенты

Линейный градиент

linearGradient меняет цвета вдоль линии. x1/y1 до x2/y2 задают направление (0% 0% до 100% 0% — слева направо). Элементы <stop> задают цветовые точки; offset — 0–100% или 0–1. Ссылайтесь на градиент через fill='url(#id)'. Градиенты должны находиться в <defs>.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <defs>
    <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="0%">
      <stop offset="0%" stop-color="red"/>
      <stop offset="50%" stop-color="yellow"/>
      <stop offset="100%" stop-color="green"/>
    </linearGradient>
  </defs>

  <rect x="10" y="10" width="180" height="80" fill="url(#grad1)"/>
</svg>

Радиальный градиент

radialGradient расходится из центральной точки. cx/cy — центр, r — радиус. fx/fy — фокус (где начинается цвет 0%), его смещение создаёт эффект направленного света. По умолчанию: cx/cy на 50%, r на 50%, fx/fy совпадают с cx/cy.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <defs>
    <radialGradient id="grad2" cx="50%" cy="50%" r="50%" fx="50%" fy="50%">
      <stop offset="0%" stop-color="white"/>
      <stop offset="50%" stop-color="orange"/>
      <stop offset="100%" stop-color="darkred"/>
    </radialGradient>
  </defs>

  <circle cx="100" cy="100" r="90" fill="url(#grad2)"/>
</svg>

Единицы градиента и распространение

gradientUnits='objectBoundingBox' (по умолчанию) делает координаты относительными каждого элемента (0–1), поэтому один градиент подходит любому элементу. 'userSpaceOnUse' использует абсолютные координаты SVG, поэтому градиент позиционируется в документе — удобно для выравнивания градиентов между несколькими фигурами.

svg
<svg width="300" height="100" viewBox="0 0 300 100">
  <defs>
    <!-- objectBoundingBox (default): coords are 0-1 relative to the shape -->
    <linearGradient id="g1" x1="0" y1="0" x2="1" y2="0">
      <stop offset="0" stop-color="blue"/>
      <stop offset="1" stop-color="cyan"/>
    </linearGradient>

    <!-- userSpaceOnUse: coords are in the SVG's user units -->
    <linearGradient id="g2" x1="0" y1="0" x2="200" y2="0"
                    gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="red"/>
      <stop offset="1" stop-color="yellow"/>
    </linearGradient>

    <!-- spreadMethod: pad (default), reflect, repeat -->
    <linearGradient id="g3" x1="0" y1="0" x2="0.3" y2="0"
                    spreadMethod="repeat">
      <stop offset="0" stop-color="green"/>
      <stop offset="1" stop-color="lime"/>
    </linearGradient>
  </defs>
  <rect width="100" height="100" x="0" fill="url(#g1)"/>
  <rect width="100" height="100" x="100" fill="url(#g2)"/>
  <rect width="100" height="100" x="200" fill="url(#g3)"/>
</svg>

Прозрачность стопов и несколько стопов

У каждого стопа может быть stop-opacity (0–1) для переходов прозрачности. Комбинируйте много стопов для сложных цветовых растяжек. Этот градиент заката идёт от прозрачного синего сверху к непрозрачному тёмно-красному снизу — частая техника для атмосферных фонов.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <defs>
    <linearGradient id="sunset" x1="0" y1="0" x2="0" y2="1">
      <stop offset="0%" stop-color="deepskyblue" stop-opacity="0"/>
      <stop offset="40%" stop-color="orange" stop-opacity="0.8"/>
      <stop offset="70%" stop-color="orangered"/>
      <stop offset="100%" stop-color="darkred"/>
    </linearGradient>
  </defs>
  <rect width="200" height="200" fill="url(#sunset)"/>
</svg>

Переиспользование градиентов

Определите градиент один раз в <defs> и ссылайтесь на него на любом числе фигур через fill='url(#id)'. Используйте href, чтобы вывести новый градиент из существующего, переопределяя только часть атрибутов (например, направление). Это делает SVG DRY и уменьшает размер файла.

svg
<svg width="300" height="100" viewBox="0 0 300 100">
  <defs>
    <!-- A reusable gradient -->
    <linearGradient id="metal" x1="0" y1="0" x2="0" y2="1">
      <stop offset="0%" stop-color="#eee"/>
      <stop offset="50%" stop-color="#999"/>
      <stop offset="100%" stop-color="#333"/>
    </linearGradient>

    <!-- Gradient referencing another via href -->
    <linearGradient id="metal-horizontal" href="#metal"
                    x1="0" y1="0" x2="1" y2="0"/>
  </defs>

  <!-- Same gradient on multiple shapes -->
  <rect x="10" y="10" width="80" height="80" fill="url(#metal)"/>
  <circle cx="150" cy="50" r="40" fill="url(#metal)"/>
  <rect x="210" y="10" width="80" height="80" fill="url(#metal-horizontal)"/>
</svg>
06

Паттерны

Базовый паттерн

<pattern> заполняет фигуру повторяющимся рисунком. Дочерние элементы паттерна определяют одну плитку; width/height задают размер плитки. patternUnits='userSpaceOnUse' (рекомендуется) означает, что размеры плитки в пользовательских единицах SVG, независимо от заливаемой фигуры. Ссылка — fill='url(#id)'.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <defs>
    <pattern id="dots" x="0" y="0" width="20" height="20"
             patternUnits="userSpaceOnUse">
      <circle cx="10" cy="10" r="3" fill="steelblue"/>
    </pattern>
  </defs>

  <rect width="200" height="200" fill="url(#dots)"/>
</svg>

Единицы паттерна

patternUnits='objectBoundingBox' (по умолчанию) задаёт плитки как долю фигуры — паттерн масштабируется с каждой фигурой. 'userSpaceOnUse' использует абсолютные единицы, поэтому паттерн одинаков на разных фигурах независимо от размера. Большинство реальных паттернов использует userSpaceOnUse.

svg
<svg width="300" height="100" viewBox="0 0 300 100">
  <defs>
    <!-- objectBoundingBox (default): tile size is relative to shape -->
    <!-- 0.1 = 10% of the shape's width/height -->
    <pattern id="p1" width="0.1" height="0.1">
      <rect width="10" height="10" fill="red" opacity="0.5"/>
    </pattern>

    <!-- userSpaceOnUse: tile size is in SVG units -->
    <pattern id="p2" width="20" height="20"
             patternUnits="userSpaceOnUse">
      <rect width="10" height="10" fill="blue" opacity="0.5"/>
    </pattern>
  </defs>

  <rect width="150" height="100" fill="url(#p1)"/>
  <rect x="150" width="150" height="100" fill="url(#p2)"/>
</svg>

Полосы и шахматный узор

patternTransform вращает, масштабирует или скашивает весь паттерн. Для полос залейте половину плитки одним цветом, другую половину другим, затем поверните. Шахматный узор использует четыре rect (или две пары L-образных фигур) на плитку. Такие паттерны часты в схемах и текстурах.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <defs>
    <!-- Diagonal stripes -->
    <pattern id="stripes" width="20" height="20"
             patternUnits="userSpaceOnUse"
             patternTransform="rotate(45)">
      <rect width="20" height="10" fill="gold"/>
      <rect y="10" width="20" height="10" fill="black"/>
    </pattern>

    <!-- Checkerboard -->
    <pattern id="checker" width="40" height="40"
             patternUnits="userSpaceOnUse">
      <rect width="40" height="40" fill="white"/>
      <rect width="20" height="20" fill="black"/>
      <rect x="20" y="20" width="20" height="20" fill="black"/>
    </pattern>
  </defs>

  <rect width="100" height="200" fill="url(#stripes)"/>
  <rect x="100" width="100" height="200" fill="url(#checker)"/>
</svg>

Единицы содержимого паттерна

patternContentUnits управляет системой координат для дочерних элементов паттерна (не размером плитки). 'objectBoundingBox' делает координаты детей долями фигуры — полезно, когда детали паттерна должны масштабироваться пропорционально каждой фигуре. Редко, но мощно.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <defs>
    <!-- patternContentUnits: how the pattern's children are measured -->
    <!-- userSpaceOnUse (default): children use SVG units -->
    <!-- objectBoundingBox: children are relative to the shape -->
    <pattern id="pb" width="0.25" height="0.25"
             patternContentUnits="objectBoundingBox">
      <circle cx="0.125" cy="0.125" r="0.05" fill="green"/>
    </pattern>
  </defs>

  <!-- The dots scale with each shape's bounding box -->
  <rect width="100" height="100" fill="url(#pb)"/>
  <rect x="100" width="100" height="200" fill="url(#pb)"/>
</svg>

Вложенные паттерны

Паттерны могут содержать градиенты, другие паттерны и любое содержимое SVG. Этот сеточный паттерн заливает каждую ячейку лёгким градиентом и рисует линии сетки сверху. Вложенность позволяет строить сложные текстуры. Держите размеры плиток разумными, чтобы избежать проблем производительности на очень мелких плитках.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <defs>
    <!-- A pattern can reference another pattern or gradient -->
    <pattern id="grid" width="40" height="40"
             patternUnits="userSpaceOnUse">
      <rect width="40" height="40" fill="url(#cellGrad)"/>
      <path d="M 40 0 L 0 0 0 40" fill="none" stroke="#ccc"/>
    </pattern>

    <linearGradient id="cellGrad">
      <stop offset="0" stop-color="#f0f8ff"/>
      <stop offset="1" stop-color="#e0e0ff"/>
    </linearGradient>
  </defs>

  <rect width="200" height="200" fill="url(#grid)"/>
</svg>
07

Transform

Translate

translate(tx, ty) сдвигает элемент на tx, ty. Если ty опущен, он равен 0. Трансформация применяется к системе координат элемента, поэтому атрибуты x/y относительны сдвинутого начала. CSS-трансформации (через style) работают на inline SVG в современных браузерах и могут анимироваться CSS-переходами.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <!-- Original -->
  <rect x="10" y="10" width="40" height="40" fill="red"/>

  <!-- Translated 80px right -->
  <rect x="10" y="10" width="40" height="40" fill="blue"
        transform="translate(80, 0)"/>

  <!-- translate with one arg moves only horizontally -->
  <rect x="10" y="10" width="40" height="40" fill="green"
        transform="translate(0, 50)"/>

  <!-- Equivalent in CSS (for inline SVG in HTML) -->
  <rect x="10" y="10" width="40" height="40" fill="orange"
        style="transform: translate(150px, 0);"/>
</svg>

Rotate

rotate(angle, cx, cy) вращает на angle градусов вокруг точки (cx, cy). Без cx/cy вращение идёт вокруг начала (0,0), что часто не то, что нужно. Углы по часовой стрелке (положительные) или против (отрицательные). Всегда указывайте центр, чтобы вращать элемент на месте.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <rect x="50" y="50" width="100" height="20" fill="red"/>

  <!-- rotate(angle) around origin (0,0) -->
  <rect x="50" y="50" width="100" height="20" fill="blue"
        transform="rotate(45)"/>

  <!-- rotate(angle, cx, cy) around point (cx, cy) -->
  <rect x="50" y="50" width="100" height="20" fill="green"
        transform="rotate(45, 100, 60)"/>

  <!-- Negative angles rotate counterclockwise -->
  <rect x="50" y="50" width="100" height="20" fill="orange"
        transform="rotate(-30, 100, 60)"/>
</svg>

Scale и Skew

scale(sx, sy) умножает размеры; один аргумент масштабирует одинаково по обеим осям. Масштабирование также влияет на stroke-width и позиции. skewX/skewY скашивают элемент вдоль оси на угол. Все трансформации относительны начала (0,0), поэтому масштабирование фигуры при x=100 ещё и сдвигает её.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <!-- Original square -->
  <rect x="10" y="10" width="50" height="50" fill="red"/>

  <!-- scale(2): 2x in both dimensions -->
  <rect x="10" y="10" width="50" height="50" fill="blue"
        transform="scale(2)"/>

  <!-- scale(sx, sy): different x and y scaling -->
  <rect x="10" y="10" width="50" height="50" fill="green"
        transform="scale(1, 2)"/>

  <!-- skewX / skewY: shear the shape -->
  <rect x="10" y="10" width="50" height="50" fill="orange"
        transform="skewX(30)"/>
</svg>

Матричная трансформация

matrix(a,b,c,d,e,f) — базовая форма всех трансформаций. a,d масштабируют; b,c скашивают; e,f сдвигают. Большинство разработчиков используют именованные трансформации (translate, rotate и т. д.) ради читаемости, но matrix — то, что выдают инструменты, и удобно для комбинирования или разбора.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <!-- transform="matrix(a, b, c, d, e, f)" -->
  <!-- Represents: [a c e] [b d f] [0 0 1] -->
  <!-- New x = a*x + c*y + e -->
  <!-- New y = b*x + d*y + f -->

  <!-- Identity (no change) -->
  <rect width="50" height="50" fill="red" transform="matrix(1,0,0,1,0,0)"/>

  <!-- Translate (100, 50) -->
  <rect width="50" height="50" fill="blue" transform="matrix(1,0,0,1,100,50)"/>

  <!-- Scale 2x and translate -->
  <rect width="50" height="50" fill="green" transform="matrix(2,0,0,2,50,0)"/>
</svg>

Комбинирование трансформаций

Несколько трансформаций в атрибуте применяются справа налево (самая правая выполняется первой). Значит 'translate(100,100) rotate(45)' сначала вращает фигуру вокруг её начала, затем сдвигает — обычно это и нужно. CSS-трансформации с transform-origin часто интуитивнее для inline SVG.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <!-- Multiple transforms apply right-to-left -->
  <rect x="0" y="0" width="40" height="40" fill="red"
        transform="translate(100, 100) rotate(45) scale(2)"/>

  <!-- This means: scale, then rotate, then translate -->
  <!-- Order matters! rotate then translate != translate then rotate -->

  <!-- transform-origin via CSS (for inline SVG) -->
  <rect x="80" y="80" width="40" height="40" fill="blue"
        style="transform: rotate(45deg); transform-origin: center;"/>

  <!-- transform-origin: center, 50% 50%, or explicit coords -->
</svg>

transform-origin (CSS)

При анимации SVG через CSS явно задавайте transform-origin (в пользовательских единицах SVG) и transform-box (fill-box для рамки элемента, view-box для полотна SVG). Без этого вращение центрируется на начале SVG, а не на элементе. CSS-анимации и переходы работают на inline SVG.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <style>
    .gear {
      transform-origin: 100px 100px;  /* SVG user units */
      transform-box: fill-box;        /* or view-box */
      animation: spin 4s linear infinite;
    }
    @keyframes spin {
      to { transform: rotate(360deg); }
    }
  </style>

  <circle class="gear" cx="100" cy="100" r="50" fill="orange"/>
  <circle cx="100" cy="100" r="10" fill="black"/>
</svg>
08

Группа (g)

Базовая группировка

<g> группирует элементы, чтобы они делили атрибуты (fill, stroke, transform и т. д.) и управлялись как единое целое. Дети наследуют презентационные атрибуты группы. Группы необходимы для организации сложных SVG и применения трансформаций сразу к нескольким фигурам.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <g fill="steelblue" stroke="navy" stroke-width="2">
    <!-- Children inherit the group's attributes -->
    <circle cx="60" cy="60" r="30"/>
    <rect x="100" y="30" width="60" height="60" rx="5"/>
    <path d="M 30 150 L 100 110 L 170 150 Z"/>
  </g>

  <!-- Without g, you'd repeat fill/stroke on each element -->
</svg>

Трансформации группы

transform на <g> создаёт новую систему координат для детей. Это ключ к переиспользуемым компонентам: проектируйте вокруг (0,0), затем позиционируйте всю группу через translate. Координаты детей относительны преобразованного начала группы.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <!-- A transform on a group applies to all children -->
  <g transform="translate(100, 100) rotate(45)">
    <rect x="-30" y="-30" width="60" height="60" fill="red"/>
    <circle cx="0" cy="0" r="15" fill="white"/>
  </g>

  <!-- The group defines its own coordinate system -->
  <!-- Children use coords relative to the group's origin -->
  <g transform="translate(50, 150)">
    <text x="0" y="0">Origin here</text>
    <circle cx="0" cy="-20" r="5"/>
  </g>
</svg>

Вложенные группы

Группы могут вкладываться сколь угодно глубоко. Каждая вложенная трансформация складывается — на внутренний элемент влияют все трансформации предков по порядку. Так строят иерархические сцены (например, персонаж с вращающимися конечностями, каждая с движущимися кистями). Держите вложенность разумной ради производительности.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <g transform="translate(100, 100)">  <!-- outer group -->
    <g transform="scale(0.5)">          <!-- inner group -->
      <circle r="80" fill="blue"/>
      <g transform="translate(40, 0)">  <!-- innermost -->
        <circle r="20" fill="white"/>
      </g>
    </g>
  </g>

  <!-- Transforms compound: the innermost circle is -->
  <!-- translated, scaled, and translated again -->
</svg>

id групп и ссылки

Дайте группе id и ссылайтесь через <use href='#id'>, чтобы дублировать её. Это основа SVG-спрайтов и переиспользуемых компонентов. Группа может жить в <defs> (не отрисовываясь напрямую) и инстанцироваться много раз с разными трансформациями. Переопределение атрибутов на <use> ограничено.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <defs>
    <g id="star">
      <polygon points="50,5 61,38 95,38 67,58 78,90 50,70 22,90 33,58 5,38 39,38"
               fill="gold" stroke="orange"/>
    </g>
  </defs>

  <!-- Reference the group with <use> -->
  <use href="#star" transform="translate(0, 0) scale(0.5)"/>
  <use href="#star" transform="translate(100, 0) scale(0.5)"/>
  <use href="#star" transform="translate(0, 50) scale(0.3)"/>
</svg>

Условные группы

Группы с id — идеальные точки для CSS (состояния hover, active) и обработки событий JavaScript. Рассматривайте <g> как компонент: соберите его фигуры, дайте id и работайте с ним как с единицей. Обработчики на группе ловят события всех её детей.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <!-- <g> can have ids for CSS targeting and JS selection -->
  <g id="button" class="interactive" data-action="save">
    <rect width="80" height="30" rx="5" fill="steelblue"/>
    <text x="40" y="20" text-anchor="middle" fill="white">Save</text>
  </g>

  <style>
    #button:hover rect { fill: royalblue; }
    #button { cursor: pointer; }
  </style>

  <script>
    document.getElementById("button").addEventListener("click", save);
  </script>
</svg>

Группа и symbol

<symbol> создан специально для переиспользуемых иконок: он никогда не отрисовывается напрямую и имеет свой viewBox, поэтому <use> может задавать ему размер независимо. <g> в <defs> тоже работает, но лишён возможности viewBox. Для иконочных систем предпочитайте <symbol> — он сам управляет масштабом и пропорциями.

svg
<svg width="0" height="0" viewBox="0 0 0 0">
  <!-- <g> in <defs>: original is hidden, use can instantiate -->
  <defs>
    <g id="icon-g">
      <rect width="20" height="20" fill="red"/>
    </g>
  </defs>

  <!-- <symbol> is like <g> but supports viewBox and is never rendered -->
  <symbol id="icon-s" viewBox="0 0 20 20">
    <rect width="20" height="20" fill="blue"/>
  </symbol>

  <!-- Use with explicit size (symbol scales to fit) -->
  <use href="#icon-g" x="0" y="0"/>
  <use href="#icon-s" x="40" y="0" width="40" height="40"/>
</svg>
09

Use / Symbol / Defs

Элемент defs

<defs> хранит переиспользуемые определения, которые не рисуются до ссылки на них: градиенты, паттерны, фильтры, clip path, маски, символы и группы. Хранение в defs оставляет отрисованный вывод чистым и отражает намерение. Всё вне defs рендерится сразу.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <defs>
    <!-- Anything in defs is defined but NOT rendered -->
    <linearGradient id="myGrad">
      <stop offset="0" stop-color="red"/>
      <stop offset="1" stop-color="blue"/>
    </linearGradient>

    <pattern id="myPattern" width="20" height="20">
      <circle cx="10" cy="10" r="5" fill="url(#myGrad)"/>
    </pattern>

    <g id="myShape">
      <rect width="40" height="40" rx="5"/>
    </g>
  </defs>

  <!-- Reference and render them -->
  <rect width="100" height="100" fill="url(#myPattern)"/>
  <use href="#myShape" x="120" y="30" fill="green"/>
</svg>

Элемент use

<use> клонирует и рендерит определённый элемент (g, symbol или любую фигуру). x/y позиционируют экземпляр. fill/stroke на <use> переопределяют исходник, только если тот не задавал их (наследование CSS). transform применяется к экземпляру. Так работают SVG-спрайты.

svg
<svg width="300" height="100" viewBox="0 0 300 100">
  <defs>
    <g id="cloud">
      <circle cx="30" cy="50" r="20" fill="white"/>
      <circle cx="50" cy="45" r="25" fill="white"/>
      <circle cx="75" cy="50" r="20" fill="white"/>
    </g>
  </defs>

  <!-- Basic use -->
  <use href="#cloud"/>

  <!-- Positioned and styled -->
  <use href="#cloud" x="120" y="0" fill="lightgray"/>
  <use href="#cloud" x="200" y="10" transform="scale(0.5)" fill="silver"/>
</svg>

Элемент symbol

<symbol> определяет переиспользуемую графику со своим viewBox. В отличие от <g>, он никогда не рендерится напрямую и масштабируется под размеры элемента <use>. fill='currentColor' позволяет потребителю задать цвет через CSS color. Это стандартный паттерн для иконочных систем SVG.

svg
<!-- In a hidden sprite file or <defs> -->
<svg width="0" height="0" style="position:absolute">
  <symbol id="heart" viewBox="0 0 32 32">
    <path d="M16 28 C 4 18, 4 8, 12 8 C 14 8, 16 10, 16 12
             C 16 10, 18 8, 20 8 C 28 8, 28 18, 16 28 Z"
          fill="currentColor"/>
  </symbol>

  <symbol id="star" viewBox="0 0 32 32">
    <polygon points="16,2 20,12 31,12 22,19 25,30 16,23 7,30 10,19 1,12 12,12"
             fill="currentColor"/>
  </symbol>
</svg>

<!-- Usage: size with width/height, color with CSS -->
<svg width="24" height="24"><use href="#heart"/></svg>
<svg width="48" height="48"><use href="#star" style="color: gold"/></svg>

Внешние ссылки SVG

<use> может ссылаться на символы во внешних SVG-файлах через href='file.svg#id'. Однако поддержка браузерами неоднородна (IE нет, ограничения CORS), и это ломается с file://. Надёжный подход — встроить скрытый SVG-спрайт в начало HTML и ссылаться на символы в том же документе.

svg
<!-- Reference a symbol in an external .svg file -->
<svg width="24" height="24">
  <use href="icons.svg#heart"/>
</svg>

<!-- The external file (icons.svg) would contain: -->
<!-- <svg xmlns="http://www.w3.org/2000/svg" style="display:none"> -->
<!--   <symbol id="heart" viewBox="0 0 32 32">...</symbol> -->
<!-- </svg> -->

<!-- Note: external references have limited browser support -->
<!-- and don't work with file:// protocol. Inline is more reliable. -->
<!-- For production, inline the sprite at the top of your HTML body. -->

Переопределение атрибутов use

Когда исходная фигура опускает презентационный атрибут (вроде fill), <use> может его задать — экземпляр наследует значение. Если исходник задаёт fill, fill у use игнорируется (презентационные атрибуты сильнее наследования CSS). Чтобы символы были настраиваемыми, опускайте атрибуты, которые хотите переопределять.

svg
<svg width="300" height="100" viewBox="0 0 300 100">
  <defs>
    <!-- Shape without explicit fill — inherits from use -->
    <circle id="ball" cx="20" cy="20" r="15"/>
  </defs>

  <!-- Each use can set its own fill -->
  <use href="#ball" fill="red"/>
  <use href="#ball" x="50" fill="green"/>
  <use href="#ball" x="100" fill="blue" stroke="black" stroke-width="2"/>
</svg>

Вложенность symbol и спрайт

Это продакшен-паттерн для иконок SVG: один скрытый спрайт-SVG в начале документа со всеми иконками как <symbol>, затем <use> для рендеринга где угодно. currentColor заставляет иконки наследовать цвет текста. CSS управляет размером. Спрайт кэшируется после первой загрузки и быстр на каждой странице.

svg
<!-- A complete inline SVG sprite system -->
<svg style="display:none" aria-hidden="true">
  <symbol id="icon-home" viewBox="0 0 24 24">
    <path d="M12 3 L2 12 H5 V21 H10 V14 H14 V21 H19 V12 H22 Z"/>
  </symbol>
  <symbol id="icon-search" viewBox="0 0 24 24">
    <circle cx="11" cy="11" r="7" fill="none" stroke="currentColor" stroke-width="2"/>
    <line x1="16" y1="16" x2="21" y2="21" stroke="currentColor" stroke-width="2"/>
  </symbol>
</svg>

<!-- Reference anywhere in HTML -->
<svg class="icon"><use href="#icon-home"/></svg>
<svg class="icon"><use href="#icon-search"/></svg>

<style>
  .icon { width: 24px; height: 24px; fill: currentColor; }
</style>
10

Фильтры

Основы фильтров

<filter> содержит один или несколько фильтрующих примитивов (элементы fe*), обрабатывающих графику. in='SourceGraphic' берёт собственный рендеринг элемента. Применяется через filter='url(#id)'. Фильтры могут быть дорогими — используйте умеренно на небольших элементах, а не на больших фонах.

svg
<svg width="200" height="120" viewBox="0 0 200 120">
  <defs>
    <filter id="blur1">
      <!-- feGaussianBlur: stdDeviation is the blur radius -->
      <feGaussianBlur in="SourceGraphic" stdDeviation="3"/>
    </filter>
  </defs>

  <!-- Without filter -->
  <text x="10" y="30" font-size="24" fill="red">Sharp</text>

  <!-- With filter -->
  <text x="10" y="70" font-size="24" fill="red"
        filter="url(#blur1)">Blurred</text>
</svg>

Тень (drop shadow)

Тень комбинирует feOffset (сдвиг), feGaussianBlur (размытие), feFlood (цвет), feComposite (нанести цвет на тень) и feMerge (положить тень под оригинал). x/y/width/height фильтра (по умолчанию от -10% до 110%) нужно увеличить, иначе тень обрежется.

svg
<svg width="200" height="120" viewBox="0 0 200 120">
  <defs>
    <filter id="shadow" x="-20%" y="-20%" width="140%" height="140%">
      <!-- Offset the source -->
      <feOffset in="SourceAlpha" dx="4" dy="4" result="offset"/>
      <!-- Blur the offset copy -->
      <feGaussianBlur in="offset" stdDeviation="3" result="blur"/>
      <!-- Color the shadow -->
      <feFlood flood-color="black" flood-opacity="0.5" result="color"/>
      <feComposite in="color" in2="blur" operator="in" result="shadow"/>
      <!-- Put shadow under the original -->
      <feMerge>
        <feMergeNode in="shadow"/>
        <feMergeNode in="SourceGraphic"/>
      </feMerge>
    </filter>
  </defs>

  <rect x="20" y="20" width="80" height="60" fill="white"
        filter="url(#shadow)"/>
</svg>

Простая тень (CSS)

Для простых теней на inline SVG CSS filter: drop-shadow() намного проще, чем строить SVG-фильтр. Он учитывает фактический контур фигуры (а не только рамку, как box-shadow). Используйте SVG-фильтры только для сложных многошаговых эффектов, которые CSS не выразить.

svg
<!-- Modern browsers: use CSS filter instead of SVG filter -->
<svg width="200" height="100" viewBox="0 0 200 100">
  <rect x="50" y="20" width="100" height="60" fill="white"
        style="filter: drop-shadow(4px 4px 4px rgba(0,0,0,0.5));"/>
</svg>

<!-- In CSS -->
<style>
  .shadowed { filter: drop-shadow(0 0 10px rgba(0,0,0,0.3)); }
</style>

<!-- CSS drop-shadow follows the shape's alpha, unlike box-shadow -->
<!-- which only shadows the bounding box -->

Цветовая матрица

feColorMatrix преобразует цвета через матрицу 5x4 (RGBA на входе, RGBA на выходе). type='saturate' со значениями 0–1 обесцвечивает; type='hueRotate' сдвигает оттенок в градусах; type='luminanceToAlpha' превращает яркость в альфу. Полезно для оттенков серого, сепии и цветокоррекции содержимого SVG.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <defs>
    <!-- Convert to grayscale -->
    <filter id="grayscale">
      <feColorMatrix type="matrix"
        values="0.33 0.33 0.33 0 0
                0.33 0.33 0.33 0 0
                0.33 0.33 0.33 0 0
                0    0    0    1 0"/>
    </filter>

    <!-- Built-in saturation -->
    <filter id="desaturate">
      <feColorMatrix type="saturate" values="0"/>
    </filter>
  </defs>

  <image href="photo.jpg" width="100" height="100" filter="url(#grayscale)"/>
  <image href="photo.jpg" x="100" width="100" height="100" filter="url(#desaturate)"/>
</svg>

Световые эффекты

feSpecularLighting и feDiffuseLighting имитируют 3D-освещение по карте высот 2D-фигуры (выводится из альфы). surfaceScale управляет глубиной; элемент света (fePointLight, feDistantLight, feSpotLight) задаёт направление. В сочетании с feComposite получаются эффекты тиснения, скоса и 3D-текста.

svg
<svg width="200" height="120" viewBox="0 0 200 120">
  <defs>
    <filter id="emboss">
      <!-- Create a height map from the alpha -->
      <feGaussianBlur in="SourceAlpha" stdDeviation="2" result="blur"/>
      <!-- Lighting from upper-left -->
      <feSpecularLighting in="blur" surfaceScale="5"
                          specularConstant="0.8" specularExponent="20"
                          lighting-color="white" result="spec">
        <fePointLight x="-50" y="-50" z="200"/>
      </feSpecularLighting>
      <feComposite in="spec" in2="SourceGraphic"
                   operator="in" result="lit"/>
      <feComposite in="SourceGraphic" in2="lit" operator="arithmetic"
                   k1="0" k2="1" k3="1" k4="0"/>
    </filter>
  </defs>

  <text x="10" y="70" font-size="48" font-weight="bold"
        fill="gray" filter="url(#emboss)">3D</text>
</svg>

Turbulence (текстура)

feTurbulence генерирует процедурный шум (тип fractal или turbulence) — полезен для текстур вроде помех, облаков, воды или зернистости бумаги. baseFrequency управляет масштабом (0.5 — мелко, 0.05 — облачно). numOctaves добавляет детали за счёт скорости. Комбинируйте с feColorMatrix или feDisplacementMap для эффектов.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <defs>
    <!-- feTurbulence generates Perlin noise -->
    <filter id="noise" x="0" y="0" width="100%" height="100%">
      <feTurbulence type="fractalNoise" baseFrequency="0.65"
                    numOctaves="3" stitchTiles="stitch"/>
      <feColorMatrix type="matrix"
        values="0 0 0 0 0  0 0 0 0 0  0 0 0 0 0  0 0 0 0.1 0"/>
    </filter>
  </defs>

  <rect width="200" height="200" fill="steelblue"/>
  <rect width="200" height="200" filter="url(#noise)"/>

  <!-- type: "fractalNoise" or "turbulence" -->
  <!-- baseFrequency: lower = larger blobs, higher = finer grain -->
  <!-- numOctaves: more = more detail (slower) -->
</svg>
11

Обрезка и маскирование

Clip path

clipPath задаёт границу с жёсткими краями — пиксели внутри видны, снаружи скрыты. Сама фигура обрезки не рисуется. clip-path ссылается на неё через url(#id). Обрезка бинарна (внутри или снаружи); для мягких переходов используйте маски. Текст как clip path создаёт классический эффект «изображение внутри текста».

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <defs>
    <!-- A clip path: only the inside is visible -->
    <clipPath id="circleClip">
      <circle cx="100" cy="100" r="80"/>
    </clipPath>
  </defs>

  <!-- The image is clipped to the circle -->
  <rect width="200" height="200" fill="steelblue"
        clip-path="url(#circleClip)"/>

  <!-- Any shape can be a clip path -->
  <clipPath id="textClip">
    <text x="100" y="120" font-size="80" text-anchor="middle"
          font-weight="bold">SVG</text>
  </clipPath>
  <rect width="200" height="200" fill="gold" clip-path="url(#textClip)"/>
</svg>

Маска

В отличие от clip-path (бинарного), маски поддерживают альфу: белые области полностью видны, чёрные скрыты, серые частично прозрачны. Используйте градиент как содержимое маски для плавных затемнений. Маски тяжелее clip path, но необходимы для мягких переходов и эффектов с фото.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <defs>
    <!-- A mask: white = visible, black = hidden, gray = partial -->
    <mask id="fadeMask">
      <linearGradient id="fadeGrad" x1="0" y1="0" x2="0" y2="1">
        <stop offset="0" stop-color="white"/>
        <stop offset="1" stop-color="black"/>
      </linearGradient>
      <rect width="200" height="200" fill="url(#fadeGrad)"/>
    </mask>
  </defs>

  <!-- The image fades from top to bottom -->
  <rect width="200" height="200" fill="red" mask="url(#fadeMask)"/>
</svg>

Единицы clip path

clipPathUnits='objectBoundingBox' заставляет clip path масштабироваться под рамку каждого элемента (координаты 0–1), поэтому один clip path работает для фигур разного размера. 'userSpaceOnUse' (по умолчанию) использует абсолютные координаты SVG. Большинство переиспользуемых обрезок использует objectBoundingBox.

svg
<svg width="300" height="100" viewBox="0 0 300 100">
  <defs>
    <!-- userSpaceOnUse (default): clip coords in SVG units -->
    <clipPath id="clip1" clipPathUnits="userSpaceOnUse">
      <rect x="10" y="10" width="50" height="50"/>
    </clipPath>

    <!-- objectBoundingBox: coords are 0-1 relative to the element -->
    <clipPath id="clip2" clipPathUnits="objectBoundingBox">
      <rect x="0.1" y="0.1" width="0.8" height="0.8"/>
    </clipPath>
  </defs>

  <rect width="100" height="100" fill="red" clip-path="url(#clip1)"/>
  <rect x="100" width="100" height="80" fill="blue" clip-path="url(#clip2)"/>
  <rect x="200" width="100" height="60" fill="green" clip-path="url(#clip2)"/>
</svg>

CSS clip-path

CSS clip-path поддерживает базовые фигуры (circle, ellipse, polygon, inset) напрямую без SVG и может ссылаться на элементы SVG clipPath через url(#id). Это работает и на HTML-элементах, не только на SVG. Маскирование CSS также поддерживается современными браузерами через mask-image.

svg
<style>
  /* CSS clip-path works on SVG and HTML elements */
  .circle {
    clip-path: circle(50% at 50% 50%);
  }
  .triangle {
    clip-path: polygon(50% 0%, 100% 100%, 0% 100%);
  }
  /* Reference an SVG clipPath */
  .svg-clip {
    clip-path: url(#myClip);
  }
</style>

<svg width="200" height="100">
  <defs>
    <clipPath id="myClip">
      <circle cx="50" cy="50" r="40"/>
    </clipPath>
  </defs>
  <rect class="svg-clip" width="200" height="100" fill="purple"/>
</svg>

Практика: изображение в тексте

Обрезка градиента или изображения по тексту — популярная техника дизайна. clipPath содержит элемент <text>; обрезанный rect заливается градиентом и виден только внутри букв. Это работает и с <image> — поместите фото внутрь текста для заголовков в журнальном стиле.

svg
<svg width="400" height="120" viewBox="0 0 400 120">
  <defs>
    <clipPath id="textShape">
      <text x="200" y="90" font-size="80" font-weight="900"
            text-anchor="middle" font-family="Arial">SUMMER</text>
    </clipPath>
  </defs>

  <!-- Background (visible only through the text) -->
  <rect width="400" height="120" fill="black"/>

  <!-- Image clipped to the text shape -->
  <rect width="400" height="120" fill="url(#sunsetGrad)"
        clip-path="url(#textShape)"/>

  <linearGradient id="sunsetGrad" x1="0" y1="0" x2="0" y2="1">
    <stop offset="0" stop-color="#ff6b6b"/>
    <stop offset="0.5" stop-color="#feca57"/>
    <stop offset="1" stop-color="#ff9ff3"/>
  </linearGradient>
</svg>
12

Анимация (SMIL)

animate (базово)

<animate> со временем меняет атрибут. attributeName — цель; from/to задают диапазон; dur — длительность; repeatCount='indefinite' зацикливает навсегда. SMIL-анимации декларативны (JS не нужен) и работают в большинстве браузеров, кроме IE. Анимация живёт как дочерний элемент цели.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <rect x="0" y="40" width="20" height="20" fill="red">
    <animate attributeName="x"
             from="0" to="180"
             dur="2s"
             repeatCount="indefinite"/>
  </rect>

  <!-- The rect moves from x=0 to x=180 over 2 seconds, forever -->
</svg>

animateTransform

<animateTransform> анимирует атрибут transform. type выбирает операцию (rotate, scale, translate, skewX, skewY). Для rotate from/to — это 'angle cx cy' (центральная точка). Так вращают элементы без JavaScript. На элемент может работать только один animateTransform, если не использовать additive='sum'.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <rect x="80" y="80" width="40" height="40" fill="blue">
    <animateTransform attributeName="transform"
                      type="rotate"
                      from="0 100 100" to="360 100 100"
                      dur="3s"
                      repeatCount="indefinite"/>
  </rect>

  <!-- type can be: rotate, scale, translate, skewX, skewY -->
  <!-- For rotate, the values are "angle cx cy" -->
</svg>

animateMotion

<animateMotion> двигает элемент по пути. Ссылайтесь на путь через <mpath href='#id'> или задайте path напрямую. rotate='auto' ориентирует элемент по направлению движения — необходимо для стрелок, машин и персонажей. Это SVG-способ анимации по пути без JS.

svg
<svg width="200" height="150" viewBox="0 0 200 150">
  <defs>
    <path id="motionPath" d="M 10 75 Q 100 0, 190 75" fill="none"/>
  </defs>

  <!-- A circle follows the path -->
  <circle r="10" fill="red">
    <animateMotion dur="3s" repeatCount="indefinite">
      <mpath href="#motionPath"/>
    </animateMotion>
  </circle>

  <!-- Show the path for reference -->
  <use href="#motionPath" stroke="gray" stroke-width="1"/>

  <!-- rotate="auto" makes the element face the direction of motion -->
  <circle r="5" fill="blue">
    <animateMotion dur="3s" repeatCount="indefinite" rotate="auto">
      <mpath href="#motionPath"/>
    </animateMotion>
  </circle>
</svg>

Ключевые кадры и easing

Для многошаговых анимаций используйте values (через точку с запятой), keyTimes (доли 0–1) и keySplines (easing Безье на сегмент). calcMode='spline' включает easing; 'linear' — по умолчанию. Это повторяет CSS-анимацию по ключевым кадрам, но на чистом SVG. Прямоугольник качается туда-обратно с плавным easing.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <rect x="0" y="40" width="20" height="20" fill="green">
    <animate attributeName="x"
             values="0; 80; 180; 80; 0"
             keyTimes="0; 0.25; 0.5; 0.75; 1"
             keySplines="0.5 0 0.5 1; 0 0 1 1; 0.5 0 0.5 1; 0 0 1 1"
             calcMode="spline"
             dur="4s"
             repeatCount="indefinite"/>
  </rect>

  <!-- values: the animated values at each keyTime -->
  <!-- keyTimes: 0-1 fractions of dur (semicolon-separated) -->
  <!-- keySplines: cubic-bezier easing between each pair -->
  <!-- calcMode: "discrete", "linear", "paced", or "spline" -->
</svg>

begin, end и триггеры

begin может быть смещением времени (2s), событием (click, mouseenter) или ссылкой на событие другой анимации (anim1.end, anim1.begin+1s). fill='freeze' удерживает конечное значение после завершения (иначе всё возвращается назад). Это позволяет запускать анимации по клику и связывать их без JavaScript.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <!-- begin: when to start (time or event) -->
  <rect x="10" y="10" width="30" height="30" fill="red">
    <animate attributeName="width" from="30" to="100"
             dur="1s" begin="2s" fill="freeze"/>
  </rect>

  <!-- begin on a click event -->
  <rect x="10" y="60" width="30" height="30" fill="blue" id="trigger">
    <animate attributeName="x" from="10" to="150"
             dur="1s" begin="click" fill="freeze"/>
  </rect>

  <!-- begin when another animation ends -->
  <rect x="10" y="80" width="30" height="10" fill="green">
    <animate attributeName="x" from="10" to="150"
             dur="1s" begin="trigger.click+1s" fill="freeze"/>
  </rect>
</svg>

Альтернатива: CSS-анимация

Для inline SVG в веб-страницах CSS-анимации часто проще SMIL и лучше поддерживаются инструментами. Используйте transform-box: fill-box, чтобы transform-origin: center относился к элементу, а не к полотну SVG. SMIL остаётся полезен для отдельных SVG-файлов (CSS недоступен) и движения по пути.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <style>
    .pulse {
      animation: pulse 1.5s ease-in-out infinite;
      transform-origin: center;
      transform-box: fill-box;
    }
    @keyframes pulse {
      0%, 100% { transform: scale(1); opacity: 1; }
      50% { transform: scale(1.2); opacity: 0.7; }
    }
  </style>

  <circle class="pulse" cx="100" cy="50" r="20" fill="red"/>
</svg>

<!-- CSS animations are more maintainable for web pages -->
<!-- SMIL is better for standalone .svg files -->
13

События

События мыши

Элементы SVG поддерживают стандартные DOM-события: click, mouseenter, mouseleave, mousemove, mousedown, mouseup, dblclick. Используйте addEventListener как на HTML-элементах. 'this' внутри обработчика указывает на элемент SVG. Меняйте свойства реактивно через setAttribute.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <rect id="box" x="10" y="10" width="80" height="80" fill="steelblue"/>

  <script>
    var box = document.getElementById("box");
    box.addEventListener("click", function (e) {
      alert("Clicked at " + e.clientX + "," + e.clientY);
    });
    box.addEventListener("mouseenter", function () {
      this.setAttribute("fill", "tomato");
    });
    box.addEventListener("mouseleave", function () {
      this.setAttribute("fill", "steelblue");
    });
  </script>
</svg>

Сенсорные события

SVG поддерживает touchstart, touchmove, touchend. Преобразуйте экранные координаты в координаты SVG через createSVGPoint и getScreenCTM().inverse() — это необходимо, когда SVG масштабирован или адаптивен. preventDefault() на touchstart предотвращает вмешательство жестов вроде прокрутки.

svg
<svg width="200" height="200" viewBox="0 0 200 200">
  <circle id="touch" cx="100" cy="100" r="30" fill="purple"/>

  <script>
    var circle = document.getElementById("touch");
    circle.addEventListener("touchstart", function (e) {
      e.preventDefault();  // prevent scrolling
      this.setAttribute("fill", "orange");
    });
    circle.addEventListener("touchend", function () {
      this.setAttribute("fill", "purple");
    });
    // touchmove for dragging
    circle.addEventListener("touchmove", function (e) {
      var touch = e.touches[0];
      var pt = svg.createSVGPoint();
      pt.x = touch.clientX; pt.y = touch.clientY;
      var svgP = pt.matrixTransform(svg.getScreenCTM().inverse());
      this.setAttribute("cx", svgP.x);
      this.setAttribute("cy", svgP.y);
    });
  </script>
</svg>

Преобразование координат

Когда у SVG viewBox отличается от пиксельного размера, экранные координаты не отображаются 1:1 в координаты SVG. createSVGPoint + getScreenCTM().inverse() преобразуют корректно, учитывая viewBox, масштабирование CSS и даже трансформации предков. Это важно для точного определения кликов.

svg
<svg width="500" height="300" viewBox="0 0 1000 600" id="mysvg">
  <rect width="1000" height="600" fill="lightblue"/>

  <script>
    var svg = document.getElementById("mysvg");
    svg.addEventListener("click", function (e) {
      // Convert screen (clientX/Y) to SVG user coordinates
      var pt = svg.createSVGPoint();
      pt.x = e.clientX;
      pt.y = e.clientY;

      // getScreenCTM maps SVG coords to screen; inverse maps back
      var svgPoint = pt.matrixTransform(
        svg.getScreenCTM().inverse()
      );

      console.log("SVG coords:", svgPoint.x, svgPoint.y);
      // This accounts for viewBox scaling and CSS sizing
    });
  </script>
</svg>

Делегирование событий

Делегирование событий — один обработчик на родительской группе вместо многих на детях — эффективнее и автоматически обрабатывает динамически добавленные фигуры. e.target — фигура, по которой кликнули; e.currentTarget — элемент с обработчиком. Используйте атрибуты data-* для метаданных каждой фигуры.

svg
<svg width="300" height="100" viewBox="0 0 300 100">
  <g id="shapes">
    <circle cx="50" cy="50" r="30" fill="red" data-name="circle1"/>
    <rect x="100" y="20" width="60" height="60" fill="blue" data-name="rect1"/>
    <polygon points="220,20 280,20 250,80" fill="green" data-name="tri1"/>
  </g>

  <script>
    // One listener on the parent group handles all children
    document.getElementById("shapes").addEventListener("click", function (e) {
      var target = e.target;
      var name = target.getAttribute("data-name");
      console.log("Clicked:", name, target.tagName);
      // e.target is the actual shape; e.currentTarget is the group
    });
  </script>
</svg>

Перетаскивание

Классический паттерн перетаскивания в SVG: mousedown ставит флаг, mousemove обновляет позицию элемента (по преобразованным координатам SVG), mouseup снимает флаг. Прикрепляйте mousemove/mouseup к SVG (не к элементу), чтобы перетаскивание продолжалось, даже когда курсор уходит с фигуры. Это основа редакторов на SVG.

svg
<svg width="400" height="300" viewBox="0 0 400 300" id="canvas">
  <circle id="draggable" cx="200" cy="150" r="30" fill="orange" cursor="grab"/>

  <script>
    var circle = document.getElementById("draggable");
    var svg = document.getElementById("canvas");
    var dragging = false;

    function getSVGPoint(e) {
      var pt = svg.createSVGPoint();
      pt.x = e.clientX; pt.y = e.clientY;
      return pt.matrixTransform(svg.getScreenCTM().inverse());
    }

    circle.addEventListener("mousedown", function () {
      dragging = true;
      this.setAttribute("cursor", "grabbing");
    });
    svg.addEventListener("mousemove", function (e) {
      if (!dragging) return;
      var p = getSVGPoint(e);
      circle.setAttribute("cx", p.x);
      circle.setAttribute("cy", p.y);
    });
    svg.addEventListener("mouseup", function () {
      dragging = false;
      circle.setAttribute("cursor", "grab");
    });
  </script>
</svg>
14

JavaScript и DOM

Создание элементов

Элементы SVG нужно создавать через document.createElementNS(namespace, tagName) — createElement для SVG не работает (создаёт неизвестные HTML-элементы). Пространство имён SVG — 'http://www.w3.org/2000/svg'. Для свойств используйте setAttribute. Это основа динамической генерации SVG.

svg
<svg id="canvas" width="200" height="200" viewBox="0 0 200 200">
  <script>
    var svg = document.getElementById("canvas");
    var NS = "http://www.w3.org/2000/svg";

    // createElementNS is required for SVG elements
    var circle = document.createElementNS(NS, "circle");
    circle.setAttribute("cx", "100");
    circle.setAttribute("cy", "100");
    circle.setAttribute("r", "50");
    circle.setAttribute("fill", "red");
    svg.appendChild(circle);

    // Create a path
    var path = document.createElementNS(NS, "path");
    path.setAttribute("d", "M 10 10 L 100 100");
    path.setAttribute("stroke", "black");
    svg.appendChild(path);
  </script>
</svg>

Изменение элементов

Используйте setAttribute/getAttribute для презентационных атрибутов SVG (fill, stroke, width и т. д.). classList работает надёжно во всех браузерах. Установка style.fill работает, потому что отображается в CSS-свойство. Избегайте innerHTML для SVG (неоднородно между браузерами); стройте DOM через createElementNS.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <rect id="r" x="10" y="10" width="50" height="50" fill="blue"/>

  <script>
    var r = document.getElementById("r");

    // Change attributes
    r.setAttribute("fill", "red");
    r.setAttribute("width", "80");

    // Get attribute values
    var w = r.getAttribute("width");  // "80"

    // Remove attributes
    r.removeAttribute("fill");

    // Class manipulation (use classList, not className for SVG in some browsers)
    r.classList.add("highlight");
    r.classList.toggle("active");

    // Style (use setAttribute for presentation attributes)
    r.style.fill = "green";  // works via CSS
  </script>
</svg>

Чтение геометрии

getBBox() возвращает рамку в пользовательских единицах SVG (без учёта трансформаций). getBoundingClientRect() возвращает экранные координаты (после всех трансформаций и CSS). getTotalLength() даёт длину path/line; getPointAtLength(d) возвращает точку на расстоянии d — необходимо для анимаций по пути и проверки попадания.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <rect id="r" x="10" y="10" width="80" height="50" fill="blue"/>

  <script>
    var r = document.getElementById("r");

    // Get bounding box in SVG user units
    var bbox = r.getBBox();
    console.log(bbox.x, bbox.y, bbox.width, bbox.height);

    // Get bounding box in screen coordinates (after transforms)
    var cbox = r.getBoundingClientRect();
    console.log(cbox.left, cbox.top, cbox.width, cbox.height);

    // Total length of a path or line
    var path = document.querySelector("path");
    var len = path.getTotalLength();
    var point = path.getPointAtLength(len / 2);  // midpoint
  </script>
</svg>

Dataset и атрибуты данных

Элементы SVG поддерживают атрибуты data-* и свойство dataset, как и HTML. Это чистый способ связать данные с фигурами для интерактивных приложений — хранить ID узлов, подписи или состояние, не засоряя визуальные атрибуты. Читайте через element.dataset.key, задавайте так же.

svg
<svg width="200" height="100" viewBox="0 0 200 100">
  <circle cx="50" cy="50" r="20" fill="red"
          data-id="123" data-label="node"/>

  <script>
    var circle = document.querySelector("circle");

    // dataset reads data-* attributes
    console.log(circle.dataset.id);     // "123"
    console.log(circle.dataset.label);  // "node"

    // Set data attributes
    circle.dataset.selected = "true";  // adds data-selected="true"

    // Use for storing state
    circle.dataset.visits = "0";
    circle.dataset.visits = String(+circle.dataset.visits + 1);
  </script>
</svg>

Динамическая генерация path

Динамическая генерация SVG — основа собственных графиков. Стройте атрибут d, конкатенируя команды M/L из данных, затем создавайте элемент через createElementNS. Этот подход даёт полный контроль без библиотеки графиков. Для сложных визуализаций рассмотрите D3.js, который элегантно оборачивает этот паттерн.

svg
<svg width="300" height="150" viewBox="0 0 300 150" id="chart">
  <script>
    var NS = "http://www.w3.org/2000/svg";
    var svg = document.getElementById("chart");
    var data = [10, 50, 30, 80, 45, 90, 25];

    // Build a path string from data points
    var d = "M 0 " + (150 - data[0]);
    for (var i = 1; i < data.length; i++) {
      d += " L " + (i * 40) + " " + (150 - data[i]);
    }

    var path = document.createElementNS(NS, "path");
    path.setAttribute("d", d);
    path.setAttribute("fill", "none");
    path.setAttribute("stroke", "steelblue");
    path.setAttribute("stroke-width", "2");
    svg.appendChild(path);

    // Add dots at each point
    data.forEach(function (val, i) {
      var c = document.createElementNS(NS, "circle");
      c.setAttribute("cx", i * 40);
      c.setAttribute("cy", 150 - val);
      c.setAttribute("r", 3);
      c.setAttribute("fill", "red");
      svg.appendChild(c);
    });
  </script>
</svg>

Советы по производительности

Для производительности: объединяйте вставки в DOM через DocumentFragment (один reflow), используйте requestAnimationFrame для JS-анимаций (синхронизация с обновлением экрана) и не запрашивайте атрибуты в плотных циклах (кэшируйте значения). SVG хорош примерно до нескольких сотен элементов; для тысяч (частицы, плотные графики) Canvas или WebGL быстрее.

svg
<script>
  // Batch DOM operations with document fragments
  var fragment = document.createDocumentFragment();
  for (var i = 0; i < 1000; i++) {
    var c = document.createElementNS(NS, "circle");
    c.setAttribute("cx", i);
    c.setAttribute("cy", 50);
    c.setAttribute("r", 2);
    fragment.appendChild(c);
  }
  svg.appendChild(fragment);  // one reflow, not 1000

  // Use requestAnimationFrame for animations
  function animate() {
    element.setAttribute("cx", +element.getAttribute("cx") + 1);
    requestAnimationFrame(animate);
  }
  animate();

  // For many elements, consider <canvas> instead (faster)
  // SVG slows down with thousands of nodes due to DOM overhead
</script>
15

Адаптивный SVG (viewBox)

Основы viewBox

viewBox='minX minY width height' определяет внутреннюю систему координат. Первые два значения панорамируют вид; последние два задают масштаб. SVG масштабирует эту область под свои width/height. Это отделяет координаты рисования от размера рендеринга — рисуйте один раз в любом масштабе, в коробке 100x100 или 1920x1080.

svg
<!-- viewBox="minX minY width height" -->
<svg viewBox="0 0 100 100" width="200" height="200">
  <!-- A circle at center of a 100x100 coordinate system -->
  <circle cx="50" cy="50" r="50" fill="blue"/>
</svg>

<!-- viewBox shifts the visible area -->
<svg viewBox="50 50 50 50" width="200" height="200">
  <!-- Now showing only the bottom-right quadrant -->
  <!-- The same circle, but zoomed in 2x on that corner -->
  <circle cx="50" cy="50" r="50" fill="blue"/>
</svg>

preserveAspectRatio

preserveAspectRatio управляет тем, как viewBox вписывается в элемент при разных пропорциях. 'meet' (по умолчанию) вписывает целиком, добавляя поля. 'slice' заполняет целиком, обрезая излишек. 'none' растягивает, искажая. Часть xMidYMid управляет выравниванием: Min/Mid/Max по обеим осям.

svg
<!-- Default: preserve aspect ratio, center, letterbox -->
<svg viewBox="0 0 100 50" width="200" height="200"
     preserveAspectRatio="xMidYMid meet">
  <rect width="100" height="50" fill="blue"/>
</svg>

<!-- "slice": fill entirely, crop overflow -->
<svg viewBox="0 0 100 50" width="200" height="200"
     preserveAspectRatio="xMidYMid slice">
  <rect width="100" height="50" fill="red"/>
</svg>

<!-- "none": stretch to fill (distorts) -->
<svg viewBox="0 0 100 50" width="200" height="200"
     preserveAspectRatio="none">
  <rect width="100" height="50" fill="green"/>
</svg>

Полностью адаптивный SVG

Для адаптивного SVG: опустите атрибуты width/height, задайте viewBox и управляйте размером через CSS (width: 100%, height: auto). SVG масштабируется под контейнер, сохраняя пропорции. display: block убирает разрыв базовой линии у inline SVG. Это стандартный паттерн для гибкого SVG в адаптивной вёрстке.

svg
<!-- Omit width/height, set viewBox, use CSS to size -->
<svg viewBox="0 0 100 100" style="width: 100%; height: auto; display: block;">
  <circle cx="50" cy="50" r="50" fill="orange"/>
</svg>

<!-- In a container with max-width -->
<div style="max-width: 500px; margin: auto;">
  <svg viewBox="0 0 400 300" style="width: 100%; height: auto;">
    <rect width="400" height="300" fill="steelblue"/>
  </svg>
</div>

Вложенный SVG и overflow

Вложенные элементы <svg> создают независимые вьюпорты со своим viewBox и preserveAspectRatio. Это мощно для графиков с панелями фиксированных пропорций или UI-компонентов. overflow='visible' позволяет содержимому рисоваться за пределами вложенного вьюпорта (по умолчанию hidden). Каждый вложенный svg может масштабировать содержимое независимо.

svg
<svg width="300" height="200" viewBox="0 0 300 200">
  <!-- Nested SVG creates a new viewport -->
  <svg x="10" y="10" width="100" height="100" viewBox="0 0 50 50">
    <circle cx="25" cy="25" r="25" fill="red"/>
  </svg>

  <!-- overflow="hidden" (default) clips content outside -->
  <svg x="120" y="10" width="100" height="100" viewBox="0 0 50 50"
       overflow="visible">
    <circle cx="25" cy="25" r="30" fill="blue"/>
  </svg>

  <!-- Each nested svg can have its own preserveAspectRatio -->
  <svg x="230" y="10" width="60" height="100" viewBox="0 0 50 50"
       preserveAspectRatio="xMidYMid slice">
    <circle cx="25" cy="25" r="25" fill="green"/>
  </svg>
</svg>

Гибкий размер текста

Размеры шрифта внутри SVG с viewBox масштабируются вместе с SVG: шрифт 20px в viewBox шириной 400 при показе шириной 800 отрисуется как 40px. Чтобы текст зависел от вьюпорта браузера (а не SVG), используйте CSS-единицы вьюпорта (vw, vh) в атрибуте style. Так заголовки SVG масштабируются гибко.

svg
<svg viewBox="0 0 400 100" style="width:100%;height:auto;">
  <style>
    /* Use viewBox units for font-size — scales with the SVG */
    text { font-size: 20px; }
    /* Note: 'px' here means SVG user units, not CSS px */
  </style>

  <text x="200" y="50" text-anchor="middle">Scales with SVG</text>
</svg>

<!-- For truly responsive text relative to viewport, use CSS: -->
<svg viewBox="0 0 400 100" style="width:100%;height:auto;">
  <text x="200" y="50" text-anchor="middle"
        style="font-size: 5vw;">5% of viewport width</text>
</svg>

<!-- Or use container queries / media queries on the SVG element -->

Управление пропорциями

Комбинируйте CSS aspect-ratio на контейнере с width/height 100% на SVG для предсказуемого адаптивного поведения. Это предотвращает сдвиг вёрстки (CLS), резервируя место до загрузки SVG. viewBox соответствует пропорциям, поэтому содержимое не искажается. Это современная лучшая практика встраивания SVG.

svg
<!-- Use CSS aspect-ratio for consistent sizing -->
<div style="width: 100%; max-width: 600px; aspect-ratio: 16/9;">
  <svg viewBox="0 0 1600 900" style="width:100%;height:100%;">
    <rect width="1600" height="900" fill="black"/>
    <text x="800" y="450" text-anchor="middle" dominant-baseline="middle"
          fill="white" font-size="48">16:9 Container</text>
  </svg>
</div>

<!-- aspect-ratio ensures the container keeps proportions -->
<!-- even before the SVG loads, preventing layout shift -->
16

SVG и Canvas

Модель рендеринга

SVG — retained mode: каждая фигура это DOM-элемент, который можно исследовать, стилизовать и переанимировать позже. Canvas — immediate mode: вы отдаёте команды рисования, которые закрашивают пиксели, а фигуры не сохраняются как объекты. SVG лучше для интерактивного интерфейса; Canvas лучше для тысяч динамических пикселей.

svg
<!-- SVG: retained mode (DOM-based) -->
<svg width="200" height="100">
  <circle cx="50" cy="50" r="30" fill="red"/>
  <!-- Each element is a DOM node, accessible via JS -->
</svg>

<!-- Canvas: immediate mode (pixel-based) -->
<canvas id="c" width="200" height="100"></canvas>
<script>
  var ctx = document.getElementById("c").getContext("2d");
  ctx.beginPath();
  ctx.arc(50, 50, 30, 0, Math.PI * 2);
  ctx.fillStyle = "red";
  ctx.fill();
  // Pixels are drawn; the circle isn't an object anymore
</script>

Когда использовать SVG

Выбирайте SVG для: графики, независимой от разрешения (иконки, логотипы), доступности (скринридеры обходят DOM), интерактивности (события на фигурах), SEO (текст выделяется) и умеренного числа элементов (до нескольких сотен). Файлы SVG текстовые (хорошо сжимаются gzip) и редактируются в дизайн-инструментах.

svg
<!-- SVG is ideal for:
     - Icons and logos (crisp at any size)
     - Charts with few elements (D3.js)
     - Interactive diagrams (clickable shapes)
     - Illustrations with editable layers
     - Accessibility-required graphics
-->
<svg viewBox="0 0 24 24" width="48" height="48">
  <path d="M12 2 L2 22 H22 Z" fill="triangle"/>
</svg>
<!-- Stays sharp whether displayed at 16px or 1024px -->
<!-- Each part can have its own click handler -->
<!-- Screen readers can access <title> and <desc> -->

Когда использовать Canvas

Выбирайте Canvas для: большого числа элементов (тысячи фигур), перерисовки каждый кадр (игры, частицы), манипуляций с пикселями (фильтры, эффекты) и когда доступность DOM не нужна. Canvas быстрее по чистой пропускной способности пикселей, но его сложнее сделать доступным или интерактивным на уровне отдельных фигур.

svg
<!-- Canvas is ideal for:
     - Games (hundreds of sprites per frame)
     - Particle systems
     - Real-time image processing
     - Heatmaps with thousands of cells
     - Physics simulations
-->
<canvas id="particles" width="800" height="600"></canvas>
<script>
  var ctx = document.getElementById("particles").getContext("2d");
  var particles = [];
  for (var i = 0; i < 5000; i++) {
    particles.push({ x: Math.random()*800, y: Math.random()*600 });
  }
  function draw() {
    ctx.clearRect(0, 0, 800, 600);
    particles.forEach(function (p) {
      ctx.fillRect(p.x, p.y, 2, 2);
    });
    requestAnimationFrame(draw);
  }
  draw();
</script>

Сравнение производительности

Производительность SVG падает с числом элементов, потому что каждая фигура — узел DOM с обработкой событий, стилями и вёрсткой. У Canvas постоянные накладные расходы на кадр независимо от числа фигур. Перелом примерно на 500–2000 элементах в зависимости от сложности. Для статичной или слабо анимированной графики SVG хорош; для плотных сцен в реальном времени — Canvas.

svg
<!-- SVG DOM overhead grows with element count -->
<!-- 100 circles: SVG ~0.1ms, Canvas ~0.1ms (both fine) -->
<!-- 1000 circles: SVG ~10ms, Canvas ~1ms (Canvas pulls ahead) -->
<!-- 10000 circles: SVG ~500ms+, Canvas ~10ms (SVG struggles) -->

<!-- SVG advantages:
     - No redraw needed for CSS changes (browser handles it)
     - Hardware-accelerated transforms
     - Only changed elements re-render (incremental)
-->
<!-- Canvas advantages:
     - Constant redraw cost regardless of history
     - No DOM memory overhead per shape
     - Direct pixel access (getImageData, putImageData)
-->

Гибридный подход

Комбинируйте: Canvas для плотного, часто перерисовываемого слоя (тепловая карта, частицы) и SVG поверх для интерактивного интерфейса (подсказки, маркеры выделения, подписи). Слой SVG остаётся чётким и доступным, а Canvas берёт тяжёлую пиксельную работу. Этот паттерн используют картографические библиотеки вроде Leaflet и инструменты графиков вроде ECharts.

svg
<!-- SVG for UI chrome, Canvas for dense content -->
<div style="position:relative; width:800px; height:600px;">
  <!-- Canvas renders the heatmap (fast for thousands of cells) -->
  <canvas width="800" height="600" style="position:absolute; top:0; left:0;">
  </canvas>

  <!-- SVG overlay for interactive tooltips and selection -->
  <svg width="800" height="600" viewBox="0 0 800 600"
       style="position:absolute; top:0; left:0;">
    <g id="overlay"></g>
  </svg>
</div>

<script>
  // Draw heatmap on canvas (performant)
  // Add hover tooltips as SVG elements (accessible, styled)
</script>

Сравнение доступности

SVG изначально доступнее: DOM обходим, текст выделяется и ищется, <title>/<desc> дают описания. Canvas требует дополнительной работы — нужно добавить role/aria-label и текстовый запасной контент внутри тега <canvas>. Для графиков и визуализаций данных доступность SVG — большое преимущество.

svg
<!-- SVG: screen readers traverse the DOM -->
<svg role="img" aria-label="Sales chart showing 20% growth">
  <title>Sales Chart</title>
  <desc>Bar chart with 5 quarters, Q3 highest at $2M</desc>
  <rect .../>  <!-- each bar is a DOM element -->
</svg>
<!-- Text in SVG is selectable and searchable -->

<!-- Canvas: just pixels to a screen reader -->
<canvas role="img" aria-label="Sales chart showing 20% growth">
  <!-- Must provide text fallback inside the canvas tag -->
  Sales chart: Q1 $1M, Q2 $1.3M, Q3 $2M, Q4 $1.8M
</canvas>
<!-- No DOM, no selectable text, harder to make accessible -->
17

SVG-спрайт

Настройка inline-спрайта

Определите все иконки как элементы <symbol> в скрытом SVG в начале страницы. У каждого символа свой viewBox и id. Спрайт загружается один раз и кэшируется на сессию. Использование currentColor для fill/stroke позволяет каждому применению наследовать цвет окружающего текста, что делает темизацию тривиальной.

svg
<!-- Place this hidden SVG at the top of your HTML body -->
<svg xmlns="http://www.w3.org/2000/svg" style="display:none" aria-hidden="true">
  <symbol id="icon-home" viewBox="0 0 24 24">
    <path d="M12 3 L2 12 H5 V21 H10 V14 H14 V21 H19 V12 H22 Z"/>
  </symbol>
  <symbol id="icon-user" viewBox="0 0 24 24">
    <circle cx="12" cy="8" r="4"/>
    <path d="M4 21 C 4 16, 8 14, 12 14 C 16 14, 20 16, 20 21 Z"/>
  </symbol>
  <symbol id="icon-search" viewBox="0 0 24 24">
    <circle cx="11" cy="11" r="7" fill="none" stroke="currentColor" stroke-width="2"/>
    <line x1="16" y1="16" x2="21" y2="21" stroke="currentColor" stroke-width="2"/>
  </symbol>
</svg>

Использование иконок спрайта

Каждый <use> создаёт экземпляр иконки. CSS-класс .icon задаёт размер по умолчанию; подклассы переопределяют варианты. Поскольку символы используют fill='currentColor', цвет иконки следует свойству CSS color — задайте color на кнопке, и её иконка совпадёт. Так работают крупные иконочные системы (GitHub, Bootstrap).

svg
<!-- Reference any icon with <use> -->
<svg class="icon"><use href="#icon-home"/></svg>
<svg class="icon"><use href="#icon-user"/></svg>
<svg class="icon icon-large"><use href="#icon-search"/></svg>

<style>
  .icon {
    width: 24px;
    height: 24px;
    fill: currentColor;  /* inherits text color */
    display: inline-block;
    vertical-align: middle;
  }
  .icon-large { width: 48px; height: 48px; }
</style>

<!-- Color via CSS color (because fill="currentColor") -->
<button style="color: red;">
  <svg class="icon"><use href="#icon-home"/></svg> Home
</button>

Спрайт из внешнего файла

Внешние ссылки на спрайт (href='file.svg#id') имеют слабую поддержку браузерами и проблемы CORS. Надёжный подход: получить файл спрайта и вставить его как inline HTML в начало body. Это кэшируется по HTTP и работает везде. Многие сборщики (svg-sprite-loader, gulp-svg-sprite) автоматизируют это.

svg
<!-- icons.svg (a separate file) -->
<svg xmlns="http://www.w3.org/2000/svg" style="display:none">
  <symbol id="icon-home" viewBox="0 0 24 24">...</symbol>
</svg>

<!-- Reference external symbols (limited browser support) -->
<svg class="icon"><use href="icons.svg#icon-home"/></svg>

<!-- More reliable: fetch and inject the sprite -->
<script>
  fetch("icons.svg")
    .then(r => r.text())
    .then(text => {
      var div = document.createElement("div");
      div.style.display = "none";
      div.innerHTML = text;
      document.body.insertBefore(div, document.body.firstChild);
    });
</script>

Генерация спрайта при сборке

Сборщики автоматизируют создание спрайта: положите отдельные .svg-файлы в папку, и инструмент соберёт их в спрайт с правильными обёртками <symbol>. Популярны svg-sprite-loader (webpack), gulp-svg-sprite и vite-plugin-svg. Так иконки остаются отдельными файлами в разработке, но собираются в бандл для продакшена.

svg
<!-- Using svg-sprite-loader (webpack) -->
// import all icons in a folder
const req = require.context("./icons", true, /\.svg$/);
req.keys().forEach(req);

// In your component:
<svg class="icon"><use href="#icon-home"/></svg>

<!-- Using gulp-svg-sprite -->
// gulpfile.js
const svgSprite = require("gulp-svg-sprite");
gulp.task("sprite", () =>
  gulp.src("icons/*.svg")
    .pipe(svgSprite({ mode: { symbol: { dest: "." } } }))
    .pipe(gulp.dest("dist"))
);
// Outputs dist/symbol/svg/sprite.symbol.svg

Доступность иконок спрайта

Для доступности: если иконка чисто декоративная (рядом с текстом), пометьте её aria-hidden='true'. Если она несёт смысл сама по себе, добавьте role='img' и aria-label на <svg>. Для кнопок только с иконкой ставьте aria-label на <button>, а не на SVG. Никогда не полагайтесь только на иконку без доступного имени.

svg
<!-- Decorative icon (hidden from screen readers) -->
<svg class="icon" aria-hidden="true">
  <use href="#icon-decoration"/>
</svg>

<!-- Meaningful icon (with label) -->
<svg class="icon" role="img" aria-label="Home">
  <use href="#icon-home"/>
</svg>

<!-- Icon button with visible text (icon is decorative) -->
<button>
  <svg class="icon" aria-hidden="true"><use href="#icon-home"/></svg>
  <span>Home</span>
</button>

<!-- Icon-only button (needs aria-label on the button) -->
<button aria-label="Search">
  <svg class="icon" aria-hidden="true"><use href="#icon-search"/></svg>
</button>

Двухцветные и многоцветные иконки

Многоцветные иконки сложны со спрайтами, потому что клоны <use> ограниченно переопределяемы. Для двухцветных иконок используйте currentColor для основного и фиксированный цвет для вторичного. CSS-переменные (custom properties) внутри символа позволяют потребителям переопределять отдельные части — современная техника гибкой темизации.

svg
<svg style="display:none">
  <!-- Icon with two fill regions -->
  <symbol id="icon-mail" viewBox="0 0 24 24">
    <rect x="2" y="4" width="20" height="16" rx="2" fill="currentColor"/>
    <path d="M2 6 L12 13 L22 6" fill="white"/>
  </symbol>
</svg>

<!-- Override individual parts via CSS (limited: works if the
     symbol uses currentColor and CSS variables) -->
<svg class="icon" style="color: steelblue;">
  <use href="#icon-mail"/>
</svg>

<!-- For full multi-color control, use CSS custom properties -->
<symbol id="icon-alert" viewBox="0 0 24 24">
  <path fill="var(--icon-bg, currentColor)" d="M12 2 L2 22 H22 Z"/>
  <text x="12" y="18" text-anchor="middle" fill="var(--icon-fg, white)">!</text>
</symbol>

<svg class="icon" style="--icon-bg: red; --icon-fg: yellow;">
  <use href="#icon-alert"/>
</svg>
18

Оптимизация SVG

SVGO CLI

SVGO — стандартный оптимизатор SVG. Он удаляет метаданные, комментарии, мусор редакторов (пространства имён Inkscape/Illustrator), неиспользуемые defs и избыточные атрибуты, часто сокращая размер файла на 30–60%. Прогоняйте через него все продакшен-SVG. Используйте --show-plugins, чтобы увидеть возможности, и конфиг-файл для включения и отключения конкретных оптимизаций.

svg
# Install SVGO globally
npm install -g svgo

# Optimize a single file (overwrites)
svgo icon.svg

# Optimize to a new file
svgo icon.svg -o icon.min.svg

# Optimize a folder
svgo -f icons/ -o icons/min/

# Show available plugins
svgo --show-plugins

# Use a specific config
svgo --config=svgo.config.js icon.svg

Частые оптимизации

SVGO удаляет: XML-декларации, комментарии и пространства имён редакторов (Adobe, Inkscape), метаданные, неиспользуемый xlink, enable-background, xml:space, избыточный fill-rule='nonzero' (он по умолчанию). Он сокращает цветовые значения (#FF0000 → red), схлопывает пробелы и объединяет пути. Результат семантически идентичен, но намного меньше.

svg
<!-- Before optimization (from Illustrator) -->
<?xml version="1.0" encoding="utf-8"?>
<!-- Generator: Adobe Illustrator 25.0 -->
<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     xmlns:a="http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"
     width="100px" height="100px" viewBox="0 0 100 100"
     enable-background="new 0 0 100 100" xml:space="preserve">
  <metadata>...</metadata>
  <path d="..." fill="#FF0000" fill-rule="nonzero"/>
</svg>

<!-- After SVGO -->
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
  <path d="..." fill="red"/>
</svg>

Оптимизация путей

SVGO переводит абсолютные координаты в относительные, где короче, использует H/V вместо L для горизонтальных и вертикальных линий, убирает лишние десятичные и может объединять пути одинаковой формы. Эти оптимизации путей часто вдвое сокращают длину строки. Плагин 'convertPath' делает это; он включён по умолчанию.

svg
<!-- SVGO can merge and simplify paths -->
<!-- Before: multiple paths with redundant points -->
<g>
  <path d="M 10 10 L 20 10 L 20 20 L 10 20 Z" fill="red"/>
  <path d="M 10 10 L 20 10 L 20 20 L 10 20 Z" fill="none" stroke="black"/>
</g>

<!-- After: merged into one path with combined commands -->
<path d="M10 10h10v10H10z" fill="red" stroke="black"/>

<!-- Path command shortcuts:
     L 20 10  ->  h 10  (relative horizontal)
     L 10 20  ->  v 10  (relative vertical)
     Z closes the path
-->

Группировка и наследование

Переносите общие атрибуты (fill, stroke, font) в родительский <g>, чтобы дети их наследовали. Это уменьшает размер файла и упрощает массовые изменения стиля. Плагины SVGO 'mergePaths' и 'moveElemsAttrsToGroup' автоматизируют это. При ручном написании SVG группируйте сразу — это чище и поддерживаемее.

svg
<!-- Before: repeated attributes on each element -->
<svg viewBox="0 0 100 100">
  <rect x="10" y="10" width="20" height="20" fill="red" stroke="black" stroke-width="2"/>
  <rect x="40" y="10" width="20" height="20" fill="red" stroke="black" stroke-width="2"/>
  <rect x="70" y="10" width="20" height="20" fill="red" stroke="black" stroke-width="2"/>
</svg>

<!-- After: group with shared attributes -->
<svg viewBox="0 0 100 100">
  <g fill="red" stroke="black" stroke-width="2">
    <rect x="10" y="10" width="20" height="20"/>
    <rect x="40" y="10" width="20" height="20"/>
    <rect x="70" y="10" width="20" height="20"/>
  </g>
</svg>

Gzip и доставка

SVG сжимается gzip на 70–90%, потому что это повторяющийся XML-текст. Убедитесь, что веб-сервер сжимает image/svg+xml через gzip или brotli. Для доставки: встраивайте критичный (в первом экране) SVG, чтобы избежать блокирующего запроса; для иллюстраций ниже используйте <img loading='lazy'>. Агрессивно кэшируйте SVG — он редко меняется.

svg
<!-- SVG is text, so it gzips very well (70-90% reduction) -->
<!-- Ensure your server sends SVG with gzip/brotli compression: -->

<!-- Apache .htaccess -->
AddType image/svg+xml .svg
<IfModule mod_deflate.c>
  AddOutputFilterByType DEFLATE image/svg+xml
</IfModule>

<!-- Nginx -->
# gzip_types image/svg+xml;

<!-- HTML: use the right loading strategy -->
<img src="hero.svg" loading="lazy" decoding="async">

<!-- For above-the-fold critical SVG, inline it to avoid a request -->
<!-- For below-the-fold, use <img loading="lazy"> to defer -->

Конфиг-файл SVGO

Конфиг-файл настраивает SVGO. Частые правки: сохранять viewBox (removeViewBox включён по умолчанию — ОТКЛЮЧИТЕ его, чтобы адаптивность работала), удалять width/height для гибких SVG (removeDimensions) и включать cleanupIDs для спрайтов (сокращает имена id). multipass прогоняет оптимизации до стабилизации ради минимального вывода.

svg
// svgo.config.js (SVGO 2+)
module.exports = {
  multipass: true,  // run multiple passes for best result
  js2svg: {
    indent: 2,
    pretty: true,   // readable output (false for minified)
  },
  plugins: [
    { name: "preset-default" },         // sensible defaults
    { name: "removeDimensions", active: true },  // remove width/height (use viewBox)
    { name: "removeViewBox", active: false },    // KEEP viewBox (opposite of default)
    { name: "removeXMLNS", active: false },      // keep xmlns for standalone files
    { name: "cleanupIDs", active: true },        // minify id names
    { name: "mergePaths", active: true },
  ],
};
19

Лучшие практики

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

Для доступного SVG: добавьте <title> и <desc>, свяжите их через aria-labelledby, задайте role='img', чтобы скринридеры объявляли SVG как изображение, и добавьте focusable='false', чтобы избежать проблем с tab-стопом в IE/Edge. Декоративные SVG должны быть aria-hidden='true'. Эти практики делают SVG пригодным для вспомогательных технологий.

svg
<!-- 1. Always include <title> and <desc> for meaningful SVGs -->
<svg role="img" aria-labelledby="title-id desc-id">
  <title id="title-id">Annual Revenue Chart</title>
  <desc id="desc-id">A bar chart showing revenue from 2019 to 2023,
    rising from $1M to $5M.</desc>
  <!-- chart content -->
</svg>

<!-- 2. Decorative SVG: hide from screen readers -->
<svg aria-hidden="true" focusable="false">
  <!-- purely visual flourish -->
</svg>

<!-- 3. focusable="false" prevents IE/Edge from making SVG focusable -->
<!-- 4. Use role="img" so screen readers treat SVG as a single image -->

Используйте viewBox, а не width/height

Всегда включайте viewBox — он определяет внутреннюю систему координат и включает масштабирование. Для иконок задавайте width/height через CSS (не атрибутами), чтобы один и тот же SVG работал в любом размере. Для адаптивной графики вообще опускайте width/height и используйте width:100%; height:auto в CSS. Плагин SVGO removeDimensions закрепляет это.

svg
<!-- GOOD: viewBox makes the SVG scalable -->
<svg viewBox="0 0 24 24" style="width: 24px; height: 24px;">
  <path d="..."/>
</svg>

<!-- BAD: fixed width/height limits scalability -->
<svg width="24" height="24">
  <path d="..."/>
</svg>

<!-- For responsive: omit width/height, size with CSS -->
<svg viewBox="0 0 100 100" style="width:100%;height:auto;">
  <circle cx="50" cy="50" r="50"/>
</svg>

currentColor для темизации

Используйте fill='currentColor' (или stroke), чтобы иконки наследовали цвет окружающего текста. Это делает темизацию тривиальной: задайте color на родителе, и все иконки совпадут. Это также включает состояния hover/active через CSS-переходы цвета. Избегайте хардкода цветов в переиспользуемых символах, если они не должны быть фиксированными (как брендовый логотип).

svg
<!-- GOOD: use currentColor so the icon inherits text color -->
<symbol id="icon" viewBox="0 0 24 24">
  <path fill="currentColor" d="..."/>
</symbol>

<!-- Usage: color via CSS -->
<button style="color: tomato;">
  <svg class="icon"><use href="#icon"/></svg> Themed
</button>

<button style="color: steelblue;">
  <svg class="icon"><use href="#icon"/></svg> Also themed
</button>

<!-- BAD: hardcoded colors can't be themed -->
<symbol id="icon">
  <path fill="#333333" d="..."/>  <!-- always gray -->
</symbol>

Семантическая группировка

Группируйте элементы по логической роли (фон, оси, данные, подписи) с осмысленными id, а не только по типу фигуры. Это упрощает поддержку, стилизацию и скриптинг SVG — можно показывать, скрывать или перестилизовывать целые группы. Это также помогает доступности (aria-labelledby на группах) и отладке.

svg
<svg viewBox="0 0 200 200">
  <!-- Group by logical component, not just by shape type -->
  <g id="background">
    <rect width="200" height="200" fill="#f0f0f0"/>
  </g>
  <g id="chart-axis">
    <line x1="20" y1="180" x2="180" y2="180" stroke="black"/>
    <line x1="20" y1="20" x2="20" y2="180" stroke="black"/>
  </g>
  <g id="chart-data" fill="steelblue">
    <rect x="30" y="100" width="20" height="80"/>
    <rect x="60" y="60" width="20" height="120"/>
    <rect x="90" y="80" width="20" height="100"/>
  </g>
  <g id="labels" font-size="10" fill="black">
    <text x="40" y="195" text-anchor="middle">Q1</text>
    <text x="70" y="195" text-anchor="middle">Q2</text>
  </g>
</svg>

Избегайте overdraw и сложности

Overdraw (рисование полностью перекрытых фигур) тратит время рендеринга — удаляйте скрытые элементы. Упрощайте пути: используйте кривые C/Q вместо сотен крошечных отрезков; уменьшайте точность десятичных (10.499999 → 10.5). Для сложных иллюстраций подумайте, не будет ли растровое изображение меньше и быстрее. Профилируйте через paint profiler браузера.

svg
<!-- BAD: layered shapes that cover each other (overdraw) -->
<g>
  <rect width="100" height="100" fill="red"/>
  <rect width="100" height="100" fill="blue"/>  <!-- covers red -->
  <rect width="100" height="100" fill="green"/> <!-- covers blue -->
</g>
<!-- The red and blue are never visible but still rendered -->

<!-- GOOD: only draw what's visible -->
<rect width="100" height="100" fill="green"/>

<!-- BAD: path with 10,000 points for a simple shape -->
<path d="..."/>  <!-- over-tessellated -->

<!-- GOOD: simplify paths; use curves instead of many line segments -->
<path d="M 10 50 Q 50 10, 90 50"/>  <!-- one curve vs 100 lines -->

Тестирование и валидация

Тестируйте SVG как любой код: валидируйте XML, проверяйте рендеринг в разных браузерах (в Safari есть особенности с некоторыми фильтрами), тестируйте на разных размерах (иконки 16px и герои 500px), проверяйте вывод скринридера и размер файла (иконки должны быть меньше 2 КБ). Запускайте SVGO в CI, чтобы неоптимизированные SVG не уходили в продакшен. Немного тестов предотвращает сюрпризы в продакшене.

svg
<!-- 1. Validate SVG XML -->
<!-- Use the W3C validator: https://validator.w3.org/ -->

<!-- 2. Test in multiple browsers -->
<!-- Chrome, Firefox, Safari, Edge, (IE if required) -->

<!-- 3. Test at different sizes -->
<div style="width: 16px;"><svg>...</svg></div>  <!-- icon -->
<div style="width: 500px;"><svg>...</svg></div> <!-- hero -->

<!-- 4. Test with screen readers (VoiceOver, NVDA) -->

<!-- 5. Check file size after optimization -->
ls -la icon.svg  # should be under 2KB for simple icons

<!-- 6. Verify currentColor theming works -->
<!-- 7. Ensure no hardcoded dimensions block responsiveness -->

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.