Skip to content

SVG Folha de referência

Scalable Vector Graphics para imagens independentes de resolução.

01

Estrutura Básica

Esqueleto de Documento SVG

O atributo xmlns declara o namespace SVG. width/height definem o tamanho renderizado em pixels. viewBox define o sistema de coordenadas interno. SVG pode ser um arquivo .svg autônomo ou embutido inline no HTML, onde a declaração XML e o xmlns são opcionais.

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>

Embutindo SVG no HTML

SVG inline é o mais flexível — você pode estilizá-lo com CSS e scriptá-lo com JS, como o HTML. <img> e background-image tratam o SVG como imagem estática (sem CSS/JS interno). <object> o carrega como documento separado, com DOM próprio, permitindo algum scripting.

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>

Sistema de Coordenadas

SVG usa um sistema de coordenadas com origem no canto superior esquerdo: X para a direita, Y para baixo. O atributo viewBox define o espaço de coordenadas interno — o SVG escala o conteúdo para caber no width/height do elemento, então um viewBox de 0 0 100 100 num elemento de 200px renderiza tudo a 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>

Width, Height e Unidades

Unidades do usuário (sem sufixo) equivalem a px. Porcentagens são relativas ao pai. Para SVG responsivo, omita width/height e defina o viewBox — o SVG escala para o contêiner preservando a proporção. 'auto' no height com um viewBox mantém as proporções.

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>

Namespaces e xlink

SVG 2 introduziu suporte direto a href em <use>, <image> e <a>, tornando xlink:href obsoleto. Navegadores modernos suportam href puro. Mantenha o namespace xlink só se precisar suportar navegadores muito antigos. SVG inline no HTML não precisa estritamente do atributo 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 -->

Comentários e Metadados

<title> e <desc> fornecem texto de acessibilidade lido por leitores de tela — sempre inclua-os em SVGs significativos. <metadata> guarda dados estruturados (RDF, Dublin Core) para ferramentas. Comentários usam a mesma sintaxe <!-- --> do 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

Formas

Retângulo (rect)

rect exige x, y, width, height. rx/ry criam cantos arredondados (se só rx for definido, ry assume rx). fill='none' torna o interior transparente. stroke-width é centrado na borda, então metade se estende para fora da geometria.

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>

Círculo e Elipse

circle é definido pelo centro (cx, cy) e pelo raio r. ellipse tem rx e ry separados para esticar. Ambos assumem cx/cy = 0 se omitidos. Diferente do rect, círculos/elipses não podem ter cantos arredondados — já são curvos.

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>

Linha (line)

line liga dois pontos. Não tem fill (apenas stroke). stroke-dasharray cria linhas tracejadas — o padrão é 'comprimento-do-traço,comprimento-do-vão' repetido. stroke-linecap (butt, round, square) controla as pontas.

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 e Polygon

polyline desenha segmentos de linha ligados sem fechar a forma (o fill se aplica como se fechada, mas nenhum stroke liga as pontas). polygon fecha automaticamente, ligando o último ponto ao primeiro. points é uma lista de pares x,y separados por espaço ou vírgula.

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>

Atributos Comuns de Formas

fill e stroke são as duas principais propriedades de pintura. opacity afeta o elemento inteiro; fill-opacity e stroke-opacity agem de forma independente. stroke-linecap (butt/round/square) molda as pontas de linha; stroke-linejoin (miter/round/bevel) molda os cantos.

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>

Regras de Preenchimento (evenodd)

fill-rule determina como regiões sobrepostas de uma forma são preenchidas. 'nonzero' (padrão) preenche com base na direção do contorno. 'evenodd' preenche regiões envolvidas um número ímpar de vezes — isso cria o clássico efeito de 'furo de rosca' em paths que se cruzam e polígonos concêntricos.

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

Visão Geral dos Comandos de Path

O elemento <path> é a forma SVG mais poderosa — seu atributo d guarda uma string de comandos de desenho. Comandos maiúsculos usam coordenadas absolutas; minúsculos, coordenadas relativas à posição atual da caneta. M, L, C, Q, A, Z são os comandos centrais.

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 (Linhas)

M move a caneta sem desenhar. L desenha até um ponto. H/V desenham linhas horizontal/vertical (uma coordenada). Z fecha o path de volta ao início. As versões minúsculas (l, h, v, z) interpretam coordenadas como deslocamentos da posição atual, tornando subcaminhos reutilizáveis.

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 e S (Bézier Cúbica)

C desenha uma Bézier cúbica com dois pontos de controle que puxam a curva. O primeiro controle (x1,y1) afeta a tangente inicial; o segundo (x2,y2) afeta a tangente final. S continua suavemente espelhando o segundo ponto de controle da curva anterior — basta especificar o novo segundo controle e o ponto final.

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 e T (Bézier Quadrática)

