F#中实现62进制递增生成字母数字串及相关运算的最优方法

基础映射：利用ASCII有序特性实现字符-数值转换 #

完全可以利用ASCII码的有序性实现字符和0-61数值的互转，无需预定义映射表，实现逻辑如下：

let charToValue (c: char) =
    match c with
    | c when c >= '0' && c <= '9' -> int c - int '0'
    | c when c >= 'a' && c <= 'z' -> 10 + int c - int 'a'
    | c when c >= 'A' && c <= 'Z' -> 36 + int c - int 'A'
    | _ -> invalidArg (nameof c) "仅支持0-9、a-z、A-Z字符"

let valueToChar (n: int) =
    match n with
    | n when n >= 0 && n < 10 -> char (int '0' + n)
    | n when n >= 10 && n < 36 -> char (int 'a' + (n - 10))
    | n when n >= 36 && n < 62 -> char (int 'A' + (n - 36))
    | _ -> invalidArg (nameof n) "数值必须在0-61范围内"

递增操作（等价i++）的函数式实现 #

函数式实现采用不可变递归逻辑，直接处理字符串的字符序列，从最低位（最右侧）开始处理进位，没有可变变量，符合F#的编程范式，也适配Akka Actor模型的不可变消息传递要求：

let increment (s: string) =
    let rec addOne carry chars =
        match chars, carry with
        | [], 0 -> []
        | [], 1 -> [valueToChar 0] // 最高位进位，补充新的高位
        | c::rest, 0 -> c::rest
        | c::rest, 1 ->
            let newValue = charToValue c + 1
            if newValue < 62 then
                (valueToChar newValue)::rest
            else
                (valueToChar 0)::(addOne 1 rest)
    // 反转字符列表方便从最低位开始计算
    s.ToCharArray() |> List.ofArray |> List.rev |> addOne 1 |> List.rev |> System.String.Concat

示例运行结果：

• increment "9" 返回 "a"
• increment "z" 返回 "A"
• increment "Z" 返回 "00"
• increment "0Z" 返回 "10"

任意算术运算实现 #

方案1：基于BigInteger转换（推荐绝大多数场景使用） #

如果序列长度在BigInteger支持范围内（几乎覆盖所有常规业务场景），最简方案是先把62进制串转为BigInteger执行运算，再转换回62进制串，所有.NET内置的算术运算都可以直接复用：

open System.Numerics

let fromBase62 (s: string) =
    s.ToCharArray()
    |> Array.fold (fun acc c -> acc * 62 + bigint (charToValue c)) BigInteger.Zero

let toBase62 (n: BigInteger) =
    if n = BigInteger.Zero then "0"
    else
        let rec buildChars num =
            if num = BigInteger.Zero then []
            else
                let remainder = int (num % 62)
                (valueToChar remainder) :: buildChars (num / 62)
        buildChars n |> List.rev |> System.String.Concat

// 实现x = x + 100的操作
let add100 (s: string) =
    s |> fromBase62 |> (+) (bigint 100) |> toBase62

示例运行结果：add100 "0" 返回 "1C"（100的62进制表示为1*62 + 38，38对应大写字母C）。

方案2：逐位运算（适合超长序列场景） #

如果需要处理超出BigInteger范围的超长短序列，可以基于递归逐位处理进位实现加减运算，逻辑和递增操作类似，仅需要扩展为支持指定加数的逐位相加即可。

内容的提问来源于stack exchange，提问作者DimitrisMel