Unicode-teckeninspektör

Inspektera Unicode-strängar tecken för tecken i webbläsaren.

Inga uppladdningarIngen registreringOmedelbara resultat
Unicode & UTF-8/16Nollbredd & homoglyfer100% Lokalt • Noll Uppladdningar
Granska tecken
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis Unicode-teckeninspektör?

Byggd från grunden för strikt integritet, snabb körning och utan krångel. Inga prenumerationer eller konton krävs.

Detektering av osynliga tecken & Bidi-styrkoder

Synliggör icke-utskrivbara styr- och formattecken inklusive U+200B ZWSP, U+FEFF BOM, U+00A0 NBSP, U+00AD mjukt bindestreck samt dubbelriktade Trojan Source-styrtecken (U+202A till U+202E, U+2066 till U+2069).

Byteuppdelning för UTF-8 & UTF-16LE/BE

Visar exakta hexadecimala UTF-8-bytesekvenser (1 till 4 byte enligt RFC 3629) sida vid sida med UTF-16LE- och UTF-16BE-kodenheter, vilket avslöjar surrogatpar för tilläggsplan ovanför U+FFFF.

UAX #29-grafem kontra kodenhetsmått

Jämför utökade grafemkluster mot antalet Unicode-skalärer, JavaScript UTF-16-kodenheter och UTF-8-bytelängd för att felsöka strängkapningsbuggar och överskridna databaskolumner.

Homoglyfdiagnostik & 100 % lokal integritet

Flaggar förväxlingsbara UTS #39-tecken som kyrilliska kontra latinska glyfer och typografiska citattecken helt på klientsidan i webbläsarens minne, så att tokens, loggar och kod aldrig lämnar din enhet.

Utiliome jämfört med molnalternativ

Jämför vår lokala WebAssembly-motor med äldre molnverktyg.

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Detektering av osynliga tecken & Bidi-styrkoder Synliggör icke-utskrivbara styr- och formattecken inklusive U+200B ZWSP, U+FEFF BOM, U+00A0 NBSP, U+00AD mjukt bindestreck samt dubbelriktade Trojan Source-styrtecken (U+202A till U+202E, U+2066 till U+2069). Begränsade alternativ utan avancerad anpassning
Byteuppdelning för UTF-8 & UTF-16LE/BE Visar exakta hexadecimala UTF-8-bytesekvenser (1 till 4 byte enligt RFC 3629) sida vid sida med UTF-16LE- och UTF-16BE-kodenheter, vilket avslöjar surrogatpar för tilläggsplan ovanför U+FFFF. Kräver externa verktyg eller manuell hantering
Integritet och databehandling 100 % lokalt i webbläsaren (ingen serveruppladdning) Laddar upp data till externa molnservrar
Pris och kontokrav 100 % gratis för alltid utan registrering Kräver kontoregistrering eller betald prenumeration
Så fungerar det

Hur du använder Unicode-teckeninspektör i 3 enkla steg

Ingen programinstallation krävs. Allt körs direkt i din webbläsare.

1

Klistra in text eller släpp en fil

Klistra in en sträng, identifierare, loggrad eller ladda upp en UTF-8-fil som misstänks innehålla osynliga nollbreddstecken, trasiga emojisekvenser eller oväntade bytelängder.

2

Inspektera metadata per tecken

Granska varje teckens skalära U+XXXX-kodpunkt, officiella Unicode-namn, General Category, blocktillhörighet, hexadecimala UTF-8- och UTF-16LE/BE-byte samt säkerhetsvarningar.

3

Isolera avvikelser eller kopiera ren utdata

Filtrera direkt fram osynliga formattecken eller förväxlingsbara homoglyfer, rensa bort oönskade styrtecken eller kopiera tabellen med byteinspektion till felrapporter.

Inspektera dolda tecken, surrogatpar och homoglyfer

Snabbsvar: Klistra in valfri sträng för att dela upp den i enskilda skalära Unicode-värden och avslöja osynliga tecken som U+200B Zero Width Space eller U+FEFF BOM, sammansatta ZWJ-emojisekvenser och förväxlingsbara icke-ASCII-tecken tillsammans med deras exakta UTF-8- och UTF-16-bytesekvenser.

