{"canonical_url":"https://engineer.company/da/glossary/utf-8/","content_markdown":"# UTF-8\n\n## Hvad det er\n\nUTF-8 er den kodning, der gør Unicode-tekst til bytes. Unicode-standarden\ndefinerer den som den kodningsform, der gemmer hver Unicode-skalarværdi, det vil\nsige ethvert kodepunkt undtagen de surrogater, der er sat af til UTF-16, som en\nsekvens på én til fire bytes. Et tegn, som brugeren opfatter som ét, kan bestå\naf flere skalarværdier og derfor kræve flere bytes. Den er en af standardens tre kodningsformer ved\nsiden af UTF-16 og UTF-32, og den, som nettets egne standarder kræver. Som\nbetegnelse, i en HTML-side eller en HTTP-header, skrives den som regel med små\nbogstaver, utf-8, og nogle gange uden bindestreg, utf8; Encoding Standard\ngodtager begge og skelner ikke mellem store og små bogstaver i betegnelserne.\n\nUTF-8 blev udtænkt i september 1992 af Ken Thompson efter designkriterier, som\nRob Pike havde opstillet, til styresystemet Plan 9, og den hed både FSS-UTF og\nUTF-2, før den fik sit nuværende navn. RFC 3629, IETF's definition fra 2003,\nbegrænser den til kodepunkterne U+0000 til U+10FFFF, det samme koderum, som\nUnicode har. Da RFC'en blev skrevet, tillod beskrivelsen af UTF-8 i\nISO/IEC 10646 stadig sekvenser på op til seks bytes; efter RFC'en og\nUnicode-standarden fylder ingen Unicode-skalarværdi mere end fire.\n\nDe forreste bit i hver byte fortæller, hvilken slags byte det er. En byte, hvis\nøverste bit er 0, er et tegn for sig selv, et af ASCII's 128 tegn. En byte, der\nbegynder med 110, 1110 eller 11110, indleder en sekvens på to, tre eller fire\nbytes, og hver af de efterfølgende bytes begynder med 10 og bærer seks bit mere\naf kodepunktet. Hele formatet kan stå i fire rækker, hvor x står for\nkodepunktets bit:\n\n```text\nU+0000..U+007F     0xxxxxxx\nU+0080..U+07FF     110xxxxx 10xxxxxx\nU+0800..U+FFFF     1110xxxx 10xxxxxx 10xxxxxx\nU+10000..U+10FFFF  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx\n```\n\nRækken med tre bytes udelader surrogaterne, U+D800 til U+DFFF: de er ikke tegn,\nog enhver bytesekvens, der ville kode et af dem, er ugyldig.\n\nFire egenskaber følger af den form, og Unicode-standarden nævner hver af dem ved\nnavn. UTF-8 er gennemsigtig for ASCII: bytes fra 00 til 7F betyder det samme som\ni ASCII og optræder aldrig inde i et andet tegn. Den er selvsynkroniserende: en\nstartbyte er let at skelne fra en fortsættelsesbyte. En binær sortering af\nUTF-8-strenge giver samme rækkefølge som en sortering efter kodepunkt. Og den\nhar ingen byterækkefølge, så spørgsmålet om big-endian eller little-endian, som\nUTF-16 og UTF-32 må tage stilling til, opstår aldrig.\n\n## Hvorfor det betyder noget\n\nNettet har lagt sig fast på den. WHATWG's Encoding Standard, den specifikation,\nbrowsere implementerer for at læse og skrive tekst, kalder UTF-8 den mest\nvelegnede kodning til udveksling af Unicode og kræver den til nye protokoller og\nformater og til eksisterende formater, der tages i brug i nye sammenhænge. Den\nbeder forfattere om at bruge UTF-8 og om at angive den med betegnelsen utf-8.\nHTML følger trop: et dokuments kodning skal være UTF-8, uanset om dokumentet\nangiver det eller ej, og redigeringsværktøjer skal som standard bruge UTF-8 til\nnye dokumenter. Et produkt, der udgiver sider, sender JSON eller tager imod\nformularer, forventes allerede at tale den.\n\nDesignet forklarer, hvorfor den beslutning har holdt. Fordi ASCII-bytes aldrig\noptræder inde i et andet tegn, virker et program skrevet til ASCII stadig på\nUTF-8-tekst: en parser, der deler ved kommaer, skråstreger eller linjeskift,\nfinder dem i en dansk eller ukrainsk sætning præcis der, hvor de står, og aldrig\nmidt i et å eller et Ґ. Fordi et program, der lander et vilkårligt sted, finder\nstarten på en kodet skalarværdi ved at søge højst fire bytes bagud, og som regel færre,\nkan afkodningen fortsætte ved en efterfølgende velformet sekvens i stedet for\nat miste resten af filen. Det lover ikke præcis ét erstatningstegn for hver\nbeskadiget byte. En søgning efter én komplet kodet skalarværdi rammer aldrig\nen del af en anden. Fordi den binære rækkefølge er\nkodepunkternes rækkefølge, kan en database eller et program sortere UTF-8-bytes\nuden at afkode dem. Den rækkefølge er dog en teknisk rækkefølge: den sætter å\nfør æ og ø, hvor en dansk ordbog slutter alfabetet med æ, ø og å.\n\nStørrelsen er prisen. Unicode-standarden kalder UTF-8 rimelig kompakt: meget\nmindre end UTF-16 for ASCII-syntaks og vestlige sprog og betydeligt større for\nasiatiske skriftsystemer som hindi, thai, kinesisk, japansk og koreansk. I det danske grundalfabet\nkoster bogstaver én byte bortset fra æ, ø og å, der fylder to; andre bogstaver\nmed accent kan kræve flere. Ukrainsk fylder to bytes for hvert kyrillisk bogstav\nog én for ASCII-mellemrum, cifre og tegnsætning, men anden tegnsætning kan kræve flere. Derfor rummer et felt, der måles i bytes, omtrent halvt så\nmange ukrainske bogstaver som engelske.\n\n## Sådan ser det ud i praksis\n\nDe enkelte bytes er lette at få frem. Node.js har, ligesom en browser, Encoding\nStandards `TextEncoder`, der skriver en streng som UTF-8:\n\n```js\nconst hex = (bytes) =\u003e\n  [...bytes].map((b) =\u003e b.toString(16).padStart(2, \"0\")).join(\" \");\nconst encoder = new TextEncoder();\nfor (const text of [\"A\", \"å\", \"Ґ\", \"€\", \"𐌂\"]) {\n  console.log(text, hex(encoder.encode(text)).toUpperCase());\n}\n```\n\nKørt i Node.js 25 skriver koden hvert tegn og dets bytes i hexadecimal:\n\n```text\nA 41\nå C3 A5\nҐ D2 90\n€ E2 82 AC\n𐌂 F0 90 8C 82\n```\n\nBogstavet A er ASCII og beholder sin ene byte. Det danske å er U+00E5, der\nkræver otte bit, én mere end de syv, en enkelt byte giver plads til, så det får\nmønsteret med to bytes. Dets værdi på elleve bit, 00011100101, deles i 00011\nog 100101; startbyten bliver 110 efterfulgt af 00011, altså C3, og\nfortsættelsesbyten bliver 10 efterfulgt af 100101, altså A5. Det ukrainske Ґ,\nU+0490, fylder to bytes på samme måde, eurotegnet tre og det gammelitaliske\nbogstav 𐌂, der ligger over U+FFFF, fire. Den første byte i hver sekvens melder\nsekvensens længde: C3 og D2 begynder med 110, E2 med 1110 og F0 med 11110.\n\nDette site skriver alle sider i UTF-8 og siger det, hvor HTML beder om det. Det\nførste element i head på hver side er `\u003cmeta charset=\"utf-8\"\u003e`, med den\nbetegnelse, utf-8, som Encoding Standard foreskriver, og et godt stykke inden\nfor de første 1.024 bytes, hvor HTML kræver, at angivelsen står. Sitets\n[kolofon](/da/credits/) har et afsnit med tjek udefra, og ingen af dem er\nvores: hvert af dem kører en live-test i stedet for at tage vores ord for noget.\nEt af dem er W3C's internationaliseringstjek, der læser de sprog- og\ntegnsætsangivelser, som gør hver sprogudgave af sitet læselig for den rette\nlæser.\n\n## Hvor det går galt\n\n**En bytegrænse skærer et tegn over.** En kolonne, et beskedfelt eller en\nbuffer, der måles i bytes, kan slutte midt i en sekvens. Navnet Ærø er tre tegn\nog fem bytes, og en grænse på fire beholder Æ, r og den første byte af ø:\n\n```js\nconst bytes = new TextEncoder().encode(\"Ærø\");\nconst cut = new TextDecoder().decode(bytes.slice(0, 4));\nconsole.log(bytes.length, [...cut].map((c) =\u003e c.codePointAt(0).toString(16)));\nconsole.log(new TextEncoder().encodeInto(\"Ærø\", new Uint8Array(4)));\n```\n\n```text\n5 [ 'c6', '72', 'fffd' ]\n{ read: 2, written: 3 }\n```\n\nDen enlige startbyte afkodes som U+FFFD, erstatningstegnet, så det gemte\nnavn ender med en pladsholder dér, hvor ø'et stod. Skær i stedet ved en\ngrænse mellem Unicode-skalarværdier. `encodeInto` på sidste linje gør det af sig selv: med fire bytes til\nrådighed skriver den kun de tre bytes for Æ og r og melder i `read`, hvor meget\naf strengen den tog, talt i UTF-16-enheder. Kode, der skærer i bytes, den\nallerede har, kan gå baglæns forbi fortsættelsesbytes, altså dem, der begynder\nmed 10, til startbyten og skære dér. Det holder UTF-8-sekvensen velformet; at bevare et helt tegn, som brugeren opfatter det, kræver også, at grænserne mellem grafemklynger respekteres.\n\n**Et byte order mark står forrest i filen.** UTF-8 har ingen byterækkefølge og\nbehøver derfor intet mærke, men en konverter, der laver UTF-16 med et byte order\nmark om til UTF-8, gør mærket til de tre bytes EF BB BF. Unicode-standarden\nkræver dem ikke, siger, at de ikke har betydning for, om en implementering\noverholder standarden, og anbefaler dem ikke som signatur for UTF-8. Programmer,\nder læser filer, behandler dem forskelligt. Her rummer filen bom.json de tre\nbytes efterfulgt af `{\"name\":\"Ærø\"}`:\n\n```js\nimport { readFileSync } from \"node:fs\";\n\nconst text = readFileSync(\"bom.json\", \"utf8\");\nconsole.log(text.codePointAt(0).toString(16));\ntry {\n  JSON.parse(text);\n} catch (error) {\n  console.log(error.name);\n}\nconsole.log(JSON.parse(new TextDecoder().decode(readFileSync(\"bom.json\"))));\n```\n\n```text\nfeff\nSyntaxError\n{ name: 'Ærø' }\n```\n\nNodes `readFileSync` beholder mærket som tegnet U+FEFF, og `JSON.parse` afviser\nteksten på grund af det. `TextDecoder` følger Encoding Standard og fjerner\nmærket, og så kan de samme bytes parses uden problemer. I en browser vejer\nmærket endnu tungere: Encoding Standard sætter det over alt andet, også over\nHTTP-headeren `Content-Type`. Skriv UTF-8 uden mærket, og hvor filer kommer fra\nandre systemer, så afkod dem med en dekoder, der fjerner det, eller fjern et\nindledende U+FEFF før parsningen.\n\n**Et tjek læser bytes, før de er afkodet.** RFC 3629 beskriver en parser, der\ntjekker sit input i kodet form og afviser bytes 2F 2E 2E 2F, stitrinnet »/../«,\nmen lukker 2F C0 AE 2E 2F igennem, hvor C0 AE er en ugyldig stavemåde af punktum\npå to bytes, som parseren alligevel læser som et punktum. RFC'en noterer, at\nnetop det trick blev brugt af en udbredt virus, der angreb webservere i 2001.\nSiden Unicode 3.1 er den slags former, der ikke er de kortest mulige, ugyldige,\nog bytes C0, C1 og F5 til FF forekommer aldrig i gyldig UTF-8. En dekoder, der\noverholder standarden, `TextDecoder` iblandt, gør de fem bytes til en skråstreg,\nto U+FFFD og »./«, så der ikke er noget »/../« tilbage, der kan smutte forbi.\nUnicode-standarden er lige så streng med det, der følger efter en fejl: en\ndekoder, der sluger de gyldige bytes efter en ugyldig startbyte, overholder ikke\nstandarden og kan udnyttes til angreb, og `TextDecoder` gør bytes C2 41 42 til\nU+FFFD efterfulgt af AB. Afkod først med platformens egen dekoder, tjek derefter\nden afkodede tekst, og skriv aldrig selv en UTF-8-dekoder, eller et bytemønster,\nder skal gøre det ud for en.\n\n**Erstatning skjuler skaden.** Som standard erstatter en dekoder hver ugyldig\nsekvens med U+FFFD og fortsætter. Det er rigtigt, når en side skal vises, og\nforkert, når data skal importeres: teksten ser næsten normal ud, den gemte kopi\nhar mistet de oprindelige bytes, og afsenderen får aldrig at vide, hvor filen\nvar beskadiget. Encoding Standard nævner to fejltilstande for afkodning,\n»replacement« og »fatal«, og for identifikatorer og bytesekvenser inde i et\nformat eller en protokol lader den andre standarder vælge en dekoder, der fejler\ni stedet for at erstatte. I JavaScript kaster\n`new TextDecoder(\"utf-8\", { fatal: true })` en `TypeError` for det afklippede\nnavn ovenfor i stedet for at returnere det. Brug den fatale tilstand overalt,\nhvor tekst gemmes, signeres eller sammenlignes, afvis inputtet med en besked,\nafsenderen kan handle på, og behold erstatningen til visning.\n\n**Angivelsen kommer for sent, mangler eller er forkert.** HTML kræver, at det\nelement, der angiver kodningen, er komplet inden for dokumentets første 1.024\nbytes. Det kræver en angivelse, selv når alle tegn er ASCII, fordi browseren\nskal bruge en kodning til det, folk skriver i formularer, og til de URL'er,\nscripts bygger. En betegnelse, der ser harmløs ud, kan også være den forkerte: i\nEncoding Standard er »ascii«, »latin1« og »iso-8859-1« alle betegnelser for\nwindows-1252, så en side, der er angivet som ASCII, læses som windows-1252. Sæt\n`\u003cmeta charset=\"utf-8\"\u003e` først i head, send\n`Content-Type: text/html; charset=utf-8` med hver side, og behandl enhver anden\nbetegnelse begge steder som en defekt.\n\n## Læs mere\n\n- [The Unicode Standard, Chapter 3: Conformance](https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-3/#G27817)\n  — definitionen af UTF-8, tabellen over gyldige bytesekvenser, byte order\n  mark, og hvordan en konverter skal behandle ugyldigt input.\n- [The Unicode Standard, Chapter 2: General Structure](https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-2/)\n  — hvorfor UTF-8 er gennemsigtig for ASCII, selvsynkroniserende og fri for\n  byterækkefølge, og hvordan størrelsen er i forhold til UTF-16.\n- [RFC 3629: UTF-8, a transformation format of ISO 10646](https://www.rfc-editor.org/rfc/rfc3629)\n  — IETF's definition, historien fra Plan 9 og de sikkerhedshensyn, der ligger\n  bag angrebet med overlange kodninger af en sti.\n- [Encoding Standard](https://encoding.spec.whatwg.org/) — WHATWG's\n  specifikation, som browsere følger: hvorfor UTF-8 er påkrævet, hvordan\n  afkodning behandler byte order mark og fejl, og grænsefladerne `TextEncoder`\n  og `TextDecoder`.\n- [HTML: Specifying the document's character encoding](https://html.spec.whatwg.org/multipage/semantics.html#charset)\n  — hvad en angivelse skal sige, hvor den skal stå, og hvorfor en side, der kun\n  er skrevet i ASCII, har brug for en.\n\n\u003chttps://engineer.company/da/glossary/utf-8/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hvordan UTF-8 gemmer skalarværdier i én til fire bytes, hvorfor nettet kræver det, og fem fejl, hvor halve tegn, mærker og ugyldige bytes ødelægger tekst.","formats":{"gemtext":"https://engineer.company/da/glossary/utf-8/index.gmi","gopher":"https://engineer.company/da/glossary/utf-8/gophermap","html":"https://engineer.company/da/glossary/utf-8/","json":"https://engineer.company/da/glossary/utf-8/index.json","markdown":"https://engineer.company/da/glossary/utf-8/index.md","pdf":"https://engineer.company/da/glossary/utf-8/index.pdf"},"kind":"page","language":"da","title":"Hvad er UTF-8?","url":"https://engineer.company/da/glossary/utf-8/","version":1}