Naar de inhoud
OneKitly

Wat een minifier mag weghalen, en wat niet

Gepubliceerd op 19-5-2025 · 17 min leestijd · Ontwikkelaarstools

Daniel Okonkwo

Daniel Okonkwo — Front-enddeveloper en techredacteur bij OneKitly

Webprestaties · Bestandsformaten

Getoetst aan 6 bronnen

Profiel bekijken →
Kort gezegd

Een minifier mag alleen wijzigingen maken die de betekenis behouden, en de moeilijke gevallen zijn allemaal witruimte die geen decoratie is. In CSS is de spatie in „div p” een afstammelingscombinator: haal hem weg en de selector raakt iets volstrekt anders. De spaties rond >, + en ~ kunnen weg — esbuild maakte van „.card > footer” „.card>footer” en liet „.card .card-title” onaangeroerd. Binnen calc() zijn de spaties rond + en − verplicht: Chrome meldt CSS.supports voor calc(100% - 2px) als true en voor calc(100%-2px) als false, en het tweede toekennen laat de eigenschap leeg. Spaties rond * en / zijn optioneel. In HTML is witruimte tussen inline-elementen gerenderde inhoud — twee spans maten 36,92 px breed met een spatie ertussen en 27,28 px zonder, een verschuiving van 9,64 px — en ze is binnen pre en textarea volledig betekenisvol. In JavaScript betekent automatische puntkomma-invoeging dat regels samenvoegen het gedrag verandert: een functie waarvan de return op zijn eigen regel staat, geeft undefined terug tot je de regels samenvoegt, waarna hij het object teruggeeft. En hernoemen stopt bij de grens van een tekenreeks; property mangling maakte van een werkende opzoeking undefined. Wat de opbrengst betreft: op de assets van deze pagina bespaarde brotli alleen 66,2%, en eerst minificeren voegde daar maar 18,1% aan toe.

Advertentie

Minificatie moet de betekenis behouden, en het interessante deel is de witruimte die betekenis draagt: de afstammelingscombinator, de spaties binnen calc(), het gat tussen twee inline-elementen. Hier gemeten op echte bestanden, inclusief hoeveel brotli je toch al ging besparen.

De enige regel: de uitvoer moet zich identiek gedragen

Minificatie is een compilerstap met één contract: de uitvoer moet in gedrag identiek zijn aan de invoer. Niet vergelijkbaar, niet dicht genoeg in de buurt — identiek in elk gedrag waarop een pagina kan bouwen. Alles wat een minifier doet volgt daaruit, en elke minificatiefout is een plek waar iemand aannam dat een byte decoratie was terwijl de specificatie zegt dat het data is.

Dat onderscheid is de reden dat minifiers op basis van reguliere expressies gevaarlijk zijn en die op basis van een parser niet. Een tool die witruimte met een patroon weghaalt, heeft geen idee of een bepaalde spatie twee tokens scheidt voor de leesbaarheid of twee tokens tot één samengestelde betekenis samenvoegt. Een tool die de invoer tokeniseert volgens de CSS Syntax-module of de ECMAScript-grammatica, een boom bouwt en die opnieuw uitschrijft, kan de fout helemaal niet maken, want op het moment dat het iets afdrukt, ligt de betekenis al in de boom vast.

Alles hieronder is uitgevoerd en niet uit het hoofd opgeschreven. De voorbeelden zijn met esbuild geminificeerd, de groottes zijn met zlib in node gemeten op gzip-niveau 9 en brotli-kwaliteit 11, en de beweringen over CSS en opmaak zijn in headless Chrome gecontroleerd.

Advertentie

CSS: de spatie die een combinator is

In een selector is witruimte tussen twee samengestelde selectors de afstammelingscombinator. „div p” selecteert elke p binnen een div; „divp” selecteert een elementtype dat niet bestaat, en „.card .card-title” selecteert een .card-title binnen een .card terwijl „.card.card-title” één element selecteert dat beide klassen draagt. De spatie is een token en geen opmaak, en geen enkele correcte minifier haalt hem weg.