Q usa um ponto de controle em vez de dois — mais simples, mas menos flexível que C. T continua um Q suavemente espelhando seu ponto de controle, exigindo apenas o ponto final. Curvas quadráticas são comuns em glifos de fontes e paths de ícones simples, onde um único ponto de controle basta.

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 (Arco)

A desenha um arco elíptico. rx, ry são os raios; x-rotation inclina a elipse. large-arc-flag (0/1) escolhe o arco mais curto ou mais longo entre os pontos. sweep-flag (0/1) escolhe anti-horário ou horário. Arcos são delicados — muitos designers usam curvas C em vez disso, pela previsibilidade.

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>

Exemplos Práticos de Path

Ícones reais combinam M, L, C e Z para traçar formas. O coração usa Béziers cúbicas para curvas suaves. O check são só três pontos com pontas de linha arredondadas. O balão de fala mistura linhas H/V para o retângulo e comandos L para a cauda. Comece simples e depois refine os pontos de controle.

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

Texto

Texto Básico

A coordenada y refere-se à linha de base do texto por padrão, não ao topo. text-anchor (start/middle/end) controla o alinhamento horizontal relativo a x. dominant-baseline (auto/middle/hanging/...) controla o alinhamento vertical. Ambos são essenciais para centralizar texto.

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>

Estilizando Texto

Texto SVG suporta a maioria das propriedades de fonte CSS como atributos. font-family aceita pilhas de fontes padrão. stroke no texto desenha um contorno — use um stroke-width pequeno para não ofuscar o fill. letter-spacing e word-spacing funcionam como no 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 (Subtexto)

<tspan> permite estilizar ou posicionar partes do texto de forma diferente — como <span> no HTML. dx/dy deslocam relativamente ao caractere anterior; x/y absolutos saltam para uma nova posição (use x com o valor original e dy para quebras de linha). tspan é como você constrói texto multilinha no 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>

Texto ao Longo de um Path

<textPath> renderiza texto ao longo de qualquer elemento path. Referencie o path por id via href (moderno) ou xlink:href (legado). startOffset (um comprimento ou porcentagem) posiciona o texto ao longo do path. É a técnica padrão para rótulos curvos em arcos, círculos ou formas personalizadas.

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>

Modo de Escrita e Direção

writing-mode='tb' faz o texto fluir de cima para baixo (comum na tipografia do Leste Asiático). direction='rtl' reverte a ordem dos caracteres para escritas da direita para a esquerda. Para rotação arbitrária, use o atributo transform — rotate(ângulo, cx, cy) gira em torno do ponto (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>

Acessibilidade de Texto

Texto SVG é selecionável e acessível por padrão, mas SVG decorativo deve ter <title> e <desc>. Para SVG inline usado como elementos de UI, adicione role='img' e aria-label para que leitores de tela anunciem o significado. Evite colocar informação essencial só em texto SVG — texto HTML é mais acessível.

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

Gradientes

Gradiente Linear

linearGradient transiciona cores ao longo de uma linha. x1/y1 até x2/y2 definem a direção (0% 0% até 100% 0% é da esquerda para a direita). Elementos <stop> definem os pontos de cor; offset vai de 0-100% ou 0-1. Referencie o gradiente com fill='url(#id)'. Gradientes devem viver em <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>

Gradiente Radial

radialGradient irradia de um ponto central. cx/cy é o centro, r é o raio. fx/fy é o ponto focal (onde a cor de 0% começa) — deslocá-lo cria um efeito de luz direcional. Padrões: cx/cy em 50%, r em 50%, fx/fy espelhando 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>

Unidades e Propagação do Gradiente

gradientUnits='objectBoundingBox' (padrão) torna as coordenadas relativas a cada forma (0-1), então o mesmo gradiente serve para qualquer elemento. 'userSpaceOnUse' usa coordenadas absolutas do SVG, então o gradiente é posicionado no documento — útil para alinhar gradientes entre múltiplas formas.

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 e Múltiplos Stops

Cada stop pode ter stop-opacity (0-1) para transições de transparência. Combine muitos stops para rampas de cor complexas. Este gradiente de pôr do sol vai de azul transparente no topo a vermelho escuro opaco embaixo — uma técnica comum para fundos atmosféricos.

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>

Reutilizando Gradientes

Defina um gradiente uma vez em <defs> e referencie-o em quantas formas quiser via fill='url(#id)'. Use href para derivar um novo gradiente de um existente, sobrescrevendo só alguns atributos (como a direção). Isso mantém seu SVG DRY e reduz o tamanho do arquivo.

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

Patterns

Pattern Básico

Um <pattern> ladrilha um gráfico repetido. Os filhos do pattern definem um ladrilho; width/height definem o tamanho do ladrilho. patternUnits='userSpaceOnUse' (recomendado) significa que as dimensões do ladrilho estão em unidades do usuário do SVG, independentes da forma preenchida. Referencie com 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>

Unidades do Pattern

patternUnits='objectBoundingBox' (padrão) dimensiona os ladrilhos como fração da forma — o pattern escala com cada forma. 'userSpaceOnUse' usa unidades absolutas, então o pattern é consistente entre formas, independentemente do tamanho. A maioria dos patterns reais usa 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>

Listras e Tabuleiro

patternTransform rotaciona, escala ou inclina o pattern inteiro. Para listras, preencha metade do ladrilho com uma cor e a outra metade com outra, depois rotacione. O tabuleiro usa quatro rects (ou dois pares em L) por ladrilho. Esses patterns são comuns em diagramas e texturas.

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

patternContentUnits controla o sistema de coordenadas dos elementos filhos do pattern (não o tamanho do ladrilho). 'objectBoundingBox' torna as coordenadas dos filhos frações da forma — útil quando você quer que o detalhe do pattern escale proporcionalmente com cada forma. Raro, mas poderoso.

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>

Patterns Aninhados

Patterns podem conter gradientes, outros patterns ou qualquer conteúdo SVG. Este pattern de grade preenche cada célula com um gradiente sutil e desenha linhas de grade por cima. O aninhamento permite construir texturas complexas. Mantenha os ladrilhos de tamanho razoável para evitar problemas de desempenho com ladrilhos muito pequenos.

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) move um elemento por tx, ty. Se ty for omitido, assume 0. A transformação se aplica ao sistema de coordenadas do elemento, então os atributos x/y ficam relativos à origem transladada. Transformações CSS (via style) funcionam em SVG inline em navegadores modernos e podem ser animadas com transições 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(ângulo, cx, cy) gira por ângulo graus em torno do ponto (cx, cy). Sem cx/cy, gira em torno da origem (0,0), o que geralmente não é o que você quer. Ângulos são horários (positivos) ou anti-horários (negativos). Sempre especifique o centro para girar um elemento no lugar.

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 e Skew

