Characters vs Numbers - Character Data Types | OneNoughtOne

0/361

Data Structures & AlgorithmsCharacter Data Types

Character Data Types

LevelBeginner

Duration50 mins

TopicCharacter Data Types

1 / 4

Characters vs Numbers

When '7' Is Not a Number

Consider a seemingly simple question: What is 7?

If you're thinking mathematically, 7 is the fourth prime number, the natural number following 6 and preceding 8, a value you can add, subtract, multiply, or divide. But when a user types '7' on their keyboard, when you see '7' on a web page, or when a program reads '7' from a text file—is that the same thing?

The answer is no, and understanding why is fundamental to computing.

In the world of computers, the character '7' and the numeric value 7 are profoundly different entities, stored differently, processed differently, and used for completely different purposes. This distinction—between characters and numbers—is one of the cornerstones of data representation, and mastering it will clarify everything from input parsing to encoding bugs to text processing algorithms.

What You Will Learn

By the end of this page, you will understand the fundamental difference between character data and numeric data, why computers distinguish between them at the hardware level, how this distinction manifests in programming, and why conflating them causes bugs that plague production systems worldwide.

The Nature of Numeric Data

Let's establish a precise understanding of what numeric data means in computing.

A number, in the computational sense, is a value that participates in arithmetic operations. When you store the integer 7 in a variable, you're storing a quantity—a mathematical entity that can be:

Added to other numbers (7 + 3 = 10)
Subtracted, multiplied, divided (7 * 2 = 14)
Compared mathematically (7 > 5 is true)
Used in calculations, algorithms, and formulas
Incremented or decremented (7 + 1 = 8)

How computers store numbers:

At the hardware level, a numeric value like 7 is stored directly in its binary representation. The integer 7 becomes 0111 in binary (or more precisely, 00000111 in an 8-bit representation). This binary pattern is recognized by the CPU's arithmetic logic unit (ALU), which can perform mathematical operations on it directly.

Binary Representation of Numeric Values
Decimal Value	8-bit Binary	Purpose
0	00000000	Arithmetic zero—the additive identity
7	00000111	A quantity representing seven units
42	00101010	A quantity representing forty-two units
255	11111111	Maximum value in unsigned 8-bit representation

The crucial insight is that these binary patterns are native to computation. The CPU's circuits are designed to interpret these bit patterns as mathematical quantities and perform operations on them. Addition, subtraction, comparison—all of these are hardware operations that work directly on the binary representation of numbers.

The relationship between representation and operations:

When you add 7 + 3, the CPU takes the bit pattern 00000111 and the bit pattern 00000011, runs them through its binary adder circuits, and produces 00001010 (which is 10). No interpretation or translation is needed—the bits are the number.

Numbers Are Values, Not Symbols

A numeric value represents a mathematical quantity. It doesn't matter what base you express it in—7 in decimal, VII in Roman numerals, or 111 in binary all represent the same quantity. The computer stores that quantity in binary because circuits work on binary, but the value itself transcends any particular representation.

The Nature of Character Data

Now let's explore what character data means in computing.

A character is a symbol from a writing system—a letter, digit, punctuation mark, or other glyph that humans use to communicate textually. When you store the character '7' in a variable, you're storing a symbol—a visual representation meant for human reading, not mathematical computation.

The character '7' cannot naturally participate in arithmetic:

'7' + '3' doesn't equal 10—it either concatenates to '73' or causes an error (depending on the language)
'7' * '2' is meaningless as multiplication—you can't multiply symbols
'7' > '5' compares lexicographically (dictionary order), not numerically

How computers store characters:

Since computers only understand binary, characters must be assigned numeric codes that represent them. The character '7' isn't stored as the value 7—it's stored as the code point 55 (in ASCII/Unicode), which in binary is 00110111.

This is a fundamental distinction: the character '7' and the number 7 have completely different binary representations:

Data	Meaning	Binary Representation
Number 7	Mathematical quantity	`00000111`
Character '7'	Symbol representing the digit	`00110111`

Same Appearance, Different Bits

When you see '7' on a screen, your brain interprets it as the number seven. But the computer may have stored 00000111 (the number 7) or 00110111 (the character '7'). These are entirely different values, and confusing them is a common source of bugs.

The encoding bridge:

Since computers can only store numbers, we need a system that assigns each character a unique numeric code. This system is called an encoding or character set. The encoding is essentially a lookup table:

Character → Numeric Code (for storage)
Numeric Code → Character (for display)

When you type 'A' on the keyboard, the encoding assigns it code 65. When the program displays code 65, the encoding maps it back to 'A'. The character itself is an abstraction—what's actually stored is always a number representing that character.

Character Data Properties

•Symbolic representation — Characters are symbols from writing systems, not mathematical quantities
•Encoded as numbers — Every character maps to a numeric code point for storage
•Display-oriented — Characters exist to be rendered as human-readable text
•Non-arithmetic — Mathematical operations on characters are either undefined or semantically different
•Order is lexicographic — Character comparison follows dictionary order, not numeric magnitude

The Fundamental Conversion Problem

Understanding the distinction between characters and numbers leads us to one of the most common operations in programming: conversion between them.

Character to Number (Parsing):

When a user types "42" into a text field, the program receives the characters '4' and '2'—not the number 42. To perform arithmetic, the program must parse this character sequence into a numeric value:

"42" (two characters) → 42 (one number)

This parsing involves:

Reading character '4', recognizing it represents digit 4
Reading character '2', recognizing it represents digit 2
Combining them positionally: 4×10 + 2 = 42

parsing-example
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Character to Number conversion
const userInput = "42";  // This is a STRING of characters
 
// Wrong: Direct operation treats it as text
console.log(userInput + 10);  // "4210" (string concatenation!)
 
// Correct: Parse the characters into a number first
const numericValue = parseInt(userInput, 10);  // 42
console.log(numericValue + 10);  // 52 (numeric addition)
 
// The conversion process:
// '4' (code 52) - '0' (code 48) = 4 (numeric value of digit)
// '2' (code 50) - '0' (code 48) = 2 (numeric value of digit)
// Result: 4 * 10 + 2 = 42

Number to Character (Formatting):

The reverse operation is equally important. When you calculate a result (say, 42) and need to display it, you must format the number into characters:

42 (one number) → "42" (two characters)

This formatting involves:

42 ÷ 10 = 4 remainder 2
Digit 4 → character '4' (code 52)
Digit 2 → character '2' (code 50)
Combine into string "42"

Parsing (Text → Number)

•Input: Characters from user/file/network
•Output: Numeric value for computation
•Common functions: parseInt, parseFloat, atoi
•Error case: Non-numeric characters
•Example: "123" → 123

Formatting (Number → Text)

•Input: Numeric result from calculation
•Output: Characters for display/storage
•Common functions: toString, sprintf, itoa
•Options: Decimal places, locale formatting
•Example: 123 → "123"

The Mental Model

Think of parsing and formatting as crossing a bridge between two worlds: the world of text (human-readable, character-based) and the world of computation (machine-operable, number-based). Every time data enters or leaves a program for human consumption, it crosses this bridge.

Why This Distinction Matters

The character/number distinction isn't academic pedantry—it's the source of countless real-world bugs and security vulnerabilities. Let's examine why this matters in practice.

Bug Category 1: Accidental Concatenation

In dynamically typed languages, mixing strings and numbers often produces string concatenation instead of arithmetic:

concatenation-bug
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// JavaScript: The classic bug
const quantity = "10";  // From form input (string!)
const price = 5;        // From database (number)
 
// Bug: String + Number = String concatenation in JS
const total = quantity * price;  // 50 (coercion works here)
const wrong = quantity + price;  // "105" (NOT 15!)
 
// In a shopping cart:
function calculateTotal(items) {
    let total = "0";  // Bug: should be number 0, not string "0"
    for (const item of items) {
        total += item.price;  // Concatenates! "0" + 10 = "010"
    }
    return total;  // Returns "0102030" instead of 60
}

Bug Category 2: Sorting Confusion

Characters sort lexicographically (dictionary order), not numerically. This leads to infamous sorting bugs:

sorting-bug
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Sorting numbers represented as strings
const versions = ["1.9", "1.10", "1.2", "1.11"];
 
// Lexicographic sort (treating as text)
versions.sort();
console.log(versions);  // ["1.10", "1.11", "1.2", "1.9"]
// Because "1.10" < "1.2" in dictionary order ('.' < '2')
 
// Common file listing bug
const files = ["file1.txt", "file10.txt", "file2.txt", "file9.txt"];
files.sort();
// Result: ["file1.txt", "file10.txt", "file2.txt", "file9.txt"]
// Expected: ["file1.txt", "file2.txt", "file9.txt", "file10.txt"]
 
