Textcodierung

Code

Ein Code ist Darstellung einer Information mit einem bestimmten System.

Beispielsweise kann die Zahl 15 wie folgt dargestellt, d.h. codiert werden:

Fünfzehn: als Wort geschrieben
$15$: im Dezimalsystem notiert
$1111_{(2)}$: im Binärsystem notiert
XV: als römische Zahl geschrieben
: notiert als Strichliste
⠼⠁⠑: Braille-Schrift

Diese Codierung von Zahlen brauchen wir im Alltag, z.B. wenn wir rechnen oder einen Aufsatz schreiben, aber auch beim Jassen oder bei einem Würfelspiel.

Da der Computer im Binärsystem arbeitet und Dinge digital, also mit Nullen und Einsen abspeichert, müssen die Dinge auch mit Binärzahlen codiert werden.

Codierung und Decodierung

Zeichen werden codiert, indem das zu codierende Zeichen in einer Tabelle gesucht wird und dann durch den entsprechenden binären Code ersetzt wird.

Ein einfacher 5-bit-Code für Textzeichen ist in der folgenden Tabelle dargestellt. Das Leerzeichen wird üblicherweise mit ␣ dargestellt.

Zeichen	Code	Zeichen	Code	Zeichen	Code
␣	`00000`	K	`01011`	V	`10110`
A	`00001`	L	`01100`	W	`10111`
B	`00010`	M	`01101`	X	`11000`
C	`00011`	N	`01110`	Y	`11001`
D	`00100`	O	`01111`	Z	`11010`
E	`00101`	P	`10000`	,	`11011`
F	`00110`	Q	`10001`	-	`11100`
G	`00111`	R	`10010`	.	`11101`
H	`01000`	S	`10011`	?	`11110`
I	`01001`	T	`10100`	@	`11111`
J	`01010`	U	`10101`

Aufgabe: Decodieren Sie den folgenden Text:
01001 01110 00110 01111 10010 01101 00001 10100 01001 01011

Das Decodieren mit der Tabelle ist eher mühsam, da das Suchen eines bestimmten Codes in der Tabelle recht aufwändig ist. Deshalb wird für die Decodierung häufig ein sogenannter Binärbaum verwender.

Der binäre Baum wird parallel zu den binär codierten Daten von oben nach unten durchgegangen. Wenn eine Null auftritt, geht man im Baum nach links, wenn eine Eins auftritt, nach rechts.

Wenn man bei einem Zeichen ankommt, weiss man, dass die abgearbeiteten Bits dieses Zeichen darstellen.

Unten ist der Binärbaum für den Pentacode abgebildet.

ASCII

Der American Standard Code for Information Interchange oder kurz ASCII ist eine ursprünglich 7-bit-lange Zeichencodierung, die 1963 definiert wurde. Sie umfasst 95 normale Zeichen und 33 Steuerzeichen^[1]. Heute werden die 7-bit-Folgen in einem Byte abgespeichert, wobei das höchste Bit (ganz links) immer 0 ist. ASCII ist immer noch ein sehr weit verbreiteter Standard, um Text zu codieren.

Die normalen Zeichen sind in der folgenden Tabelle aufgeführt:

