Go: converte stringhe in array in numero intero

Question

Come si convertono le stringhe in un array in numeri interi in un array in go?

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

a

[1, 2, 3] 

Ho cercato per alcune soluzioni online, ma non sono riuscito a trovarlo. Ho provato a scorrere l'array e ho fatto strconv.ParseFloat (v, 64) dove v è il valore ma non ha funzionato.

Answer 1

Dovrai effettivamente scorrere la sezione. Se la sezione contiene solo numeri interi, non è necessario disporre di ParseFloat, Atoi.

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) 
} 

On Playground.

Answer 2

Ad esempio,

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) 
} 

uscita:

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

giochi:

http://play.golang.org/p/QwNO8R_f90

Answer 3

Una fetta è un descrittore di un segmento matrice
È costituita
- un puntatore alla matrice,
- la lunghezza del segmento e
- la capacità (la lunghezza massima del segmento)

seguito, stringa Array/fetta viene convertito in int Array/Fetta:

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) 
    } 
} 

uscita:

[0 0 24 3 15] 
[0 0 2 5 1 5 11 13] 

che ho usato in un progetto, così ha fatto un piccolo ottimizzazioni da altre risposte, contrassegnate come // O per sopra, anche fissato un po 'in readabi lity for others

Buona fortuna