Go：将数组中的字符串转换为整数

如何在go中将数组中的字符串转换为数组中的整数

["1", "2", "3"]

到

---

我在网上搜索了一些解决方案，但找不到。我尝试循环遍历数组，并执行strconv.ParseFloat（v，64），其中v是值，但它不起作用。

您必须循环遍历片段。如果切片仅包含整数，则不需要使用

ParseFloat

import "fmt"
import "strconv"

func main() {
    var t = []string{"1", "2", "3"}
    var t2 = []int{}

    for _, i := range t {
        j, err := strconv.Atoi(i)
        if err != nil {
            panic(err)
        }
        t2 = append(t2, j)
    }
    fmt.Println(t2)
}

例如，

package main

import (
    "fmt"
    "strconv"
)

func sliceAtoi(sa []string) ([]int, error) {
    si := make([]int, 0, len(sa))
    for _, a := range sa {
        i, err := strconv.Atoi(a)
        if err != nil {
            return si, err
        }
        si = append(si, i)
    }
    return si, nil
}

func main() {
    sa := []string{"1", "2", "3"}
    si, err := sliceAtoi(sa)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("%q %v\n", sa, si)
}

输出：

["1" "2" "3"] [1 2 3]

游乐场：

---

切片是数组段的描述符
它包括
-指向数组的指针，
-段的长度，以及
-其容量（管段的最大长度）

下面，字符串数组/切片转换为int数组/切片：

package main

import (
    "fmt"
    "log"
    "strconv"
    "strings"
)

func Slice_Atoi(strArr []string) ([]int, error) {
    // NOTE:  Read Arr as Slice as you like
    var str string                           // O
    var i int                                // O
    var err error                            // O

    iArr := make([]int, 0, len(strArr))
    for _, str = range strArr {
        i, err = strconv.Atoi(str)
        if err != nil {
            return nil, err                  // O
        }
        iArr = append(iArr, i)
    }
    return iArr, nil
}

func main() {
    strArr := []string{
        "0 0 24 3 15",
        "0 0 2 5 1 5 11 13",
    }

    for i := 0; i < len(strArr); i++ {
        iArr, err := Slice_Atoi(strings.Split(strArr[i], " "))
        if err != nil {
            log.Print("Slice_Atoi failed: ", err)
            return
        }
        fmt.Println(iArr)
    }
}

我在一个项目中使用了，其他回复中的一些小优化（上面标记为//O）也为其他回复修复了一点可读性

---

祝你好运这里是另一个例子：

var t = []string{"1", "2", "3"}
str := strings.Join(t, "")
if _, err := strconv.Atoi(str); err != nil {
    // do stuff, in case str can not be converted to an int
}
var slice []int // empty slice
for _, digit := range str {
    slice = append(slice, int(digit)-int('0')) // build up slice
}

我喜欢这一点，因为如果

t

中的每个数字都可以转换为int，您只需检查一次。这样更有效吗？我不知道

---

为什么需要

int（'0'）

？因为

int（）

将字符转换为相应的ASCII码（）。对于0，这将是48。因此，您必须从“ascii十进制”中对应的数字中减去48。

这是一个古老的问题，但所有答案都忽略了一个事实，即输入长度是预先知道的，因此可以通过预分配目标切片来改进：

package main

import "fmt"
import "strconv"

func main() {
    var t = []string{"1", "2", "3"}
    var t2 = make([]int, len(t))
    
    for idx, i := range t {
        j, err := strconv.Atoi(i)
        if err != nil {
            panic(err)
        }
        t2[idx] = j
    }
    fmt.Println(t2)
}

游乐场：

var t = []string{"1", "2", "3"}
str := strings.Join(t, "")
if _, err := strconv.Atoi(str); err != nil {
    // do stuff, in case str can not be converted to an int
}
var slice []int // empty slice
for _, digit := range str {
    slice = append(slice, int(digit)-int('0')) // build up slice
}

package main

import "fmt"
import "strconv"

func main() {
    var t = []string{"1", "2", "3"}
    var t2 = make([]int, len(t))
    
    for idx, i := range t {
        j, err := strconv.Atoi(i)
        if err != nil {
            panic(err)
        }
        t2[idx] = j
    }
    fmt.Println(t2)
}