Unicode-Zeichen-Inspektor

Analysieren Sie Unicode-Strings Zeichen für Zeichen im Browser.

Kein Upload nötigOhne RegistrierungSofortige Ergebnisse
Unicode & UTF-8/16Nullbreite & Homoglyphen100% Lokal • Keine Uploads
Zeichen untersuchen
Offline-Engine bereit100 % privater Browser-Arbeitsbereich • Keine Cloud-Uploads
100% Privat • Keine Server-Datei-Uploads

Warum das kostenlose Unicode-Zeichen-Inspektor von Utiliome nutzen?

Entwickelt für höchsten Datenschutz, sofortige Ausführung und einfache Nutzung. Keine Abos oder Registrierungen erforderlich.

Erkennung unsichtbarer Zeichen & Bidi-Overrides

Deckt nicht druckbare Steuer- und Formatierungszeichen auf, darunter U+200B ZWSP, U+FEFF BOM, U+00A0 NBSP, U+00AD Soft Hyphen sowie bidirektionale Trojan-Source-Overrides (U+202A bis U+202E, U+2066 bis U+2069).

UTF-8 & UTF-16LE/BE Byte-Aufschlüsselung

Zeigt exakte hexadezimale UTF-8-Byte-Sequenzen (1 bis 4 Bytes gemäß RFC 3629) neben UTF-16LE- und UTF-16BE-Code-Units an und legt Surrogate-Paare für zusätzliche Ebenen oberhalb von U+FFFF offen.

UAX #29 Graphem- vs. Code-Unit-Metriken

Vergleicht erweiterte Graphem-Cluster mit Unicode-Skalarwerten, JavaScript UTF-16-Code-Units und der UTF-8-Bytelänge, um String-Slicing-Bugs und Datenbank-Spaltenüberläufe zu diagnostizieren.

Homoglyphen-Diagnose & 100 % lokaler Datenschutz

Markiert leicht verwechselbare Zeichen nach UTS #39 wie kyrillische vs. lateinische Glyphen sowie typografische Anführungszeichen vollständig clientseitig im Browser-Speicher – Tokens, Logs und Code verlassen niemals Ihr Gerät.

Utiliome vs. traditionelle Cloud-Tools

Vergleichen Sie unsere lokale WebAssembly-Engine mit alten Cloud-Tools.

Funktion Utiliome (Lokaler Browser) Klassische Cloud-Konverter
Erkennung unsichtbarer Zeichen & Bidi-Overrides Deckt nicht druckbare Steuer- und Formatierungszeichen auf, darunter U+200B ZWSP, U+FEFF BOM, U+00A0 NBSP, U+00AD Soft Hyphen sowie bidirektionale Trojan-Source-Overrides (U+202A bis U+202E, U+2066 bis U+2069). Eingeschränkte Optionen ohne erweiterte Anpassung
UTF-8 & UTF-16LE/BE Byte-Aufschlüsselung Zeigt exakte hexadezimale UTF-8-Byte-Sequenzen (1 bis 4 Bytes gemäß RFC 3629) neben UTF-16LE- und UTF-16BE-Code-Units an und legt Surrogate-Paare für zusätzliche Ebenen oberhalb von U+FFFF offen. Erfordert externe Tools oder manuelle Nachbearbeitung
Datenschutz & Verarbeitung 100 % lokale Browser-Verarbeitung (null Server-Uploads) Lädt Daten auf externe Cloud-Server hoch
Preismodell & Konto-Pflicht Dauerhaft 100 % kostenlos ohne Registrierung Erfordert Registrierung oder kostenpflichtiges Abo
So funktioniert's

Unicode-Zeichen-Inspektor in 3 einfachen Schritten nutzen

Keine Softwareinstallation erforderlich. Alles läuft direkt in Ihrem Webbrowser.

1

Text einfügen oder Datei ablegen

Fügen Sie einen String, Bezeichner oder Log-Eintrag ein oder laden Sie eine UTF-8-Datei hoch, die mutmaßlich Nullbreitenzeichen, defekte Emoji-Sequenzen oder unerwartete Bytelängen enthält.

2

Metadaten pro Zeichen prüfen

Untersuchen Sie für jedes Zeichen den skalaren U+XXXX-Codepoint, den offiziellen Unicode-Namen, die General Category, den Unicode-Block, die UTF-8- und UTF-16LE/BE-Hex-Bytes sowie Sicherheitswarnungen.

