ASCII-referenstabell

Sök i US-ASCII (0–127) och Latin-1 (128–255) i webbläsaren via decimaltal, hex, oktalt, 8-bitars binärkod och escape-sekvenser.

Inga uppladdningarIngen registreringOmedelbara resultat
7-bitars ASCII & Latin-1Dec, Hex, Okt, Bin & HTMLByteinspektör för text
Öppna ASCII-tabell
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis ASCII-referenstabell?

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

Komplett 0–255-tabell för ANSI X3.4 & ISO-8859-1

Täcker alla 128 standardpositioner i 7-bitars US-ASCII (RFC 20 C0-styrtecken och skrivbara tecken) tillsammans med utökad 8-bitars ISO-8859-1 Latin-1 (128-255) C1-styrkoder och västeuropeiska symboler.

Synkroniserade kolumner för talbaser & escape-sekvenser

Korsrefererar decimaltal (0-255), hexadecimalt (0x00-0xFF), 3-siffrigt oktalt (000-377), utfylld 8-bitars binärkod, C/JS-escape-sekvenser, caret-notation för terminal (^@, ^M, ^?) och HTML-entiteter.

Omedelbar flerfältssökning & gruppfilter

Filtrera alla 256 byterader direkt genom att skriva en synlig glyf, styrmnemonik som LF eller ESC, hex-byte som 0x1B, 8-bitars binärmönster, caret-sekvens eller HTML-entitet.

Slå upp på klientsidan utan fördröjning

Utför all filtrering, intervallväxling och kopiering med ett klick direkt i webbläsarens minne utan nätverksanrop eller externa beroenden.

Utiliome jämfört med molnalternativ

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

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Komplett 0–255-tabell för ANSI X3.4 & ISO-8859-1 Täcker alla 128 standardpositioner i 7-bitars US-ASCII (RFC 20 C0-styrtecken och skrivbara tecken) tillsammans med utökad 8-bitars ISO-8859-1 Latin-1 (128-255) C1-styrkoder och västeuropeiska symboler. Begränsade alternativ utan avancerad anpassning
Synkroniserade kolumner för talbaser & escape-sekvenser Korsrefererar decimaltal (0-255), hexadecimalt (0x00-0xFF), 3-siffrigt oktalt (000-377), utfylld 8-bitars binärkod, C/JS-escape-sekvenser, caret-notation för terminal (^@, ^M, ^?) och HTML-entiteter. 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 ASCII-referenstabell i 3 enkla steg

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

1

Välj ASCII-intervall eller styrteckengrupp

Visa hela bytetabellen från 0 till 255 eller begränsa raderna till C0-styrtecken (0-31 och 127), skrivbar 7-bitars US-ASCII (32-126) eller utökad ISO-8859-1 Latin-1 (128-255).

2

Filtrera på talbas, mnemonik, caret eller escape

Skriv valfritt tecken, mnemonik (NUL, CR, LF, DEL), decimaltal, hexvärde (0x0A, 7F), binär byte (01000001), caret-genväg (^C), C/JS-escape (\r, \x1b) eller HTML-entitet ( ).

3

Kopiera formaterade literaler direkt

Klicka på valfritt värde på en matchande rad för att kopiera dess hexliteral, decimala heltal, 8-bitars binärsträng, escape-sekvens eller HTML-entitet rakt in i din parser eller källkodsfil.

Snabbguide: Styrtecken, skrivbara glyfer och utökade bytevärden

Snabbsvar: Slå upp vilket bytevärde som helst från 0 till 255 för att korsreferera dess styrmnemonik eller glyf, decimaltal, hex, oktalt, 8-bitars binärkod, C/JavaScript-escape, caret-notation för terminal och HTML-entitet – perfekt vid felsökning av HTTP CRLF-inramning, ANSI-terminalsekvenser och binära nätverksprotokoll.

När utvecklare skriver lexikaliska analysatorer (lexers), inspekterar TCP-paketdumpar eller konfigurerar seriell och terminalbaserad I/O, översätter de ständigt mellan råa bytevärden och symboliska representationer. Nedan följer en referensöversikt över de vanligaste ankarraderna för C0-styrtecken (0–31, 127), skrivbar 7-bitars US-ASCII (32–126) och utökad ISO-8859-1 Latin-1 (128–255):