// Fix: Use numeric comparison
files.sort((a, b) => {
    const numA = parseInt(a.match(/\d+/)[0]);
    const numB = parseInt(b.match(/\d+/)[0]);
    return numA - numB;
});

Bug Category 3: Comparison Failures

Comparing characters doesn't work like comparing numbers:

comparison-bug
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Python comparison gotcha
user_age = input("Enter your age: ")  # Returns STRING, not int!
 
# Bug: String comparison, not numeric
if user_age > "18":  # "9" > "18" is True (lexicographic!)
    print("Access granted")  # A 9-year-old gets access!
 
# Correct approach
if int(user_age) > 18:  # Convert to number first
    print("Access granted")
 
# Another example
scores = ["9", "80", "100", "7"]
print(max(scores))  # "9" - because "9" > "8" > "1" > "7" lexicographically
print(max(map(int, scores)))  # 100 - correct numeric maximum

Security Implications

These bugs aren't just annoyances—they can be security vulnerabilities. Age checks, access controls, limit validations: if these use string comparison on numeric-looking data, attackers can bypass them. Always parse numeric input to actual numbers before comparison.

The Character Code Connection

Now let's explore the mechanics of how characters become numbers through encoding.

The encoding table:

Every character encoding defines a mapping between characters and numeric codes. For the basic Latin alphabet and digits, these codes are standardized across virtually all encodings:

Common Character Codes (ASCII/UTF-8 Compatible)
Character	Decimal Code	Hexadecimal	Binary
'0'	48	0x30	00110000
'1'	49	0x31	00110001
'9'	57	0x39	00111001
'A'	65	0x41	01000001
'Z'	90	0x5A	01011010
'a'	97	0x61	01100001
'z'	122	0x7A	01111010
Space	32	0x20	00100000

The clever design of digit codes:

Notice something elegant: the digits '0' through '9' have codes 48 through 57. This means:

'0' has code 48
'1' has code 49 (48 + 1)
'9' has code 57 (48 + 9)

The numeric value of any digit character can be computed by subtracting 48 (the code for '0'):

Digit value = Character code - 48
'7' → Code 55 → 55 - 48 = 7 ✓
'3' → Code 51 → 51 - 48 = 3 ✓

This is why you often see code like char - '0' to convert a digit character to its numeric value.

digit-conversion
Multi-language
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Converting digit characters to numeric values
 
// In C/C++
char digitChar = '7';
int numericValue = digitChar - '0';  // '7' - '0' = 55 - 48 = 7
 
// In JavaScript
const charCode = '7'.charCodeAt(0);  // 55
const numericValue = charCode - '0'.charCodeAt(0);  // 55 - 48 = 7
// Or simply: const numericValue = '7' - '0';  // JS coerces to numbers
 
// In Python
char = '7'
code = ord(char)  # 55
numeric_value = ord(char) - ord('0')  # 55 - 48 = 7
# Or: numeric_value = int(char)  # More Pythonic
 
// The reverse: converting numeric value back to digit character
// In C/C++
int value = 7;
char digitChar = value + '0';  // 7 + 48 = 55 = '7'
 
// In JavaScript
const char = String.fromCharCode(7 + 48);  // '7'

A Pattern to Remember

The digit characters '0'-'9' have consecutive codes starting at 48. Uppercase letters 'A'-'Z' have consecutive codes starting at 65. Lowercase letters 'a'-'z' have consecutive codes starting at 97. This consecutive arrangement enables elegant arithmetic on characters: 'A' + 1 = 'B', 'a' + 25 = 'z'.

Single Characters vs Strings

An important distinction exists between a single character and a string of characters—even when the string contains just one character.

The Single Character:

A single character is a primitive data type in many languages. It occupies a fixed amount of memory (typically 1-4 bytes depending on encoding) and represents exactly one symbol:

char letter = 'A';  // Occupies exactly 1 byte (in ASCII/UTF-8)

The String:

A string is a sequence of characters—a non-primitive data structure that can hold zero or more characters. Even a one-character string is fundamentally different from a single character:

Character vs String: Key Differences
Property	Single Character	String (even length 1)
Type	Primitive (char)	Non-primitive (sequence)
Memory	Fixed (1-4 bytes)	Variable (length + overhead)
Mutability	Immutable value	Often mutable (varies by language)
Operations	Code arithmetic, comparison	Concatenation, slicing, searching
Length	Always 1	Can be 0, 1, or more
Null/Empty	Every char has a value	Can be empty string