3

Anomalien isolieren oder bereinigten Text kopieren

Filtern Sie gezielt nach unsichtbaren Formatierungszeichen oder täuschend ähnlichen Homoglyphen, entfernen Sie unerwünschte nicht druckbare Codepoints oder kopieren Sie die Byte-Inspektionstabelle für Bug-Reports.

Versteckte Zeichen, Surrogate-Paare und Homoglyphen analysieren

Schnelle Antwort: Fügen Sie einen beliebigen String ein, um ihn in einzelne Unicode-Skalarwerte zu zerlegen. So machen Sie unsichtbare Zeichen wie U+200B Zero Width Space oder U+FEFF BOM, mehrteilige ZWJ-Emoji-Sequenzen und verwechselbare Nicht-ASCII-Homoglyphen samt ihrer exakten UTF-8- und UTF-16-Byte-Sequenzen sichtbar.

Parser-Fehler, ungültige Webhook-Signaturen und fehlgeschlagene SQL-Abfragen werden häufig durch Zeichen verursacht, die in Terminal-Emulatoren und Code-Editoren identisch – oder komplett unsichtbar – dargestellt werden. Betrachten wir eine Umgebungsvariable, die aus einem Dokumentationsportal oder einer Chat-Nachricht kopiert wurde und optisch exakt wie api_key=prod aussieht:

Visuelle Darstellung: api_key=prod
String.length:        14 (erwartet: 12)
UTF-8-Bytelänge:      19 Bytes (erwartet: 12 Bytes)

Untersucht man diesen 14 Einheiten langen String im Unicode-Zeichen-Inspektor, kommen drei verschiedene Anomalien zum Vorschein, die sich in scheinbar reinem ASCII-Text verbergen: eine führende Byte Order Mark (<BOM>), ein kyrillisches Homoglyph anstelle des lateinischen a und ein eingebettetes breitenloses Leerzeichen (<ZWSP>):

[
  {
    "index": 0,
    "badge": "<BOM>",
    "codePoint": "U+FEFF",
    "name": "ZERO WIDTH NO-BREAK SPACE",
    "category": "Cf (Format)",
    "block": "Arabic Presentation Forms-B",
    "utf8Hex": "EF BB BF",
    "utf16BE": "FE FF",
    "utf16LE": "FF FE",
    "warning": "Invisible zero-width format character"
  },
  {
    "index": 1,
    "glyph": "а",
    "codePoint": "U+0430",
    "name": "CYRILLIC SMALL LETTER A",
    "category": "Ll (Lowercase Letter)",
    "block": "Cyrillic",
    "utf8Hex": "D0 B0",
    "utf16BE": "04 30",
    "utf16LE": "30 04",
    "warning": "Confusable homoglyph for Latin U+0061 ('a')"
  },
  {
    "index": 2,
    "glyph": "p",
    "codePoint": "U+0070",
    "name": "LATIN SMALL LETTER P",
    "category": "Ll (Lowercase Letter)",
    "block": "Basic Latin",
    "utf8Hex": "70",
    "utf16BE": "00 70",
    "utf16LE": "70 00",
    "warning": null
  },
  {
    "index": 8,
    "badge": "<ZWSP>",
    "codePoint": "U+200B",
    "name": "ZERO WIDTH SPACE",
    "category": "Cf (Format)",
    "block": "General Punctuation",
    "utf8Hex": "E2 80 8B",
    "utf16BE": "20 0B",
    "utf16LE": "0B 20",
    "warning": "Invisible zero-width format character"
  }
]

Der Inspektor verdeutlicht zudem, warum Emojis aus mehreren Codepoints in verschiedenen Laufzeitumgebungen völlig unterschiedliche Längen aufweisen. Die Analyse des einzelnen sichtbaren Technologen-Emojis 👨💻 zeigt drei skalare Codepoints, die durch <ZWJ> (U+200D) verbunden sind und in JavaScript 5 UTF-16-Code-Units sowie 11 Bytes in UTF-8 belegen:

Graphem-Cluster (UAX #29):  1   -> [ "👨💻" ]
Unicode-Skalar-Codepoints:  3   -> U+1F468 (Man) + U+200D (<ZWJ>) + U+1F4BB (Laptop)
UTF-16-Code-Units (.length): 5   -> D83D DC68 + 200D + D83D DCBB
UTF-8-kodierte Bytes:       11  -> F0 9F 91 A8 + E2 80 8D + F0 9F 92 BB

Unicode-Kodierungsmechanik, Graphem-Grenzen und Sicherheitsrisiken

Schnelle Antwort: Unicode bildet 1.112.064 gültige Skalarwerte über 17 Ebenen in UTF-8 mit variabler Breite (1 bis 4 Bytes gemäß RFC 3629) oder UTF-16 (2 oder 4 Bytes über Surrogate-Paare gemäß RFC 2781) ab. Abweichungen zwischen Graphem-Clustern, kanonischen Normalisierungsformen und unsichtbaren Bidi-Steuerzeichen führen zu Parser-Bugs und Sicherheitslücken.

Skalarwerte, UTF-8-Präfix-Bits (RFC 3629) und UTF-16-Surrogate (RFC 2781)

Der Unicode-Coderaum erstreckt sich von U+0000 bis U+10FFFF über 17 Ebenen (Planes) mit jeweils 65.536 Codepoints. Abzüglich der 2.048 reservierten Surrogate-Positionen (U+D800 bis U+DFFF) existieren exakt 1.112.064 gültige Unicode-Skalarwerte:

  • UTF-8 kodiert Basic Latin auf Ebene 0 (U+0000 bis U+007F) in 1 Byte (0xxxxxxx), U+0080 bis U+07FF in 2 Bytes (110xxxxx 10xxxxxx), die übrigen Zeichen der Basic Multilingual Plane (BMP, U+0800 bis U+FFFF) in 3 Bytes (1110xxxx 10xxxxxx 10xxxxxx) und zusätzliche Astralebenen (U+10000 bis U+10FFFF) in 4 Bytes (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx). Da Folgebytes immer mit 10 beginnen, ist UTF-8 selbstsynchronisierend und enthält niemals Null-Bytes (0x00) innerhalb von Nicht-Null-Zeichen.
  • UTF-16 stellt Skalarwerte der BMP direkt als einzelne 16-Bit-Code-Unit dar. Bei Zeichen von U+10000 bis U+10FFFF wird 0x10000 subtrahiert, was einen 20-Bit-Offset (0x00000 bis 0xFFFFF) ergibt: Die oberen 10 Bits bilden das High-Surrogate (0xD800 bis 0xDBFF), die unteren 10 Bits das Low-Surrogate (0xDC00 bis 0xDFFF). UTF-16BE serialisiert das höchstwertige Byte zuerst (D8 3D DC 80), während UTF-16LE die Byte-Reihenfolge innerhalb jeder 16-Bit-Einheit umkehrt (3D D8 80 DC).

Kanonische Äquivalenz (UAX #15) und Graphem-Segmentierung (UAX #29)

Visuell identischer Text besitzt häufig unterschiedliche zugrunde liegende Byte-Darstellungen. Gemäß Unicode Standard Annex #15 kann é in der Normalization Form C (NFC) als vorkomponiertes Zeichen U+00E9 (UTF-8 C3 A9) oder in der Normalization Form D (NFD) als Basiszeichen U+0065 (e) gefolgt von U+0301 (COMBINING ACUTE ACCENT, General Category Mn, UTF-8 65 CC 81) gespeichert werden. macOS-Dateisysteme normalisieren Dateinamen in Richtung NFD, während Linux, Windows und Browser-Formulare standardmäßig NFC verwenden – wodurch naive byteweise String-Vergleiche, S3-Key-Lookups und HMAC-Prüfungen fehlschlagen, sofern nicht vorab normalisiert wird.

Ebenso kann das Abschneiden von Strings nach UTF-16-Index (str.slice(0, 10)) ein High-Surrogate von seinem Low-Surrogate trennen (was zu ungepaarten Surrogaten führt, die in UTF-8 zu U+FFFD-Ersetzungszeichen serialisiert werden) oder ein Basiszeichen von seinen kombinierenden Diakritika, Variationsselektoren (U+FE0E, U+FE0F) oder regionalen Flaggenindikatoren (U+1F1E6 bis U+1F1FF) abspalten. Vom Benutzer wahrgenommene Zeichen müssen entlang der Grenzen für erweiterte Graphem-Cluster nach UAX #29 segmentiert werden.

Trojan Source (`CVE-2021-42574`) und UTS #39 Confusables

Zwei Zeichenklassen in Unicode stellen akute Risiken für die Anwendungssicherheit dar:

  1. Bidirektionale Overrides (Cf): Die Codepoints U+202A bis U+202E (<LRE>, <RLE>, <PDF>, <LRO>, <RLO>) und Isolates U+2066 bis U+2069 (<LRI>, <RLI>, <FSI>, <PDI>) weisen Text-Renderer an, die Anzeigereihenfolge umzukehren, ohne die logische Speicherreihenfolge zu ändern. Angreifer nutzen nicht geschlossene Bidi-Steuerzeichen, um aktive Bedingungen in Kommentaren oder String-Literalen zu tarnen (CVE-2021-42574).
  2. Homoglyphen-Spoofing (UTS #39): Schriftübergreifende Doppelgänger (U+0430 kyrillisches а, U+03BF griechisches ο, U+FF21 vollbreites A) ermöglichen es Angreifern, täuschend echte Domainnamen zu fälschen (IDN-Homograph-Angriffe), Variablen im Quellcode zu überschatten (CVE-2021-42694) oder Wortfilter zu umgehen.

Unicode-Zeichen-Inspektor vs. verwandte Text- und Kodierungs-Tools

Schnelle Antwort: Nutzen Sie den Unicode-Zeichen-Inspektor, um Strings Zeichen für Zeichen auf versteckte Steuercodes, Homoglyphen und Byte-Sequenzen zu prüfen. Verwenden Sie die ASCII-Tabelle zum Nachschlagen der Codes 0 bis 255, den Unicode-Konverter für Massenkonvertierungen oder das Unicode Escape Tool für sprachspezifische Escape-Literale.

Wählen Sie das passende Werkzeug aus unserem Zeichen- und Kodierungs-Cluster, je nachdem, ob Sie einen unbekannten String diagnostizieren, eine Standard-Bytetabelle nachschlagen oder String-Literale für Quellcode transformieren möchten:

Funktion Unicode-Zeichen-Inspektor ASCII-Tabelle Unicode-Konverter Unicode Escape & Unescape Tool
Hauptanwendung Zeichenweise Diagnose-Analyse von eingefügten Strings oder Dateien Interaktive Referenztabelle für Byte-Codes 0–255 Massenkonvertierung zwischen Text, Codepoints und Byte-Arrays Escapen und Unescapen von Quellcode-String-Literalen
Unsichtbare & Bidi-Warnungen Markiert <ZWSP>, <BOM>, <NBSP> und Trojan-Source-Bidi-Codes Listet C0- (0–31, 127) und C1-Steuerzeichen (128–159) auf Kodiert Steuerzeichen numerisch ohne Sicherheits-Badges Wandelt Nicht-ASCII-Zeichen in sichtbare \uXXXX-Escapes um
Homoglyphen-Erkennung Meldet schriftübergreifende UTS-#39-Lookalikes und typografische Satzzeichen Deckt nur 7-Bit-US-ASCII und ISO-8859-1 Latin-1 ab Keine Analyse verwechselbarer Schriften Keine Analyse verwechselbarer Schriften
Graphem- vs. UTF-16-Vergleich Zeigt UAX-#29-Grapheme, Skalarwerte, UTF-16-Units und UTF-8-Bytes Feste 1-Byte-Tabellenzeilen (8-Bit) Gibt vollständige UTF-8-, UTF-16- und UTF-32-Streams aus Erhält oder paart UTF-16-Surrogate (\uD83D\uDE80 vs. \u{1F680})
Sprach-Escape-Syntax Zeigt rohe Hex-Codepoints (U+XXXX) und Bytewerte Zeigt C/JS-Escapes, Caret-Notation (^M) und HTML-Entities Formatiert hexadezimale/dezimale Codepoint-Listen Dedizierte Escape-Modi für JS, JSON, Python, CSS, Rust und HTML
  • Wechseln Sie zur ASCII-Tabelle, wenn Sie eine schnelle Übersicht für 7-Bit-US-ASCII (0–127) und Extended Latin-1 (128–255) mit binären Bitmasken, Oktalcodes und Terminal-Caret-Notation benötigen.
  • Nutzen Sie den Unicode-Konverter, wenn Sie ganze Textblöcke stapelweise in fortlaufende U+XXXX-Listen oder hexadezimale UTF-8/UTF-16/UTF-32-Streams umwandeln möchten.
  • Verwenden Sie das Unicode Escape & Unescape Tool, um \uXXXX-, \u{XXXXX}-, \xXX- oder CSS-\XXXXXX-Sequenzen für JSON-Payloads und Quelldateien zu erzeugen oder zu dekodieren, oder öffnen Sie den Zeichenzähler, um Texte auf SEO-Meta-Tag-Längen und SMS-Segmentgrenzen (GSM-7/UCS-2) zu prüfen.
FAQ

Unicode-Zeichen-Inspektor FAQ und technische Anleitung

Alles, was Sie über die Nutzung des kostenlosen Online-unsichtbare zeichen anzeigen von Utiliome wissen müssen.

Warum gibt JavaScript String.length für ein einzelnes sichtbares Zeichen 2 oder mehr zurück?

JavaScript, Java und C# messen die String-Länge in 16-Bit-UTF-16-Code-Units statt in Unicode-Skalarwerten oder erweiterten Graphem-Clustern nach UAX #29. Jedes Zeichen außerhalb der Basic Multilingual Plane (oberhalb von U+FFFF, wie z. B. U+1F680 Rakete) benötigt ein High- und Low-Surrogate-Paar und hat daher eine .length von 2. Zusammengesetzte Emoji-Sequenzen, die mit U+200D Zero Width Joiner (<ZWJ>) und U+FE0F Variation Selector-16 verknüpft sind, kombinieren mehrere Skalarwerte zu einer einzigen sichtbaren Glyphe, was oft zu .length-Werten zwischen 5 und 11 führt.

Welche unsichtbaren Unicode-Zeichen beschädigen am häufigsten JSON, YAML und Quellcode?

Die vier häufigsten Verursacher sind U+00A0 No-Break Space (<NBSP>, unter macOS oft versehentlich per Option+Leertaste getippt, was YAML-Einrückungen und SQL-Parser zerstört), U+FEFF Byte Order Mark (<BOM>, das beim Zusammenfügen von unter Windows gespeicherten Dateien mitten im Text landet), U+200B Zero Width Space (<ZWSP>, beim Kopieren aus Rich-Text-Dokumenten, PDFs oder Chat-Apps in API-Tokens eingeschleppt) sowie typografische Anführungszeichen (U+201C und U+201D), die gerade ASCII-Anführungszeichen (U+0022) ersetzen.

Wie erkenne ich bidirektionale Trojan-Source-Override-Angriffe in Code-Snippets?

Trojan Source (CVE-2021-42574) nutzt neun bidirektionale Unicode-Steuerzeichen der Kategorie Cf – U+202A (<LRE>), U+202B (<RLE>), U+202C (<PDF>), U+202D (<LRO>), U+202E (<RLO>), U+2066 (<LRI>), U+2067 (<RLI>), U+2068 (<FSI>) und U+2069 (<PDI>) –, um Quellcode-Tokens visuell umzustellen, sodass ausführbare Anweisungen beim Code-Review wie auskommentiert wirken. Wenn Sie verdächtigen Code in den Inspektor einfügen, wird jeder versteckte Bidi-Codepoint exakt an seinem Zeichenindex offengelegt.

Warum schlagen strikte Gleichheitsprüfungen bei zwei optisch identischen Strings mit Akzenten fehl?

Unicode erlaubt gemäß UAX #15 mehrere kanonisch äquivalente Darstellungen. Beispielsweise ist 'é' in der Normalization Form C (NFC) ein einzelner vorkomponierter Skalarwert U+00E9 (UTF-8-Bytes C3 A9), während es in der Normalization Form D (NFD) aus zwei Skalarwerten besteht: U+0065 ('e') gefolgt vom Combining Acute Accent U+0301 (UTF-8-Bytes 65 CC 81). Die Untersuchung beider Strings zeigt die unterschiedlichen Codepoint-Sequenzen auf, sodass Sie vor dem Hashing oder Vergleich .normalize('NFC') anwenden können.

Werden eingefügte Texte oder hochgeladene Dateien an einen Server übertragen?

Nein. Zeichensegmentierung, Codepoint-Extraktion, UTF-8- und UTF-16LE/BE-Byte-Berechnung sowie die Prüfung auf verwechselbare Homoglyphen laufen vollständig in Ihrem Browser über native clientseitige JavaScript-APIs. API-Schlüssel, Produktions-Logs und private Quellcode-Ausschnitte verbleiben ausnahmslos im lokalen Arbeitsspeicher.