UTF-16

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 11 februari 2018; kontroller kräver 27 redigeringar .

UTF-16 ( Unicode Transformation Format ) inom datavetenskap  är ett av sätten att koda tecken från Unicode som en sekvens av 16 -bitars ord . 

Denna kodning låter dig skriva Unicode-tecken i intervallen U+0000..U+D7FF och U+E000..U+10FFFF (totalt antal 1 112 064 ). I det här fallet skrivs varje tecken i ett eller två ord (ett surrogatpar). UTF-16-kodningen beskrivs i Appendix Q till den internationella standarden ISO/IEC 10646 och täcks även av IETF RFC 2781 "UTF-16, en kodning av ISO 10646".

Utseendehistorik

Den första versionen av Unicode (1991) var en 16-bitars kodning med fast bredd; det totala antalet olika tecken var 2 16 ( 65 536 ). I den andra versionen av Unicode (1996) beslutades det att avsevärt utöka kodområdet; för att upprätthålla kompatibilitet med de system där 16-bitars Unicode redan var implementerad och UTF-16 skapades. Området 0xD800-0xDFFF, reserverat för surrogatpar, tillhörde tidigare området "tecken för privat bruk".

Eftersom 2 20 +2 16 −2048 ( 1 112 064 ) tecken kan visas i UTF-16 , valdes detta nummer som det nya värdet för Unicode-kodutrymmet.

Principen för kodning

DC00 DFFE DFF
D800 010 000 0103FE 0103FF
D801 010400 0107FE 0107FF
DBFF 10FC00 10FFFE  

I UTF-16 kodas tecken som dubbelbyteord med alla möjliga värdeområden (från 0 till FFFF 16 ). Det är möjligt att koda Unicode-tecken i intervallen 0000 16 ..D7FF 16 och E000 16 ..FFFF 16 . Området D800 16 ..DFFF 16 uteslutet härifrån används bara för att koda de så kallade surrogatparen - tecken som är kodade med två 16-bitars ord.

Unicode-tecken upp till och med FFFF 16 (exklusive intervallet för surrogat) skrivs som de är med ett 16-bitars ord.

Tecken i intervallet 10000 16 ..10FFFF 16 (mer än 16 bitar) är kodade enligt följande schema:

Endianness

Ett enda UTF-16-tecken representeras av en sekvens av två byte eller två par byte. Vilken av de två byten som kommer först, hög eller låg, beror på endianness . Ett system som är kompatibelt med x86-processorer kallas little endian , medan de med m68k och SPARC -processorer  kallas big endian .

Byteordningsmärke används för att bestämma byteordningen .  I början av texten skrivs koden U+FEFF. Vid läsning, om U+FFFE ansågs istället för U+FEFF, är byteordningen omvänd (liten endian), eftersom U+FFFE-koden i Unicode inte kodar ett tecken och är reserverad bara för att bestämma byten ordning. Eftersom UTF-8 inte använder värdena 0xFE och 0xFF kan du använda byteordermärket som en funktion för att skilja mellan UTF-16 och UTF-8.

UTF-16LE och UTF-16BE

Det är också möjligt att specificera byteordningen externt - för detta måste kodningen beskrivas som UTF-16LE eller UTF-16BE (little-endian / big-endian), och inte bara UTF-16. I det här fallet behövs inte byteordningen (U+FEFF).

UTF-16 på Windows

I Win32 API , som är vanligt i moderna versioner av Microsoft Windows operativsystem , finns det två sätt att representera text: i form av traditionella 8-bitars teckentabeller och i form av UTF-16.

När du använder UTF-16 sätter Windows inga begränsningar på textfilkodningar för applikationer, vilket tillåter dem att använda både UTF-16LE och UTF-16BE genom att ställa in och tolka lämplig byteordningsmarkering . Det interna Windows-formatet är dock alltid UTF-16LE. Denna punkt bör beaktas när du arbetar med körbara filer som använder Unicode-versioner av WinAPI-funktioner. Strängarna i dem är alltid kodade i UTF-16LE [1] .

I NTFS -filsystem , samt FAT med stöd för långa namn, skrivs även filnamn i UTF-16LE.

Procedurexempel

Exemplen nedan är skrivna i pseudokod och tar inte hänsyn till byteordningsmasken - de visar bara essensen av kodning. Byteordning - från yngre till äldre (Little-Endian, Intel x86). Typen Word är ett tvåbyteord (16-bitars heltal utan tecken) och typen UInt32 är ett 32-bitars heltal utan tecken. Hexadecimala värden börjar med ett dollartecken "$".

Kodning

I exemplet WriteWord() en villkorlig procedur som skriver ett ord (samtidigt som den interna pekaren flyttas). Funktionen LoWord()returnerar det minst signifikanta ordet av ett 32-bitars heltal (högre bitar kasseras utan att titta).

// Giltiga kodvärden: $0000..$D7FF, $E000..$10FFFF. Procedur WriteUTF16Char ( Kod : UInt32 ) If ( Kod < $10000 ) Then WriteWord ( LoWord ( Kod )) Else Kod = Kod - $10000 Var Lo10 : Word = LoWord ( Kod Och $3FF ) Var Hi10 : Word = LoWord ( Kod Shr 10 ) WriteWord ( $D800 Or Hi10 ) WriteWord ( $DC00 Or Lo10 ) End If End Procedur

Avkodning

Exemplet ReadWord()läser ett ord från strömmen (förskjuter den interna pekaren). Den kan också justera byteordningen vid behov. Funktionen WordToUInt32expanderar ett två-byte-ord till ett fyra-byte heltal utan tecken och fyller de höga bitarna med nollor. Error()bryter exekveringen (i huvudsak ett undantag ).

// Om det lyckas returneras värden // i intervallen $0000..$D7FF och $E000..$10FFFF. Funktion ReadUTF16Char : UInt32 Var Ledande : Ord // Ledande (första) ord. Var Efterföljande : Ord // Följ (andra) ordet. Leading = ReadWord () ; If ( Leading < $D800 ) Eller ( Leading > $DFFF ) Then Return WordToUInt32 ( Leading ) Else If ( Leading >= $DC00 ) Then Error ( " Ogiltig kodsekvens . " ) Else Var Code : UInt32 Code = WordToUInt32 ( Leading And $3FF ) Shl 10 Efterföljande = ReadWord () Om (( Efterföljande < $DC00 ) Eller ( Efterföljande > $DFFF )) Error ( "Ogiltig kodsekvens . " ) Else Code = Code Eller WordToUInt32 ( Efterföljande Och $ 3FF ) Return ( Kod + $10000 ) End If End If End - funktion

Anteckningar

  1. Använda Byte Order Marks . Datum för åtkomst: 18 februari 2016. Arkiverad från originalet 22 januari 2016.

Länkar