char-vs-string
Multi-language
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Java: char vs String distinction
char c = 'A';           // Primitive, 2 bytes (Java uses UTF-16)
String s = "A";         // Object, ~40+ bytes overhead
 
// Single quotes for char, double quotes for String (Java syntax)
char x = 'X';           // Valid
char y = "Y";           // Compile error!
String z = "Z";         // Valid
String w = 'W';         // Compile error!
 
// Type checking
c == 'A'                // true (char comparison)
s.equals("A")           // true (String comparison)
s == "A"                // Subtle bug! Reference equality, not value
 
// C: char vs char array (string)
char ch = 'B';          // Single character, 1 byte
char str[] = "B";       // Array: {'B', '\0'} = 2 bytes
 
// Python: No separate char type
c = 'A'                 # This is a string of length 1
type(c)                 # <class 'str'>
len(c)                  # 1

Language Varies

Some languages (like C, Java, C++) have distinct char and string types. Others (like Python, JavaScript) treat single characters as one-character strings. Understanding your language's model prevents subtle bugs and inefficiencies.

Why Separate Data Types Exist

Understanding why characters and numbers are separate data types illuminates fundamental computing principles.

Reason 1: Semantic Clarity

Numbers and characters have different meanings. A phone number like "555-1234" isn't a mathematical quantity—you wouldn't add two phone numbers or compute their average. Similarly, the temperature 72 isn't text—you need to perform calculations with it. Separate types encode this semantic difference in the type system.

Reason 2: Operation Safety

With separate types, the compiler/interpreter can catch errors at compile time or runtime:

phone = "555-1234"
temperature = 72
result = phone + temperature  # Error or warning: mixing types!

This type safety prevents entire classes of bugs before they reach production.

Reason 3: Storage Optimization

Numbers and characters have different storage requirements:

A 32-bit integer can represent values from -2 billion to +2 billion
That same 4 bytes could store 4 ASCII characters, or 1-4 UTF-8 characters

Using the right type for the right data enables efficient memory usage.

Type System Benefits

•Documentation in code — Types communicate intent: is this field for computation or display?
•Compile-time error detection — Misusing characters as numbers (or vice versa) triggers warnings
•Performance optimization — Compilers can generate optimal code when types are known
•API clarity — Function signatures clarify expected input/output types
•Refactoring safety — Changing a field's type surfaces all affected code

Reason 4: Localization and Internationalization

Numeric values are universal—7 means seven everywhere. But textual representation varies:

The number 1234.56 displays as "1,234.56" in the US, "1.234,56" in Germany
Dates, currencies, and measurements all have locale-specific text formats

Separating the numeric value from its character representation enables proper localization. The calculation uses numbers; the display uses locale-formatted characters.

The Principle

Store data in its natural type (numbers for quantities, characters for text), and convert only at system boundaries (user input, display output, file I/O). This principle prevents bugs and enables both computation and display flexibility.

Summary: Characters vs Numbers

We've established a crucial foundation for understanding character data types. Let's consolidate the key insights:

Key Takeaways

•Characters are symbols, numbers are quantities — The character '7' (code 55) and the number 7 (binary 0111) are fundamentally different
•Characters require encoding — Since computers only store numbers, characters must map to numeric codes via an encoding scheme
•Conversion is explicit — Parsing (text→number) and formatting (number→text) cross the boundary between human-readable and computable
•Mixing types causes bugs — String concatenation, lexicographic sorting, and comparison failures are common when types are confused
•Character codes are cleverly designed — Digits '0'-'9' have sequential codes enabling simple digit-value conversion via subtraction
•Single characters differ from strings — Even one-character strings are non-primitive with different memory and operations
•Type separation serves multiple purposes — Semantic clarity, safety, optimization, and localization all benefit from distinct types

What's next:

Now that we understand the fundamental distinction between characters and numbers, we're ready to explore how characters are encoded. The next page introduces ASCII and Unicode—the two encoding systems that define how characters map to codes, enabling computers to represent text from the English alphabet to the world's writing systems.

Page Complete

You now understand the fundamental difference between character data and numeric data—a distinction that underlies every text processing algorithm and input/output operation. Next, we'll explore how ASCII and Unicode encoding systems assign numeric codes to the world's characters.