{"canonical_url":"https://engineer.company/sv/glossary/utf-8/","content_markdown":"# UTF-8\n\n## Vad det är\n\nUTF-8 är kodningen som gör om Unicode-text till byte. Unicode-standarden\ndefinierar den som den kodningsform som lagrar varje Unicode-skalärvärde, det\nvill säga varje kodpunkt utom de surrogat som är reserverade för UTF-16, som en\nsekvens på en till fyra byte. Ett tecken som användaren uppfattar som ett kan\ninnehålla flera skalärvärden och därför behöva fler byte. Den är en av standardens tre kodningsformer, vid\nsidan av UTF-16 och UTF-32, och den som webbens egna standarder kräver. Som\nbeteckning, i en HTML-sida eller en HTTP-header, skrivs den oftast med gemener,\nutf-8, och ibland utan bindestreck, utf8; Encoding Standard godtar båda och\nskiljer inte mellan versaler och gemener i beteckningar.\n\nUTF-8 togs fram i september 1992 av Ken Thompson, efter designkriterier som Rob\nPike hade ställt upp, för operativsystemet Plan 9, och den gick under namnen\nFSS-UTF och UTF-2 innan den fick sitt nuvarande namn. RFC 3629, IETF:s\ndefinition från 2003, begränsar den till kodpunkterna U+0000 till U+10FFFF,\nsamma kodrymd som Unicode har. När RFC:n skrevs tillät beskrivningen av UTF-8 i\nISO/IEC 10646 fortfarande sekvenser på upp till sex byte; enligt RFC:n och\nUnicode-standarden tar inget Unicode-skalärvärde mer än fyra.\n\nDe första bitarna i varje byte talar om vilken sorts byte det är. En byte vars\nhögsta bit är 0 är ett tecken i sig, ett av de 128 tecknen i ASCII. En byte som\nbörjar med 110, 1110 eller 11110 inleder en sekvens på två, tre eller fyra byte,\noch varje byte som följer börjar med 10 och bär ytterligare sex bitar av\nkodpunkten. Hela formatet ryms på fyra rader, där x står för kodpunktens bitar:\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\nRaden med tre byte utelämnar surrogaten, U+D800 till U+DFFF: de är inte tecken,\noch varje bytesekvens som skulle koda ett av dem är ogiltig.\n\nFyra egenskaper följer av den formen, och Unicode-standarden ger var och en av\ndem ett namn. UTF-8 är transparent för ASCII: byte från 00 till 7F betyder samma\nsak som i ASCII och förekommer aldrig inuti ett annat tecken. Den är\nsjälvsynkroniserande: en startbyte är lätt att skilja från en fortsättningsbyte.\nEn binär sortering av UTF-8-strängar ger samma ordning som en sortering efter\nkodpunkt. Och den saknar byteordning, så frågan om big-endian eller\nlittle-endian, som UTF-16 och UTF-32 måste besvara, uppstår aldrig.\n\n## Varför det spelar roll\n\nWebben har bestämt sig för den. WHATWG:s Encoding Standard, specifikationen som\nwebbläsare implementerar för att läsa och skriva text, kallar UTF-8 den\nlämpligaste kodningen för utbyte av Unicode och kräver den för nya protokoll och\nformat, och för befintliga format som tas i bruk i nya sammanhang. Den uppmanar\nförfattare att använda UTF-8 och att ange den med beteckningen utf-8. HTML\nföljer efter: kodningen i ett dokument måste vara UTF-8 oavsett om dokumentet\nanger det eller inte, och redigeringsverktyg ska använda UTF-8 som standard för\nnya dokument. En produkt som publicerar sidor, skickar JSON eller tar emot\nformulär förväntas redan tala den.\n\nUtformningen förklarar varför det valet har hållit. Eftersom ASCII-byten aldrig\nförekommer inuti ett annat tecken fungerar ett program skrivet för ASCII\nfortfarande på UTF-8-text: en parser som delar vid kommatecken, snedstreck eller\nradbrytningar hittar dem i en svensk eller ukrainsk mening precis där de står,\noch aldrig mitt i ett å eller ett Ґ. Eftersom ett program som hamnar på en\ngodtycklig position hittar början på ett kodat skalärvärde genom att söka högst fyra byte\nbakåt, och oftast färre, kan avkodningen fortsätta vid en efterföljande korrekt\nsekvens i stället för att förlora resten av filen. Det lovar inte exakt ett\nersättningstecken för varje skadad byte. En sökning efter ett fullständigt\nkodat skalärvärde träffar aldrig en del av ett annat.\nEftersom den binära ordningen är kodpunkternas ordning kan en databas eller ett\nprogram sortera UTF-8-byte utan att avkoda dem. Den ordningen är ändå en teknisk\nordning: den sätter ä före å, där en svensk ordbok avslutar alfabetet med å, ä\noch ö.\n\nStorleken är priset. Unicode-standarden kallar UTF-8 rimligt kompakt: mycket\nmindre än UTF-16 för ASCII-syntax och västerländska språk, och betydligt större\nför asiatiska skriftsystem som hindi, thai, kinesiska, japanska och koreanska.\nI det svenska grundalfabetet tar bokstäver en byte utom å, ä och ö, som tar två;\nandra bokstäver med accent kan behöva fler. Ukrainska tar två byte för varje\nkyrillisk bokstav och en för ASCII-mellanslag, siffror och skiljetecken, men\nandra skiljetecken kan behöva fler. Därför rymmer ett fält som mäts i byte ungefär hälften så\nmånga ukrainska bokstäver som engelska.\n\n## Så ser det ut i praktiken\n\nBytena är lätta att ta fram. Node.js har, precis som en webbläsare, Encoding\nStandards `TextEncoder`, som skriver en sträng 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 ut varje tecken och dess byte i hexadecimal\nform:\n\n```text\nA 41\nå C3 A5\nҐ D2 90\n€ E2 82 AC\n𐌂 F0 90 8C 82\n```\n\nBokstaven A är ASCII och behåller sin enda byte. Bokstaven å är U+00E5, som\nbehöver åtta bitar, en mer än de sju som en ensam byte har plats för, så den får\nmönstret med två byte. Dess värde på elva bitar, 00011100101, delas i 00011\noch 100101; startbyten blir 110 följt av 00011, alltså C3, och\nfortsättningsbyten blir 10 följt av 100101, alltså A5. Det ukrainska Ґ, U+0490,\ntar två byte på samma sätt, eurotecknet tre och den fornitaliska bokstaven 𐌂,\nsom ligger över U+FFFF, fyra. Den första byten i varje sekvens talar om hur lång\nsekvensen är: C3 och D2 börjar med 110, E2 med 1110 och F0 med 11110.\n\nDen här webbplatsen skriver alla sidor i UTF-8 och säger det där HTML ber om\ndet. Det första elementet i head på varje sida är `\u003cmeta charset=\"utf-8\"\u003e`, med\nbeteckningen utf-8, som Encoding Standard föreskriver, och gott och väl inom de\nförsta 1024 byten, där HTML kräver att deklarationen ska stå.\nWebbplatsens [kolofon](/sv/credits/) har ett avsnitt med kontroller utifrån, och\ningen av dem är vår: var och en kör ett test i realtid i stället för att ta vårt\nord för något. En av dem är W3C Internationalization Checker, som läser de\ndeklarationer av språk och teckenkodning som gör varje språkversion av\nwebbplatsen läsbar för rätt läsare.\n\n## Var det går fel\n\n**En bytegräns skär ett tecken i två delar.** En kolumn, ett meddelandefält\neller en buffert som mäts i byte kan sluta mitt i en sekvens. Det danska\nortnamnet Ærø är tre tecken och fem byte, och en gräns på fyra behåller Æ, r och\nden första byten av ø:\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 ensamma startbyten avkodas som U+FFFD, ersättningstecknet, så det\nlagrade namnet slutar med en platshållare där ø stod. Klipp i stället vid en\ngräns mellan Unicode-skalärvärden. `encodeInto` på sista raden gör det på egen hand: med fyra byte\ntill förfogande skriver den bara de tre byten för Æ och r, och rapporterar i\n`read` hur mycket av strängen den tog, räknat i UTF-16-enheter. Kod som klipper\nbyte den redan har kan gå bakåt förbi fortsättningsbyten, de som börjar med 10,\ntill startbyten och klippa där. Det håller UTF-8-sekvensen korrekt; för att bevara ett helt tecken som användaren uppfattar det måste också gränserna mellan grafemkluster respekteras.\n\n**En byteordningsmarkering står först i filen.** UTF-8 saknar byteordning och\nbehöver därför ingen markering, men en konverterare som gör om UTF-16 med en\nbyteordningsmarkering till UTF-8 gör markeringen till de tre byten EF BB BF.\nUnicode-standarden kräver dem inte, säger att de inte påverkar om en\nimplementation följer standarden, och rekommenderar dem inte som signatur för\nUTF-8. Program som läser filer behandlar dem olika. Här innehåller filen\nbom.json de tre byten följda av `{\"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` behåller markeringen som tecknet U+FEFF, och `JSON.parse`\navvisar texten på grund av den. `TextDecoder` följer Encoding Standard och tar\nbort markeringen, och då går samma byte att tolka utan problem. I en webbläsare\nväger markeringen ännu tyngre: Encoding Standard sätter den över allt annat,\nockså över HTTP-headern `Content-Type`. Skriv UTF-8 utan markeringen, och där\nfiler kommer från andra system, avkoda dem med en avkodare som tar bort den,\neller ta bort ett inledande U+FEFF före tolkningen.\n\n**En kontroll läser byten innan de har avkodats.** RFC 3629 beskriver en parser\nsom kontrollerar sin indata i kodad form och avvisar byten 2F 2E 2E 2F,\nsökvägssteget ”/../”, men släpper igenom 2F C0 AE 2E 2F, där C0 AE är en\notillåten stavning av punkt på två byte, som parsern ändå läser som en punkt.\nRFC:n berättar att just det tricket användes av ett utbrett virus som angrep\nwebbservrar år 2001. Sedan Unicode 3.1 är sådana former, som inte är de kortaste\nmöjliga, ogiltiga, och byten C0, C1 och F5 till FF förekommer aldrig i giltig\nUTF-8. En avkodare som följer standarden, `TextDecoder` bland dem, gör om de fem\nbyten till ett snedstreck, två U+FFFD och ”./”, så det finns inget ”/../” kvar\nsom kan slinka igenom. Unicode-standarden är lika sträng med det som kommer\nefter ett fel: en avkodare som sväljer de giltiga byten efter en ogiltig\nstartbyte följer inte standarden och kan utnyttjas för angrepp, och\n`TextDecoder` gör om byten C2 41 42 till U+FFFD följt av AB. Avkoda först med\nplattformens egen avkodare, kontrollera sedan den avkodade texten, och skriv\naldrig en UTF-8-avkodare, eller ett bytemönster som ska göra samma nytta, för\nhand.\n\n**Ersättningen döljer skadan.** Som standard ersätter en avkodare varje ogiltig\nsekvens med U+FFFD och fortsätter. Det är rätt när en sida ska visas och fel när\ndata ska importeras: texten ser nästan normal ut, den sparade kopian har\nförlorat de ursprungliga byten, och avsändaren får aldrig veta var filen var\nskadad. Encoding Standard namnger två fellägen för avkodning, ”replacement” och\n”fatal”, och för identifierare och bytesekvenser inuti ett format eller ett\nprotokoll låter den andra standarder välja en avkodare som misslyckas i stället\nför att ersätta. I JavaScript kastar `new TextDecoder(\"utf-8\", { fatal: true })`\nett `TypeError` för det avklippta namnet ovan i stället för att returnera det.\nAnvänd det fatala läget överallt där text sparas, signeras eller jämförs, avvisa\nindata med ett meddelande som avsändaren kan agera på, och behåll ersättningen\nför visning.\n\n**Deklarationen kommer för sent, saknas eller är fel.** HTML kräver att\nelementet som deklarerar kodningen står i sin helhet inom dokumentets\nförsta 1024 byte. Det kräver en deklaration även när alla tecken är ASCII,\neftersom webbläsaren behöver en kodning för det folk skriver i formulär och för\nURL:er som skript bygger. En beteckning som ser harmlös ut kan också vara fel: i\nEncoding Standard är ”ascii”, ”latin1” och ”iso-8859-1” alla beteckningar för\nwindows-1252, så en sida som deklareras som ASCII läses som windows-1252. Sätt\n`\u003cmeta charset=\"utf-8\"\u003e` först i head, skicka\n`Content-Type: text/html; charset=utf-8` med varje sida, och behandla varje\nannan beteckning på något av ställena som en bugg.\n\n## Läs mer\n\n- [The Unicode Standard, Chapter 3: Conformance](https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-3/#G27817)\n  — definitionen av UTF-8, tabellen över giltiga bytesekvenser,\n  byteordningsmarkeringen och hur en konverterare ska hantera ogiltig indata.\n- [The Unicode Standard, Chapter 2: General Structure](https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-2/)\n  — varför UTF-8 är transparent för ASCII, självsynkroniserande och fri från\n  byteordning, och hur storleken står sig mot 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 från Plan 9 och säkerhetsövervägandena bakom\n  angreppet med överlånga kodningar av en sökväg.\n- [Encoding Standard](https://encoding.spec.whatwg.org/) — WHATWG:s\n  specifikation, som webbläsare följer: varför UTF-8 krävs, hur avkodningen\n  hanterar byteordningsmarkering och fel, och gränssnitten `TextEncoder` och\n  `TextDecoder`.\n- [HTML: Specifying the document's character encoding](https://html.spec.whatwg.org/multipage/semantics.html#charset)\n  — vad en deklaration måste säga, var den måste stå och varför en sida som\n  bara är skriven i ASCII behöver en.\n\n\u003chttps://engineer.company/sv/glossary/utf-8/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur UTF-8 lagrar skalärvärden i en till fyra byte, varför webben kräver det, och fem fel där klippt text, märken och ogiltiga byte förstör text.","formats":{"gemtext":"https://engineer.company/sv/glossary/utf-8/index.gmi","gopher":"https://engineer.company/sv/glossary/utf-8/gophermap","html":"https://engineer.company/sv/glossary/utf-8/","json":"https://engineer.company/sv/glossary/utf-8/index.json","markdown":"https://engineer.company/sv/glossary/utf-8/index.md","pdf":"https://engineer.company/sv/glossary/utf-8/index.pdf"},"kind":"page","language":"sv","title":"Vad är UTF-8?","url":"https://engineer.company/sv/glossary/utf-8/","version":1}