Базовая структура
Скелет SVG-документа
Атрибут xmlns объявляет пространство имён SVG. width/height задают размер рендеринга в пикселях. viewBox определяет внутреннюю систему координат. SVG может быть отдельным .svg-файлом или встроен в HTML inline, где XML-декларация и xmlns необязательны.
<?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, допуская часть скриптования.
<!-- 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 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 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 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 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>Фигуры
Прямоугольник (rect)
rect требует x, y, width, height. rx/ry создают скруглённые углы (если задан только rx, ry по умолчанию равен rx). fill='none' делает внутреннюю часть прозрачной. stroke-width центрируется на крае, поэтому половина выходит за геометрию.
<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 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 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 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 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 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>Path
Обзор команд path
Элемент <path> — самая мощная фигура SVG: его атрибут d хранит строку команд рисования. Команды в верхнем регистре используют абсолютные координаты; в нижнем — координаты относительно текущей позиции пера. M, L, C, Q, A, Z — базовые команды.
<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 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 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 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 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 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>Текст
Базовый текст
Координата y по умолчанию относится к базовой линии текста, а не к верху. text-anchor (start/middle/end) управляет горизонтальным выравниванием относительно x. dominant-baseline (auto/middle/hanging/...) управляет вертикальным выравниванием. Оба нужны для центрирования текста.
<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 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 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 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 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 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>Градиенты
Линейный градиент
linearGradient меняет цвета вдоль линии. x1/y1 до x2/y2 задают направление (0% 0% до 100% 0% — слева направо). Элементы <stop> задают цветовые точки; offset — 0–100% или 0–1. Ссылайтесь на градиент через fill='url(#id)'. Градиенты должны находиться в <defs>.
<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 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 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 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 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>Паттерны
Базовый паттерн
<pattern> заполняет фигуру повторяющимся рисунком. Дочерние элементы паттерна определяют одну плитку; width/height задают размер плитки. patternUnits='userSpaceOnUse' (рекомендуется) означает, что размеры плитки в пользовательских единицах SVG, независимо от заливаемой фигуры. Ссылка — fill='url(#id)'.
<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 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 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 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 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>Transform
Translate
translate(tx, ty) сдвигает элемент на tx, ty. Если ty опущен, он равен 0. Трансформация применяется к системе координат элемента, поэтому атрибуты x/y относительны сдвинутого начала. CSS-трансформации (через style) работают на inline SVG в современных браузерах и могут анимироваться CSS-переходами.
<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 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 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 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 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 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>Группа (g)
Базовая группировка
<g> группирует элементы, чтобы они делили атрибуты (fill, stroke, transform и т. д.) и управлялись как единое целое. Дети наследуют презентационные атрибуты группы. Группы необходимы для организации сложных 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 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 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 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 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 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>Use / Symbol / Defs
Элемент defs
<defs> хранит переиспользуемые определения, которые не рисуются до ссылки на них: градиенты, паттерны, фильтры, clip path, маски, символы и группы. Хранение в defs оставляет отрисованный вывод чистым и отражает намерение. Всё вне defs рендерится сразу.
<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 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.
<!-- 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 и ссылаться на символы в том же документе.
<!-- 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 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 управляет размером. Спрайт кэшируется после первой загрузки и быстр на каждой странице.
<!-- 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>Фильтры
Основы фильтров
<filter> содержит один или несколько фильтрующих примитивов (элементы fe*), обрабатывающих графику. in='SourceGraphic' берёт собственный рендеринг элемента. Применяется через filter='url(#id)'. Фильтры могут быть дорогими — используйте умеренно на небольших элементах, а не на больших фонах.
<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 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 не выразить.
<!-- 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 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 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 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>Обрезка и маскирование
Clip path
clipPath задаёт границу с жёсткими краями — пиксели внутри видны, снаружи скрыты. Сама фигура обрезки не рисуется. clip-path ссылается на неё через url(#id). Обрезка бинарна (внутри или снаружи); для мягких переходов используйте маски. Текст как clip path создаёт классический эффект «изображение внутри текста».
<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 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 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.
<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 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>Анимация (SMIL)
animate (базово)
<animate> со временем меняет атрибут. attributeName — цель; from/to задают диапазон; dur — длительность; repeatCount='indefinite' зацикливает навсегда. SMIL-анимации декларативны (JS не нужен) и работают в большинстве браузеров, кроме IE. Анимация живёт как дочерний элемент цели.
<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 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 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 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 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 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 -->События
События мыши
Элементы SVG поддерживают стандартные DOM-события: click, mouseenter, mouseleave, mousemove, mousedown, mouseup, dblclick. Используйте addEventListener как на HTML-элементах. 'this' внутри обработчика указывает на элемент SVG. Меняйте свойства реактивно через setAttribute.
<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 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 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 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 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>JavaScript и DOM
Создание элементов
Элементы SVG нужно создавать через document.createElementNS(namespace, tagName) — createElement для SVG не работает (создаёт неизвестные HTML-элементы). Пространство имён SVG — 'http://www.w3.org/2000/svg'. Для свойств используйте setAttribute. Это основа динамической генерации SVG.