Development @ Characters @ PS-Trainer

Zeichen und Strings
Zeichen und Zeichenketten Die meisten Programmiersprachen unterscheiden nicht zwischen einzelnen Zeichen und Zeichenketten (Strings): In diesem Fall ist ein einzelnes Zeichen ein String der Länge 1 Die Programmiersprachen ↓ C/C++ unterscheiden streng zwischen einzelnen Zeichen und Zeichenketten (Strings).	Leer-String Ein solcher String enthält keine Zeichen, gilt jedoch trotzdem als String-Variable ! Fast alle Programmiersprachen unterscheiden streng zwischen einem Leer-String, der Zahl 0 und dem (unbestimmten) Wert Null.
String-Länge Alle Programme und Programmiersprachen müssen die Länge von Strings codieren. Dazu gibt es 3 gängige Methoden: ● Fixe Länge ● Angabe der Länge ● Terminator-Zeichen ♣ Beachten sie: Je nach Programmiersprache geben die Funktionen zur Berechnung der String-Länge entweder die Anzahl der Zeichen oder der Bytes zurück - das kann unterschiedlich sein ! Fixe Länge: Die Länge ist im Programm, in der Datei oder in einem Standard festgelegt. Kürzere Strings mus man mit Leer-Zeichen füllen, es gibt keine Leer-Strings. Längere Strings sind unzulässig: Sie ergeben Fehler, werden abgeschnitten oder verwenden beim Schreiben den (illegalen) Speicherplatz von anderen Variablen. Strings fixer Länge waren in der IT-Urzeit weit verbreitet und werden heute nur mehr selten verwendet. In Datenbanken und Dateien kann man Strings fixer Länge schneller adressieren.	Angabe der String-Länge Die meisten Programmiersprachen und Datei-Formate verwenden diese Methode. Die ersten 1, 2 oder 4 Byte der String-Variablen werden zur Angabe der Länge verwendet. Das erlaubt flexibles und kompaktes Speichern, braucht jedoch mehr Aufwand zur Adressierung. Mit 1 Byte kann man Strings bis <=255 Zeichen codieren, mit 2 Byte <=65535 und mit 4 Byte <= 4294967295 Terminator-Zeichen Die Programmiersprache ↓ C/C++ und einige Datei-Formate verwenden diese Methode: Ein String kann beliebig lang sein und wird am Ende mit einem dazu reservierten Zeichen abgeschlossen. Dieses Zeichen darf selbst im String nicht vorkommen, oder muss darin 'maskiert' werden. ↓ C/C++ verwendet als Terminator ein Null-Byte, das Datei-Format CSV (Comma-Separated Values) einen Beistrich. Einige Dateien verwenden als Trennzeichen ein führendes (!) Tabulator-Zeichen (HT, → ASCII-Code 09). ♦ Details zu den Funktionen pack() und unpack() (Codierung und Decodierung interner Daten-Formate).
Zeichensatz Strings können prinzipiell Bytes aller Werte (0..255) enthalten. Zur korrekten Interpretaion ist die Vereinbarung eines → Zeichensatzes notwendig = einer Verweis-Tabelle zur Verknüpfung von Zeichen und Code-Zahlen. ● Für den → ASCII-Zeichensatz und die meisten nationalen oder regionalen Zeichensätze (z.B. → Latin-1) wird pro Zeichen 1 Byte verwendet. Damit kann man allerdings nur maximal 256 verschiedene Zeichen angeben. ● Wenn man zusätzliche Zeichen codieren will, dann muss man entweder für Teile des Strings andere nationale Zeichensätze vereinbaren (sehr aufwändig) oder die betreffenden Zeichen maskieren, d.h. durch besondere Maßnahmen umschreiben. Beispiel: Codierung des Umlauts Ä in → HTML: Ä oder Ä oder Ä - das kostet z.B. zusätzlich 5 Byte je Umlaut.	Der Standard → Unicode Zeichensatz definiert derzeit max. 2097152 (je nach Betriebssystem mindestens 65536) verschiedene Zeichen. Zur Codierung stehen verschiedene Transport-Formen (→ UTF) zur Verfügung. Das meist-verwendete Unicode Transport-Format ist → UTF-8: ● In diesem Fall werden die weltweit meist-verwendeten 128 → ASCII-Zeichen so wie in jedem anderen Zeichensatz mit je 1 Byte codiert. ● Weitere 1920 Zeichen werden mit je 2 Byte codiert, darunter alle in Europa, Nord- und Südamerika verwendeten Zeichen (z.B. die deutschen Umlaute). ● Weitere 63488 Zeichen werden mit je 3 Byte codiert, darunter das €-Zeichen. ● Weitere ca. 2 Mio Zeichen kann man mit je 4 Byte codieren, darunter die meist-verwendeten asiatischen Zeichen.

Schrift-Familie

In der Informatik wird zwischen der Bedeutung eines Zeichens und seiner Darstellung unterschieden.

Die Bedeutung wird durch den → Zeichen-Code bestimmt: Die ersten 128 Zeichen (Code 0...127) sind fast immer eindeutig (Ausnahme: → EBCDIC). Verwenden sie für alle anderen Zeichen (Code>=128) am besten den weltweit eindeutigen → Unicode, und keine nationalen oder regionalen Zeichensätze.

● Die Zeichen-Bedeutung fällt in die Verantwortung der/des HerstellerIn eines IT-Produkts (Datei, Webseite...).

Die Darstellung eines Zeichens wird durch die jeweilige Schrift-Familie (font-family) bestimmt.
Die Anzahl der darstellbaren Zeichen ist je nach Familie unterschiedlich !

Auf modernen Betriebssystemen sind mindestens einige Familien installiert, mit denen man alle → Unicode-Zeichen 0...65535 darstellen kann.
Darüber hinaus gibt es eine sehr große Anzahl von Schrift-Familien, die man z.T. kostenfrei aus dem internet laden kann: Viele davon enthalten viel weniger Zeichen, z.B. nur Großbuchstaben, oder keine deutschen Umlaute.

● Die Darstellung fällt in die Verantwortung der/des IT-KonsumentIn: Wenn z.B. Zeichen dieser Webseite nicht korrekt dargestellt werden, dann können sie die von ihrem Browser verwendete Schrift-Familie ändern.

Zeichen in Kalkulations-Programmen

LibreOffice, OpenOffice, MS-Excel, ...

Umwandlung CodeNummer → Zeichen:

Dazu dient die veraltete, aber in jedem Programm enthaltene Funktion ZEICHEN(), die man nur auf CodeNummern im Bereich 0..255 anwenden kann.
● Besser ist die LibreOffice-Funktion UNIZEICHEN() für alle → Unicode Zeichen, auf gängigen Windows-Systemen immehin im Bereich 0..65535

Dieses Beispiel erzeugt in Spalte B eine Liste aller druckbaren Zeichen mit den Code-Nummern 32 (Leerzeichen) bis 126 und in Spalte C eine Liste der Zeichen-Codes.
Man beginnt die Tabelle in Zeile 30: In diesem Fall entspricht die Zeile genau der Code-Nummer.

	A	B	C
31		ZEICHEN	CODE
32	32	=ZEICHEN(A32)	=CODE(B32)
33	=A32+1	=ZEICHEN(A33)	=CODE(B33)
34	=A33+1	=ZEICHEN(A34)	=CODE(B34)
...
127	=A126+1	=ZEICHEN(A127)	=CODE(B127)
128	=A127+1	=ZEICHEN(A128)	=CODE(B128)
...
255	=A254+1	=ZEICHEN(A255)	=CODE(B255)
256	=A255+1	=UNIZEICHEN(A256)	=UNICODE(B256)
...

♣ Tipp: Ab Zeile 33 kann man die Zellen nach unten ausfüllen;
Die Unicode-Funktionen ersetzen (wenn verfügbar) die veralteten Funktionen. Man kann sie bereits ab Zeile 32 verwenden, bzw. muss sie ab Zeile 256 verwenden.

Umwandlung Zeichen → CodeNummer

