Go: konwersja ciągów w tablicy na liczbę całkowitą

Question

Jak przekonwertować ciągi znaków w tablicy na liczby całkowite w tablicy w programie go?

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

do

[1, 2, 3] 

Rozglądałem dla niektórych rozwiązań w Internecie, ale nie mógł go znaleźć. Próbowałem przejść przez tablicę i wykonałem polecenie strconv.ParseFloat (v, 64), gdzie v jest wartością, ale nie działa.

Answer 1

Będziesz musiał rzeczywiście przejść przez plaster. Jeśli plasterek zawiera tylko liczby całkowite, nie jest wymagana żadna potrzeba: 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) 
} 

Na Playground.

Answer 2

Przykładowo

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

wyjściowa:

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

zabaw:

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

Answer 3

Kawałek jest deskryptorem segmentu tablicy
składa się z
- wskaźnik do tablicy
- długość segmentu,
- zdolność (maksymalna długość segmentu)

Poniżej ciąg tablicy/segmentu przekształca int Array/segmentu:

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

wyjściowa:

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

użyłem w projekcie, więc zrobiłem małe optymalizacje z innymi odpowiedziami, oznaczonej jako // o wyżej, stały też trochę w readabi lity dla innych

Powodzenia