Complete ASCII Table with Decimal, Hex & Binary Values

ASCII (American Standard Code for Information Interchange) is a character encoding standard that assigns numeric codes to letters, numbers, and symbols. This complete reference includes all 128 ASCII characters with decimal, hexadecimal, binary, and HTML entity values.

Table of Contents

1. What is ASCII?
2. ASCII Control Characters (0-31)
3. Printable ASCII Characters (32-126)
4. Common ASCII Character Uses
5. ASCII vs Unicode
6. How to Use ASCII Codes
7. Summary

What is ASCII?

ASCII is a 7-bit character encoding standard developed in the 1960s. Each character is represented by a number from 0 to 127, which computers use to store and transmit text. ASCII includes:

• Control characters (0-31): Non-printable codes used for text formatting and device control
• Printable characters (32-126): Letters, numbers, punctuation, and symbols you can see and type
• DEL character (127): Delete control character

ASCII Control Characters (0-31)

Control characters are non-printable codes used to control devices like printers and terminals. While many are obsolete, some remain essential.

Most Important Control Characters

View Tab character (9) | View Line Feed (10) | View Carriage Return (13)

Complete Control Characters Table

Printable ASCII Characters (32-126)

These are the characters you can see and type on a standard keyboard.

Space and Symbols (32-47)

Numbers (48-57)

View all number codes

More Symbols (58-64)

Uppercase Letters (65-90)

View letter A (65) | View all uppercase letters

Brackets and More (91-96)

Lowercase Letters (97-122)

View letter a (97) | View all lowercase letters

Final Characters (123-127)

Common ASCII Character Uses

Programming Characters

Essential Symbols:

• Space (32) - Most common character, separates tokens
• Tab (9) - Code indentation
• Parentheses ( ) (40, 41) - Function calls, grouping
• Brackets [ ] (91, 93) - Arrays, indexing
• Braces { } (123, 125) - Code blocks, objects
• Semicolon ; (59) - Statement terminator
• Equals = (61) - Assignment operator
• Quotes " ' (34, 39) - Strings

Mathematical Operators:

• Plus + (43) - Addition
• Minus - (45) - Subtraction
• Asterisk * (42) - Multiplication
• Slash / (47) - Division
• Percent % (37) - Modulo

Comparison:

• Less than < (60)
• Greater than > (62)
• Equals = (61)

ASCII vs Unicode

When to Use ASCII

✅ Use ASCII for:

• Working with legacy systems
• File formats that require ASCII
• Network protocols
• Performance-critical applications
• Programming language keywords

When to Use Unicode

✅ Use Unicode for:

• International websites
• Supporting multiple languages
• Emojis and special symbols
• Modern web development (UTF-8 is standard)

How to Use ASCII Codes

JavaScript

// Convert character to ASCII code
'A'.charCodeAt(0);  // Returns: 65
'z'.charCodeAt(0);  // Returns: 122

// Convert ASCII code to character
String.fromCharCode(65);   // Returns: 'A'
String.fromCharCode(122);  // Returns: 'z'

// Check if character is uppercase
function isUpperCase(char) {
  const code = char.charCodeAt(0);
  return code >= 65 && code <= 90;
}

// Check if character is a digit
function isDigit(char) {
  const code = char.charCodeAt(0);
  return code >= 48 && code <= 57;
}

// Convert case (using ASCII math)
function toUpperCase(char) {
  const code = char.charCodeAt(0);
  if (code >= 97 && code <= 122) {
    return String.fromCharCode(code - 32);
  }
  return char;
}

function toLowerCase(char) {
  const code = char.charCodeAt(0);
  if (code >= 65 && code <= 90) {
    return String.fromCharCode(code + 32);
  }
  return char;
}

Python

# Convert character to ASCII code
ord('A')   # Returns: 65
ord('z')   # Returns: 122

# Convert ASCII code to character
chr(65)    # Returns: 'A'
chr(122)   # Returns: 'z'

# Check if character is alphanumeric
def is_alphanumeric(char):
    code = ord(char)
    return (65 <= code <= 90) or (97 <= code <= 122) or (48 <= code <= 57)

# Case conversion
def to_upper(char):
    code = ord(char)
    if 97 <= code <= 122:
        return chr(code - 32)
    return char

C/C++

#include <stdio.h>

// Characters are already ASCII values
char c = 'A';
printf("%d", c);  // Prints: 65

// Convert ASCII to character
char c = 65;
printf("%c", c);  // Prints: A

// Check if uppercase
int isUpperCase(char c) {
    return c >= 65 && c <= 90;
}

// Convert to lowercase
char toLowerCase(char c) {
    if (c >= 65 && c <= 90) {
        return c + 32;
    }
    return c;
}

Java

// Convert character to ASCII
char c = 'A';
int ascii = (int) c;  // Returns: 65

// Convert ASCII to character
char c = (char) 65;   // Returns: 'A'

// Using Character class
Character.isDigit('5');      // true
Character.isLetter('A');     // true
Character.isUpperCase('A');  // true
Character.toLowerCase('A');  // 'a'

PHP

<?php
// Convert character to ASCII
ord('A');   // Returns: 65

// Convert ASCII to character
chr(65);    // Returns: 'A'

// Check character type
ctype_alpha('A');   // true
ctype_digit('5');   // true
ctype_upper('A');   // true
?>

Programming Patterns with ASCII

Caesar Cipher Example

function caesarCipher(text, shift) {
  let result = '';
  
  for (let i = 0; i < text.length; i++) {
    let code = text.charCodeAt(i);
    
    // Uppercase letters (65-90)
    if (code >= 65 && code <= 90) {
      code = ((code - 65 + shift) % 26) + 65;
    }
    // Lowercase letters (97-122)
    else if (code >= 97 && code <= 122) {
      code = ((code - 97 + shift) % 26) + 97;
    }
    
    result += String.fromCharCode(code);
  }
  
  return result;
}

caesarCipher('Hello World', 3);  
// Returns: 'Khoor Zruog'

caesarCipher('Khoor Zruog', -3);  
// Returns: 'Hello World'

Validating ASCII-Only Strings

// Check if string contains only ASCII characters
function isASCII(str) {
  for (let i = 0; i < str.length; i++) {
    if (str.charCodeAt(i) > 127) {
      return false;
    }
  }
  return true;
}

isASCII('Hello');  // true
isASCII('Hello 👋');  // false

// Remove non-ASCII characters
function removeNonASCII(str) {
  return str.replace(/[^\x00-\x7F]/g, '');
}

removeNonASCII('Hello 👋 World');  
// Returns: 'Hello  World'

Quick Reference: Most Used ASCII Codes

Summary

ASCII remains fundamental to computing despite being 60+ years old. The first 128 characters of modern Unicode are identical to ASCII, ensuring backward compatibility. Whether you're debugging character encoding issues, working with legacy systems, or understanding how computers represent text, this ASCII table is your complete reference.

Key Takeaways:

✅ ASCII uses 7 bits to encode 128 characters (0-127)
✅ Control characters (0-31) handle formatting and device control
✅ Printable characters (32-126) include all letters, numbers, and symbols
✅ Uppercase and lowercase letters are exactly 32 apart
✅ Modern UTF-8 includes ASCII as its first 128 characters
✅ ASCII is still essential for programming, URLs, and protocols

Related Guides

• ASCII vs Unicode vs UTF-8: Understanding Character Encoding
• ASCII Control Characters Explained
• HTML Entities Reference
• Browse All ASCII Codes →