Dazu dient die in jedem Programm enthaltene Funktion CODE() für den Bereich 0..255
● Besser geeignet ist die LibreOffice-Funktion UNICODE() (auf Windows für den Bereich 0..65535

Veraltete Funktionen: ZEICHEN(), CODE()

● Bis CodeNr=126 werden die druckbaren Zeichen des Standard → ASCII-Codes angezeigt, auf CodeNr=127 das nicht druckbare Delete-Zeichen.
● Auf CodeNr 128..159 folgen die von Microsoft an Stelle der Standard Steuerzeichen verwendeten Zeichen.
● Auf CodeNr 160..255 folgen die Zeichen des Standard Unicode, identisch mit Code → ISO-8859-1 (Latin-1).

Aktuelle Funktionen: UNIZEICHEN(), UNICODE()

● Auf CodeNr 256..65535 folgen die Zeichen des Standard Unicode.
♣ Unicode-Zeichen sind (im Gegensatz zu den Zeichen der → ISO-8859-Codes und der nicht Standard-konformen Windows-Codes weltweit eindeutig zugeordnet, d.h. sie werden unabhängig von Betriebssystem, Software und Version korrekt angezeigt und nicht durch andere nationale Sonderzeichen ersetzt.

Unicode-Zeichen

Alle gängigen Programme bieten die Möglichkeit, zumindest die wichtigsten der auf Windows verfügbaren 65536 → Unicode-Zeichen einzusetzen.
Die Menü-Befehle sind unterschiedlich benannt. Suchen sie nach 'Unicode, Sonderzeichen, ...'

• Unicode-Zeichen sind Buchstaben - Man kann sie daher aus jedem Text kopieren und in einen anderen Text einsetzen, sowie in jede Größe und Farbe setzen. Die Auswahl der Schrift-Familie ist teilweise auf die meist-verwendeten begrenzt, da manche Schriften (Fonts) noch keine oder nur wenige Unicode-Zeichen enthalten.
• Wenn sie einzelne Unicode-Zeichen oft benötigen, dann können sie diese in einen beliebigen Text eintragen und jederzeit von dort kopieren.
Die → Unicode-Seite dieses Webs bietet die Möglichkeit, alle (Live an ihrem eigenen System) verfügbaren Zeichen anzusehen und zu kopieren.
• Verwenden sie keine 'Bilderschrift' (Dingbats, ...) - Damit hergestellte Dokumente funktionieren meist nur am eigenen PC. Man findet alle benötigten Symbole im Unicode und kann damit weltweit eindeutige Dokumente erzeugen.

Die hier vorgestellten Standard Text-Funktionen (aller Kalkulations-Programme) sind bei der Arbeit mit Zeichen nützlich:

Länge

Die Funktion liefert die Anzahl der Zeichen, inkl. führender oder folgender Leerzeichen. Zahlen werden vor Anwendung der Funktion in Texte (Strings) umgewandelt.

Beispiel:

LÄNGE("ABCxyz") = 6
LÄNGE(456) = 3

Verkettung und Typ-Umwandlung

Der Operator & wird zur Verkettung von Strings verwendet.

Als Elemente zur Verkettung geeignet sind Strings ("ABC"), Zeichen [ZEICHEN(65)] oder Adressen von Zellen (A1), deren Inhalt verkettet wird.

♣ Tipp: Ohne besondere Maßnahmen werden Zahlenwerte immer rechtsbündig, Strings immer linksbündig dargestellt. Man kann falsch formulierte Zahlen daran erkennen, dass sie linksbündig angezeigt werden.

Beispiel:

"A"&ZEICHEN(66)&"C" = "ABC"

Zahlenwerte werden bei Verkettung in Strings umgewandelt:

"A"&123&"Z" = "A123Z"

Umgekehrt werden nur solche Strings in Zahlen umgewandelt, die ausschließlich Ziffern (Vorzeichen, Kommazeichen) enthalten:

"123"+1 = 124
"123x"+1 = #WERT! (Fehler-Meldung)

Die Funktion TEXT() erlaubt die Umwandlung von Zahlen in Strings unter Angabe eines Format-Strings:

TEXT(123;"00000#") = "000123"

Beispiele für Format-Strings finden sie im Menü

Suchen

Beide Funktionen liefern die Position des gesuchten Textes als Zahl.

Die erste Position wird mit der Zahl=1 bezeichnet. Die Suche kann optional auch nach dem ersten Zeichen beginnen.

SUCHEN(Suchtext; Text; Erstes_Zeichen) ignoriert den Unterschied zwischen Groß- und Kleinbuchstaben. Beispiel:

SUCHEN("B"; "abcABC"; 1) = 2

FINDEN(Suchtext; Text; Erstes_Zeichen) unterscheidet streng zwischen Groß- und Kleinbuchstaben. Beispiel:

FINDEN("B"; "abcABC"; 1) = 5

Teile

Die 3 Funktionen isolieren Teile aus einem Text.

Sie werden oft mit dem Ergebnis einer Suche kombiniert: In diesem Fall isoliert man den Teil von oder bis zu einer bestimmten Position.

LINKS(Text; Anzahl_Zeichen) isoliert die angegebene Anzahl am Beginn des Textes. Beispiel:

LINKS("ABCxyz";2) = "AB"

LINKS(Text; Anzahl_Zeichen) isoliert die angegebene Anzahl am Ende des Textes. Beispiel:

RECHTS("ABCxyz";2) = "yz"

TEIL(Text; Erstes_Zeichen; Anzahl_Zeichen) isoliert die angegebene Anzahl an einer beliebigen Position. Beispiel:

TEIL("ABCxyz";3;2) = "Cx"

Ersetzen

Die Funktion ERSETZEN() wird oft mit einer Suche kombiniert. Man ersetzt damit einen an einer bestimmten Position gefundenen Text.

ERSETZEN(Alter_Text; Erstes_Zeichen; Anzahl_Zeichen; Neuer_Text) ersetzt einmalig einen durch seine Position bestimmten Text. Beispiel:

ERSETZEN("ABCxyz"; 3; 2; "*") = "AB*yz"

Wechseln

Diese Funktion eignet sich gut für allgemeine Änderungen in vielen verschiedenen Texten. WECHSELN(Text; Alter_Text; Neuer_Text; ntes_Auftreten) ersetzt jedes Auftreten einer durch ihren Inhalt bestimmten Zeichenfolge.
Wenn man das n_te_Auftreten nicht definiert, wird die Funktion auf jeden Treffer angewendet.

Beispiel:

WECHSELN("täglich"; "ä"; "ae") = "taeglich"

Umwandlung einer Zahl (hier in Zelle A1) in einen Zahlen-String mit Dezimal-Punkt (international) und eines internationalen Zahlen-Strings (hier in A2) in eine Zahl::

WECHSELN(TEXT(A1;"0,0");",";".") = 123.456
WERT(WECHSELN(A2;".";",")) = 123,456

Zeichen in Webseiten (HTML)

HTML ist jene 'Programmiersprache' (Auszeichnungs-Sprache), in welcher alle Webseiten abgefasst sind.

ASCII-Zeichen

● (Fast) Alle druckbaren → ASCII-Zeichen dürfen in einem HTML-Quelltext vorkommen. Das sind die Zeichen mit den Codes 32..126

● Davon ausgenommen sind jene 4 Zeichen, welche in HTML für besondere Funktionen ('Programme') verwendet werden.

● Nationale Sonderzeichen mit CodeNummern >126 (z.B. ÄÖÜäöüß€ ) sollte man keinesfalls im Quelltext verwenden - auch dann nicht, wenn es durch Angabe eines nationalen Zeichensatzes theoretisch erlaubt wäre. Man erkennt solche Webseiten an den falsch dargestellten Umlauten...

● Lösung: Maskieren sie diese Zeichen so wie im Absatz unten angegeben.

Ignorierte Zeichen

Leerzeichen (space, blank), Tabulator und Zeilen-Umbruch (CR, LF) werden in HTML ohne Unterschied als Trennzeichen interpretiert, d.h. in jedem Fall wie ein einfaches Leerzeichen angezeigt.

• Mehrfach hintereinander gesetzte Trennzeichen werden ignoriert, d.h. genau so wie ein einzelnes Leerzeichen angezeigt.
• Ausnahme: Innerhalb des HTML-Elements <pre></pre> werden auch die Trennzeichen genauso dargestellt wie in der Textverarbeitung.

Maskierung

Keines der für → HTML- oder → XHTML-Funktionen verwendeten Zeichen darf in den Daten von HTML-Quelltext vorkommen. Die in der Tabelle gezeigten Zeichen dürfen nur für HTML-Funktionen verwendet werden. Beispiel:

<b>Das ist erlaubt<b> aber das < ist > verboten !
Maskiert < ist > erlaubt.

Maskierung der reservierten Zeichen in → HTML oder → XHTML:

Chr	mnem	dec	hex
"	"	"	"
&	&	&	&
<	<	<	<
>	>	>	>

Die in Spalte Chr angeführten Zeichen muss man im Quelltext durch einen der 3 Codes (mnemonisch, dezimal, hexadezimal) ersetzen (maskieren).

Unicode

Alle Zeichen mit CodeNummern >126 müssen maskiert werden. Im deutschen Sprachraum betrifft das die Umlaute ÄÖÜäöüß und das €-Zeichen.
● Für diese und die meisten anderen häufigen Sonderzeichen bietet HTML die Maskierung mit mnemonischen Codes, z.B. ä (a-Umlaut) für das kleine ä

• Unicode geht jedoch weit über die nationale Reichweite anderer Zeichensätze hinaus. Man kann (in Webseiten, Texten oder anderen Dokumenten) Zeichen aus allen weltweit gängigen Sprachen verwenden, z.B.

äöü αβγ АБГ åðø usw.

Man kann im HTML-Quelltext jedes Zeichen wahlweise mnemonisch, dezimal (selten) oder hexadezimal (empfohlen) angeben.
♦ Details: Liste aller mnemonischen HTML-Codes.

Codierung von Sonderzeichen in → HTML oder → XHTML:

Chr	HTML		Chr	HTML
Ä	Ä	Ä	ä	ä	ä
Ö	Ö	Ö	ö	ö	ö
Ü	Ü	Ü	ü	ü	ü
			ß	ß	ß
€	€	€

Beispiel: Dieser HTML-Quelltext

Ein größerer Betrag in €

wird auf der Webseite so dargestellt:

Ein größerer Betrag in €

Das letzte Beispiel der Tabelle bezeichnet das 'geschützte Leerzeichen'   (non-breakable space).

Zeichen in der Linux-Konsole (Bash)
Umwandlung CodeNummer → Zeichen Der ANSI-C Standard (↓ Programmiersprache C/C++) definiert einige häufig verwendete Zeichen als 'Escape-Sequenzen', die auch in den meisten Versionen der Linux Shell-Konsole so verwendet werden. • Die Anweisung echo interpretiert Escape-Sequenzen (nur) mit Option -e Details finden sie im Manual # man echo	Beispiel: str=A'\x42'C echo $str echo -e $str Ausgabe: A\x42C ABC

Zeichen in Basic (LibreOffice-Baisc, Visual Basic VBA)
Position und Länge In VisualBasic wird (im Gegensatz zu modernen Programmiersprachen) die Position von Zeichen in Strings (Text-Variablen) beginnend mit 1 bezeichnet.	Bei Angabe der Länge wird wie üblich das erste Zeichen mit 1 gezählt: s = "abc" k = Len(s) // ergibt k=3
Umwandlung CodeNummer → Zeichen Basic bietet dazu die Funktion Chr() Sie akzeptiert in LibreOffice Argumente im Bereich 0..65535, in MS-Programmen nur im Bereich 0..255 Nur in MS-Programmen gibt es auch die Funktion ChrW() für Argumente im Bereich 0..65535. In den gleichen (!) Progamm-Versionen fehlt allerdings die entsprechende Kalkulations-Funktion UNIZEICHEN() Die Funktion des Beispiels ersetzt diese Funktion, d.h. man kann sie in Kalkulations-Programmen (Excel) als 'Benutzerdefinierte Funktion' verwenden. In LibreOffice oder OpenOffice ist das nicht notwendig, da dort die Standard-Funktion UNIZEICHEN() geboten wird.	Beispiel: Diese Basic-Funktion gibt ein (ASCII- oder) Unicode-Zeichen zurück (nur für MS-Programme notwendig, funktioniert jedoch auch in LibreOffice). Function unicode_chr(unicode As Long) As String If (unicode < 0) Then unicode = 0 On Error GoTo libre unicode_chr = ChrW(unicode) Exit Function libre: unicode_chr = Chr(unicode) End Function
Umwandlung Zeichen → CodeNummer Basic bietet dazu die Funktion Asc() Sie akzeptiert in LibreOffice die ersten 65536 Unicode-Zeichen, in MS-Programmen nur die ersten 255 Zeichen. Nur in MS-Programmen gibt es auch die Funktion AscW() für die ersten 65536 Unicode-Zeichen. Die von AscW() zurückgegebenen Zahlen werden für Zeichen > 32767 als negative Zahlen interpretiert, daher korrigiert die rechts vorgestellte Funktion dieses Verhalten. Die Funktion des Beispiels kann die Standard-Funktion UNICODE() in MS-Excel ersetzen.	Beispiel: Diese Basic-Funktion gibt die (ASCII- oder) Unicode-Nummer zurück (nur für MS-Programme notwendig, funktioniert jedoch auch in LibreOffice). Function unicode_asc(zeichen As String) As Long Dim uc As Long On Error GoTo libre uc = AscW(zeichen) If uc < 0 Then uc = uc& + &H10000 unicode_asc = uc& Exit Function libre: unicode_asc = Asc(zeichen) End Function
Non-Standard Bei allen Produkten des IT-Marktführers muss man besonders auf den → Code-Bereich U+80..U+9F achten. Dieser Bereich enthält in allen Standard Zeichensätzen nicht druckbare Steuerzeichen, in jenen von Microsoft einige bunt zusammengewürfelte Zeichen aus unterschiedlichen Bereichen. Die meisten dieser Zeichen haben kaum Bedeutung, das €-Zeichen kommt jedoch oft vor: Es wird von M$-Programmen meist mit CodeNummer=0x80 codiert und nicht mit der Standard CodeNummer=0x20AC Das führt in vielen Fällen zu Problemen. Man kann das vermeiden, wenn man das Zeichen sauber codiert (ideal, aber mit M$-Programmen nicht durchführbar) oder zumindest nachträglich korrigiert - zum Beispiel mit der rechts gezeigten Funktion.	Function euro_corr(text As String) As String On Error GoTo libre euro_corr = Replace(text, Chr(&H80), ChrW(&H20AC)) Exit Function libre: euro_corr = Replace(text, Chr(&H80), Chr(&H20AC)) End Function M$-Programme haben übrigens kein Problem, richtig codierte Texte anzuzeigen, z.B. solche, die mit der gezeigten Funktion korrigiert wurden. Sauber codierte Texte funktionieren allerdings überall, nicht nur in M$-Umgebung.
Suche Funktion InStr() sucht nach der ersten gefundenen Position eines Musters. Die Zeichen-Position wird ab 1 gezählt. Argumente: Start-Position (optional, hier nicht verwendet), durchsuchter Text (Haystack), gesuchtes Muster (Needle). Bei leerem String oder erfolgloser Suche ist das Ergebnis 0	s = "ABCabc" p = InStr(s, "a") ' ergibt p=4
Teile Die Funktionen Left(Text,Länge), Mid(Text, Start,Länge) und Right(Text,Länge) geben Teil-Strings zurück, so wie rechts gezeigt.	s = "Das ist ein Test" t = Left(s,3) ' ergibt t="Das" u = Mid(s,5,3) ' ergibt u="ist" v = Right(s,4) ' ergibt v="Test"
Ersetzen VBA kennt keine Regulären Ausdrücke, daher braucht man andere Funktionen, z.B. Replace(Text, gesuchtes_Muster, Ersatz_Text) Das Beispiel ersetzt in einem Text das nur im deutschen Sprachraum übliche Dezimal-Komma durch den intenational verwendeten Dezimal-Punkt.	s = "123,456" t = Replace(s, ",", ".") ' ergibt s="123.456"
Sonstige String-Funktionen Funktionen LCase(), UCase() zur Umwandlung in kleine oder große Buchstaben. Funktionen LTrim(), RTrim(), Trim() zum Entfernen führender und/oder folgender Leerzeichen. Mit Funktion String() kann man Text-Strings aus beliebig oft wiederholten Zeichen herstellen. Das Beispiel zeigt, wie man das verwenden kann, um Zahlen-Strings fixer Länge (hier: 10 Zeichen) mit führenden Nullen darzustellen. Das funktioniert ohne Rücksicht auf die (national unterschiedlich) eingestellten Zahlen-Formate.	Umwandlung in kleine bzw. große Buchstaben: s = "abcXYZ" k = LCase(s) ' ergibt k="abcxyz" g = UCase(s) ' ergibt g="ABCXYZ" Strings aus wiederholten Zeichen s = String(10,"0") ' ergibt s="0000000000" n = 1234 s = Right(s & CStr(n),10) ' ergibt s="0000001234"
Weitere String-Funktionen von und mit VBA ► auf der Seite VBA-Strings: DatenTyp, Operatoren, Grund-Funktionen, Teile und Wiederholungen, ...	► auf der Seite Split() & Join(): Zerlegung und Zusammensetzung von "Strukturierten Strings" wie z.B. IP-Adressen, Datei-Pfade, Internet-Adressen, Datum & Zeit

Zeichen in C/C++
C und C++ sind Low-Level Programmiersprachen mit strengen Regeln. Sehr schnell, aber für Amateure wenig geeignet.	Die Programmierung von Zeichen und Strings erfolgt in vielen Details anders als in anderen Programmiersprachen und ist für AnfängerInnen relativ schwierig. Hier werden lediglich einige einfache Beispiele vorgestellt.
Deklaration In C/C++ muss man alle verwendeten Elemente vor ihrer Verwendung deklarieren, insbesondere auch die Variablen. Die Deklaration muss die Type und den Namen der Variablen und enthalten. • C/C++ unterscheidet strang zwischen einzelnen Zeichen und Zeichenketten (Strings).	Deklaration einer Zeichen-Variablen: char c; Der Ort der Deklaration bestimmt den Bereich der Gültigkeit (z.B. global oder lokal in einer einzelnen Funktion oder Klasse).
Zeichen und ganze Zahlen In der Programmiersprache C/C++ sind Zeichen und positive ganze 1-Byte-Zahlen äquivalent. • Es kommt auf das → Ausgabe-Format an, ob eine Variable als Zeichen (%c) oder als ganze Zahl (%d) angezeigt wird.	Daher ist es u.a. möglich, mit Zeichen/Bytes auch zu rechnen: Addition von +1 ergibt das nächste folgende Zeichen (nächster ↓ Absatz), Addition von +32 wandelt Großbuchstaben in Kleinbuchstaben um, usw.
Zuweisung von Zeichen Zur Zuweisung eines ASCII-Zeichens an eine Variable vom Typ char schließt man das Zeichen in ' Single Quotes ein. • Zahlen >127 oder non-ASCII-Zeichen werden als negative Werte interpretiert. In jedem Fall wird daraus wieder ein ASCII-Zeichen, wenn man den Wert (mit & 0x7F) auf 7 Bit abschneidet. ♦ Details zu BitLevel-Operationen	Beispiel: char c,d,e,f; c = 'A'; printf("%c = %d\n ",c,c); d = c + 1; printf("%c + 1 = %c\n",c,d); e = 67; printf("%c = %d\n",e,e); f = 218 & 0x7F; printf("%c = %d\n",f,f); Ausgabe: A = 65 A + 1 = B C = 67 Z = 90
Escape-Sequenzen Im ANSI-C-Standard wurde festgelegt, einige Sonderzeichen mit Hilfe einer Syntax wie \n auszudrücken. • Das \ Backslash-Zeichen und das unmittelbar folgende Zeichen bilden eine Einheit mit spezieller Bedeutung (in diesem Fall das ASCII-Zeichen LF = LineFeed, neue Zeile, Zeilen-Umbruch, mit der CodeNummer 10 = 0x0A).	Die Standard C-Escape Sequenzen wurden von vielen anderen Programmiersprachen und Programmen übernommen. • Die allgemeine Form \xhh definiert ein Zeichen mit seinem 2stelligen hexadezimalen ASCII-Code: char c; c = '\x5A'; printf("c = '%c' = %d = 0x%X\n",c,c,c); Ausgabe: c = 'Z' = 90 = 0x5A
Umwandlung CodeNummer → Zeichen Der Operator oder die Funktion char liefert das ASCII-Zeichen einer ganzen Zahl. Je nach dem verwendeten Compiler ist eine der beiden Versionen oder beide verwendbar.	int n; char c; c = char(n); c = (char)n;
Umwandlung Zeichen → CodeNummer Operator bzw. Funktion int liefern die CodeNummer eines Zeichens.	n = int(c); n = (int)c;
Strings (Texte, Zeichenfolgen) werden in C/C++ als Arrays der Type char behandelt. Diese Programmiersprache speichert nicht die Länge eines Strings, sondern verwendet als End-Marke ein Null-Byte \0 Daher kann ein String in C/C++ zwar beliebig lang sein, jedoch keine Null-Bytes enthalten. • Prinzipiell ist die/der EntwicklerIn dafür verantwortlich, dass jeder Srtring mit einem Null-Byte abgeschlossen wird. • Das Verhalten der Funktionen ist nicht einheitlich: Manche setzen automatisch ein Null-Byte an das String-Ende, manche kümmern sich nicht darum ! • Die Zuweisung einer String-Konstanten bei der Deklaration (Beispiel cb) ist meist möglich. Davon wird jedoch abgeraten, weil sie als normale Anweisung illegal ist. • Das Beispiel rechts zeigt die Zuweisung einzelner Bytes und die Ausgabe mit → Funktion printf()	Deklaration von String-Variablen: char ca[20]; char cb[20]="ABC"; char pcc; Zuweisung von String-Daten // ca="illegal"; ca[0]=65; // ASCII "A" ca[0]='B'; ca[1]=0x43; // ASCII "C" ca[2]=0; printf("ca = %s \n",ca); Ausgabe: (Details zur → Funktion printf() ) ca = ABC Das Verweis-Ziel des Pointers pcc ist anfangs nicht definiert, daher ist dafür auch kein Speicher reserviert. Zur Anwendung muss man ihn auf eine verwendbare Adresse setzen, z.B.: pcc = ca; Der Pointer pcc weist danach auf die gleiche Adresse wie ca und damit auf den gleichen String.
String-Library Die Standard-Bibliothek <string.h> bietet die wichtigsten Funktionen zur Programmierung von Strings. • Die Zuweisung von Daten an einen String erfolgt am besten mit Funktion strcopy() • Zur Verkettung von Strings (Konstanten und Variablen) verwendet man Funktion strcat()	Einige wichtige Funktionen der Bibliothek <string.h> #include <string.h> strcpy(cb,"xyz"); strcat (ca,"rst"); strcat (ca,cb); i = strlen(ca); // Laenge in Bytes
Funktionen C/C++ Funktionen geben niemals einen String zurück. Das aufrufende Parent-Programm übergibt den String (=den Pointer auf das chr-Array) als Argument an die Funktion (so wie für die Funktionen von <string.h> gezeigt).	In diesem Fall verwendet die Funktion keine Kopie, sondern den gleichen Speicherplatz wie das Parent-Programm, welches nach Ausführung der Funktion ohne Rückgabe direkt auf den allenfalls geänderten String zugreifen kann.
Unicode Die Standard-Funktionen verwalten char-Variable als Bytes, ohne Rücksicht auf ihre Bedeutung. • Daher ist lediglich die Zuweisung von → ASCII-Zeichen<128 zuverlässig (Beispiel ca). • Bei Zuweisung von Codes >=128 hängt es vom → Zeichensatz des Ausgabe-Programms ab, welches Zeichen angezeigt wird, z.B. → DOS (Beispiel cb) oder → ISO-8859-1 (Latin-1, Windows, Beispiel cc). In String-Konstanten kann man jedem Byte mit dem Prefix \x einen eindeutigen hexadezimalen Wert zuweisen. • Die direkte Codierung von → Unicode-Zeichen >U+00FF ist nicht möglich. Man verwendet eines der → UTF-Formate, vorzugsweise → UTF-8: In diesem Fall werden die deutschen Sonderzeichen mit je 2 Byte codiert.	Codierung von → ASCII-Zeichen und von deutschen Umlauten: strcpy(ca,"ABC"); // ASCII Deutsche Umlaute (Ä, Ö, Ü): strcpy(cb,"\x8E\x99\x9a"); // DOS strcpy(cc,"\xC4\xD6\xdc"); // ISO-8859-1 // UTF-8: strcpy(cd,"\xC3\x84\xC3\x96\xC3\x9C"); Bei Ausgabe an eine → Windows-Konsole (cmd.exe) wird nur der String cb korrekt angezeigt. Bei Ausgabe an eine Text-Datei wird der → UTF-8 String cd von den meisten Text-Editor Programmen richtig interpretiert.

Zeichen in CSS CSS ist eine 'Sprache' zur Angabe von Layout und Format. Wichtig, da für alle Produkte der modernen Informatik anwendbar.
Umwandlung CodeNummer → Zeichen CSS erlaubt u.a. auch die Manipulation von Daten (Content). Man kann den Inhalt eines Elements durch führende (before) oder folgende (after) Zeichen oder Texte ergänzen. Sonderzeichen kann man mit Backslash und ihrem 4stelligen hexadezimalen → Unicode bezeichnen.	Beispiel: Das Zeichen U+25CF (●) wird am Anfang aller HTML <h2>-Elemente eingefügt: h2:before{content:"\25CF";}
Schrift-Familie in jedem Betriebssysteme sind Schrift-Familien für diese 3 Standard Schrift-Formen installiert: serif, sans-serif, monospace Das jeweilige Betriebssystem legt fest, welche Schrift-Familie mit diesen Begriffen verknüpft wird. Meist enthalten diese Schriften besonders viele Zeichen, z.B. mindestens die ersten 0...65535 → Unicode-Zeichen.	Mit der CSS-Anweisung font-family kann man eine Liste von Schrift-Familien angeben. Jede dieser Listen sollte mit einer der 3 Standard Familien-Namen enden, z.B. font-family: Helvetica, Verdana, Arial, sans-serif;

Zeichen in Javascript
Position und Länge In Javascript (und allen anderen modernen Programmiersprachen) zählt man die Position von Zeichen in Strings (Text-Variablen) mit 0 beginnend.	Bei Angabe der Länge wird allerdings (so wie im natürlichen Sprachgebrauch) bereits das erste Zeichen mit 1 gezählt: s = "abc"; k = s.length; // ergibt 3 Die Anwendung auf eine Zahl ergibt Fehler: z = 123; k = z.length; // ergibt undefined
Umwandlung CodeNummer → Zeichen Direkt im Code angegebene Zeichen werden mit \ Backslash und ihrer 4stelligen hexadezimalen CodeNummer bezeichnet. Alternativ kann man die Methode fromCharCode() für die Zusammensetzung eines Strings durch Angabe der CodeNummern verwenden. Häufig gebrauchte Sonderzeichen werden durch verkürzte Codes dargestellt wie hier für den \n Zeilen-Umbruch gezeigt. Die Methode charAt() isoliert ein einzelnes Zeichen aus einer String-Variablen. Die Position wird im Argument als ganze dezimale Zahl oder mit Prefix 0x hexadezimal angegeben.	Beispiel: Codierung von deutschen Sonderzeichen und Zeilen-Umbruch: alert("Gro\u00DFe\n\u00C4hnlichkeit"); Beispiel: Erzeugung eines Strings "ABC" durch Angabe der ASCII/Unicode-Nummern: s = String.fromCharCode(65,66,67); Beispiel: In der Schleife wird je 1 Zeichen aus der String-Variablen s entnommen und angezeigt: s = "abc"; for(i=0; i<s.length; i++) { c = s.charAt(i); alert("Zeichen (pos "+i+")="+c); }
Umwandlung Zeichen → CodeNummer Die Methode charCodeAt() gibt die ASCII- bzw. Unicode-Nummer eines Zeichens als positive ganze Zahl zurück. Das Argument bezeichnet die Position des Zeichens, beginnend mit 0 für das erste Zeichen.	Beispiel: Umwandlung eines Umlauts (hier ä) in äquivalente ASCII-Zeichen: s = "1Az"; for(i=0; i<s.length; i++) { c = s.charAt(i); u = s.charCodeAt(i); alert("Code("+c+")="+u); }
Verkettung Der Operator + wird zur Verkettung von Strings verwendet. Wenn man versucht, Strings und Zahlen miteinander zu verketten, werden die Zahlen vor der Verkettung in Strings umgewandelt - auch dann, wenn die Strings eindeutig als Zahlen erkennbar wären !	Beispiele: "abc"+"xyz" = "abcxyz" "abc"+"123" = "abc123" Missverständnisse sind hier vor-programmiert: "123"+4 = "1234" 123+"4" = "1234"
Umwandlung Zahl → String Die Methode toString() wandelt eine Zahl in einen String um. • Gleitkomma-Zahlen werden mit Komma-Punkt umgewandelt, so wie international üblich. Dabei wird die volle → Genauigkeit (typisch 15-16 Dezimalstellen) angegeben, schließende Nullen werden jedoch weggelassen. • Die Methode akzeptiert die Basis eines Zahlen-Systems als Argument. Ohne Angabe wird das Dezimalsystem angenommen. Das ist praktisch, um → Zahlen in den üblichen IT-Systemen anzuzeigen (2,8,10,16). • Die Hexadezimal-Ziffern a..f werden mit Klein-Buchstaben angegeben. • Zeigen sie besser nur ganze Zahlen in anderen Zahlen-Systemen an. Die Umwandlung von Gleitkomma-Zahlen funktioniert nicht mit allen Browsern / Versionen zuverlässig. Die Methoden toFixed() und toExponential() erzeugen Strings von Gleitkomma-Zahlen mit wählbarer Anzahl von Kommastellen. Die letzte Stelle wird korrekt gerundet.	Beispiele: 123.toString() = "123" (5/3).toString() = "1.6666666666666667" Zahlensysteme der Informatik: x = 255; x.toString(2) = "11111111" x.toString(8) = "377" x.toString() = x.toString(10) = "255" x.toString(16) = "ff" "0x"+x.toString(16).toUpperCase = "0xFF" Wählbare Anzahl von Komma-Stellen: x = 5000/3; x.toString() = "1666.6666666666667" x.toFixed = "1667" x.toFixed(2) = "1666.67" x.toExponential = "1.6666666666666667e+3" x.toExponential(3) = "1.667e+3"
Umwandlung String → Zahl ► Die Methode parseInt() wandelt einen String in eine ganze Zahl um. • Der String wird als Argument übergeben. Ohne weitere Angaben wird das dezimale System verwendet. • Wenn der String mit "0" beginnt, dann wird ohne Warnung das octale System (Basis 8) verwendet. • Wenn der String mit "0x" beginnt, wird das hexadezimale System (Basis 16) verwendet. • Wenn ein String mit unzulässigen Zeichen (auch Leerzeichen !) beginnt, wird isNaN zurückgegeben. • Wenn ein String nach den erlaubten Ziffern unzulässige Zeichen enthält, dann wird die Umwandlung an dieser Stelle abgebrochen. • Man kann das gewünschte Zahlensystem (2..36) als 2.Argument angeben. Das ist wichtig, wenn man Dezimalzahlen mit (möglicherweise) führenden Nullen umwandeln will ! ► Die Methode parseFloat() wandelt einen String in eine Gleitkomma-Zahl um. • Als Komma-Zeichen ist nur der . Punkt erlaubt. Die Korrektur erfolgt am besten mit einem → Regulären Ausdruck. • Wenn ein String mit unzulässigen Zeichen beginnt, wird isNaN zurückgegeben. • Wenn ein String nach den erlaubten Zeichen unzulässige Zeichen oder Leerzeichen (!) enthält, dann wird die Umwandlung an dieser Stelle abgebrochen. • Führende Zeichen +0 (manchmal auch Leerzeichen) werden ignoriert, ein - Zeichen ist erlaubt.. • Die Angabe im 'wissenschaftlichen Format' ist möglich. Sowohl Mantisse als auch Exponent können Vorzeichen oder führende Nullen, jedoch keine Leerzeichen (!) enthalten. ♦ Weitere Details beim Thema Runden ► Es nicht möglich, den Wert NaN in einem Vergleich zu verwenden. Dazu ist die Funktion isNaN() vorgesehen.	Beispiele mit ganzen Zahlen : parseInt("123") = 123 parseInt("0123") = 83 // octal parseInt("0x123") = 291 // hexadezimal parseInt("#123") = NaN // not a number parseInt("123.456") = 123 parseInt("123,456") = 123 Angabe des Zahlensystems: parseInt("101",2) = 5 parseInt("123",2) = 1 // Abbruch nach 1.Ziffer parseInt("123",8) = 83 parseInt("0123",10) = 123 // wichtig parseInt("123",16) = 291 parseInt("0x123",16) = 291 parseInt("#123",16) = NaN Gleitkomma-Beispiele: parseFloat("12.34") = 12.34 parseFloat("12,34") = 12 // Abbruch parseFloat(12.345e+2) = 1234.5 parseFloat(+012.345E+02) = 1234.5 parseFloat("-12.34e-e2") = -0.1234 parseFloat("12.34 e+12") = 12.34 // Abbruch Korrekturen: Kommazeichen, Leerzeichen: x = " 12,34 "; x = x.replace(/,/,"."); x = x.replace(/\s/g,""); y = parseFloat(x); // ergibt y = 12.34 Erfolgs-Test: r = parseInt(t); if( isNaN(r) ) {...} else{...}
Suche Javascript bietet die Methoden indexOf() und lastIndexOf() zur Suche nach der numerischen Position von Zeichen, beginnend mit 0 für das erste Zeichen. indexOf() sucht den ersten Treffer, lastIndexOf() den letzten Treffer. Ohne Treffer wird der Wert -1 zurückgegeben. ♣ Tipp: In der Praxis sind meist ↓ Reguläre Ausdrücke besser zur Suche geeignet.	Beispiel: Suche nach Zeichen/String-Position: s = "XYZxyzXYZxyz"; p = s.indexOf("yz"); q = s.lastIndexOf("yz"); // ergibt p=3, q=9
Teile Die beiden äquivalenten Methoden slice() und substring() bezeichnen einen Teil-String durch die Position des ersten Zeichens und jene des auf das letzte folgenden Zeichens. Die Methode substr() bezeichnet einen Teil durch die Position des Anfangs-Zeichens und die Anzahl der Zeichen. Wenn man das 2. Argument weglässt, wird in allen Fällen der Teil bis zum Ende des Strings zurückgegeben. ♣ Tipp: In den meisten Fällen lassen sich diese Funktionen durch wesentlich effizienter arbeitende ↓ Reguläre Ausdrücke ersetzen.	Beispiele zur Isolation von Teil-Strings: s = "Das ist ein Test" t = s.slice(4,7); t = s.substring(4,7); // ergibt t="ist" t = s.slice(4); t = s.substring(4); // ergibt t="ist ein Test" u = s.substr(4,3); // ergibt u="ist" u = s.substr(4); // ergibt u="ist ein Test"
Reguläre Ausdrücke eignen sich am besten zur professionellen Verarbeitung von Strings. Die Methoden match(), replace(), search(), split() bieten sehr umfangreiche Möglichkeiten, kompakte Programmierung und rasche Ausführung. ♦ Details auf den Seiten zum Thema Reguläre Ausdrücke (RegExp).	Beispiel: Suche nach einem der Zeichen JYjy am Anfang der eingegebenen Antwort: s = prompt("Ja oder Nein ?"); if(s.match(/^[jy]/i)) {alert("Na also");} else{alert("Warum nicht ?");} Weitere Beispiele im Kapitel → Reguläre Ausdrücke (RegExp)
Sonstige String-Funktionen Die Methoden toLowerCase() und toUpperCase() werden oft verwendet, um einen String für die nachfolgende Analyse vorzubereiten. Man kann diese dann z.B. auf Großbuchstaben beschränken.	Umwandlung in kleine bzw. große Buchstaben: s = "abcXYZ"; k = s.toLowerCase(); // ergibt k="abcxyz" g = s.toUpperCase(); // ergibt g="ABCXYZ"

Zeichen in Perl
Position und Länge In Perl zählt man die Position von Zeichen in Strings (Text-Variablen) mit 0 beginnend.	Die Berechnung der Länge erfolgt mit Funktion length() $s = 'abc'; $k = length($s); # ergibt $k=3 Bei bedingten Verzweigungen (Vergleichen) kann man alternativ formulieren: if(length($txt)) {...} if($txt) {...}
Umwandlung CodeNummer → Zeichen Innerhalb eines Strings kann man beliebige Byte-Zeichen durch \ Backslash und den 2stelligen hexadezimalen Code angeben. Für häufig verwendete Sonderzeichen (z.B. Zeilen-Umbruch \n) kann man Abkürzungen verwenden. Wenn man Perl Konsolen-Programme (CLI) verwendet, muss man die unterschiedliche Codierung der Sonderzeichen (Details auf Seite ASCII/ANSI) beachten.	Beispiel: Codierung von Zeilen-Umbruch und deutschen Sonderzeichen: 'Der große böse Wolf' und 'schön grün' (mit Umbruch zwischen den Worten): # Unicode: $ede = "Der gro\xDFe b\xF6se Wolf"; $green = 'sch'.chr(0xF6)."n\ngr".chr(0xFC).'n'; # DOS: $ede = "Der gro\xE1e b\x94se Wolf"; $green = 'sch'.chr(0x94)."n\ngr".chr(0x81).'n';
Umwandlung Zeichen → CodeNummer Funktion ord gibt die CodeNummer eines Zeichens zurück.	Beispiel: Ausgabe aller Buchstaben eines Strings mit Zeichen und CodeNummer $txt='abc'; for($i=0;$i<length($txt);$i++) { $c = substr($txt,$i,1); print 'ord('.$c.')='.ord($c)."\n"; }
● Im Bereich $k<=#7F wird der ASCII-Code ausgegeben. Dort können sie statt des HTML-Codes &#$k; auch direkt das Zeichen chr($k) ausgeben. ● Im Bereich #80..#9F wird meist der 'ANSI-Code' (Windows-1252) ausgegeben. ● Oberhalb >#9F ist der ANSI-Code identisch mit ISO-8859-1 (Latin-1). Dieses Programm läuft ohne Änderung auch in → Perl. Perl arbeitet auch im Bereich >#7F mit chr($k), PHP muss jedoch den → HTML-Code &#$k;verwenden. ● Mit Perl können sie die Zeichen auch auf der Konsole ausgeben, dann müssen sie jedoch chr($k) statt des HTML-Codes verwenden, das Leerzeichen (#20) wird nicht mit   maskiert. Auf der Konsole erhalten sie im Bereich $k>#7F den DOS-Code.	Ein kleines PHP oder Perl-Programm ( Live--Test) zur Ausgabe der Zeichen 0..255 (hex 00..FF). An Stelle der nicht druckbaren Steuerzeichen wird ein Punkt . ausgegeben. for($i=0;$i<16;$i++) { print sprintf("%X",$i); for($j=0;$j<16;$j++) { $k=16*$i+$j; //$c=chr($k); if($i<2) {$c=".";} if($k==32) {$c=" ";} if($k>126 && $k<160) {$c=".";} else {$c="&#$k;";} print " $c"; } print "<br />\n"; }
Verkettung und Typ-Umwandlung In modernen Script-Sprachen werden meist keine Typen vereinbart. Man verlässt sich darauf, dass die Programmiersprache die richtigen Typen verwendet und bei Bedarf ungefragt umwandelt. Das ist bequem und funktioniert meistens - jedoch nicht immer. ► Der verwendete Operator bestimmt in den meisten Fällen den Ergebnis-Typ. Zur Verkettung von Strings wird ein . Punkt verwendet.	Beispiele "ABC" . "xyz" = "ABCxyz" "ABC" . 123 = "ABC123" "ABC" + 123 = 123 "123" . "789" = "123789" "123" + 789 = 912 "123" + "789" = 912 Typ-Umwandlung erzwingen: x = "123" + 0; ergibt auf jeden Fall eine Zahl. Dieser Trick ist mindestens dann empfehlenswert, wenn man den Zahlenwert in einem Vergleich (if...) oder als Abbruch-Bedingung einer Schleife (while...) verwendet.
String-Marken " und ' Zur expliziten Angabe von Strings werden die Zeichen ' (Single Quote) und " (Double Quote) verwendet. ● Alle Zeichen innerhalb von ' ' (Single Quotes) werden genauso verwendet wie im Quelltext, insbesondere auch \ Backslash und die Namen von Variablen (z.B. $x ) ● Innerhalb von " " (Double Quotes) wird ein \ Backslash als Maskierungs-Zeichen für das unmittelbar folgende Zeichen verwendet. Die Namen von Variablen (z.B. $x ) werden durch deren aktuelle Werte ersetzt. ♣ Tipp: Verzichten sie auf die Bequemlichkeit, die Namen von Variablen in " " Strings zu verwenden, und machen sie sich die Mühe, explizite String-Daten und Variable bei der Verkettung von Strings streng zu trennen. Das ist nicht nur eindeutig, sondern bei der Ausführung wesentlich schneller !	Beispiele $t = "xyz"; print "t = $t \n"; Ausgabe: t=xyz (bequem, am Ende neue Zeile) print 't = $t \n'; Ausgabe: t=$t \n (ohne neue Zeile, eher unerwünscht) Empfehlenswert: print 't = '.$t."\n"; Ausgabe: t=xyz (neue Zeile, schnell) Ausgabe einer → Umgebungs-Variablen: Bequem: print "System-Pfade = $ENV{'PATH'}\n"; oder sicher & schnell: print 'System-Pfade = '.$ENV{'PATH'}."\n";
String-Funktionen Wie die meisten modernen Script-Sprachen bietet auch Perl eine große Anzahl spezialisierter Funktionen zur Verarbeitung von Strings. Einige davon befinden sich in der Standard-Version, noch weit mehr in den zahlreichen Modulen.	Beispiel: Umwandlung in Groß- und Kleinbuchstaben: $t0 = "AbCxYz"; $t1 = uc($t0); $t2 = lc($t0);
Reguläre Ausdrücke (RegExp) sind die Grundlage für die besondere Stärke von Perl im Bereich der anspruchsvollen und professionellen Textverarbeitung. RegExp werden in Perl nicht mit Funktionen sondern mit Operatoren (rechts in roter Schrift) angewendet.	Beispiel: Ein → ISO-Datum wird in einem einzigen Ausdruck getestet und daraus das Monat isoliert: $t = "2000-01-23 12:34:56"; if ($t=~m/\d\d\d\d-(\d\d)/) { print "Monat = $1\n"; } ♦ Details und Beispiele im Kapitel Reguläre Ausdrücke
Funktionen pack() und unpack() Diese mächtigen Funktionen erlauben die Umwandlung aller gängigen Daten-Typen, darunter auch von Zeichen und Strings. Die zahlreichen Möglichkeiten - bis zur Einflussnahme auf BitLevel - werden auf einer eigenen Seite vorgestellt. ♦ Details zu den Funktionen pack() und unpack()	Beispiele zur Erzeugung von Strings aus Codenummern: $t1 = pack('cccc',65,66,67,68); # $t1 = 'ABCD' $t2 = pack('c',97..103); # $t2='abcdefg' $t3 = pack('c4',0x41,0x42,0x43,0x44); # $t3 = 'ABCD' $t4 = pack('a4','abc','x'); # $t4 = "abc\0" Beispiel: Das Array @ac wird mit den Codenummern des Strings $s gefüllt: $s = 'Test'; @ac = unpack('c',$s); # @ac = (84,101,115,116)

Zeichen in PHP
Position und Länge In PHP zählt man die Position von Zeichen in Strings (Text-Variablen) mit 0 beginnend.	Die Berechnung der Länge erfolgt mit Funktion strlen() $s = 'abc'; $k = strlen($s); # ergibt $k=3 Bei bedingten Verzweigungen (Vergleichen) kann man alternativ formulieren: if(strlen($txt)) {...} if($txt) {...}
Umwandlung CodeNummer → Zeichen Funktion chr() liefert das Zeichen einer CodeNummer	chr($n)
Umwandlung Zeichen → CodeNummer Funktion ord() liefert die Codenummer eines Zeichens	ord($c)
Verkettung und Typ-Umnwandlung Es gelten die gleichen Regeln wie bei ↑ Perl. Der Ergebnis-Typ einer Verkettung wird meistens durch den verwendeten Operator bestimmt: Zur String-Verkettung verwendet man einen . Punkt, zur arithmetischen Verknüpfung die üblichen Operatoren +-*/	String-Marken " und ' Zur expliziten Angabe von String-Daten im Quelltext werden die gleichen Marken und Regeln angewendet wie bei ↑ Perl. ♣ Tipp: Wer sich die Mühe macht, explizite String-Daten und Variable sauber zu trennen, erzeugt besseren und schneller ausführbaren Code.
String-Funktionen In der Programmiersprache PHP haben sich im Laufe der Zeit sehr viele verschiedene Funktionen angesammelt. Im Manual-Bereich 'String Functions' werden derzeit ca. 100 Funktionen vorgestellt.	Beispiel: Umwandlung in Groß- und Kleinbuchstaben: $t0 = "AbCxYz"; $t1 = strtoupper($t0); $t2 = strtolower($t0);
Reguläre Ausdrücke Die wichtigen Funktionen zur Verarbeitung von → Regulären Ausdrücken sind in allen neueren Versionen Perl-kompatibel und im Standard-Modul enthalten, d.h. man braucht kein eigenes Modul zu laden, um die 8 PCRE-Funktionen zu verwenden.	Beispiel: Diese Anweisung löscht aus einem String $t alle Steuerzeichen mit Codenummern <32 $t = preg_replace('/[\x{0}-\x{1F}]/','',$t); Man verwendet solche Anweisungen, um gefährliche oder unerwünschte Zeichen aus Strings zu entfernen.
Funktionen pack() und unpack() Diese Funktionen dienen ebenso wie in ↑ Perl zur Codierung und Decodierung von Daten auf BitLevel Ebene.	♦ Details zu den Funktionen pack() und unpack() in diesem Web und im Original PHP-Manual unter 'Misc.Functions'

Zeichen in Regulären Ausdrücken (RegExp)
Alle modernen Programmiersprachen bieten die Methoden der → Regulären Ausdrücke (RegExp). Sie sind am besten zur Verarbeitung von Strings geeignet. Insbesondere komplizierte Aufgaben lassen sich mit RegExp einfach lösen. Der Code ist sehr kompakt, die Ausführung viel rascher als bei den sonst notwendigen Schleifen, bedingten Verzweigungen usw.	Dieses Web enthält mehrere Seiten zum Thema → Regulären Ausdrücke (Syntax, Anwendung in Programmiersprachen, Beispiele, ...). Hier wird lediglich vorgestellt, wie man Sonderzeichen in RegExp codiert.
Umwandlung CodeNummer → Zeichen • Generell kann man jedes 1-Byte-Zeichen mit \ Backslash und nachfolgend dem 2stelligen hexadezimalen Code angeben. Beispiel: Code dezimal 65 = hexadezimal 0x41 bezeichnet das ASCII-Zeichen A \41 Bei Zeichen mit Code-Nummern >127 hängt es vom verwendeten Zeichensatz ab, welches Zeichen damit gemeint ist. Beispiel: Code dezimal 220 = hexadezimal 0xDC bezeichnet im Zeichensatz → ISO-8859-1 (Latin-1) das Ü \DC Im Zeichensatz → ISO-8859-7 (Greek) bezeichnet der gleiche Code das Zeichen ά • In einigen Fällen (z.B. PHP je nach Version und CodeNummer) funktioniert diese einfache Syntax nicht. Schließen sie daher in PHP den Hex-Code in {} Klammern ein, z.B. für das Null-Byte: \x{00}	• Ein wichtiges RexExp-Element ist die Formulierung von Zeichen-Bereichen. Ein Bereich wird durch das erste und das letzte Zeichen in ASCII-Reihenfolge bestimmt, durch - getrennt und in [] eingeschlossen. Beispiel: Die Ziffern 0123456789 [0-9] Für Sonderzeichen (und generell bei allen evtl. möglichen Missverständnissen) verwendet man die Code-Nummern, z.B. für den gleichen Bereich: [\x30-\x39] In PHP sollte man die Hex-Codes prinzipiell in {} einschließen: [\x{30}-\x{39}] • Alle Zeichen mit besonderer Bedeutung ('Programm') in RegExp muss man zur Verwendung in Daten mit einem vorangestellten \ Backslash maskieren, z.B. \$ oder \? Ein Sonderfall ist der \ Backslash: Dieses Zeichen muss man in PHP mit \\\ formulieren, oder besser verständlich mit seinem ASCII-Code: \x{5C}

Zeichen in der Datenbank-Struktur

Planung und Struktur

Die Konfiguration einer Datenbank wirkt sich stark auf die praktische Verwendbarkeit aus (nächstes Kapitel ↓ SQL-Anwendung).
Fehlerhafte oder kurzsichtige Einstellung kann man zwar später korrigieren, das ist jedoch heikel und meist sehr aufwändig.

Es ist erstaunlich wie viele Datenbanken noch immer in nationalen Zeichensätzen organisiert sind. Eine globalisierten Gesellschaft erfordert den Umgang mit anderen Kulturen und Sprachen. Allein in der EU wird ein halbes Dutzend verschiedener nationaler Zeichensätze verwendet, die nicht miteinander kompatibel sind.
♣ Tipp: Planen sie neue Datenbanken nur mit dem international eindeutigen Zeichensatz → Unicode, und stellen sie bestehende Datenbanken darauf um.

Zeichensatz

Beim Anlegen von Datenbank-Objekten kann und soll man den zu verwendenden Zeichensatz (character set) definieren.

Zu jedem Zeichensatz gibt es mehrere nationale SortierFolgen (Collation), mit denen indirekt auch der Zeichensatz (und in manchen Fällen die FeldType) eingestellt wird.

Der Standard-Zeichensatz von MySQL ist ohne Maßnahmen meist auf latin1 eingestellt, allerdings in schwedischer Sortierfolge (collation).

♣ Tipp: Stellen sie schon beim Anlegen einer Datenbank den gewünschten Zeichensatz ein - Er wird automatisch auf alle Tabellen und Felder dieser Datenbank vererbt. Wenn es notwendig ist, einzelne Tabellen oder Felder anders einzustellen, dann kann man das nachträglich jederzeit durchführen.

• So erhält man mit MySQL eine Liste aller verfügbaren Zeichensätze:

show character set;

Wichtige Zeichensätze sind Unicode (empfehlenswert,als ucs2 oder utf8 ), der mitteleuropäische (deutsche) Zeichensatz (häufig, latin1) oder Standard-ASCII (strikt, ascii). Von der Verwendung exotischer oder → firmen-eigener Zeichensätze (Windows cp*) wird abgeraten.
So erhält man mit MySQL eine Liste aller verfügbaren Sortierfolgen (collations) eines Zeichensatzes (hier am Beispiel latin1):

show collation like 'latin1%';

● Der → Unicode Zeichensatz (ucs2,utf8) funktioniert weltweit eindeutig. Man kann zusätzlich zu den deutschen Umlauten auch die Zeichen fast aller anderen Sprachen verwenden. Die Daten werden auf jedem PC originalgetreu angezeigt.

• Die Unicode-Version ucs2 verwendet je 2 Byte für alle Zeichen. Verwenden sie diesen Zeichensatz für String-Felder fixer Länge.

• Die Unicode-Version utf8 spart Speicherplatz: Die häufigen ASCII-Zeichen verwenden nur 1 Byte, die deutschen Umlaute ÄÖÜäöüß je 2 Byte pro Zeichen, das € Zeichen 3 Byte.
• Diesen Vorteil kann man jedoch nur bei Feldern der Type varchar nutzen. In Feldern fixer Länge wird pro Zeichen die in UTF-8 maximale Länge von 3 Byte reserviert, d.h. man belegt in diesem Fall viel mehr Speicherplatz als nötig.

● Der mitteleuropäische (deutsche) Zeichensatz funktioniert nur im erweiterten deutschen Sprachraum.
Man kann damit keine Zeichen anderer Sprachen (griechische, kyrillische, slawische, ungarische, ...) speichern. Auf einem PC anderer Sprach-Einstellung werden Umlaute und Sonderzeichen nicht originalgetreu angezeigt.
Vorteil gegenüber Unicode: Alle Zeichen brauchen nur je 1 Byte, das € Zeichen wird allerdings nicht Standard-konform gespeichert.

Bei der technischen Ausstattung heutiger Server-PC gibt es kaum noch Argumente für die Verwendung der veralteten nationalen Zeichensätze.

Änderung des Zeichensatzes

Die rechts vorgestellten Beispiele kann man mit dem Administrations-Programm → phpMyAdmin oder direkt als SQL-Anweisung ausführen:
• Die Daten von Datenbanken und Tabellen mit (vorherigem) Zeichnsatz latin1 werden dabei nicht verändert. Trotzdem führt man derart heikle Arbeiten nur nach Erstellung einer Sicherungs-Kopie aus !
• In umgekehrter Richtung (Änderung von Unicode auf einen 1-Byte Zeichensatz) würden alle MultiByte-Zeichen auf 8 Bit abgeschnitten.

Änderung der Zeichensatz-Einstellung einer Datenbank auf Unicode:

alter database meine_db

default character set ucs2
default collate ucs2_general_ci;

Änderung der Zeichensatz-Einstellung einer Tabelle auf Unicode:

alter table meine_tabelle

default character set ucs2
default collate ucs2_general_ci;

Länge

Beim Anlegen von Feldern einer String-Type (z.B. varchar) muss man die maximale Länge angeben. Die Angabe erfolgt normalerweise in Zeichen - Andere Datenbanken oder Versionen können die Angabe allerdings in Byte verstehen - Das ergibt Unterschiede für MultiByte-Zeichen.

Wenn man versucht, längere Texte einzutragen als in der Struktur vorgegeben, dann werden diese ohne Warnung auf die maximale Länge gekürzt !

♣ Tipp: Legen sie String-Felder in mindestens der doppelten Länge an, wie für die Daten erwartet wird. Man kann die Feld-Länge später problemlos verkürzen, aber man kann abgeschnittene Daten nie mehr regenerieren.

So erhalten sie Angaben zur Länge der eingetragenen Daten: Durchschnittliche Länge in Byte und deren Standardabweichung, maximale Länge.

select avg(length(field)) as 'avg',
std(length(field)) as 'stdev',
max(length(field))as 'max'
from table;

• Wenn das gemessene Maximum identisch mit dem in der Struktur festgelegten ist, dann wurden die betreffenden Strings wahrscheinlich bereits abgeschnitten (Stichproben).
• Wenn die String-Länge ungefähr der Normalverteilung gehorcht, dann kann man aus Mittelwert und Standardabweichung die notwendige maximale Länge schätzen:

Anteil	max.Länge
90%	avg + 0.9 * stdev
99%	avg + 1.6 * stdev
99.9%	avg + 2.2 * stdev
99.99%	avg + 2.6 * stdev

Schreiben von Zeichen

(z.B. mit SQL-Anweisungen insert, update).
Man kann beliebigen Text in ein Feld einer String-Type (z.B. varchar) eingeben, oder mit ↓ Funktion char() Sonderzeichen definieren.
Es hängt jedoch vom eingestellten Zeichensatz ab, welche Zeichen tatsächlich gespeichert werden:

• In einem 1-Byte Zeichensatz (z.B. latin1) werden nur Zeichen mit CodeNummern 0..255 gespeichert. Beim Versuch, Unicode-Zeichen (wie z.B. α,β,γ) einzugeben, werden die CodeNummern auf 8 Bit gekürzt. In diesem Fall werden ohne Warnung andere Zeichen gespeichert als eingegeben !

• Ein Sonderfall ist das € Zeichen: In einem 1-Byte Zeichensatz wird der Code U+20AC nicht abgeschnitten, sondern das Zeichen mit dem von Windows verwendeten Code U+80 gespeichert - Das kann bei der weiteren Verabeitung unangenehme Folgen haben.

• Wenn man Unicode (ucs2) oder UTF-8 (utf8) als Zeichensatz einstellt, dann werden auch MultiByte-Zeichen gespeichert. Das €-Zeichen wird in diesem Fall korrekt mit CodeNummer U+20AC gespeichert.

Vorsicht: Das beschriebene Verhalten hängt vom Datenbank-Programm, der Version und Konfiguration ab. Testen sie vor einer realen Anwendung stets das Verhalten ihrer Datenbank.

Zeichen in der Datenbank-Anwendung (SQL)

Anwendung

Dieses Kapitel demonstriert ausgewählte Themen der Datenbank-Anwendung. Die Ergebnisse hängen wesentlich von der ↑ Konfiguration (Struktur) ab, die im Kapitel oberhalb vorgestellt wird.

♣ Tipp: Eine sorgfältige Planung spart sehr viel Zeit und Arbeit, die man andernfalls später zur Korrektur fehlerhafter oder kurzsichtiger Planung investieren muss...

1-Byte Zeichensätze

Jede gängige Datenbank beherrscht mehrere 1-Byte Zeichensätze, z.B. den in Mitteleuropa und im deutschen Sprachraum meist-verwendeten nationalen Zeichensatz latin1 (→ ISO-8859-1), welcher je 1 Byte für jedes seiner 256 Zeichen verwendet.

Der 1-Byte-Zeichensatz ascii (→ ASCII) verwendet ebenfalls je 1 Byte, jedoch nur für 128 Zeichen.

MultiByte

→ Unicode und einige andere nationale Zeichensätze verwenden entweder generell oder nur für bestimmte Zeichen mehrere Bytes. Alle gängigen Datenbanken beherrschen mindestens den international eindeutigen Standard Unicode.
Unicode verwendet für fast alle Zeichen deutsch-sprachiger Texte nur 1 Byte, lediglich für die 7 Sonderzeichen ÄÖÜäöüß je 2 Byte.

• Derzeit unterstützt MySQL nur Unicode-Zeichen im 16-Bit Bereich U+0000..U+FFFF, d.h. die meist verwendeten Zeichen. Unicode ist derzeit allerdings mit 21 Bit definiert (32mal so viele Zeichen) und wird wohl in Zukunft auf 24 und 32 Bit erweitert.

Kommunikation

Der Austausch von Daten zwischen dem DB-Server (z.B. → MySQL) und einem Client-Programm (z.B. in der Programmiersprache → PHP) erfolgt ohne weitere Maßnahmen in dem für die ausgewählte Datenbank definierten Standard Zeichensatz.

Wenn die Kommunikation mit einem anderen Zeichensatz erfolgen soll, dann kann man das unmittelbar nach der Verbindung mit der Anweisung set names anordnen.
Das ist im deutsch-sprachigen Raum nur für Unicode-Daten sinnvoll und notwendig.

Beispiel (PHP) für Kommunikation im 'Unicode Transformation Format' UTF-8 :

$dbobj = new mysqli($host,$user,$pswd,$dbname);
$sql = "set names 'utf8'";
$sqlres = $dbobj->query($sql);

Unicode (ucs2) kann man nicht direkt zur Kommunuikation verwenden, nur eine der Unicode Transport-Formen wie (vorzugsweise) → UTF-8.

So werden die aktuellen Werte aller mit dem Zeichensatz zusammenhängenden Variablen angezeigt:

show variables like 'character_set%';
show variables like 'collation%';

Position und Länge

Die Position des ersten Zeichens eines String-Feldes wird in SQL mit 1 bezeichnet.

Die Länge kann man in Zeichen oder Bytes messen:
• Funktion length liefert die Länge = Anzahl Bytes in einem Feld. Der Wert ist bei Verwendung von Multi-Byte Zeichen größer als die Anzahl der Zeichen !
• Funktion char_length liefert die Anzahl der Zeichen in einem Feld.

Ausgabe einer 2spaltigen Liste der Daten-Länge eines Feldes field, in Byte und Zeichen:

select length(field) as 'byte_len',

char_length(field) as 'char_len'
from table;

♣ Tipp: (Nur) Im Zeichensatz utf8 kann man für String-Felder (z.B. Namen, Adressen, ...) die mittlere Länge in Byte und Zeichen messen. Das Verhältnis zeigt den durchschnittlich verwendeten Speicherplatz pro Zeichen: Er liegt in der Praxis nur unwesentlich >1 Byte - Das zeigt die Effizienz von UTF-8

Suche

Diese Funktionen kann man zur Suche verwenden:

LOCATE(substr,str), LOCATE(substr,str,pos)
POSITION(substr IN str) is a synonym for LOCATE(substr,str).
INSTR(str,substr)

replace
INSERT(str,pos,len,newstr)

Teile

Die Funktionen left(string,length); substr(string,start,length); right(string,length) liefern Teil-Strings aus dem Inhalt des angegebenen Felds.
Die Funktionen mid, substring sind äquivalent zur Funktion substr
Neben der Standard-Syntax (from..to) kann man in den meisten Datenbank-Produkten die Syntax mit durch Beistrich getrennten Argumenten verwenden.
Wenn das Argument start (äquivalent position) einen negativen Wert hat, dann wird die Start-Position vom Ende des Strings rückwärts gezählt.

select left(field,3) from table;
select mid(field,3,5) from table;
select substr(field from 3 for 5) from table;
select right(field,3) from table;

Umwandlung CodeNummer → Zeichen

SQL bietet die Funktion char zur Umwandlung von CodeNummern in Zeichen.
Mit Argumenten <128 liefert char 1-Byte ASCII-Zeichen.
Argumente 128..255 liefern ein 1-Byte-Zeichen des eingestellten (default) oder angegebenen Zeichensatzes.

Ausgabe einzelner Zeichen:

select char(65) as 'Test';

# liefert A (1 Byte)

select char(0xD8 using latin1);

# liefert Ø (1 Byte / ISO-8859-1)

select char(0xD8 using greek);

# liefert Ψ (1 Byte / ISO-8859-7)

select char(0x4A8 using ucs2);

# liefert * (* Byte / Unicode) idem als Unicode=3A8 euro=20AC (3 Byte?)

select char(0x20AC using ucs2);

# liefert € (* Bytes)

Umwandlung Zeichen → CodeNummer

Die Funktion ascii() ermittelt die CodeNummer eines Zeichens. Bei Anwendung auf einen String wird nur das erste Zeichen analysiert.
Funktion ord() liefert von 1-Byte-Zeichen deren Codenummer, von MultiByte-Zeichen eine ganze Zahl...

Ausgabe der CodeNummern der Anfangs-Buchstaben:

select ascii(field) from table;

Diese Tabelle zeigt, wie Zeichen aus unterschiedlichen Bereichen je nach dem für ein Feld konfigurierten Zeichensatz von der Datenbank codiert werden: Ord bezeichnet die CodeNummer und Len die Länge in Byte, jeweils bei der Ausgabe.

Chr	ISO-8859-1 latin1		Unicode ucs2		UTF-8 utf8
Chr	Ord	Len	Ord	Len	Ord	Len
A	0x41	1	0x0041	2	0x41	1
z	0x7A	1	0x007A	2	0x7A	1
Ä	0xC4	1	0x00C4	2	0xC384	2
Ø	0xD8	1	0x00D8	2	0xC398	2
Ψ	0x3F	1	0x03A8	2	0xCEA8	2
€	0x80	1	0x20AC	2	0xE282AC	3
●	0x3F	1	0x25CF	2	0xE2978F	3

Hinweise zur Tabelle:
• ASCII-Zeichen mit CodeNummern 0..127 = 0x00..0x7F (hier vertreten durch A und z ) werden in jedem Zeichensatz korrekt gespeichert. Mit ucs2 werden dafür allerdings 2 Byte verwendet.

• Sonderzeichen im Bereich 128..255 = 0x80..0xFF (hier vertreten durch Umlaut Ä) werden von 1-Byte Zeichensätzen unterschiedlich (!) interpretiert. Sie werden daher nur mit dem Zeichensatz der jeweiligen Eingabe korrekt wiedergegeben.

• Mit den Zeichensätzen ucs2 und utf8 werden alle Zeichen 0x0000..0xFFFF korrekt ('verlustfrei') gespeichert.

• Im Zeichensatz ucs2 werden für jedes Zeichen 2 Byte verwendet, unabhängig von dessen CodeNummer.
• Der Zeichensatz utf8 verwendet für die 128 häufigsten (ASCII)-Zeichen nur 1 Byte, für die folgenden 1920 weniger häufigen Sonderzeichen (z.B. deutsche Umlaute) des Bereichs (U+0080..U+07FF) 2 Byte und für die weiteren 63488 eher seltenen Zeichen (U+0800..U+FFFF) 3 Byte.

Der kritische Bereich U#0080..U+00FF:

• Das folgende Beispiel zeigt, welche Probleme mit Zeichen dieses Bereichs auftreten:
Wenn man das Zeichen (hier z.B. mit CodeNummer 0xD8) im Zeichensatz latin1 einträgt, dann erhält man das Zeichen Ø

• Wenn man die gleiche CodeNummer im Zeichensatz greek einträgt, erhält man das Zeichen Ψ. Dieses giechische Zeichen hat die Unicode-Nummer U+03A8

• Wenn man das giechische Zeichen Ψ mit seinem Unicode U+03A8 einträgt, dann wird es mit jedem 1-Byte Zeichensatz falsch angezeigt, weil die Codenummer auf 0x3F abgeschnitten wird.

♣ Tipp: Verwenden sie besser keine 1-Byte Zeichensätze. Mit ucs2 oder utf8 sind derartige Probleme beseitigt.

Sonstige String-Funktionen

lower=lcase, upper,
ltrim, rtrim, trim
lpad, rpad,
repeat, reverse

Umwandlung ASCII ↔ ANSI

Werkzeuge ascii2ansi und ansi2ascii
Mit Programmen der Programmiersprache C++ lassen sich beliebige Zeichencode-Umwandlungen besonders rasch ausführen.
Das Beispiel rechts demonstriert (vereinfacht) die Umwandlung ASCII → ANSI.
In C++ gibt es keinen Unterschied zwischen Zeichen und 1-Byte-Zahlen. Es kommt auf das Ausgabe-Format an (%c,%d), wie ein Zeichen angezeigt wird.

Die Umwandlung erfolgt mit Hilfe einer ('Lookup')-Tabelle t. Diese Methode wird angewendet, wenn die Umwandlung keinem Algorithmus folgt. Da die beiden Codes im Bereich 0..126 übereinstimmen, werden nur Zeichen >126 umgewandelt.
Einige ASCII-Zeichen haben in ANSI keine Entsprechung (und umgekehrt), sie werden hier mit Code 63 (Zeichen ? ) übersetzt.
Mit etwas Geschick können sie aus der Lookup-Tabelle t die 'inverse' Tabelle für ansi2ascii erzeugen.
Alle Angaben ohne Gewähr, Verwendung auf eigenes Risiko !

Anwendung (Windows):

C:\> ascii2ansi umwandeln.txt

oder

C:\> ascii2ansi in.txt out.txt

Download der beiden Win-Programme ascii2ansi.exe und ansi2ascii.exe als komprimiertes Archiv (zip).

Cygwin enthält das Konsolen-Programm ascii.exe zur Anzeige von ASCII-Code bzw. → ISO-88549-1 (Latin-1) Code auf einer Text-Konsole.

Beispiel in der Programmiersprache C (C++): Verwendung einer Verweis-Tabelle (Lookup table) zur Code-Umwandlung.
Nach diesem Beispiel kann man jeden 1-Byte Zeichencode in jedem anderen umwandeln.

// ascii2ansi

#include <stdio.h>
int main(int argc, char* argv[]) {

int i,ic;
char inpath[]="in.txt";
char outpath[]="out.txt";
char line[1024];
FILE *instream,*outstream;
int t[]={63,199,252,233,226,228,224,229,231,
234,235,232,239,238,236,196,197,201,230,198,
244,246,242,251,249,255,214,220,248,163,216,
215,131,225,237,243,250,241,209,170,186,191,
174,172,189,188,161,171,187,63,63,63,63,63,
193,194,192,169,63,63,63,63,162,165,63,63,
63,63,63,63,63,227,195,63,63,63,63,63,63,63,
164,240,208,202,203,200,63,205,206,207,63,
63,63,63,166,204,63,211,223,212,210,245,213,
181,254,222,218,219,217,253,221,175,180,173,
177,63,190,182,167,247,184,176,168,183,185,
179,178,63,160};
instream = fopen(inpath,"rt");
outstream = fopen(outpath,"wt");
while (fgets(line,1000,instream) != NULL) {

for(i=0;i<int(strlen(line));i++) {

ic=int(line[i]);
if(ic<0) {ic+=256;}
if(ic>126) {

ic=t[ic-127];
line[i]=ic;

}

}
fputs(line,outstream);

}
fclose(instream);
fclose(outstream);
return 0;

}

ASCII und ANSI in Programmiersprachen
Jede Programmiersprache bietet Möglichkeiten zur Verarbeitung von einzelnen Zeichen und 'Strings' aus mehreren Zeichen. In diesem Kapitel finden sie ausgewählte Funktionen für einzelne Zeichen.	♣ Tipp: Der Variablen-Typ 'Integer' eignet sich nicht für Unicode, da sein Wertebereich meist bei 32767. endet ( je nach System). Verwenden sie besser andere Typen wie z.B. 'Long'. Tipp: Verwenden sie für neue Entwicklungen nur → Unicode-kompatible-Funktionen !
Tipps & Tricks: ● Kleinbuchstaben liegen im ASCII & ANSI-Code um den Betrag 32. (#20) höher als die entsprechenden Großbuchstaben. Wenn ein Zeichen sicher (!) ein Buchstabe ist, dann kann man es durch Addition bzw. Subtraktion der Zahl 32 klein/groß umwandeln. ● Das gilt auch für die deutschen Umlaute äöü sowie für die meisten anderen Sonderzeichen, die aus lateinischen Buchstaben abgeleitet sind. ● Die Zeichen $ _ zählen in manchen IT-Bereichen ebenfalls zu den Buchstaben.	● Leider folgen die Zeichen 9 und A nicht unmittelbar aufeinander. Daher muss man bei der Umwandlung von / nach Hexadezimal-Code die dazwischen liegenden 7 Zeichen überspringen. ● Verwenden sie bei eigenen Entwicklungen sicherheitshalber keines der ANSI-Zeichen #80..#9F, sondern an deren Stelle die entsprechenden → Unicode-Zeichen. ANSI ist in diesem Bereich nicht konform mit Unicode und dem Standard → ISO-8859-1.
● Im Bereich $k<=#7F wird der ASCII-Code ausgegeben. Dort können sie statt des HTML-Codes &#$k; auch direkt das Zeichen chr($k) ausgeben. ● Im Bereich #80..#9F wird meist der 'ANSI-Code' (Windows-1252) ausgegeben. ● Oberhalb >#9F ist der ANSI-Code identisch mit ISO-8859-1 (Latin-1). Dieses Programm läuft ohne Änderung auch in → Perl. Perl arbeitet auch im Bereich >#7F mit chr($k) , PHP muss jedoch den → HTML-Code &#$k;verwenden. ● Mit Perl können sie die Zeichen auch auf der Konsole ausgeben, dann müssen sie jedoch chr($k) statt des HTML-Codes verwenden, das Leerzeichen (#20) wird nicht mit   maskiert. Auf der Konsole erhalten sie im Bereich $k>#7F den DOS-Code.	Ein kleines PHP oder Perl-Programm (Live--Test) zur Ausgabe der Zeichen 0..255 (hex 00..FF). An Stelle der nicht druckbaren Steuerzeichen wird ein Punkt . ausgegeben. for($i=0;$i<16;$i++) { print sprintf("%X",$i); for($j=0;$j<16;$j++) { $k=16*$i+$j; //$c=chr($k); if($i<2) {$c=".";} if($k==32) {$c=" ";} if($k>126 && $k<160) {$c=".";} else {$c="&#$k;";} print " $c"; } print "<br>\n"; }

Zeichencodes	PC-Codes für Buchstaben, Ziffern und Sonderzeichen
Zeichen & Strings	Zeichen & Zeichenketten, String-Länge, Zeichensatz
Schrift-Familie	Unterschied zwischen Bedeutung und Darstellung
Kalkulation	Zeichen in LibreOffice, OpenOffice-Calc, MS-Excel, ...
HTML	(Sonder)-Zeichen in Webseiten, Maskierung
Bash	Sonderzeichen an der Linux Shell-Konsole
Basic	Basic-(VBA)-Funktionen Chr, ChrW, Asc, AscW, Suchen, Ersetzen
C/C++	Äquivalente Typen byte und char
CSS	Angabe von Sonderzeichen mit Unicode-Nr
Javascript	Methoden charAt(), charCodeAt(), fromCharCode(), ...
Perl	Funktionen chr(), ord(), pack(), unpack(), Reguläre Ausdrücke, ...
PHP	Funktionen chr(), ord(), pack(), unpack(), Reguläre Ausdrücke, ...
RegExp	Zeichen in Regulären Ausdrücken
Datenbank	Zeichen in der Verwaltung von Datenbanken
SQL	Zeichen in der 'Datenbank-Sprache' SQL
Tipps	Tipps & Tricks zu Zeichen & Strings

Zeichen-Programmierung

Zeichen und Zeichen-Codes in Programmiersprachen

Zeichen und Strings

Zeichen und Zeichenketten

Leer-String

String-Länge

Zeichensatz

Schrift-Familie

Zeichen in Kalkulations-Programmen

Umwandlung CodeNummer → Zeichen:

Umwandlung Zeichen → CodeNummer

Veraltete Funktionen: ZEICHEN(), CODE()

Aktuelle Funktionen: UNIZEICHEN(), UNICODE()

Länge

Verkettung und Typ-Umwandlung

Suchen

Teile

Ersetzen

Wechseln

Zeichen in Webseiten (HTML)

Ignorierte Zeichen

Maskierung

Zeichen in der Linux-Konsole (Bash)

Umwandlung CodeNummer → Zeichen

Zeichen in Basic (LibreOffice-Baisc, Visual Basic VBA)

Position und Länge

Umwandlung CodeNummer → Zeichen

Umwandlung Zeichen → CodeNummer

Non-Standard

Suche

Teile

Ersetzen

Sonstige String-Funktionen

Weitere String-Funktionen von und mit VBA

Zeichen in C/C++

Deklaration

Zeichen und ganze Zahlen

Zuweisung von Zeichen

Escape-Sequenzen

Umwandlung CodeNummer → Zeichen

Umwandlung Zeichen → CodeNummer

Strings

String-Library

Funktionen

Zeichen in CSS

Umwandlung CodeNummer → Zeichen

Schrift-Familie

Zeichen in Javascript

Position und Länge

Umwandlung CodeNummer → Zeichen

Umwandlung Zeichen → CodeNummer

Verkettung

Umwandlung Zahl → String

Umwandlung String → Zahl

Suche

Teile

Sonstige String-Funktionen

Zeichen in Perl

Position und Länge

Umwandlung CodeNummer → Zeichen

Umwandlung Zeichen → CodeNummer

Verkettung und Typ-Umwandlung

String-Marken " und '

String-Funktionen

Zeichen in PHP

Position und Länge

Umwandlung CodeNummer → Zeichen

Umwandlung Zeichen → CodeNummer

Verkettung und Typ-Umnwandlung

String-Marken " und '

String-Funktionen

Zeichen in Regulären Ausdrücken (RegExp)

Umwandlung CodeNummer → Zeichen

Zeichen in der Datenbank-Struktur

Planung und Struktur

Zeichensatz

Änderung des Zeichensatzes

Länge

Schreiben von Zeichen

Zeichen in der Datenbank-Anwendung (SQL)