scale(sx, sy) multiplica as dimensões; um argumento escala ambos igualmente. Escalar também afeta stroke-width e posições. skewX/skewY cisalham o elemento ao longo de um eixo por um ângulo. Todas as transformações são relativas à origem (0,0), então escalar uma forma em x=100 também a move.

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>

Transformação Matrix

matrix(a,b,c,d,e,f) é a forma subjacente de todas as transformações. a,d escalam; b,c inclinam (skew); e,f transladam. A maioria dos desenvolvedores usa as transformações nomeadas (translate, rotate etc.) por legibilidade, mas matrix é o que as ferramentas geram e é útil para combinar transformações ou fazer parsing.

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>

Combinando Transformações

Múltiplas transformações no atributo se aplicam da direita para a esquerda (a mais à direita acontece primeiro). Isso significa que 'translate(100,100) rotate(45)' gira a forma em torno da própria origem primeiro e depois a move — geralmente o que você quer. Transformações CSS com transform-origin costumam ser mais intuitivas para SVG 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)

Ao animar SVG com CSS, defina transform-origin explicitamente (em unidades do usuário do SVG) e transform-box (fill-box para a bounding box do elemento, view-box para a tela do SVG). Sem isso, a rotação se centra na origem do SVG, não do elemento. Animações e transições CSS funcionam em SVG 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>
08

Grupo (g)

Agrupamento Básico

<g> agrupa elementos para que compartilhem atributos (fill, stroke, transform etc.) e possam ser manipulados como unidade. Os filhos herdam atributos de apresentação do grupo. Grupos são essenciais para organizar SVGs complexos e aplicar transformações a várias formas de uma vez.

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>

Transformações de Grupo

Uma transformação em <g> cria um novo sistema de coordenadas para seus filhos. Essa é a chave para construir componentes reutilizáveis: desenhe em torno de (0,0) e depois posicione o grupo inteiro com translate. As coordenadas dos filhos são relativas à origem transformada do grupo.

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>

Grupos Aninhados

Grupos podem se aninhar arbitrariamente. Cada transformação aninhada se compõe — o elemento mais interno é afetado por todas as transformações ancestrais, em ordem. É assim que você constrói cenas hierárquicas (ex.: um personagem com membros rotativos, cada membro com mãos móveis). Mantenha o aninhamento razoável, pelo desempenho.

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>

IDs e Referências de Grupo

Dê a um grupo um id e referencie-o com <use href='#id'> para duplicá-lo. Esta é a base dos sprites SVG e dos componentes reutilizáveis. O grupo pode viver em <defs> (não renderizado diretamente) e ser instanciado muitas vezes com transformações diferentes. Sobrescrever atributos em <use> é limitado.

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>

