Three ways to implement Base62 encoding based on Go language and comparative analysis

1. Current status and solutions of standard database

1. Standard library comparison table

2. Solution

Solution 1: Use third-party librariesThere are multiple mature Base62 implementation libraries on GitHub, such as:

• /mattheath/base62
• /eknkc/basex(Support any binary)

Installation example：

go get /mattheath/base62

Code Example：

package main
 
import (
	"fmt"
	"/mattheath/base62"
)
 
func main() {
	// Encoding	encoded := (123456789) // Output "7BSj" 
	// Decode	decoded, _ := ("7BSj") // Output 123456789 
	(encoded, decoded)
}

Solution 2: Custom implementation

If there are special requirements for performance or character sets, you can implement the Base62 algorithm yourself:

Complete implementation code (including boundary processing)

package base62
 
import (
	"errors"
	"math"
)
 
const (
	base         = 62
	characterSet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
)
 
// Encode converts uint64 numbers to Base62 stringfunc Encode(num uint64) string {
	if num == 0 {
		return string(characterSet[0])
	}
 
	var result []byte
	for num > 0 {
		remainder := num % base
		result = append(result, characterSet[remainder])
		num = num / base
	}
 
	// Invert byte order	for i, j := 0, len(result)-1; i < j; i, j = i+1, j-1 {
		result[i], result[j] = result[j], result[i]
	}
 
	return string(result)
}
 
// Decode parses Base62 string to uint64func Decode(str string) (uint64, error) {
	var num uint64
	for _, char := range str {
		pos := findCharIndex(char)
		if pos == -1 {
			return 0, ("invalid character")
		}
		if num > (math.MaxUint64-uint64(pos))/base {
			return 0, ("value out of range")
		}
		num = num*base + uint64(pos)
	}
	return num, nil
}
 
// Find the position of characters in the character setfunc findCharIndex(c rune) int {
	for i, ch := range characterSet {
		if ch == c {
			return i
		}
	}
	return -1
}

2. Key implementation details and precautions

1. Character set definition

• Standard order：0-9 → A-Z → a-z(62 characters)
• Custom order: If it needs to be compatible with other systems, it can be modifiedcharacterSet
• URL security: No extra processing required (Base62 does not contain special characters)

2. Numerical range processing

• Input Limits: Maximum supportuint64Range (0 ~ 18,446,744,073,709,551,615)
• Overflow detection: Add boundary checking when decoding

if num > (math.MaxUint64-uint64(pos))/base {
    return 0, ("value out of range")
}

3. Performance optimization

*Note: If the slice inversion step is omitted, direct reverse splicing can improve performance by 30%

Optimized version encoding function：

func EncodeOptimized(num uint64) string {
	if num == 0 {
		return "0"
	}
 
	// Pre-allocate enough space (the maximum Base62 length of uint64 is 11)	buf := make([]byte, 0, 11)
	for num > 0 {
		remainder := num % base
		buf = append(buf, characterSet[remainder])
		num /= base
	}
 
	// Reverse fill result	res := make([]byte, len(buf))
	for i, j := 0, len(buf)-1; j >= 0; i, j = i+1, j-1 {
		res[i] = buf[j]
	}
	return string(res)
}

3. Production environment suggestions

1. Concurrency security

• Encoding/decoding functions have no shared state →Natural concurrency safety
• If you use global cache, you need to add a lock:

var (
	cache     = make(map[uint64]string)
	cacheLock 
)
 
func GetCachedEncoding(num uint64) string {
	()
	if val, exists := cache[num]; exists {
		()
		return val
	}
	()
 
	encoded := Encode(num)
 
	()
	cache[num] = encoded
	()
 
	return encoded
}

2. Distributed system adaptation

When it is necessary to generate a globally unique short chain, a distributed ID algorithm can be combined:

// Use the snowflake algorithm to generate IDfunc GenerateSnowflakeID() uint64 {
	// Implementation...}
 
// Generate short linksshortCode := (GenerateSnowflakeID())

4. Why is it not recommended to use Base64 directly?

5. Summary

• Standard library No Base62: You need to use a third-party library or implement it yourself
• Recommended plan：
  • General Scenario → Select a mature third-party library
  • High-performance customization requirements → Optimized version customization implementation
• Key points to note：
  • Character set consistency
  • Large number overflow processing
  • Distributed ID combination

By rationally selecting the implementation plan, Base62 encoding can be efficiently applied to short link generation, compact ID and other scenarios, and is fully compatible with the high concurrency characteristics of the Go language.

The above are the three ways to implement Base62 encoding based on Go language and the detailed content of the comparison and analysis. For more information about Go implement Base62 encoding, please pay attention to my other related articles!