Conversion manuelle des codépoints unicode en UTF-8 et UTF-16

les descriptions sur Wikipedia pour UTF-8 et UTF-16 sont bonnes:

procédures pour votre chaîne d'exemple:

UTF-8

UTF-8 utilise jusqu'à 4 octets pour représenter les codépoints Unicode. Pour le cas de 1 octet, utilisez le modèle suivant:

1-byte UTF-8 = 0xxxxxxx _bin = 7 bits = 0-7F _hex

le premier octet de 2, 3 et 4 octets UTF-8 commence avec 2, 3 ou 4 bits, suivi d'un bit zéro. Les octets suivants commencent toujours par le motif à deux bits 10 , laissant 6 bits pour les données:

2-byte UTF-8 = 110xxxxx 10xxxxxx _bin = 5+6(11) bits = 80-7FF _hex

3-byte UTF-8 = 1110xxxx 10xxxxxx 10xxxxxx _bin = 4+6+6(16) bits = 800-FFFF _hex

4-byte UTF-8 = 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx _bin = 3+6+6+6(21) bits = 10000-10FFFF _hex ^†

^† les codépoints Unicode ne sont pas définis au-delà de 10FF _hex .

vos codépoints sont U+006D, U+0416 et U+4E3D nécessitant respectivement des séquences UTF-8 de 1, 2 et 3 octets. Convertissez en binaire et assignez les bits:

U+006D = 1101101 _bin = 0 1101101 _bin = 6D _hex

U+0416 = 10000 010110 _bin = 110 10000 10 010110 _bin = D0 96 _hex

U+4E3D = 0100 111000 111101 _bin = 1110 0100 10 111000 10 111101 _bin = E4 B8 BD _hex

Dernier octet de la séquence:

6D D0 96 E4 B8 BD

ou si nul chaînes terminées sont souhaitées:

6D D0 96 E4 B8 BD 00

UTF-16

UTF-16 utilise 2 ou 4 octets pour représenter les codépoints Unicode. Algorithme:

U+0000 à U+D7FF utilise 2 octets 0000 _hex à D7FF _hex

U+D800 à U+DFFF sont des codépoints invalides réservés pour 4 octets UTF-16

U+E000 à U+FFFF utilise 2 octets E000 _hex FFFF _hex

U+10000 à U+10FFF utilise 4 octets UTF-16 codé comme suit:

1. soustrayez 10000 _hex du codepoint.
2. résultat Express en binaire 20 bits.
3. utilisez le modèle 110110xxxxxxxxxxxxxx 110111xxxxxxxxxxxxxx _bin pour coder les bits supérieur et inférieur en deux mots de 16 bits.

en utilisant vos codépoints:

U+006D = 006D _hex

U+0416 = 0416 _hex

U+4E3D = 4e3d _hex

maintenant, nous avons un autre problème. Certains magasins de machines les deux octets d'un mot de 16 bits dont le premier octet est le moins significatif (ce qu'on appelle les machines little-endian) et d'autres dont le premier octet est le plus significatif (les machines big-endian). UTF-16 utilise le codepoint U+FEFF (appelé le byte order mark ou BOM) pour aider une machine à déterminer si un flux de byte contient un UTF - 16 big-ou little-endian:

big-endian = ff 00 6D 04 16 4E 3D
1519300920" little-endian = FF FE 6D 00 16 04 3D 4E

Avec les nuls-la résiliation, U+0000 = 0000 _hex :

big-endian = ff 00 6D 04 16 4E 3D 00 00
1519300920" little-endian = FF FE 6D 00 16 04 3D 4E 00 00

étant donné que votre instructeur n'a pas donné de codépoint qui exigeait 4 octets UTF-16, Voici un exemple:

U+1F031 = 1f031 _hex - 10000 _hex = F031 _hex = 0000111100 0000110001 _bin =

110110 0000111100 110111 0000110001 _bin = D83C DC31 _hex

le programme suivant fera le travail nécessaire. Il ne peut pas être "manuel" assez pour vos besoins, mais au minimum vous pouvez vérifier votre travail.

#!/usr/bin/perl

use 5.012;
use strict;
use utf8;
use autodie;
use warnings;
use warnings    qw< FATAL utf8 >;
no warnings     qw< uninitialized >;
use open        qw< :std :utf8 >;
use charnames   qw< :full >;
use feature     qw< unicode_strings >;

use Encode              qw< encode decode >;
use Unicode::Normalize  qw< NFD NFC >;

my ($x) = "mЖ丽";

open(U8,">:encoding(utf8)","/tmp/utf8-out");
print U8 $x;
close(U8);
open(U16,">:encoding(utf16)","/tmp/utf16-out");
print U16 $x;
close(U16);
system("od -t x1 /tmp/utf8-out");
my $u8 = encode("utf-8",$x);
print "utf-8: 0x".unpack("H*",$u8)."\n";

system("od -t x1 /tmp/utf16-out");
my $u16 = encode("utf-16",$x);
print "utf-16: 0x".unpack("H*",$u16)."\n";