Grupos Condicionais

Grupos com ids são pontos de gancho perfeitos para CSS (hover, estados ativos) e tratamento de eventos em JavaScript. Trate um <g> como componente: reúna suas formas, dê um id e interaja com ele como unidade. Listeners de evento num grupo capturam eventos de cada um dos filhos.

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>

Group vs Symbol

<symbol> é feito sob medida para ícones reutilizáveis: nunca é renderizado diretamente e tem viewBox próprio, então <use> pode dimensioná-lo independentemente. <g> em <defs> também funciona, mas não tem o recurso de viewBox. Para sistemas de ícones, prefira <symbol> — ele cuida de escala e proporção automaticamente.

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

Elemento defs

<defs> guarda definições reutilizáveis que não são desenhadas até serem referenciadas: gradientes, patterns, filtros, clip paths, máscaras, symbols e grupos. Colocá-los em defs mantém a saída renderizada limpa e sinaliza a intenção. Qualquer coisa fora de defs renderiza imediatamente.

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>

Elemento use

<use> clona e renderiza um elemento definido (g, symbol ou qualquer forma). x/y posicionam a instância. fill/stroke em <use> sobrescrevem o original apenas se o original não os especificou (herança CSS). transform aplica-se à instância. É assim que sprites SVG funcionam.

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>

Elemento symbol

<symbol> define um gráfico reutilizável com viewBox próprio. Diferente de <g>, nunca é renderizado diretamente e escala para caber nas dimensões do elemento <use>. fill='currentColor' deixa o consumidor definir a cor via color CSS. Este é o padrão de sistemas de ícones 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>

Referências SVG Externas

<use> pode referenciar symbols em arquivos SVG externos via href='file.svg#id'. Porém, o suporte dos navegadores é irregular (nada de IE, restrições de CORS) e quebra com file://. A abordagem confiável é embutir um sprite SVG oculto no topo do HTML e referenciar os symbols no mesmo documento.

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

Sobrescrevendo Atributos do Use

Quando a forma original omite um atributo de apresentação (como fill), <use> pode defini-lo — a instância herda o valor. Se o original especifica fill, o fill do use é ignorado (atributos de apresentação vencem a herança CSS). Para symbols personalizáveis, omita os atributos que quer sobrescrever.

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>

Aninhamento de Symbol e Sprite

Este é o padrão de produção para ícones SVG: um sprite SVG oculto no topo do documento contendo cada um dos ícones como <symbol>s, e <use> para renderizá-los em qualquer lugar. currentColor faz os ícones herdarem a cor do texto. CSS controla o tamanho. O sprite é cacheado após o primeiro carregamento, rápido em toda página.

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

Filtros

Básico de Filtros

Um <filter> contém uma ou mais primitivas de filtro (elementos fe*) que processam o gráfico. in='SourceGraphic' pega o próprio render do elemento. Aplique com filter='url(#id)'. Filtros podem ser caros — use com parcimônia em elementos pequenos, não em fundos grandes.

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>

Sombra Projetada (Drop Shadow)

Uma drop shadow combina feOffset (mover), feGaussianBlur (suavizar), feFlood (cor), feComposite (aplicar cor à sombra) e feMerge (camada da sombra sob o original). O x/y/width/height do filtro (padrão -10% a 110%) precisa ser ampliado, senão a sombra é cortada.

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>

Sombra Simples (CSS)

Para sombras simples em SVG inline, o filter: drop-shadow() do CSS é muito mais simples que construir um filtro SVG. Ele respeita o contorno real da forma (não apenas a bounding box, como box-shadow). Use filtros SVG só para efeitos complexos de múltiplos passos que o CSS não expressa.

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

Color Matrix

feColorMatrix transforma cores via uma matriz 5x4 (RGBA entra, RGBA sai). type='saturate' com valores 0-1 dessatura; type='hueRotate' rotaciona o matiz em graus; type='luminanceToAlpha' converte brilho em alfa. Útil para tons de cinza, sépia e ajustes de cor em conteúdo 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>

Efeitos de Iluminação

feSpecularLighting e feDiffuseLighting simulam iluminação 3D no mapa de altura de uma forma 2D (derivado do alfa). surfaceScale controla a profundidade; o elemento de luz (fePointLight, feDistantLight, feSpotLight) define a direção. Combinado com feComposite, você obtém efeitos de relevo, bisel e texto 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>

Turbulência (Textura)

feTurbulence gera ruído procedural (tipo fractal ou turbulência) — útil para texturas como estática, nuvens, água ou granulado de papel. baseFrequency controla a escala (0.5 = fino, 0.05 = nublado). numOctaves adiciona detalhe ao custo de velocidade. Combine com feColorMatrix ou feDisplacementMap para efeitos.

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

Recorte e Máscara

