To improve the binary conversion capabilities in PHP, you must first implement custom binary conversion functions to support more than 36% of the digits and custom character sets. 1. Use toBase and fromBase functions combined with custom digits arrays to realize arbitrary binary conversion; 2. When processing large numbers, you should use the bccomp, bcmod and bcdiv functions extended by BCMath to ensure accuracy; 3. Build the BaseEncoder class to implement bidirectional security mapping to ensure reversible encoding and decoding; 4. Always verify the input and unify the character order; 5. Avoid using base_convert to handle large numbers, give priority to GMP to improve performance, and ultimately realize a robust and extensible binary conversion system.

Converting numbers between different bases isn't just a computer science classroom exercise—it's something you'll actually use in real-world PHP applications, from encoding data to working with permissions, colors, or even cryptography. While PHP has built-in functions like decbin() , dechex() , and base_convert() , mastering number systems means going beyond the basics and understanding how to handle edge cases, arbitrary bases, and custom digit sets with confidence.

Here's how to level up your base conversion game in PHP.

Handling Bases Beyond 36 with Custom Digit Sets

PHP's base_convert() is limited to bases 2 through 36, using digits 0–9 and letters a–z (case-insensitive). But what if you need base 64, base 58 (like Bitcoin addresses), or a custom encoding like 0–9A–H ?

You need a custom function:

 function toBase($number, $base, $digits) {
    if ($base < 2 || $base > strlen($digits)) {
        throw new InvalidArgumentException("Base must be between 2 and " . strlen($digits));
    }
    if ($number == 0) return $digits[0];

    $result = &#39;&#39;;
    while ($number > 0) {
        $result = $digits[$number % $base] . $result;
        $number = (int)($number / $base);
    }
    return $result;
}

function fromBase($numberStr, $base, $digits) {
    if ($base < 2 || $base > strlen($digits)) {
        throw new InvalidArgumentException("Base must be between 2 and " . strlen($digits));
    }
    $digitMap = array_flip(str_split($digits));
    $result = 0;
    $len = strlen($numberStr);
    for ($i = 0; $i < $len; $i ) {
        $char = $numberStr[$i];
        if (!isset($digitMap[$char])) {
            throw new InvalidArgumentException("Invalid character &#39;$char&#39; for base $base");
        }
        $result = $result * $base $digitMap[$char];
    }
    return $result;
}

Now you can do things like:

 $base64Digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 /';
echo toBase(255, 64, $base64Digits); // Output: "3f"

$bitcoinBase58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
echo toBase(123456789, 58, $bitcoinBase58); // Like Bitcoin's encoding

This opens doors for URL-safe encodings, obfuscation, or working with blockchain-style identifiers.

Preserving Precision with Large Numbers

PHP's integers have limits. On 32-bit systems, you're limited to ~2 billion. On 64-bit, it's about 9 quintillion. Beyond that, PHP converts to float, and you lose precision—disastrous for accurate base conversion.

Use the BCMath extension for arbitrary precision:

 function bcToBase($number, $base, $digits) {
    $result = '';
    while (bccomp($number, '0') > 0) {
        $remainder = bcmod($number, $base);
        $result = $digits[(int)$remainder] . $result;
        $number = bcdiv($number, $base, 0); // Integer division
    }
    return $result ?: $digits[0];
}

Example:

 echo bcToBase('9999999999999999999999999999999999', 16, '0123456789abcdef');
// Safely converts huge numbers to hex

Always validate input with ctype_digit() or is_numeric() and consider using gmp functions if GMP is available—GMP is faster for heavy math.

Bidirectional Mapping and Validation

When building systems that encode IDs (eg, short URLs), ensure your conversion is reversible and safe:

 class BaseEncoder {
    private $digits;
    private $base;
    private $digitMap;

    public function __construct($digits) {
        $this->digits = $digits;
        $this->base = strlen($digits);
        $this->digitMap = array_flip(str_split($digits));
    }

    public function encode($number) {
        if (!is_numeric($number) || $number < 0) {
            throw new InvalidArgumentException("Number must be a non-negative integer");
        }
        return $this->bcToBase($number);
    }

    public function decode($str) {
        $str = (string)$str;
        $result = &#39;0&#39;;
        $base = (string)$this->base;
        for ($i = 0; $i < strlen($str); $i ) {
            $char = $str[$i];
            if (!isset($this->digitMap[$char])) {
                throw new InvalidArgumentException("Invalid character: $char");
            }
            $result = bcadd(bcmul($result, $base), $this->digitMap[$char]);
        }
        return $result;
    }

    private function bcToBase($number) {
        if ($number === &#39;0&#39;) return $this->digits[0];
        $result = &#39;&#39;;
        while (bccomp($number, &#39;0&#39;) > 0) {
            $remainder = bcmod($number, $this->base);
            $result = $this->digits[(int)$remainder] . $result;
            $number = bcdiv($number, $this->base, 0);
        }
        return $result;
    }
}

Usage:

 $encoder = new BaseEncoder('0123456789abcdefghijklmnopqrstuvwxyz');
$id = '123456789012345';
$short = $encoder->encode($id); // eg, "3dpljr7q"
echo $encoder->decode($short); // Back to original

This ensures clean, reusable, and safe conversions—perfect for APIs or short link services.

Final Tips for Robust Base Conversion

• Always sanitize input : Never trust user-provided strings in fromBase() functions.
• Use consistent digit ordering : Lowercase vs uppercase matters. Stick to one standard.
• Avoid base_convert() for large numbers : It may lose precision silently.
• Test edge cases : 0, 1, very large numbers, invalid characters.
• Consider performance : For high-throughput systems, cache digit maps and prefer GMP over BCMath if available.

Mastering base conversion in PHP isn't just about math—it's about writing resilient, scalable code that handles real data correctly. Whether you're building a tiny URL service or parsing binary protocols, these techniques give you full control.

Basically, go beyond dechex() —build your own rules, handle big numbers, and make it bulletproof.

The above is the detailed content of Mastering Number Systems: Advanced Base Conversion Techniques in PHP. For more information, please follow other related articles on the PHP Chinese website!