Go 中将字符串转换为整数类型？

Question

我正在尝试将从 flag.Arg(n) 返回的字符串转换为 int。在 Go 中执行此操作的惯用方法是什么？

Answer 1

如果您控制输入数据，您可以使用

package main

import (
    "testing"
    "strconv"
)

func Atoi (s string) int {
    var (
        n uint64
        i int
        v byte
    )   
    for ; i < len(s); i++ {
        d := s[i]
        if '0' <= d && d <= '9' {
            v = d - '0'
        } else if 'a' <= d && d <= 'z' {
            v = d - 'a' + 10
        } else if 'A' <= d && d <= 'Z' {
            v = d - 'A' + 10
        } else {
            n = 0; break        
        }
        n *= uint64(10) 
        n += uint64(v)
    }
    return int(n)
}

func BenchmarkAtoi(b *testing.B) {
    for i := 0; i < b.N; i++ {
        in := Atoi("9999")
        _ = in
    }   
}

func BenchmarkStrconvAtoi(b *testing.B) {
    for i := 0; i < b.N; i++ {
        in, _ := strconv.Atoi("9999")
        _ = in
    }   
}

最快的迷你版本选项（如有必要，请写下您的支票）。结果 ：

Path>go test -bench=. atoi_test.go
goos: windows
goarch: amd64
BenchmarkAtoi-2                 100000000               14.6 ns/op
BenchmarkStrconvAtoi-2          30000000                51.2 ns/op
PASS
ok      path     3.293s

Answer 2

例如strconv.Atoi。

代码：

package main

import (
    "fmt"
    "strconv"
)

func main() {
    s := "123"

    // string to int
    i, err := strconv.Atoi(s)
    if err != nil {
        // ... handle error
        panic(err)
    }

    fmt.Println(s, i)
}

Answer 3

转换简单字符串

最简单的方法是使用 strconv.Atoi() 函数。

请注意，还有许多其他方法。例如 fmt.Sscan() 和 strconv.ParseInt() 这提供了更大的灵活性，因为您可以指定基址和位大小例子。另如 strconv.Atoi() 的文档中所述：

Atoi相当于ParseInt(s, 10, 0)，转换为int类型。

这是使用上述函数的示例（在 Go Playground 上尝试）：

flag.Parse()
s := flag.Arg(0)

if i, err := strconv.Atoi(s); err == nil {
    fmt.Printf("i=%d, type: %T\n", i, i)
}

if i, err := strconv.ParseInt(s, 10, 64); err == nil {
    fmt.Printf("i=%d, type: %T\n", i, i)
}

var i int
if _, err := fmt.Sscan(s, &i); err == nil {
    fmt.Printf("i=%d, type: %T\n", i, i)
}

输出（如果使用参数 "123")：

i=123, type: int
i=123, type: int64
i=123, type: int

解析自定义字符串

还有一个方便的 fmt.Sscanf() 提供了更大的灵活性，就像格式字符串一样，您可以指定数字格式（如宽度、基数等）以及输入 string< 中的其他额外字符/代码>。

这对于解析包含数字的自定义字符串非常有用。例如，如果您的输入以 "id:00123" 的形式提供，其中有前缀 "id:" 并且数字固定为 5 位数字，并用零填充如果更短，这很容易解析，如下所示：

s := "id:00123"

var i int
if _, err := fmt.Sscanf(s, "id:%5d", &i); err == nil {
    fmt.Println(i) // Outputs 123
}

Answer 4

以下是将字符串解析为整数的三种方法，从最快的运行时间到最慢的运行时间：

1. strconv.ParseInt(. ..) 最快
2. strconv.Atoi(...)< /code>还是很快
3. fmt.Sscanf(...) 不是非常快，但最灵活

这是一个基准测试，显示每个函数的用法和示例计时：

package main

import "fmt"
import "strconv"
import "testing"

var num = 123456
var numstr = "123456"

func BenchmarkStrconvParseInt(b *testing.B) {
  num64 := int64(num)
  for i := 0; i < b.N; i++ {
    x, err := strconv.ParseInt(numstr, 10, 64)
    if x != num64 || err != nil {
      b.Error(err)
    }
  }
}

func BenchmarkAtoi(b *testing.B) {
  for i := 0; i < b.N; i++ {
    x, err := strconv.Atoi(numstr)
    if x != num || err != nil {
      b.Error(err)
    }
  }
}

func BenchmarkFmtSscan(b *testing.B) {
  for i := 0; i < b.N; i++ {
    var x int
    n, err := fmt.Sscanf(numstr, "%d", &x)
    if n != 1 || x != num || err != nil {
      b.Error(err)
    }
  }
}

您可以通过另存为 atoi_test.go 并运行 go test -bench 来运行它=。 atoi_test.go。

goos: darwin
goarch: amd64
BenchmarkStrconvParseInt-8      100000000           17.1 ns/op
BenchmarkAtoi-8                 100000000           19.4 ns/op
BenchmarkFmtSscan-8               2000000          693   ns/op
PASS
ok      command-line-arguments  5.797s

Answer 5

试试这个

import ("strconv")

value := "123"
number,err := strconv.ParseUint(value, 10, 32)
finalIntNum := int(number) //Convert uint64 To int