ToolDeck

HTML Minifier

Minifiera HTML genom att ta bort blanksteg och kommentarer

Prova ett exempel

HTML-indata

Minifierad HTML

Körs lokalt · Säkert att klistra in hemligheter
Minifierad HTML visas här…

Vad är HTML-minifiering?

HTML-minifiering är processen att minska storleken på ett HTML-dokument utan att ändra hur webbläsaren renderar det. En HTML-minifierare tar bort tecken som bara finns till för utvecklarens läsbarhet: blanksteg mellan taggar, kommentarer, valfria sluttaggar och redundanta attributvärden. Resultatet är funktionellt identiskt med källkoden men mindre i bytestorlek, vilket innebär snabbare nedladdningar och kortare tid till first-paint för användarna.

Webbläsare tolkar HTML till ett DOM-träd och kasserar det mesta av blankstegen under den processen. En sekvens av mellanslag och radbrytningar mellan två div-taggar har ingen visuell effekt på den renderade sidan. Kommentarer ignoreras också av parsern. Minifiering utnyttjar dessa regler och tar bort det som parsern ändå skulle kasta bort, så att det aldrig behöver överföras via nätverket.

Besparingarna från HTML-minifiering varierar beroende på dokument. Tätt kommenterade mallar, serverrenderade sidor med djup indragning och CMS-utdata med inbundna stilar ser ofta en 15–30 % storleksminskning enbart från minifiering. För små dokument är de absoluta besparingarna blygsamma, men på sajter med hög trafik ger även ett par kilobyte per sidinläsning verkliga bandbreddsbesparingar över miljontals förfrågningar.

Varför använda den här HTML-minifieraren?

Klistra in din HTML och få minifierat resultat direkt. Inga byggverktyg att installera, inga konfigurationsfiler, inga konton.

Omedelbara resultat
Utdata visas medan du skriver. Klistra in en hel sida eller ett enstaka kodavsnitt och se det minifierade resultatet utan att vänta på ett CLI-kommando eller ett byggsteg.
🔒
Integritetsbaserad bearbetning
All minifiering körs i din webbläsare med JavaScript. Din HTML lämnar aldrig din enhet. Säkert att använda med kod som innehåller interna URL:er, tokens eller kunddata.
📊
Storleksrapportering
Se original- och minifierade byteantal sida vid sida. Vet exakt hur många byte du sparade innan du bestämmer dig för att använda den minifierade versionen.
📋
Kopiera med ett klick
Kopiera det minifierade resultatet till urklipp med ett klick. Klistra in det i din driftsättningspipeline, bädda in det i en e-postmall eller inchecka det direkt.

Användningsfall för HTML Minifier

Frontendutveckling
Minifiera HTML-mallar innan du driftsätter till produktion. Minska nyttolasten för serverrenderade sidor, utdata från statiska webbplatsgeneratorer eller skal för enkelsidiga applikationer.
Backendteknik
Ta bort kommentarer och blanksteg från HTML-svar genererade av ramverk på serversidan som Django, Rails eller Laravel innan de skickas till klienter.
DevOps och CI-pipelines
Lägg till ett HTML-minifieringssteg i din byggpipeline. Verifiera att utdata renderas korrekt efter minifiering innan du publicerar till staging eller produktion.
QA och testning
Jämför minifierat utdata från två byggen för att kontrollera oväntade strukturella förändringar. Minifiering normaliserar blanksteg, vilket gör strukturella diff:ar renare.
Optimering av e-postmallar
E-postklienter sätter storleksgränser på HTML-e-post (Gmail klipper meddelanden över 102 KB). Minifiera e-postmallar för att hålla dig under gränsen med allt innehåll intakt.
Lära sig webbprestanda
Studenter kan klistra in HTML och se vilka delar som tas bort vid minifiering. Detta lär ut vilka tecken som är semantiskt meningsfulla för webbläsare och vilka som är rent kosmetiska.

Vad HTML-minifiering tar bort

En fullständig HTML-minifierare tillämpar flera omvandlingar utöver borttagning av blanksteg. Tabellen nedan listar de vanligaste teknikerna, ordnade från säkraste (alltid förlustfria) till mest aggressiva (kan bryta kantfall om de tillämpas okritiskt).

TeknikFöreEfter
Whitespace between tags<div> <p> text </p> </div><div><p>text</p></div>
HTML comments<!-- TODO: fix later -->(removed entirely)
Redundant attribute quotesclass="main"class=main
Boolean attribute valuesdisabled="disabled"disabled
Empty attribute valuesid=""(attribute removed)
Optional closing tags</li>, </td>, </p>(removed when safe)
Type on script/styletype="text/javascript"(removed — default)
Protocol in URLshttps://cdn.example.com//cdn.example.com

Minifiering kontra Gzip-komprimering

Utvecklare frågar ibland om minifiering fortfarande är nödvändigt när servern redan tillämpar Gzip- eller Brotli-komprimering. Det korta svaret: ja, och de fungerar bäst tillsammans.

Minifiering
Verkar på textnivå. Tar bort tecken som parsern ignorerar: kommentarer, blanksteg, redundanta attribut. Minskar den råa filstorleken innan någon komprimering tillämpas. Sker en gång vid byggtid.
Gzip / Brotli-komprimering
Verkar på bytenivå. Hittar återkommande bytemönster och kodar dem med kortare referenser. Tillämpas på varje HTTP-svar av webbservern. Dekomprimeras av webbläsaren vid mottagning.