Zeichen	Hex	Binär	Zeichen	Hex	Binär
␣	$20_{(16)}$	`00100000`	P	$50_{(16)}$	`01010000`
!	$21_{(16)}$	`00100001`	Q	$51_{(16)}$	`01010001`
"	$22_{(16)}$	`00100010`	R	$52_{(16)}$	`01010010`
#	$23_{(16)}$	`00100011`	S	$53_{(16)}$	`01010011`
$	$24_{(16)}$	`00100100`	T	$54_{(16)}$	`01010100`
%	$25_{(16)}$	`00100101`	U	$55_{(16)}$	`01010101`
&	$26_{(16)}$	`00100110`	V	$56_{(16)}$	`01010110`
'	$27_{(16)}$	`00100111`	W	$57_{(16)}$	`01010111`
(	$28_{(16)}$	`00101000`	X	$58_{(16)}$	`01011000`
)	$29_{(16)}$	`00101001`	Y	$59_{(16)}$	`01011001`
*	$2\text{A}_{(16)}$	`00101010`	Z	$5\text{A}_{(16)}$	`01011010`
+	$2\text{B}_{(16)}$	`00101011`	[	$5\text{B}_{(16)}$	`01011011`
,	$2\text{C}_{(16)}$	`00101100`	\	$5\text{C}_{(16)}$	`01011100`
-	$2\text{D}_{(16)}$	`00101101`	]	$5\text{D}_{(16)}$	`01011101`
.	$2\text{E}_{(16)}$	`00101110`	^	$5\text{E}_{(16)}$	`01011110`
/	$2\text{F}_{(16)}$	`00101111`	_	$5\text{F}_{(16)}$	`01011111`
0	$30_{(16)}$	`00110000`	`	$60_{(16)}$	`01100000`
1	$31_{(16)}$	`00110001`	a	$61_{(16)}$	`01100001`
2	$32_{(16)}$	`00110010`	b	$62_{(16)}$	`01100010`
3	$33_{(16)}$	`00110011`	c	$63_{(16)}$	`01100011`
4	$34_{(16)}$	`00110100`	d	$64_{(16)}$	`01100100`
5	$35_{(16)}$	`00110101`	e	$65_{(16)}$	`01100101`
6	$36_{(16)}$	`00110110`	f	$66_{(16)}$	`01100110`
7	$37_{(16)}$	`00110111`	g	$67_{(16)}$	`01100111`
8	$38_{(16)}$	`00111000`	h	$68_{(16)}$	`01101000`
9	$39_{(16)}$	`00111001`	i	$69_{(16)}$	`01101001`
:	$3\text{A}_{(16)}$	`00111010`	j	$6\text{A}_{(16)}$	`01101010`
;	$3\text{B}_{(16)}$	`00111011`	k	$6\text{B}_{(16)}$	`01101011`
<	$3\text{C}_{(16)}$	`00111100`	l	$6\text{C}_{(16)}$	`01101100`
\|	$3\text{D}_{(16)}$	`00111101`	m	$6\text{D}_{(16)}$	`01101101`
>	$3\text{E}_{(16)}$	`00111110`	n	$6\text{E}_{(16)}$	`01101110`
?	$3\text{F}_{(16)}$	`00111111`	o	$6\text{F}_{(16)}$	`01101111`
@	$40_{(16)}$	`01000000`	p	$70_{(16)}$	`01110000`
A	$41_{(16)}$	`01000001`	q	$71_{(16)}$	`01110001`
B	$42_{(16)}$	`01000010`	r	$72_{(16)}$	`01110010`
C	$43_{(16)}$	`01000011`	s	$73_{(16)}$	`01110011`
D	$44_{(16)}$	`01000100`	t	$74_{(16)}$	`01110100`
E	$45_{(16)}$	`01000101`	u	$75_{(16)}$	`01110101`
F	$46_{(16)}$	`01000110`	v	$76_{(16)}$	`01110110`
G	$47_{(16)}$	`01000111`	w	$77_{(16)}$	`01110111`
H	$48_{(16)}$	`01001000`	x	$78_{(16)}$	`01111000`
I	$49_{(16)}$	`01001001`	y	$79_{(16)}$	`01111001`
J	$4\text{A}_{(16)}$	`01001010`	z	$7\text{A}_{(16)}$	`01111010`
K	$4\text{B}_{(16)}$	`01001011`	{	$7\text{B}_{(16)}$	`01111011`
L	$4\text{C}_{(16)}$	`01001100`	\|	$7\text{C}_{(16)}$	`01111100`
M	$4\text{D}_{(16)}$	`01001101`	}	$7\text{D}_{(16)}$	`01111101`
N	$4\text{E}_{(16)}$	`01001110`	~	$7\text{E}_{(16)}$	`01111110`
O	$4\text{F}_{(16)}$	`01001111`

Unicode

Unicode ist ein internationaler Standard für Schriftzeichen und Symbole. Das Unicode-Konsortium erstellt einen Katalog von allen sinnvollen Schriftzeichen, welcher ständig erweitert wird. In der Version 14, welche im September 2021 veröffentlicht wurde, umfasst Unicode fast 150'000 Zeichen.

Hier sind ein paar Zeichen aufgeführt, um zu illustrieren, wie umfangreich Unicode ist:

Jedes Unicode-Zeichen hat eine eindeutige Unicode-Nummer, welche häufig als hexadezimale Zahl geschrieben wird. Hier wird die dezimale Schreibweise verwendet.

UTF-8

UTF-8 ist ein Code, der Unicode-Zeichen in Bits übersetzt. Ein Unicode-Zeichen wird mit ein bis vier Byte dargestellt.

Zeichen	Nummer	Bitmuster
A	65	`01000001`
ä	228	`11000011 10100100`
Schwarze Sonne mit Strahlen ☀	9728	`11100010 10011000 10000000`
Affe 🐒	128018	`11110000 10011111 10010000 10010010`

Begriffe

Wir wollen die grundlegenden Begriffe noch anhand der Unicode/UTF-8-Codierung repetieren:

Die Senderin will die Information «Ich bin müde» an den Empfänger übermitteln. Sie codiert die Information als Emoji. Das Handy codiert das Emoji mit dem Unicode/UTF-8-Standard als Bitfolge.

Die Bitfolge wird über das Internet an das Handy des Empfängers übermittelt. Das Handy des Empfängers decodiert die Bitfolge wieder zurück in das entsprechende Emoji. Die Interpretation des Emojis muss vom Empfänger selbst vorgenommen werden.

⭐️ UTF-8 im Detail

Die folgende Tabelle zeigt, wie die Codierung funktioniert:

Unicode-Bereich	Bitmuster	Anzahl Bit
0 bis 127	`0xxxxxxx`	7
128 bis 2047	`110xxxxx 10xxxxxx`	11
2048 bis 65535	`1110xxxx 10xxxxxx 10xxxxxx`	16
ab 65536	`11110xxx 10xxxxxx 10xxxxxx 10xxxxxx`	21

Unicode-Zeichen mit einer Nummer zwischen 0 und 127 werden mit einem Byte dargestellt, welches mit 0 beginnt. Somit ist UTF-8 in diesem Bereich identisch mit ASCII.

Für die anderen Zeichen wird mehr als ein Byte verwendet. Dabei beginnt jedes Byte mit einer oder mehreren 1, gefolgt von einer 0. Die Anzahl 1 im ersten Byte definieren, wie viele Bytes für das Zeichen verwendet werden. Die folgenden Bytes werden mit 10 markiert. Die x werden mit der Binärdarstellung der Unicode-Nummer aufgefüllt.

Der Vorteil dieser Codierung ist, dass zuvorderst bei einem Byte erkannt wird, ob es sich um den Anfang die Fortsetzung eines Zeichens handelt.

Erste Bits	Bedeutung
`0…`	ASCII-Zeichen
`10…`	Fortsetzung eines Zeichens mit mehreren Bytes
`110…`	Beginn eines Zeichens mit zwei Bytes
`1110…`	Beginn eines Zeichens mit drei Bytes
`11110…`	Beginn eines Zeichens mit vier Bytes

Dies wird deutlich, wenn man dies als Binärbaum darstellt:

Praktische Übung

In dieser praktischen Übung speichern Sie auf Ihrem Computer eine Textdatei und überprüfen anschliessend, ob die in der Datei gespeicherten Bits tatsächlich der Unicode/UTF-8-Codierung des Texts entsprechen.

Aufgabe 1 — Textdatei als Bytes betrachten

Schritt 1 — Texteditor öffnen

Die Editor ist eine App, in welcher Textdateien erstellt und bearbeitet werden können. Das kann man auch mit Word, dies ist jedoch umständlicher. Word-Dateien sind keine reinen Textdateien, sie enthalten auch andere Daten wie Formatierungen und Bilder.

Starten Sie die Editor-App, indem Sie im Startmenü nach «editor» suchen:

Schritt 2 — Text eingeben

Geben Sie einen kurzen Text ein. Dieser sollte nicht nur ASCII-Zeichen enthalten, sondern auch ein Umlaut wie «ä» und Emojis. Mit der Tastenkombination ⊞+. wird ein Fenster zur Auswahl von Emojis geöffnet.

Das sieht dann etwa so aus:

Schritt 3 — Textdatei speichern

Speichern Sie die Textdatei unter dem Namen Unicode-Test.txt indem Sie

die Tastenkombination Ctrl+S drücken oder
den Menüpunkt Datei ‣ Speichern auswählen.

Schritt 4 — Datei als Bytes betrachten

Mit dem Online-Tool HexEd.it können beliebige Dateien Byte für Byte betrachtet werden:

HexEd.it

Klicken Sie dort auf Datei öffnen und wählen Sie die vorhin gespeicherte Textdatei aus. Nun sehen Sie die einzelnen Bytes, welche die Datei enthält, beispielsweise:

54 73 63 68 C3 BC 73 73 20 F0 9F 98 80 21

Die Bytes werden wie in der Informatik üblich im Hexadezimalsystem angegeben. Natürlich kann man die Bytes auch binär darstellen:

01010100 01110011 01100011 01101000 11000011 10111100
01110011 01110011 00100000 11110000 10011111 10011000
10000000 00100001

In der binären können die Zeichen, welche mehrere Bytes benötigen, einfach erkannt werden. Sie beginnen mit einer 1. So ist 11000011 10111100 die Codierung der Buchstabens «ü».

Nun können Sie mit der Unicode-Zeichentabelle überprüfen, ob die Bytes tatsächlich der Unicode/UTF-8-Codierung deines Textes entsprechen:

Unicode Table

Im vorliegenden Beispiel sieht das so aus:

Byte(s)	Zeichen
`54`	T
`73`	s
`63`	c
`68`	h
`C3 BC`	ü
`73`	s
`73`	s
`20`	␣
`F0 9F 98 80`	😀
`21`	!

Aufgabe 2 — Nachricht austauschen

Erstellen Sie eine Nachricht und tauschen Sie die Nachricht als Bytes in hexadezimaler Darstellung mit jemandem aus der Klasse aus.

Decodieren Sie die erhaltene Nachricht, indem Sie die Bytes in HexEd.it eingeben und die Datei anschliessend auf Ihren Computer herunterladen und im Texteditor öffnen.

Aufgabe 3 — Andere Dateien

Betrachten Sie andere Dateien (z.B. Word-Dateien, Bilder, …) in HexEd.it und achten Sie auf folgendes:

Finden Sie in anderen Dateien auch Unicode-codierter Text?
Erkennen Sie ein Muster bei den ersten paar Bytes von Dateien des gleichen Typs?

Steuerzeichen sind spezielle Zeichen, welche beispielsweise einen Zeilen- oder Seitenumbruch darstellen. ↩︎

Textcodierung ​

Code ​

Codierung und Decodierung ​

ASCII ​

Unicode ​

UTF-8 ​

Begriffe ​

⭐️ UTF-8 im Detail ​

Praktische Übung ​

Aufgabe 1 — Textdatei als Bytes betrachten ​

Schritt 1 — Texteditor öffnen ​

Schritt 2 — Text eingeben ​

Schritt 3 — Textdatei speichern ​

Schritt 4 — Datei als Bytes betrachten ​

Aufgabe 2 — Nachricht austauschen ​

Aufgabe 3 — Andere Dateien ​