主页 / coding / 问题 / 78608449
Accepted
NotX
Asked: 2024-06-11 23:18:52 +0800 CST

删除 uint 中的前导数字，无需解析为字符串并返回

  • 772

我有一个uintas 3123456，我想得到123456as 数字（理想情况下uint），即去掉第一个数字。我知道我可以将其解析为string，删除前导字符，然后将其转换回来：

func (id *MyID) Scan(v any) (err error) {
    asBytes, ok := v.([]byte)
    ...
    myDBNumber := binary.LittleEndian.Uint64(asBytes) // the field is of type BINARY in the db
    myDBNumberStr := strconv.Itoa(int(myDBNumber))
    myDBNumberWithoutPrefix, err := strconv.Atoi(myDBNumberStr[1:])
    ...
}

由于我使用这种逻辑来sql.Scanner解析 ID，我想知道是否有办法避免这种来回解析，以提高性能（或至少比较性能）。

go

1 个回答

  1. Best Answer

    您正在寻找替代方案

    func stripLeadingAlternate(i uint) uint {
    if i < 10 {
        return 0
    }
    stripped, _ := strconv.ParseUint(strconv.FormatUint(uint64(i), 10)[1:], 10, strconv.IntSize)

    return uint(stripped)
}

    我建议计算小于该数字的最大 10 的幂并使用除法余数：

    func stripLeading(i uint) uint {
    v, m := uint64(i), uint64(1)
    for e, c := m, 0; e <= v && c < 20; c++ {
        m = e
        e *= 10
    }

    return uint(v % m)
}

    在 Go Playground 上测试一下：

    package main

import (
    "math"
    "strconv"
    "testing"
)

func Test_stripLeading(t *testing.T) {
    t.Parallel()
    tests := []uint{0, 1, 2, 9, 10, 11, 123, 999, 1000, 1001, math.MaxUint}
    for _, tt := range tests {
        t.Run(strconv.FormatUint(uint64(tt), 10), func(t *testing.T) {
            t.Parallel()
            want := stripLeadingAlternate(tt)
            if got := stripLeading(tt); got != want {
                t.Errorf("stripLeading(%d) = %v, want %v", tt, got, want)
            }
        })
    }
}

    这应该适用于unit64 位和 32 位。

    我不确定使用表格是否真的会提高性能，但您可以轻松尝试使用powers[c]而var powers = []uint64{1, 10, 100, ...}不是e *= 10：

    var powers = []uint64{
    1,
    10,
    100,
    1_000,
    10_000,
    100_000,
    1_000_000,
    10_000_000,
    100_000_000,
    1_000_000_000,
    10_000_000_000,
    100_000_000_000,
    1_000_000_000_000,
    10_000_000_000_000,
    100_000_000_000_000,
    1_000_000_000_000_000,
    10_000_000_000_000_000,
    100_000_000_000_000_000,
    1_000_000_000_000_000_000,
    10_000_000_000_000_000_000,
}

func stripLeading(i uint) uint {
    if i < 10 {
        return 0
    }

    v := uint64(i)
    c := 0
    for ; c < len(powers) && powers[c] <= v; c++ {
    }

    return uint(v % powers[c-1])
}

    在我的计算机上，基于表格的版本速度略快 (33.37 ns/op vs 35.41 ns/op)，因此我更喜欢带有乘法的较慢版本。

    var benchmarkValues = []uint{0, 1, 2, 9, 10, 11, 123, 999, 1000, 1001, math.MaxUint}

func Benchmark_stripLeading1(b *testing.B) {
    for range b.N {
        for _, v := range benchmarkValues {
            _ = stripLeading(v)
        }
    }
}

    您可能想要更改样本数字以匹配您的用例，但是在进行 SQL 调用时您无法识别差异；）

    具有字符串解析的版本有 185.2 ns/op（40 B/op、5 allocs/op），因此这可能是一个胜利。

    编辑

    使用二进制搜索的替代版本：

    func stripLeading3(i uint) uint {
    if i < 10 {
        return 0
    }
    v := uint64(i)
    c := sort.Search(len(powers), func(c int) bool { return powers[c] >= v })

    return uint(v % powers[c-1])
}

    假设接近均匀分布，这个速度会更快：

    package main

import (
    "math/rand"
    "testing"
)

func Benchmark_stripLeading(b *testing.B) {
    benchmarkValues := make([]uint, b.N)
    r := rand.New(rand.NewSource(42))
    for i := range benchmarkValues {
        benchmarkValues[i] = uint(r.Uint64())
    }

    b.ResetTimer()

    for _, v := range benchmarkValues {
        _ = stripLeading(v)
    }
}

    不过，在初始基准测试中它的速度较慢benchmarkValues[i] = uint(r.Intn(1_000_000))（89.17 ns/op）。它还输给了。

    • 0

相关问题