Clip Path

clipPath define um limite de borda dura — pixels dentro são visíveis, fora são ocultos. A forma de recorte em si não é desenhada. clip-path a referencia via url(#id). O recorte é binário (dentro ou fora); para transições suaves, use máscaras. Texto como clip path cria o clássico efeito 'imagem dentro do texto'.

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>

Mask

Diferente do clip-path (binário), máscaras suportam alfa — áreas brancas são totalmente visíveis, áreas pretas ocultas, cinzas parcialmente transparentes. Use um gradiente como conteúdo da máscara para desvanecimentos suaves. Máscaras são mais pesadas que clip paths, mas essenciais para transições suaves e efeitos fotográficos.

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>

Unidades do Clip Path

clipPathUnits='objectBoundingBox' faz o clip path escalar para a bounding box de cada elemento (coordenadas 0-1), então um único clip path serve para formas de tamanhos diferentes. 'userSpaceOnUse' (padrão) usa coordenadas absolutas do SVG. A maioria dos recortes reutilizáveis usa 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>

clip-path do CSS

O clip-path do CSS suporta formas básicas (circle, ellipse, polygon, inset) diretamente, sem SVG, e pode referenciar elementos clipPath do SVG via url(#id). Funciona em elementos HTML também, não só SVG. Mascarar via CSS também é suportado em navegadores modernos por meio de 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>

Prático: Imagem no Texto

Recortar um gradiente ou imagem para dentro do texto é uma técnica de design popular. O clipPath contém um elemento <text>; o rect recortado se preenche com o gradiente, visível apenas dentro das formas das letras. Funciona com <image> também — ponha uma foto dentro do texto para cabeçalhos estilo revista.

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

Animação (SMIL)

animate (Básico)

<animate> transiciona um atributo ao longo do tempo. attributeName é o alvo; from/to definem o intervalo; dur é a duração; repeatCount='indefinite' repete para sempre. Animações SMIL são declarativas (sem JS) e funcionam na maioria dos navegadores, exceto IE. A animação vive como filha do elemento alvo.

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> anima o atributo transform. type seleciona a operação (rotate, scale, translate, skewX, skewY). Para rotate, from/to são 'ângulo cx cy' (ponto central). É assim que você gira elementos sem JavaScript. Só um animateTransform pode rodar por elemento, a menos que use 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> move um elemento ao longo de um path. Referencie o path com <mpath href='#id'> ou defina path diretamente. rotate='auto' orienta o elemento a encarar a direção do movimento — essencial para setas, carros ou personagens. Esta é a forma SVG de fazer animação por path sem 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>

Keyframes e Easing

Para animações de múltiplos passos, use values (separados por ponto e vírgula), keyTimes (frações 0-1) e keySplines (easing Bézier por segmento). calcMode='spline' habilita easing; 'linear' é o padrão. Isso espelha a animação por keyframes do CSS, mas em SVG puro. O rect quica para frente e para trás com easing suave.

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 e Gatilhos

begin pode ser um atraso de tempo (2s), um evento (click, mouseenter) ou uma referência ao evento de outra animação (anim1.end, anim1.begin+1s). fill='freeze' segura o valor final depois que a animação termina (caso contrário, ela volta ao estado inicial). Isso permite animações acionadas por clique e encadeadas, sem 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>

Alternativa com Animação CSS

Para SVG inline em páginas web, animações CSS costumam ser mais simples que SMIL e têm melhores ferramentas. Use transform-box: fill-box para que transform-origin: center se refira ao elemento, não à tela do SVG. SMIL continua útil para arquivos SVG autônomos (sem CSS disponível) e movimento por path.

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

Eventos

Eventos de Mouse

Elementos SVG suportam eventos DOM padrão: click, mouseenter, mouseleave, mousemove, mousedown, mouseup, dblclick. Use addEventListener como faria em elementos HTML. 'this' dentro de um handler refere-se ao elemento SVG. Use setAttribute para mudar propriedades de forma reativa.

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>

Eventos de Toque

SVG suporta touchstart, touchmove, touchend. Converta coordenadas de tela para coordenadas SVG usando createSVGPoint e getScreenCTM().inverse() — essencial quando o SVG é escalado ou responsivo. preventDefault() no touchstart evita interferência de gestos como rolagem.

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>

Conversão de Coordenadas

Quando um SVG tem viewBox diferente do tamanho em pixels, as coordenadas de tela não mapeiam 1:1 para as coordenadas SVG. createSVGPoint + getScreenCTM().inverse() converte corretamente, considerando viewBox, escala CSS e até transformações em elementos ancestrais. Essencial para detecção de cliques precisa.

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>

Delegação de Eventos

Delegação de eventos — um listener num grupo pai em vez de muitos nos filhos — é mais eficiente e trata formas adicionadas dinamicamente automaticamente. e.target é a forma clicada; e.currentTarget é o elemento com o listener. Use atributos data-* para guardar metadados por forma.

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>

Interação de Arrastar

Este é o padrão clássico de arrastar em SVG: mousedown define uma flag, mousemove atualiza a posição do elemento (usando coordenadas SVG convertidas), mouseup limpa a flag. Anexe mousemove/mouseup ao SVG (não ao elemento) para que o arrasto continue mesmo quando o cursor sai da forma. Esta é a fundação dos editores baseados em 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

DOM com JavaScript

Criando Elementos

Elementos SVG devem ser criados com document.createElementNS(namespace, tagName) — createElement não funciona para SVG (cria elementos HTML desconhecidos). O namespace SVG é 'http://www.w3.org/2000/svg'. Use setAttribute para propriedades. Esta é a fundação da geração dinâmica de 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>

Modificando Elementos

Use setAttribute/getAttribute para atributos de apresentação SVG (fill, stroke, width etc.). classList funciona de forma confiável entre navegadores. Definir style.fill funciona porque mapeia para a propriedade CSS. Evite innerHTML para SVG (inconsistente entre navegadores); construa o DOM com 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>

Lendo Geometria

getBBox() retorna a bounding box em unidades do usuário do SVG (ignorando transformações). getBoundingClientRect() retorna coordenadas de tela (após todas as transformações e CSS). getTotalLength() dá o comprimento de path/linha; getPointAtLength(d) retorna o ponto na distância d — essencial para animações por path e teste de acerto.

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 e Atributos de Dados

Elementos SVG suportam atributos data-* e a propriedade dataset como o HTML. Esta é a forma limpa de associar dados a formas em aplicações interativas — guarde IDs de nós, rótulos ou estado sem poluir os atributos visuais. Leia com element.dataset.chave, defina igual.

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>

Geração Dinâmica de Paths

Gerar SVG dinamicamente é a base de gráficos personalizados. Construa o atributo d do path concatenando comandos M/L a partir dos seus dados e crie o elemento com createElementNS. Essa abordagem dá controle total sem biblioteca de gráficos. Para visualizações complexas, considere D3.js, que embrulha esse padrão com elegância.

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>

Dicas de Desempenho

Para desempenho: agrupe inserções no DOM com DocumentFragment (um único reflow), use requestAnimationFrame para animações JS (sincroniza com a atualização da tela) e evite consultar atributos em loops apertados (cacheie valores). SVG vai bem até algumas centenas de elementos; para milhares (partículas, gráficos densos), Canvas ou WebGL é mais rápido.

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 Responsivo (ViewBox)

Básico de viewBox

viewBox='minX minY width height' define o sistema de coordenadas interno. Os dois primeiros valores panoramizam a visão; os dois últimos dão zoom. O SVG escala essa região para caber no seu width/height. Isso desacopla suas coordenadas de desenho do tamanho renderizado — desenhe uma vez em qualquer escala, numa caixa 100x100 ou 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 controla como o viewBox se encaixa no elemento quando as proporções diferem. 'meet' (padrão) encaixa por inteiro, criando barras no excesso. 'slice' preenche por inteiro, cortando o excedente. 'none' estica, distorcendo. A parte xMidYMid controla o alinhamento: Min/Mid/Max para ambos os eixos.

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 Totalmente Responsivo

Para SVG responsivo: omita os atributos width/height, defina o viewBox e controle o tamanho com CSS (width: 100%, height: auto). O SVG escala para o contêiner preservando a proporção. display: block remove o vão de linha de base do SVG inline. Este é o padrão padrão para SVG fluido em layouts responsivos.

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 Aninhado e overflow

Elementos <svg> aninhados criam viewports independentes, com viewBox e preserveAspectRatio próprios. Isso é poderoso para gráficos com painéis de proporção fixa ou componentes de UI. overflow='visible' deixa o conteúdo desenhar fora do viewport aninhado (o padrão é oculto). Cada svg aninhado pode escalar seu conteúdo independentemente.

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>

Tamanho de Texto Fluida

Tamanhos de fonte dentro de um SVG com viewBox escalam com o SVG — uma fonte de 20px num viewBox de 400 de largura exibido a 800px renderiza a 40px. Para tornar o texto responsivo ao viewport do navegador (não do SVG), use unidades de viewport CSS (vw, vh) num atributo style. É assim que manchetes SVG escalam fluidamente.

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

Controle de Proporção

Combine aspect-ratio CSS no contêiner com width/height 100% no SVG para comportamento responsivo previsível. Isso previne deslocamento de layout (CLS) ao reservar espaço antes do SVG carregar. O viewBox corresponde à proporção, para que o conteúdo não distorça. É a boa prática moderna para embeds responsivos de 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 vs Canvas

Modelo de Renderização

SVG é modo retido: cada forma é um elemento DOM que você pode inspecionar, estilizar e reanimar depois. Canvas é modo imediato: você emite comandos de desenho que pintam pixels, e as formas não persistem como objetos. SVG é melhor para UI interativa; Canvas é melhor para milhares de pixels dinâmicos.

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>

Quando Usar SVG

Escolha SVG para: gráficos independentes de resolução (ícones, logos), acessibilidade (leitores de tela percorrem o DOM), interatividade (eventos por forma), SEO (texto é selecionável) e contagens moderadas de elementos (até algumas centenas). Arquivos SVG são texto (comprimem bem com gzip) e editáveis em ferramentas de design.

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

Quando Usar Canvas

Escolha Canvas para: contagens altas de elementos (milhares de formas), redesenhos por quadro (jogos, partículas), manipulação de pixels (filtros, efeitos) e quando você não precisa de acessibilidade via DOM. Canvas é mais rápido para puro rendimento de pixels, mas mais difícil de tornar acessível ou interativo no nível de forma individual.

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>

Comparação de Desempenho

O desempenho do SVG degrada com a contagem de elementos, porque cada forma é um nó DOM com tratamento de eventos, estilização e layout. O Canvas tem custo constante por quadro, independentemente da contagem de formas. O ponto de cruzamento fica em torno de 500-2000 elementos, dependendo da complexidade. Para gráficos estáticos ou levemente animados, SVG serve; para cenas densas em tempo real, use 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)
-->

Abordagem Híbrida

Combine ambos: Canvas para a camada densa e redesenhada com frequência (mapa de calor, partículas) e SVG sobreposto para UI interativa (tooltips, alças de seleção, rótulos). A camada SVG permanece nítida e acessível enquanto o Canvas cuida do trabalho pesado de pixels. Esse padrão é usado por bibliotecas de mapas como Leaflet e ferramentas de gráficos como 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>

Comparação de Acessibilidade

SVG é inerentemente mais acessível: o DOM é percorrível, o texto é selecionável e pesquisável, e <title>/<desc> fornecem descrições. Canvas exige trabalho extra — você precisa adicionar role/aria-label e fornecer conteúdo de texto alternativo dentro da tag <canvas>. Para gráficos e visualizações de dados, a acessibilidade do SVG é uma grande vantagem.

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

Sprite SVG

Configuração de Sprite Inline

Defina cada um dos ícones como elementos <symbol> dentro de um SVG oculto no topo da página. Cada symbol tem viewBox e id próprios. O sprite carrega uma vez e fica em cache pela sessão. Usar currentColor para fill/stroke permite que cada uso herde a cor do texto ao redor, tornando o tematização trivial.

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>

Usando Ícones do Sprite

Cada <use> instancia um ícone. A classe CSS .icon define um tamanho padrão; subclasses sobrescrevem para variantes. Como os symbols usam fill='currentColor', a cor do ícone segue a propriedade color do CSS — defina color num botão e seu ícone acompanha. É assim que os grandes sistemas de ícones (GitHub, Bootstrap) funcionam.

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>

Sprite de Arquivo Externo

Referências de sprite externas (href='file.svg#id') têm suporte irregular nos navegadores e problemas de CORS. A abordagem robusta: busque o arquivo de sprite e injete-o como HTML inline no topo do body. Isso cacheia via HTTP e funciona em qualquer lugar. Muitas ferramentas de build (svg-sprite-loader, gulp-svg-sprite) automatizam isso.

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>

Geração de Sprite em Tempo de Build

Ferramentas de build automatizam a criação de sprites: solte arquivos .svg individuais numa pasta e a ferramenta os concatena num sprite com wrappers <symbol> adequados. svg-sprite-loader (webpack), gulp-svg-sprite e vite-plugin-svg são populares. Isso mantém os ícones como arquivos separados no desenvolvimento, mas os empacota para produção.

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

Acessibilidade para Ícones de Sprite

Para acessibilidade: se um ícone é puramente decorativo (ao lado de texto), marque-o aria-hidden='true'. Se ele transmite significado sozinho, adicione role='img' e aria-label no <svg>. Para botões só com ícone, ponha o aria-label no <button>, não no SVG. Nunca confie no ícone sozinho sem um nome acessível.

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>

Ícones Bicolor e Multicoloridos

Ícones multicoloridos são delicados com sprites, porque os clones de <use> têm limites de sobrescrita. Para ícones bicolor, use currentColor para o primário e uma cor fixa para o secundário. Propriedades personalizadas CSS (variáveis) dentro do symbol deixam os consumidores sobrescreverem partes específicas — uma técnica moderna para tematização flexível.

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

Otimização de SVG

CLI do SVGO

SVGO é o otimizador de SVG padrão. Remove metadados, comentários, sujeira de editores (namespaces Inkscape/Illustrator), defs não usados e atributos redundantes, frequentemente cortando 30-60% do tamanho do arquivo. Rode em cada um dos SVGs de produção. Use --show-plugins para ver o que ele faz, e um arquivo de config para habilitar/desabilitar otimizações específicas.

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

Otimizações Comuns

SVGO remove: declarações XML, comentários e namespaces de editores (Adobe, Inkscape), metadados, xlink não usado, enable-background, xml:space, fill-rule='nonzero' redundante (é o padrão). Ele encurta valores de cor (#FF0000 → red), colapsa espaços em branco e mescla paths. O resultado é semanticamente idêntico, mas muito menor.

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>

Otimização de Paths

SVGO converte coordenadas absolutas em relativas quando mais curtas, usa H/V em vez de L para linhas horizontal/vertical, remove decimais desnecessários e pode mesclar paths com formas idênticas. Essas otimizações de path frequentemente cortam o comprimento da string pela metade. O plugin 'convertPath' cuida disso; fica ligado por padrão.

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

Agrupamento e Herança

Mova atributos compartilhados (fill, stroke, font) para um <g> pai para que os filhos os herdem. Isso reduz o tamanho do arquivo e facilita mudanças de estilo em massa. Os plugins 'mergePaths' e 'moveElemsAttrsToGroup' do SVGO automatizam isso. Ao escrever SVG à mão, agrupe desde o início — é mais limpo e mais sustentável.

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 e Entrega

SVG comprime 70-90% com gzip, por ser texto XML repetitivo. Garanta que seu servidor web comprima image/svg+xml com gzip ou brotli. Para entrega: embuta inline os SVGs críticos (above-the-fold) para evitar uma requisição que bloqueia o render; use <img loading='lazy'> para ilustrações abaixo da dobra. Cacheie SVG agressivamente — raramente muda.

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

Arquivo de Config do SVGO

Um arquivo de config personaliza o SVGO. Ajustes comuns: manter viewBox (removeViewBox fica ligado por padrão — DESLIGUE-o para a responsividade funcionar), remover width/height para SVGs fluidos (removeDimensions) e habilitar cleanupIDs para sprites (encurta os nomes de id). multipass roda as otimizações até estabilizar, para a menor saída.

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

Boas Práticas

Essenciais de Acessibilidade

Para SVG acessível: adicione <title> e <desc>, referencie-os via aria-labelledby, defina role='img' para que leitores de tela anunciem o SVG como imagem, e adicione focusable='false' para evitar problemas de parada de tab no IE/Edge. SVGs decorativos devem ser aria-hidden='true'. Essas práticas tornam o SVG utilizável com tecnologia assistiva.

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

Use viewBox, Não width/height

Sempre inclua viewBox — ele define o sistema de coordenadas interno e habilita a escala. Para ícones, defina width/height via CSS (não atributos) para que o mesmo SVG funcione em qualquer tamanho. Para gráficos responsivos, omita width/height por completo e use width:100%; height:auto no CSS. O plugin removeDimensions do SVGO impõe isso.

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 para Tematização

Use fill='currentColor' (ou stroke) para que os ícones herdem a cor do texto ao redor. Isso torna o tematização trivial — defina color num pai e cada um dos ícones acompanham. Também permite estados hover/active via transições de cor CSS. Evite cores fixadas no código em symbols reutilizáveis, a menos que sejam intencionalmente fixas (como um logo de marca).

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>

Agrupamento Semântico

Agrupe elementos pelo papel lógico (fundo, eixos, dados, rótulos) com ids significativos, não apenas por tipo de forma. Isso torna o SVG mais fácil de manter, estilizar e scriptar — você pode mostrar/esconder ou reestilizar grupos inteiros. Também ajuda na acessibilidade (aria-labelledby nos grupos) e na depuração.

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>

Evite Overdraw e Complexidade

Overdraw (desenhar formas totalmente cobertas) desperdiça tempo de renderização — remova elementos ocultos. Simplifique paths: use curvas C/Q em vez de centenas de segmentos minúsculos de linha; reduza a precisão decimal (10.499999 → 10.5). Para ilustrações complexas, considere se uma imagem raster seria menor e mais rápida. Faça profiling com o paint profiler do navegador.

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

Testes e Validação

Teste SVGs como qualquer código: valide o XML, verifique a renderização entre navegadores (o Safari tem peculiaridades com alguns filtros), teste em vários tamanhos (ícones de 16px vs heróis de 500px), verifique a saída do leitor de tela e confira o tamanho do arquivo (ícones devem ficar abaixo de 2KB). Rode SVGO no CI para impedir que SVGs não otimizados sejam publicados. Um pouco de teste evita surpresas em produção.

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.