De andere drie combinatoren zijn interpunctie en de spaties eromheen zijn vrij. Esbuild de vier vormen „div p”, „div>p”, „div + p” en „div ~ p” geven leverde precies „div p”, „div>p”, „div+p” en „div~p” op. De spatie van de afstammeling overleefde; de spaties rond >, + en ~ niet, want die tekens zijn op zichzelf ondubbelzinnig. In het voorbeeldstijlblad gebeurde hetzelfde met echte regels: „.card .card-title” kwam ongeschonden door terwijl „.card > footer”, „.card + .card” en „.card ~ .aside-note” werden samengetrokken.

Het geval van de at-regel is subtieler en het staren waard. De mediaquery „@media (min-width: 600px) and (max-width: 900px)” kwam eruit als „@media(min-width:600px)and (max-width:900px)”. De spatie vóór „and” ging weg, want een sluitende ronde haak beëindigt het vorige token al. De spatie ná „and” bleef, want „and(” zou als functietoken tokeniseren in plaats van als een identifier gevolgd door een haak. Dat is de hele discipline in één regel: een spatie is precies dan weg te halen wanneer de twee tokens aan weerszijden niet tot één ander token kunnen samensmelten.

CSS: de spaties binnen waarden

calc() is het scherpste voorbeeld, want de eis is asymmetrisch. De CSS Values-specificatie eist witruimte aan beide zijden van + en −, want zonder die witruimte lexeert een token als „-2px” als één negatieve dimensie en verliest de expressie haar operator. Chrome is daar precies mee eens: CSS.supports voor width en calc(100% - 2px) geeft true, terwijl calc(100%-2px), calc(100% -2px) en calc(100%- 2px) alle drie false geven. style.width = "calc(100%-2px)" toekennen laat de eigenschap een lege tekenreeks, want de hele declaratie wordt als ongeldig weggegooid.

De operatoren voor vermenigvuldigen en delen hebben dat probleem niet, en de browser bevestigt het: calc(100%*2) en calc(100%/2) geven beide true. Een minifier die de grammatica begreep, zou die twee dus kunnen samentrekken en de andere niet. In de praktijk is esbuild voorzichtig en hield hij elke spatie binnen „calc(100% - 2 * var(--gap))” — juist voor de min, en een kleine gemiste kans voor het sterretje.

In dezelfde ronde doken nog twee categorieën onaantastbare spaties op. Waarden die tekenreeksen zijn, zijn letterlijk: de declaratie content: " new " hield beide paren binnenspaties, want die tekens worden in het document geplaatst. En custom properties zijn tokenstromen in plaats van geparseerde waarden, dus liet esbuild „--card-bg: #ffffff” met de spatie na de dubbele punt staan terwijl hij diezelfde spatie uit „color: var(--card-fg)” weghaalde. De rest van het voorbeeld laat zien wat een minifier wint als hij de grammatica van de waarden wél begrijpt: rgba(0, 0, 0, 0.08) werd #00000014, #0000ff werd #00f, 150ms werd .15s, opacity 0.7 werd .7, margin: 0 0 8px 0 werd margin:0 0 8px, en ::after werd :after.

HTML: witruimte tussen inline-elementen is inhoud

De verwerking van witruimte in CSS vouwt een reeks witruimte in de normale flow samen tot één spatie — maar tot één spatie, niet tot niets. Tussen twee inline-elementen wordt die spatie gerenderd en neemt ze breedte in, dus verschuift de opmaak als je haar weghaalt. Gemeten in headless Chrome op 16 px monospace eindigden twee naast elkaar staande spans, in de bron gescheiden door een regeleinde, op x = 36,92, terwijl dezelfde twee spans zonder witruimte ertussen op x = 27,28 eindigden. Het verschil van 9,64 px is precies één spatieteken, en het is het verschil tussen een rij links die „een twee drie” leest en een die „eentweedrie” leest.

Daarom zijn agressieve HTML-minifiers instelbaar en zijn hun standaardinstellingen meestal voorzichtig. Een reeks van vijf spaties en twee regeleindes samenvouwen tot één spatie is in de normale flow altijd veilig. De laatst overgebleven spatie tussen twee inline-boxen weghalen is dat niet, en een minifier die dat als algemene regel doet, laat menu's, kruimelpaden, taglijsten en inline-pictogrammen stilletjes verschuiven. Elke tool die aanbiedt om witruimte tussen tags te verwijderen, biedt aan je opmaak te veranderen in ruil voor bytes.

Twee elementen zijn absoluut verboden terrein: pre en textarea. Beide hebben white-space: pre als standaard, dus is elke spatie, tab en regeleinde erbinnen behouden en gerenderd. De voorbeeldpagina hier bevat een ingesprongen codeblok en een textarea met betekenisvolle spaties vooraan, en de witruimtevouwer die voor de meting is gebruikt, moest voor beide een expliciete uitzondering krijgen. Elke minifier zonder die uitzondering vernielt stilletjes codevoorbeelden en voorgevulde formuliervelden. Dezelfde zorg geldt binnen script- en style-elementen, en voor een regeleinde direct na een openende pre-tag, dat de HTML-parser volgens de specificatie weggooit — een subtiliteit die zelfgebouwde tooling in beide richtingen verkeerd maakt.

JavaScript: automatische puntkomma-invoeging en hernoemen

ECMAScript voegt bij bepaalde regeleindes puntkomma's in, en dat maakt een regeleinde semantisch dragend. Het klassieke geval is een return op zijn eigen regel. function f(){ return \n { ok: true } } uitvoeren gaf undefined terug, want er wordt direct na return een puntkomma ingevoegd. Dezelfde code op één regel schrijven gaf { ok: true } terug. Een naïeve minifier die regels samenvoegt, verandert dus de waarde die de functie voortbrengt. Het omgekeerde bijt ook: het fragment let x = 1 \n ++x laat x op 2 uitkomen, terwijl die twee regels samenvoegen SyntaxError: Invalid left-hand side expression in postfix operation gooit.

Een minifier op basis van een parser kan geen van beide fouten maken, want op het moment dat hij afdrukt, is de puntkomma al beslist. Diezelfde functie met de return op zijn eigen regel aan esbuild geven leverde function t(){}export const r=void 0; op — hij hield de betekenis, zag dat de functie alleen undefined kon teruggeven, en vouwde de aanroep tot void 0. Dat is het verschil tussen een teksttransformatie en een compiler.

Het andere gevaar in JavaScript is hernoemen, en de grens ervan is exact: een minifier mag alles hernoemen waarvan hij elke verwijzing kan zien, en niets anders. Lokale variabelen en functieparameters horen daarbij, en daar komt de meeste besparing uit. Namen van objecteigenschappen niet, want een eigenschap kan worden bereikt via een tekenreeks die de minifier niet kan volgen. Gedemonstreerd: een module die [config.userName, o["userName"], o["retryCount"]] teruggaf, gaf ["ada", "ada", 3] onder gewone minificatie, en ["ada", undefined, undefined] zodra property mangling werd aangezet. De toegang met de punt is samen met de definitie hernoemd; de twee opzoekingen met een tekenreeks vroegen nog om de oude namen en vonden niets. Dezelfde valkuil treft alles wat tijdens de uitvoering bij naam wordt bereikt — toegang met vierkante haken opgebouwd uit een variabele, een rondje door JSON, bindingen van een framework, en directe eval.

Gemeten: wat minificatie waard is na compressie

Minificatie en compressie halen overlappende redundantie weg, dus ziet de tweede die aan de slag gaat er altijd minder indrukwekkend uit. Op de met de hand geschreven voorbeelden: de CSS ging van 1.434 naar 1.066 bytes, een snede van 25,7%, maar na brotli stond het paar op 552 tegen 459 — nog maar 16,8%. De JavaScript ging van 1.518 naar 747 bytes, een snede van 50,8%, maar 552 tegen 395 na brotli, dus 28,4%. De HTML ging van 1.033 naar 782 bytes, 24,3%, en 322 tegen 302 na brotli — 6,2%, ofwel twintig bytes.

De drie samenvoegen tot één paginapakket zet het eerlijke getal op tafel. De ruwe assets tellen samen 3.985 bytes en brotli brengt ze op 1.346 — een besparing van 66,2% uit compressie alleen, zonder bouwstap. Eerst minificeren en dan comprimeren geeft 1.102 bytes. De marginale bijdrage van minificatie, bovenop een compressielaag die je al hebt, is dus 244 bytes: 18,1%. Echt en het meenemen waard, maar een orde van grootte minder dan het ruwe getal suggereert.

Vier echte bestanden uit deze repository laten zien hoe sterk het antwoord afhangt van wat er in het bestand zit. globals.css kromp 68,2% ruw en 70,2% na brotli — spectaculair, en volledig verklaard door het feit dat 2.084 van zijn 3.393 bytes commentaar zijn, met alle dertien regelblokken aan beide zijden intact. app-shell.module.css, dat vooral echte declaraties bevat, gaf 4,4% ruw en 5,8% na brotli. Twee TypeScript-modules vol inhoud gaven 10,8% en 6,5% ruw, maar maar 3,4% en 2,3% na brotli, want een bestand dat vooral uit tekenreeksen bestaat, heeft bijna niets waar een minifier aan mag komen. De vuistregel: minificatie betaalt in verhouding tot hoeveel van je bestand commentaar, inspringing en lange lokale namen is, en betaalt niets op data.

Een werkende volgorde van bewerkingen

Zet eerst de compressie aan, want dat is de grootste enkele winst, het vraagt geen bouwstap en het kan niets breken. Op deze voorbeelden haalde brotli alleen 66,2% van de bytes weg. Minificeer daarna met een tool op basis van een parser per taal, op de standaardinstellingen. Grijp dan, en alleen als je een gemeten reden hebt, naar de agressieve opties — property mangling, witruimte tussen tags verwijderen — en behandel elk ervan als een wijziging die getest moet worden, want elk ervan is een plek waar het contract van betekenisbehoud met opzet is losgelaten.

Twee gewoonten zijn meer waard dan welke instelling van een minifier ook. Haal commentaar en dode code bij de bron weg in plaats van erop te vertrouwen dat de minifier ze opmerkt — globals.css bestond voor 61% uit commentaar, en dat ene feit verklaarde zijn hele reductie van 68%. En controleer de uitvoer en niet de belofte: haal de geminificeerde bundel door je testsuite, en vergelijk de gecomprimeerde groottes aan beide zijden in plaats van de ruwe, want het ruwe getal is het getal dat vleit en het gecomprimeerde getal is wat je gebruikers werkelijk downloaden.

Transformaties die esbuild op het voorbeeldstijlblad en de voorbeeldmodule heeft uitgevoerd, met het verdict over elk
VoorNaVeilig?Waarom
.card > footer.card>footerJaDe > is op zichzelf ondubbelzinnig; de spaties dragen niets
.card .card-title.card .card-title (onveranderd)Mag niet veranderenDe spatie is de afstammelingscombinator; hem weghalen selecteert één element met beide klassen
calc(100% - 2px)calc(100% - 2px) (onveranderd)Mag niet veranderenChrome meldt calc(100%-2px) als niet ondersteund en gooit de declaratie weg
content: " new "content:" new " (spaties behouden)Mag niet veranderenDe inhoud van een tekenreeks wordt letterlijk in het document geplaatst
rgba(0, 0, 0, 0.08)#00000014JaAchtcijferige hex geeft de alfa in 255sten: 0.08 wordt 20/255 = 0.0784, onzichtbaar maar niet exact
margin: 0 0 8px 0margin:0 0 8pxJaDe verkorte notatie spiegelt de tweede waarde als de vierde wordt weggelaten
return op zijn eigen regelregeleinde verwijderd door een teksttoolNeeDe functie gaf eerst undefined terug en daarna het object
o.userName en o["userName"]property mangling hernoemt alleen de eersteNeeHet gemeten resultaat ging van [ada, ada, 3] naar [ada, undefined, undefined]
CSS-compressorMinificeer CSS door commentaar en witruimte weg te halen, zodat je stijlblad kleiner wordt.Probeer de tool →
Advertentie

Veelgestelde vragen

Als mijn server al gzip of brotli stuurt, moet ik dan nog minificeren?
Ja, maar verwacht een veel kleinere winst dan de ruwe getallen suggereren, en zorg eerst dat de compressie werkt. Gemeten op de voorbeeldpagina bracht brotli alleen 3.985 bytes ruwe assets terug naar 1.346 — 66,2% bespaard zonder enige bouwstap. Eerst minificeren en dan comprimeren haalde 1.102 bytes, dus was de marginale bijdrage van minificatie 244 bytes, ofwel 18,1% erbovenop. Dat is het hebben waard, en het kost per verzoek niets zodra je bouwproces het doet. De reden dat de twee overlappen, is dat ze dezelfde redundantie aanvallen: herhaalde lange namen, reeksen inspringing en commentaartekst zijn precies waar een woordenboekcompressor het best in is. Waar minificatie nog ronduit wint, is op dingen die compressie niet kan, omdat ze semantisch zijn in plaats van tekstueel — dode code verwijderen, constanten samenvouwen, onbereikbare takken weggooien, de syntaxis van kleuren en eenheden inkorten. De volgorde die ter zake doet: compressie aan, dan minificeren, dan de gecomprimeerde groottes meten in plaats van de ruwe.
Mijn opmaak verschoof nadat ik HTML-minificatie aanzette. Waarom?
Bijna zeker omdat de minifier witruimte tussen inline-elementen heeft weggehaald, en die is gerenderde inhoud in plaats van opmaak. De verwerking van witruimte in CSS vouwt een reeks spaties en regeleindes in de normale flow samen tot één spatie — één, niet nul — en die overblijvende spatie neemt breedte in tussen twee inline-boxen. Gemeten in headless Chrome op 16 px monospace eindigden twee spans met een regeleinde ertussen in de bron op x = 36,92, en hetzelfde paar zonder enige witruimte op x = 27,28: een verschil van 9,64 px, precies één spatie. Over een navigatiebalk, een lijst tags of een rij inline-links is dat verschil onmiddellijk zichtbaar en leest het als een fout. Zoek naar een optie met een naam als collapseWhitespace met een agressieve en een voorzichtige stand, en kies de voorzichtige. Wil je geen gat tussen twee inline-elementen, haal het dan in CSS weg met een flex- of gridcontainer, of met font-size op de ouder, zodat de opmaak onafhankelijk blijft van de weergave.
Is het ooit veilig om namen van objecteigenschappen te hernoemen?
Alleen als je kunt garanderen dat elke toegang tot de eigenschap voor de minifier zichtbaar is, en dat betekent in de praktijk een naamconventie aannemen en de tool erover vertellen. Het gebruikelijke patroon is alleen eigenschappen te hernoemen die aan een patroon beantwoorden, zoals een liggend streepje aan het eind, zodat interne velden worden hernoemd en alles wat publiek is onaangeroerd blijft. Wat het breekt, is elke toegang via een tekenreeks. Hier gedemonstreerd: een module die [config.userName, o["userName"], o["retryCount"]] teruggaf, gaf ["ada", "ada", 3] onder gewone minificatie en ["ada", undefined, undefined] zodra property mangling aan stond — de toegang met de punt verhuisde mee met de definitie, de twee opzoekingen met een tekenreeks niet. Dezelfde faalvorm dekt toegang met vierkante haken opgebouwd uit een variabele, sleutels die uit JSON komen, templates van een framework die bij naam binden, en alles waarover met Object.keys wordt gereflecteerd. Omdat de breuk stil is en alleen opduikt op het codepad dat de tekenreeks gebruikt, behandel property mangling als een optimalisatie die een volledige testronde vraagt en niet als een vinkje.
Kan ik een minifier met reguliere expressies schrijven?
Je kunt iets schrijven dat meestal werkt, en dat is de slechtst mogelijke uitkomst, want de storingen zijn zeldzaam en stil. Een patroon dat reeksen witruimte weghaalt, kan een afstammelingscombinator niet van inspringing onderscheiden, kan niet zien dat de spatie vóór een min binnen calc() grammaticaal verplicht is, kan niet zien dat een regeleinde vóór een sluitende accolade is wat een return-statement undefined laat teruggeven, en kan niet zien dat de tekens binnen een tekenreeks tussen aanhalingstekens inhoud zijn. Elk van die onderscheidingen vraagt dat je de invoer tokeniseert volgens de werkelijke grammatica. De witruimtevouwer die voor de HTML-meting in dit artikel is gebruikt, is met opzet naïef, en hij had een expliciete uitzondering voor pre en textarea nodig voordat hij überhaupt correcte uitvoer gaf — en hij zou nog steeds niet veilig zijn op een pagina met inline scripts die punthaken in tekenreeksen bevatten. Het praktische antwoord is een tool op basis van een parser per taal te gebruiken en je moeite in de invoer te stoppen: minder commentaar meeleveren, geen dode code, kortere lokale namen waar dat de leesbaarheid niet schaadt.
Waarom hielp minificeren van mijn bestand vol data bijna niet?
Omdat een minifier alleen aan de syntaxis mag komen, en een databestand bijna volledig inhoud is. Tekenreeksen moeten byte voor byte overleven, objectsleutels die tijdens de uitvoering worden gebruikt kunnen niet worden hernoemd, en getallen zijn al zo kort als ze worden. De metingen in dit artikel laten het patroon duidelijk zien: twee TypeScript-modules vol inhoud uit deze repository kromp 10,8% en 6,5% ruw, maar maar 3,4% en 2,3% na brotli, want het weinige dat de minificatie weghaalde was inspringing en interpunctie die de compressor toch al ging samenpersen. Vergelijk dat met globals.css, dat 68,2% kromp — volledig omdat 2.084 van zijn 3.393 bytes commentaar waren. Is een databestand werkelijk groot, dan is de hefboom niet de minificatie maar het formaat en de levering: zet de data achter een API zodat pagina's alleen ophalen wat ze tonen, splits hem zodat een route zijn eigen deel laadt, of haal hem uit de JavaScript-bundel en zet hem in JSON dat de browser sneller kan parseren en apart kan cachen.

Artikelen die je misschien interesseren

Alle gidsen →
GidsBeautify or Minify: What Each Is For, and What It Does to the WeightFour real stylesheets run through the minifier, measured raw and after gzip. Stripping every space saved 48, 103, 104 and 147 compressed bytes; stripping comments saved 57, 1 358, 2 420 and 1 042. Plus the five inputs this minifier breaks.HandleidingHEX vs RGB: How to Read and Convert ColoursHEX and RGB are two notations for the same colours. Here's how to read each, convert between them, and add transparency.UitlegGradients, Banding, and Why the Middle Looks MuddyInterpolating in sRGB averages gamma-encoded numbers, so the midpoint of red to green is #808000 when the half-light answer is #bcbc00 — 57.2% too little light. Banding is a separate arithmetic problem: 8 bits give 256 steps, and a dark gradient may have only 28 of them. Here is both, computed.UitlegColour Schemes Are Geometry on a Wheel — and the Wheel Is WrongComplementary, triadic, analogous and split-complementary are just rotations: add 180°, 120°, 30° or 150° to a hue. The arithmetic is trivial. The problem is that the HSL hue circle is not perceptually uniform — yellow and blue at the same HSL lightness differ in luminance by 12.85 times — so a generated palette has to be contrast-checked afterwards.UitlegContrastverhouding: hoe WCAG haar werkelijk berekentDe WCAG-verhouding is (L1 + 0,05) ÷ (L2 + 0,05), en L is relatieve luminantie en geen helderheid. Groen draagt 71,52% ervan en blauw 7,22%, en daarom haalt zuiver blauw op wit 8,59:1 terwijl middengrijs zakt op 3,95:1. Hier is de hele berekening, van begin tot eind doorgerekend.UitlegHoe Instagram-lettertypes werkelijk werken (het zijn geen lettertypes)Er wordt niets opgemaakt. Elke letter wordt vervangen door een ander Unicode-teken dat er vet of cursief uitziet — en daarom leest een schermlezer het resultaat als wartaal en laten sommige apparaten lege blokjes zien.

Vergelijkbare tools

Bronnen

Een fout in dit artikel gezien?