Complete Base Conversion Guide: From Binary to Arbitrary Bases, Bitwise Ops & Internal Representation

#01

The Essence of Number Systems: Why Do We Need Different Counting Systems?

A number system (radix) is a fundamental way of representing values. An N-base system uses N distinct symbols, with each position's weight being a power of the base.

Human history has seen many counting systems:

Decimal (Base 10): The most natural counting method, originating from our ten fingers. Ancient Babylonians used sexagesimal (base 60), which still influences time and angle measurement today.
Binary (Base 2): Proposed by Leibniz in the 17th century but only truly popularized after electronic computers were invented in the 20th century. Transistor on/off states naturally map to 0 and 1.
Octal & Hexadecimal: Emerged as compact representations of binary — octal maps 3 bits per digit, hex maps 4 bits per digit, dramatically reducing written length.

#02

Common Number Systems Explained: From Binary to Base36

Base	Symbol Set	Typical Use Cases
Binary (Base 2)	0, 1	Computer storage, network protocols, bitmasks
Octal (Base 8)	0-7	Unix file permissions (chmod), some embedded systems
Decimal (Base 10)	0-9	Everyday counting, finance calculations, UI display
Hexadecimal (Base 16)	0-9, A-F	Memory addresses, color values (#RGB), MAC addresses, debug output
Base36 / Base62	0-9A-Z / 0-9a-zA-Z	Short URL generation, unique ID encoding, URL-safe encoding

This tool supports any base between 2 and 36, covering all common scenarios above. Base36 uses 0-9 and A-Z (36 characters) as a URL-friendly encoding scheme.

#03

Conversion Mathematics: Positional Expansion & Repeated Division

Method 1: Positional Expansion (Other Base → Decimal)

Multiply each digit by its positional weight (power of the base), then sum them up.

// Hex 0x1A3F → Decimal
// = 1×16³ + 10×16² + 3×16¹ + 15×16⁰
// = 4096 + 2560 + 48 + 15
// = 6719

Method 2: Repeated Division (Decimal → Other Base)

Repeatedly divide by the target base, record remainders, then read in reverse order.

// Decimal 25 → Binary
// 25 ÷ 2 = 12 remainder 1
// 12 ÷ 2 = 6  remainder 0
// 6 ÷ 2 = 3   remainder 0
// 3 ÷ 2 = 1   remainder 1
// 1 ÷ 2 = 0   remainder 1
// Reverse read: 11001

About Precision: JavaScript's regular Number type is a 64-bit float with safe integer range of -(2⁵³-1) to 2⁵³-1 (~±9 quadrillion). Beyond this range, precision is lost. This tool uses BigInt type for arbitrarily large integers without any precision loss.

#04

Core Bitwise Techniques: Essential Low-Level Operations

Bitwise operations directly manipulate binary bits — essential for performance-critical code and systems programming:

& (AND): Extract specific bits or check parity. n & 1 === 0 checks even numbers; n & 0xFF gets low 8 bits.
| (OR): Set flag bits. flags | 0b0010 sets bit 2.
^ (XOR): Flip bits or swap variables. a ^= b; b ^= a; a ^= b; swaps without temp variable.
~ (NOT): ~n = -(n+1), commonly used with AND operations.
<< (Left Shift): Equivalent to multiplying by powers of 2. n << 3 = n × 8.
>> / >>>: Arithmetic right shift preserves sign bit; logical right shift fills with zeros.

Real-world examples: IP address ↔ integer conversion, color value decomposition ((color >> 16) & 0xFF extracts red channel), permission bitmask design, etc.

#05

Internal Computer Representation: Two's Complement & IEEE 754 Floats

Two's Complement: The Secret of Negative Numbers

Computers use two's complement to represent signed integers. Its key advantage: addition and subtraction use the same circuitry, no special sign handling needed.

Positive number two's complement = original binary
Negative number two's complement = invert bits + 1
8-bit signed range: -128 ~ 127 (not -127~127!)

// 8-bit example: -5 in two's complement
// Original(5)    = 00000101
// Invert        = 11111010
// +1             = 11111011 → This is -5

IEEE 754 Floating Point Standard

Modern computers follow IEEE 754 for storing floating-point numbers:

Single precision float32: 1 sign + 8 exponent + 23 mantissa ≈ 7 significant digits
Double precision float64: 1 sign + 11 exponent + 52 mantissa ≈ 15-17 significant digits

This explains why 0.1 + 0.2 !== 0.3 in JavaScript returns 0.30000000000000004 — binary cannot exactly represent decimal 0.1.

#06

Common Pitfalls & How to Avoid Them

"Hexadecimal is bigger than decimal": Wrong! Different bases are just different representations. 255 (decimal) = FF (hex) = 11111111 (binary) — they represent the exact same value.
"parseInt auto-detects base": Dangerous! parseInt("08") returns 0 in older browsers (treated as octal). Always specify radix: parseInt(str, 10).
"Number can handle huge integers": JavaScript Number loses precision beyond 2⁵³. Always use BigInt for large integers (suffix n or BigInt() constructor).
"toString() always returns decimal": (255).toString(16) returns "ff" — you can pass target base as parameter.
"Bitwise ops work on all integers": JavaScript bitwise ops convert operands to 32-bit signed integers first, which can cause overflow. BigInt has limited bitwise support (ES2020+).

#07

Summary & Best Practices: Base Conversion in Real-World Development

When using an online base converter, you may be entering internal system encodings, key fragments, or other sensitive data. Data privacy should be your top priority.

This tool uses a frontend-only architecture — all conversion logic executes entirely within your local browser:

Zero network transmission: Your input values are never sent to any server
Zero server logs: No server involvement means no access logs or data retention
Zero registration required: Full functionality available without account login
Zero persistent storage: All data automatically cleared when you close the page

You can confidently use it for any sensitive numeric conversion needs without worrying about information leakage. For teams and enterprises, consider deploying this tool on an intranet for maximum security assurance.

Complete Base Conversion Guide