Dec  Hex   Oct  Binary    Glyph / Mnemonic  Caret  C / JS Escape  HTML Entity
---  ----  ---  --------  ----------------  -----  -------------  -----------
0    0x00  000  00000000  <NUL> (Null)      ^@     \0             &#0;
9    0x09  011  00001001  <HT>  (Tab)       ^I     \t             &#9;
10   0x0A  012  00001010  <LF>  (Line Feed) ^J     \n             &#10;
13   0x0D  015  00001101  <CR>  (Return)    ^M     \r             &#13;
27   0x1B  033  00011011  <ESC> (Escape)    ^[     \x1B           &#27;
32   0x20  040  00100000  <SP>  (Space)     -      " "            &#32;
48   0x30  060  00110000  0                 -      0              &#48;
65   0x41  101  01000001  A                 -      A              &#65;
97   0x61  141  01100001  a                 -      a              &#97;
126  0x7E  176  01111110  ~                 -      ~              &#126;
127  0x7F  177  01111111  <DEL> (Delete)    ^?     \x7F           &#127;
160  0xA0  240  10100000  <NBSP>            -      \xA0           &nbsp;
169  0xA9  251  10101001  ©                 -      \xA9           &copy;
255  0xFF  377  11111111  ÿ                 -      \xFF           &yuml;

Praktiska exempel på protokolluppslagning

Genom att mappa råa nätverksbytes mot tabellen klargörs omedelbart protokollinramning och styrsekvenser för terminaler:

1. HTTP/1.1 Header Terminator (RFC 9112):
   Hex-bytes:  0D 0A 0D 0A
   Mnemonik:   <CR><LF><CR><LF>
   Escapes:    "\r\n\r\n" (Decimalt: 13, 10, 13, 10)

2. ANSI CSI grön terminalprompt:
   Hex-bytes:  1B 5B 33 32 6D
   Avkodat:    <ESC> (0x1B / ^[) + '[' (0x5B) + '3' (0x33) + '2' (0x32) + 'm' (0x6D)
   JS-literal: "\x1b[32m"

Bitvis layout i 7-bitars US-ASCII, caret-aritmetik och nyanser i utökad 8-bitarskod

Snabbsvar: Standard US-ASCII (ANSI X3.4 / ISO/IEC 646 / RFC 20) placerar 128 tecken över 7 bitar (0x00 till 0x7F) så att skiftlägeskonvertering, siffertolkning och caret-notation kan utföras med enkla bitoperationer, medan utökade bytes (0x80 till 0xFF) skiljer sig fundamentalt mellan ISO-8859-1, Windows-1252 och UTF-8.

Matematisk bitlayout för 7-bitars US-ASCII (ANSI X3.4 / RFC 20)

Det 7-bitars US-ASCII-rutnätet (b6 b5 b4 b3 b2 b1 b0, från 0x00 till 0x7F) konstruerades medvetet så att hårdvarukretsar och lågnivåparsers kunde klassificera och omvandla tecken med enstaka bitvisa instruktioner helt utan uppslagstabeller:

  • Bit 5 (0x20, decimalt 32) för skiftlägesändring (Case Folding): Versaler A–Z upptar 0x41–0x5A (01000001–01011010), medan gemener a–z upptar 0x61–0x7A (01100001–01111010). Varje par av versal/gemen skiljer sig uteslutande åt på bit 5. Att konvertera en ASCII-bokstav till gemen görs med byte | 0x20, till versal med byte & ~0x20, och att växla skiftläge görs med byte ^ 0x20.
  • BCD-sifferjustering i lägre nibble: Siffrorna 0–9 upptar 0x30–0x39 (00110000–00111001). Genom att maskera bort de övre fyra bitarna (0011) med byte & 0x0F (eller subtrahera 0x30) får man direkt det binärkodade heltalet 0 till 9.
  • Bit 6 (0x40, decimalt 64) för caret-notation & Ctrl-mappning: Terminaldrivrutiner översätter Ctrl-kombinationer och visar C0-styrkoder (0x00–0x1F) samt <DEL> (0x7F) genom att invertera bit 6 (byte ^ 0x40). Följaktligen visas <NUL> (0x00 ^ 0x40 = 0x40) som ^@, <ETX> (0x03 ^ 0x40 = 0x43) som ^C (SIGINT), <LF> (0x0A ^ 0x40 = 0x4A) som ^J, <CR> (0x0D ^ 0x40 = 0x4D) som ^M, <ESC> (0x1B ^ 0x40 = 0x5B) som ^[ och <DEL> (0x7F ^ 0x40 = 0x3F) som ^?.

Fällan med utökade bytes (128–255): ISO-8859-1 vs Windows-1252 vs UTF-8

Eftersom US-ASCII lämnar den 8:e biten (b7, 0x80) nollställd uppstod inkompatibla 8-bitarsutökningar för värdena 128 till 255 (0x80–0xFF). Att blanda ihop dessa är grundorsaken till klassisk trasig textkodning (mojibake):

  1. ISO-8859-1 (Latin-1): Reserverar 128–159 (0x80–0x9F) för C1-styrkoder (såsom <PAD>, <NEL> och <CSI>) och tilldelar 160–255 (0xA0–0xFF) till västeuropeiska skiljetecken, valutasymboler och bokstäver med diakritiska tecken med början på <NBSP> (0xA0). Viktigt att notera är att Unicode antog ISO-8859-1 rakt av som sitt block U+0080–U+00FF (Latin-1 Supplement), vilket gör att bytevärden i ISO-8859-1 matchar Unicodes kodpunkter 1:1.
  2. Windows-1252 (CP1252): Omfördelar 27 av de 32 C1-styrkodspositionerna i 0x80–0x9F till skrivbara tecken – inklusive € (0x80, som i Unicode är U+20AC), — (0x97, U+2014) och typografiska citattecken (0x91–0x94). Enligt WHATWG Encoding Standard behandlar webbläsare deklarationer med charset=iso-8859-1 i HTML som windows-1252.
  3. UTF-8: Delar exakt enbyteskompatibilitet med 7-bitars US-ASCII (endast 0x00–0x7F). I UTF-8 är råa bytes i intervallet 0x80–0xFF aldrig giltiga enskilda Latin-1-tecken: värdena U+0080–U+00FF kräver en UTF-8-sekvens på 2 bytes (0xC2 0x80 till 0xC3 0xBF). Om en rå Latin-1-byte som 0xE9 (é) skickas till en UTF-8-parser utlöses ett avkodningsfel (U+FFFD), medan läsning av UTF-8-sekvensen 0xC3 0xA9 som ISO-8859-1 resulterar i mojibake-strängen é på två tecken.

ASCII-referenstabell jämfört med teckeninspektör och hex-avkodare

Snabbsvar: Använd ASCII-referenstabellen för att slå upp statiska bytemappningar från 0 till 255, styrmnemonik, caret-genvägar och escape-sekvenser. Använd Unicode-teckeninspektören för att granska inklistrade strängar efter dolda Unicode- eller UTF-8-bytes, eller Hex till Text Konverterare för att koda och avkoda hela hexadecimala nyttolaster.

Välj det specialiserade verktyg som passar bäst beroende på om du behöver en referenstabell på bytenivå, Unicode-diagnostik på strängnivå, bulkkonvertering av hexadecimala nyttolaster eller formaterade texttabeller:

Funktion ASCII-referenstabell Unicode-teckeninspektör Hex till Text Konverterare Formaterare för ASCII-, Unicode-ram- och Texttabeller
Huvudsyfte Sökbar 0–255-uppslagstabell för US-ASCII & ISO-8859-1 Unicode-diagnostik per tecken & detektor för dolda tecken Bulkkonvertering mellan hex-bytesträngar och läsbar text Rita justerade ASCII +---+- och Unicode-tabeller med ramtecken
Teckenomfång 256 enbyteskoder (0x00–0x7F + Latin-1 0x80–0xFF) Alla 1 112 064 skalära Unicode-värden (U+0000–U+10FFFF) Godtyckliga flerbytes UTF-8- eller ASCII-byteströmmar Godtycklig tabelldata från CSV, TSV, JSON eller Markdown
Styrkods- & Caret-info Fullständig C0/C1-mnemonik (<NUL>–<DEL>), caret (^M), oktalt, binärt Flaggar inbäddade <ZWSP>, <BOM>, <NBSP> och bidi-styrtecken Avkodar eller kodar råa hex-bytes (48 65 6C 6C 6F) Inte ett uppslagsverktyg för teckenkodning
Bästa användningsområde Kontrollera hex-, binär- och escape-koder när du skriver parsers Felsöka varför en inklistrad sträng bryter regex, JSON eller likhetsvillkor Översätta paketfångster eller hexdumpar till/från text Formatera CLI-utdata, README-dokumentation och SQL-liknande ASCII-rutnät
  • Öppna Unicode-teckeninspektör när du har en faktisk sträng eller fil med flerbytes UTF-8-emojis, blanksteg utan bredd (zero-width spaces) eller förväxlingsbara homoglyfer bortom byte 255.
  • Använd Hex till Text Konverterare för att avkoda långa hexadecimala bytedumpar (0D 0A-strömmar, Wireshark-nyttolaster eller hex-kodade loggar) direkt till UTF-8-text eller omvänt.
  • Om du vill generera justerade textrutnät med +---+---+ eller Unicode ┌───┐ för dokumentation eller kodkommentarer snarare än att slå upp teckenkoder, använd Formaterare för ASCII-, Unicode-ram- och Texttabeller, eller besök Unicode-konverterare för batchomvandlingar av U+XXXX-kodpunkter.
FAQ

ASCII-referenstabell FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis ascii tabell online.

Vad är skillnaden mellan 7-bitars US-ASCII (0-127) och utökad ASCII (128-255)?

Standard US-ASCII (ANSI X3.4 / RFC 20) definierar strikt 128 kodpositioner med hjälp av 7 bitar (0 till 127, eller 0x00 till 0x7F): 33 icke-skrivbara styrtecken (0 till 31 plus 127 <DEL>) och 95 skrivbara glyfer (32 <SP> till 126 ~). Koderna 128 till 255 (0x80 till 0xFF) sätter den 8:e biten och beror på vilken 8-bitars teckenkodning som valts. Denna referens använder ISO-8859-1 (Latin-1) för 128 till 255 eftersom dess numeriska kodvärden mappar identiskt mot skalära Unicode-värden från U+0080 till U+00FF.

Varför använder Windows och HTTP CRLF (13, 10) medan Unix och Linux använder LF (10)?

Elektromekaniska fjärrskrivare (teletypes) krävde två separata fysiska rörelser för att påbörja en ny rad: Vagnretur (<CR>, decimalt 13, 0x0D, \r) förde tillbaka skrivvagnen till vänstermarginalen, och radmatning (<LF>, decimalt 10, 0x0A, \n) matade fram pappersvalsen en rad. Internetprotokoll som HTTP/1.1, SMTP och FTP – tillsammans med CP/M, DOS och Windows – standardiserade på tvåbytessekvensen <CR><LF> (0D 0A), medan Multics, Unix, Linux och moderna macOS antog en enskild <LF>-byte (0A) som implicit radbrytning.

Är utökade Latin-1-bytes (128-255) byte-identiska med UTF-8?

Nej. Endast 7-bitars US-ASCII-värden från 0 till 127 (0x00 till 0x7F) har identisk enbyteskodning i UTF-8. Även om ISO-8859-1-bytes från 128 till 255 har exakt samma kodpunktsnummer som Unicode U+0080 till U+00FF, kodar UTF-8 detta intervall som tvåbytessekvenser som inleds med startbyten 0xC2 eller 0xC3. Exempelvis är © en enskild byte 0xA9 (decimalt 169) i ISO-8859-1, men två bytes 0xC2 0xA9 i UTF-8.

Hur beräknas caret-notation (^C, ^M, ^[, ^?) i terminalen från ASCII-koder?

Caret-notation omvandlar icke-skrivbara C0-styrbytes (0x00 till 0x1F) och <DEL> (0x7F) till skrivbara ASCII-tecken genom att växla bit 6 via bitvis XOR med 0x40 (decimalt 64). En XOR-operation på <ETX> (0x03) med 0x40 ger 0x43 ('C'), vilket skrivs som ^C. På samma sätt blir <CR> (0x0D ^ 0x40 = 0x4D) till ^M, <ESC> (0x1B ^ 0x40 = 0x5B) blir ^[ och <DEL> (0x7F ^ 0x40 = 0x3F) blir ^?.

Varför ligger DEL på 127 istället för att grupperas med styrtecknen 0 till 31?

På 7-spårs hålremsa av papper betydde kod 0 (<NUL>, binärt 0000000) att inga hål var stansade, medan kod 127 (<DEL>, binärt 1111111) betydde att alla sju hål var stansade. Eftersom fysiska hål inte kunde göras ogjorda efter ett skrivfel, backade operatörerna remsan och stansade alla sju hål över det felaktiga tecknet för att förvandla det till 127 (<DEL>), vilket hålremsläsarna sedan automatiskt hoppade över.