Parserfel, ogiltiga webhook-signaturer och misslyckade SQL-sökningar beror ofta på tecken som renderas identiskt – eller helt osynligt – i terminalemulatorer och kodredigerare. Ta till exempel en miljövariabel som kopierats från en dokumentationsportal eller chatt och som visuellt ser exakt ut som api_key=prod:

Visuell rendering: api_key=prod
String.length:     14 (förväntat 12)
UTF-8-bytelängd:   19 byte (förväntat 12 byte)

När denna sträng på 14 kodenheter körs genom Unicode-teckeninspektören avslöjas tre distinkta avvikelser dolda i vad som ser ut som vanlig ASCII-text: en inledande Byte Order Mark (<BOM>), en kyrillisk homoglyf som ersätter latinskt a samt ett inbäddat nollbreddsblanksteg (<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": "Osynligt formattecken med nollbredd"
  },
  {
    "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": "Förväxlingsbar homoglyf för latinskt 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": "Osynligt formattecken med nollbredd"
  }
]

Inspektören klargör även varför emojis sammansatta av flera kodpunkter rapporterar helt olika längder i olika körmiljöer. Om man inspekterar den enskilda synliga teknolog-emojin 👨💻 visas tre skalära kodpunkter sammanfogade med <ZWJ> (U+200D), vilket tar upp 5 UTF-16-kodenheter i JavaScript och 11 byte i UTF-8:

Grafemkluster (UAX #29):    1   -> [ "👨💻" ]
Skalära Unicode-kodpunkter: 3   -> U+1F468 (Man) + U+200D (<ZWJ>) + U+1F4BB (Laptop)
UTF-16-kodenheter (.length): 5  -> D83D DC68 + 200D + D83D DCBB
UTF-8-kodade byte:          11  -> F0 9F 91 A8 + E2 80 8D + F0 9F 92 BB

Mekaniken bakom Unicode-kodning, grafemgränser och säkerhetsrisker

Snabbsvar: Unicode mappar 1 112 064 giltiga skalära värden över 17 plan till UTF-8 med variabel bredd (1 till 4 byte enligt RFC 3629) eller UTF-16 (2 eller 4 byte via surrogatpar enligt RFC 2781). Skillnader mellan grafemkluster, kanoniska normaliseringsformer och osynliga bidi-styrtecken orsakar parserbuggar och säkerhetshål.

Skalära värden, UTF-8-prefixbitar (RFC 3629) och UTF-16-surrogat (RFC 2781)

Unicode-kodrymden sträcker sig från U+0000 till U+10FFFF över 17 plan med 65 536 kodpunkter vardera. Om man exkluderar de 2 048 reserverade surrogatpositionerna (U+D800 till U+DFFF) finns exakt 1 112 064 skalära Unicode-värden:

  • UTF-8 kodar Plan 0 Basic Latin (U+0000 till U+007F) med 1 byte (0xxxxxxx), U+0080 till U+07FF med 2 byte (110xxxxx 10xxxxxx), övriga tecken i Basic Multilingual Plane (BMP, U+0800 till U+FFFF) med 3 byte (1110xxxx 10xxxxxx 10xxxxxx) samt astrala tilläggsplan (U+10000 till U+10FFFF) med 4 byte (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx). Eftersom fortsättningsbyte alltid börjar med 10 är UTF-8 självsynkroniserande och innehåller aldrig null-byte (0x00) inuti tecken som inte är null.
  • UTF-16 representerar skalära BMP-värden direkt som en 16-bitars kodenhet. För tecken från U+10000 till U+10FFFF subtraheras 0x10000 för att ge ett 20-bitars offsetvärde (0x00000 till 0xFFFFF), där de övre 10 bitarna delas upp i ett högt surrogat (0xD800 till 0xDBFF) och de lägre 10 bitarna i ett lågt surrogat (0xDC00 till 0xDFFF). UTF-16BE serialiserar den mest signifikanta byten först (D8 3D DC 80), medan UTF-16LE vänder på byteordningen inom varje 16-bitarsenhet (3D D8 80 DC).

Kanonisk ekvivalens (UAX #15) och grafemsegmentering (UAX #29)

Visuellt identisk text har ofta olika underliggande byterepresentationer. Enligt Unicode Standard Annex #15 kan é lagras i Normalization Form C (NFC) som ett sammansatt tecken U+00E9 (UTF-8 C3 A9) eller i Normalization Form D (NFD) som basbokstaven U+0065 (e) följt av U+0301 (COMBINING ACUTE ACCENT, General Category Mn, UTF-8 65 CC 81). Filsystem i macOS normaliserar filnamn mot NFD, medan Linux, Windows och webbformulär använder NFC som standard – vilket gör att naiva bytevisa strängjämförelser, sökningar efter S3-objektnycklar och HMAC-kontroller misslyckas om texten inte normaliseras först.

På samma sätt kan strängkapning via UTF-16-index (str.slice(0, 10)) klyva ett högt surrogat från dess låga surrogat (vilket skapar ensamma oparade surrogat som serialiseras till ersättningstecknet U+FFFD i UTF-8) eller skilja ett bastecken från dess kombinerande diakritiska tecken, variationsväljare (U+FE0E, U+FE0F) eller regionala flaggindikatorer (U+1F1E6 till U+1F1FF). Tecken så som de uppfattas av användaren måste segmenteras längs gränserna för utökade grafemkluster enligt UAX #29.

Trojan Source (`CVE-2021-42574`) och förväxlingsbara tecken (UTS #39)

Två teckenklasser i Unicode utgör akuta applikationssäkerhetsrisker:

  1. Dubbelriktade styrtecken (Cf): Kodpunkterna U+202A till U+202E (<LRE>, <RLE>, <PDF>, <LRO>, <RLO>) och isoleringstecknen U+2066 till U+2069 (<LRI>, <RLI>, <FSI>, <PDI>) instruerar textrenderare att vända visningsordningen utan att ändra den logiska ordningen i minnet. Angripare använder oavslutade bidi-styrtecken för att dölja aktiva villkorssatser inuti kommentarer eller strängliteraler (CVE-2021-42574).
  2. Homoglyf-spoofing (UTS #39): Förväxlingsbara tecken mellan skriftsystem (U+0430 kyrilliskt а, U+03BF grekiskt ο, U+FF21 fullbredds-A) gör det möjligt för angripare att förfalska domännamn (IDN-homografattacker), skugga variabler i källkod (CVE-2021-42694) eller kringgå blocklistor för nyckelord.

Unicode-teckeninspektör jämfört med relaterade text- och kodningsverktyg

Snabbsvar: Använd Unicode-teckeninspektör för att granska en sträng tecken för tecken efter dolda styrkoder, homoglyfer och bytesekvenser. Använd ASCII-tabell för statiska uppslag av koder från 0 till 255, Unicode-konverterare för masskonvertering mellan text och kodpunkter, eller Verktyg för Unicode-escape för språkspecifika escape-sekvenser.

Välj rätt verktyg i tecken- och kodningsklustret beroende på om du felsöker en okänd sträng, slår upp en standardtabell för byte eller transformerar strängliteraler för källkod:

Funktion Unicode-teckeninspektör ASCII-tabell Unicode-konverterare Verktyg för Unicode-escape
Primärt arbetsflöde Diagnostisk granskning per tecken av inklistrade strängar eller filer Interaktiv referenstabell för bytekoder 0–255 Masskonvertering mellan text, kodpunkter och byte-arrayer Escaping och avkodning av strängliteraler i källkod
Varningar för dolda tecken & Bidi Markerar <ZWSP>, <BOM>, <NBSP> och Trojan Source bidi-koder Listar styrkoderna C0 (0–31, 127) och C1 (128–159) Kodar styrtecken numeriskt utan säkerhetsmärkning Konverterar icke-ASCII-tecken till synliga \uXXXX-sekvenser
Homoglyfdetektering Flaggar förväxlingsbara UTS #39-tecken och typografiska skiljetecken Täcker endast 7-bitars US-ASCII och ISO-8859-1 Latin-1 Ingen analys av förväxlingsbara skriftsystem Ingen analys av förväxlingsbara skriftsystem
Grafem kontra UTF-16-diff Visar UAX #29-grafem, skalära kodpunkter, UTF-16-enheter och UTF-8-byte Fasta tabellrader på 1 byte (8-bit) Genererar kompletta UTF-8-, UTF-16- och UTF-32-strömmar Bevarar eller parar UTF-16-surrogat (\uD83D\uDE80 kontra \u{1F680})
Språkspecifik escape-syntax Visar råa hexadecimala kodpunkter (U+XXXX) och bytevärden Visar C/JS-escapes, caret-notation (^M) och HTML-entiteter Formaterar hexadecimala/decimala kodpunktslistor Dedikerade lägen för JS, JSON, Python, CSS, Rust och HTML
  • Växla till ASCII-tabell när du behöver en snabb referenstabell för 7-bitars US-ASCII (0–127) och utökad Latin-1 (128–255) med binära bitmasker, oktala koder och caret-notation för terminaler.
  • Använd Unicode-konverterare när du vill masskonvertera ett helt textblock till sammanhängande U+XXXX-listor eller hexadecimala UTF-8/UTF-16/UTF-32-strömmar.
  • Använd Verktyg för Unicode-escape när du förbereder eller avkodar sekvenser som \uXXXX, \u{XXXXX}, \xXX eller CSS \XXXXXX för JSON-nyttolaster och källkodsfiler, eller öppna Teckenräknare när du kontrollerar textlängder mot SEO-metataggar och gränser för SMS-segment (GSM-7/UCS-2).
FAQ

Unicode-teckeninspektör FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis inspektera unicode tecken online.

Varför returnerar JavaScript String.length 2 eller mer för ett enda synligt tecken?

JavaScript, Java och C# mäter stränglängd i 16-bitars UTF-16-kodenheter i stället för skalära Unicode-värden eller utökade grafemkluster enligt UAX #29. Alla tecken utanför Basic Multilingual Plane (ovanför U+FFFF, såsom U+1F680 Rocket) kräver ett högt och lågt surrogatpar, vilket ger en .length på 2. Sammansatta emojisekvenser som fogas ihop med U+200D Zero Width Joiner (<ZWJ>) och U+FE0F Variation Selector-16 kombinerar flera skalära värden till en enda visuell glyf, vilket ofta ger .length-värden mellan 5 och 11.

Vilka osynliga Unicode-tecken orsakar oftast fel i JSON, YAML och källkod?

De fyra vanligaste bovarna är U+00A0 hårt blanksteg (<NBSP>, som ofta skrivs av misstag via Option+mellanslag på macOS och förstör YAML-indentering och SQL-parsrar), U+FEFF Byte Order Mark (<BOM>, som hamnar mitt i strömmar när filer sparade i Windows-redigerare slås ihop), U+200B Zero Width Space (<ZWSP>, som kopieras från formaterade dokument, PDF-filer eller chattappar in i API-tokens) samt typografiska citattecken (U+201C och U+201D) som ersätter raka ASCII-citattecken (U+0022).

Hur upptäcker jag dubbelriktade Trojan Source-attacker i kodavsnitt?

Trojan Source (CVE-2021-42574) utnyttjar nio dubbelriktade styrtecken i Unicode General Category 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>) och U+2069 (<PDI>) – för att visuellt kasta om ordningen på källkodstokens så att exekverbara satser ser ut att vara utkommenterade vid manuell kodgranskning. Genom att klistra in misstänkt kod i inspektören avslöjas varje dold bidi-kodpunkt på sitt exakta teckenindex.

Varför misslyckas strikta likhetskontroller för två visuellt identiska strängar med accenter?

Unicode tillåter flera kanoniskt ekvivalenta representationer enligt UAX #15. Exempelvis är 'é' i Normalization Form C (NFC) ett enda sammansatt skalärt värde U+00E9 (UTF-8-byte C3 A9), medan det i Normalization Form D (NFD) består av två skalära värden: U+0065 ('e') följt av Combining Acute Accent U+0301 (UTF-8-byte 65 CC 81). Genom att inspektera båda strängarna ser du de avvikande kodpunktssekvenserna så att du kan tillämpa .normalize('NFC') före hashning eller jämförelse.

Skickas inklistrad text eller uppladdade filer till någon server?

Nej. Teckensegmentering, extrahering av kodpunkter, beräkning av UTF-8- och UTF-16LE/BE-byte samt kontroller av förväxlingsbara homoglyfer körs helt i din webbläsare med inbyggda JavaScript-API:er på klientsidan. API-nycklar, produktionsloggar och privata kodavsnitt lämnar aldrig det lokala minnet.