Minifiering minskar den indata som Gzip bearbetar, så det komprimerade resultatet blir också mindre. Googles PageSpeed-riktlinjer rekommenderar att tillämpa båda. På en typisk sida sparar minifiering 15–25 % av råstorleken och Gzip komprimerar resultatet med ytterligare 60–80 %. Tillsammans kan total överföringsstorlek sjunka till 10–20 % av det ursprungliga ominifierade, okomprimerade dokumentet.

Kodexempel

Nedan finns fungerande exempel på HTML-minifiering i fyra miljöer. Varje exempel tar bort kommentarer och minimerar blanksteg.

JavaScript (html-minifier-terser)
import { minify } from 'html-minifier-terser'

const html = `
  <div class="card">
    <!-- user profile -->
    <p>  Hello, world!  </p>
  </div>
`

const result = await minify(html, {
  collapseWhitespace: true,
  removeComments: true,
  removeRedundantAttributes: true,
  removeEmptyAttributes: true,
})
// → '<div class="card"><p>Hello, world!</p></div>'
Python (htmlmin)
import htmlmin

html = """
<div class="card">
  <!-- user profile -->
  <p>  Hello, world!  </p>
</div>
"""

result = htmlmin.minify(html, remove_comments=True, remove_empty_space=True)
# → '<div class="card"><p>Hello, world!</p></div>'
Go (tdewolff/minify)
package main

import (
    "fmt"
    "github.com/tdewolff/minify/v2"
    "github.com/tdewolff/minify/v2/html"
)

func main() {
    m := minify.New()
    m.AddFunc("text/html", html.Minify)

    input := `<div class="card">
  <!-- user profile -->
  <p>  Hello, world!  </p>
</div>`

    result, _ := m.String("text/html", input)
    fmt.Println(result)
    // → <div class=card><p>Hello, world!</div>
}
CLI (html-minifier-terser)
# Install globally
npm install -g html-minifier-terser

# Minify a file
html-minifier-terser --collapse-whitespace --remove-comments input.html -o output.html

# Pipe from stdin
cat index.html | html-minifier-terser --collapse-whitespace --remove-comments

# With all common optimizations
html-minifier-terser \
  --collapse-whitespace \
  --remove-comments \
  --remove-redundant-attributes \
  --remove-empty-attributes \
  --minify-css true \
  --minify-js true \
  input.html -o output.min.html

Vanliga frågor

Kan HTML-minifiering bryta min sida?
Säker minifiering (ta bort kommentarer och minimera blanksteg) ändrar inte webbläsarens rendering. Aggressiva alternativ som att ta bort valfria sluttaggar eller minimera booleska attribut ingår i HTML-specifikationen och fungerar i alla moderna webbläsare. Det område som bör uppmärksammas är innehåll i pre- och textarea-element, där blanksteg är betydelsebärande. Bra minifierare bevarar blanksteg inuti dessa element.
Hur mycket mindre blir HTML efter minifiering?
Typiska besparingar ligger mellan 10 % och 30 % av den ursprungliga filstorleken, beroende på hur mycket blanksteg och hur många kommentarer källkoden innehåller. Tätt indragen, välkommenterad kod ger de största vinsterna. Redan kompakt HTML med minimal formatering kan bara krympa 5–8 %.
Ska jag minifiera HTML om jag redan använder Gzip?
Ja. Minifiering och komprimering verkar på olika nivåer. Minifiering tar bort redundanta texttecken; Gzip hittar återkommande bytemönster. Att minifiera först innebär att Gzip har mindre data att bearbeta, vilket ger ett mindre komprimerat resultat. Google rekommenderar att tillämpa båda.
Är det säkert att minifiera HTML som innehåller inbunden JavaScript?
En grundläggande minifierare som minimerar blanksteg ändrar inte innehållet inuti script-taggar. Minifierare med ett --minify-js-alternativ komprimerar även den inbundna JavaScript-koden med en JS-minifierare. Om dina inbundna skript förlitar sig på viktigt blanksteg (ovanligt), testa resultatet. De flesta inbundna skript fungerar bra efter minifiering.
Vad är skillnaden mellan HTML-minifiering och HTML-komprimering?
Minifiering är en textomvandling vid byggtid som tar bort onödiga tecken. Komprimering (Gzip, Brotli) är en binär kodning vid servertid som minskar HTTP-svaret. Minifiering är oåterkalleligt (kommentarerna är borta), medan komprimering reverseras av webbläsaren vid mottagning.
Påverkar minifiering SEO?
Nej. Sökmotorernas crawler tolkar DOM:en precis som webbläsare gör. De ignorerar blanksteg och kommentarer. Minifiering ändrar inte DOM-strukturen och påverkar därför inte hur sökmotorer indexerar din sida. Snabbare sidinläsningstider från mindre HTML kan indirekt förbättra rankningar via Core Web Vitals-signaler.
Hur skiljer sig HTML-minifiering från CSS- eller JavaScript-minifiering?
CSS- och JavaScript-minifierare byter namn på variabler, tar bort död kod och utför optimeringar specifika för dessa språk. HTML-minifierare är enklare eftersom HTML saknar variabler eller körbar logik att optimera. HTML-minifiering fokuserar på blanksteg, kommentarer och redundant attributsyntax.