Jak fmt.Scanln() czytaj na plasterek całkowitymi

Question

Mam wiersz zawierający 3 numery, które chcę czytać z stdin z fmt.Scanln(), ale ten kod nie zadziała:

X := make([]int, 3) 
fmt.Scanln(X...) 
fmt.Printf("%v\n", X) 

otrzymuję komunikat o błędzie:

cannot use X (type []int) as type []interface {} in function argument 

ja nie rozumiem.

Answer 1

Na przykład

package main 

import "fmt" 

func intScanln(n int) ([]int, error) { 
    x := make([]int, n) 
    y := make([]interface{}, len(x)) 
    for i := range x { 
     y[i] = &x[i] 
    } 
    n, err := fmt.Scanln(y...) 
    x = x[:n] 
    return x, err 
} 

func main() { 
    x, err := intScanln(3) 
    if err != nil { 
     fmt.Println(err) 
     return 
    } 
    fmt.Printf("%v\n", x) 
} 

Wejście:

1 2 3 

wyjściowa:

[1 2 3] 

Answer 2

myślę, że prawidłowa wersja powinna być

X := make([]int, 3) 
fmt.Scanln(&X[0], &X[1], &X[2]) 
fmt.Printf("%v\n", X) 

Answer 3

Ten komunikat o błędzie pojawia się b/c nie ma rozsądny sposób przekonwertować []int do []interface{}. Uwaga, dotyczy to plasterka. Tak więc składnia, której używasz, jest poprawna, ale fmt.Scanln oczekuje []interface{}. Ma to wpływ poza pkg fmt.

Powodem, dla którego widziałem, jest to, że Go zapewnia kontrolę nad układem pamięci, więc obecnie nie ma rozsądnego sposobu na konwersję plastra. Oznacza to, że musisz ręcznie wykonać konwersję, zanim przekażesz ją do funkcji oczekującej plastra danego typu. Na przykład:

package main 

import (
    "fmt" 
) 

func main() { 
    x := make([]int, 3) 
    y := make([]interface{}, 3) 
    y[0] = x[0] 
    y[1] = x[1] 
    y[2] = x[2] 

    fmt.Println(y...) 
} 

lub coś trochę bardziej ogólnie:

x := make([]int, 3) 
    y := make([]interface{}, len(x)) 
    for i, v := range x { 
     y[i] = v 
    } 

    fmt.Println(y...) 

Odnośnie konkretnego problemu, zobacz:

x := make([]*int, 3) 
    for i := range x { 
     x[i] = new(int) 
    } 

    y := make([]interface{}, 3) 

    for i, v := range x { 
     y[i] = v 
    } 

    if _, err := fmt.Scanln(y...); err != nil { 
     fmt.Println("Scanln err: ", err) 
    } 

    for _, v := range y { 
     val := v.(*int) 
     fmt.Println(*val) 
    } 

Answer 4

Idiomatic Go byłoby:

func read(n int) ([]int, error) { 
    in := make([]int, n) 
    for i := range in { 
    _, err := fmt.Scan(&in[i]) 
    if err != nil { 
     return in[:i], err 
    } 
    } 
    return in, nil 
} 

interface{} nic nie znaczy. Nie używaj go, jeśli nie musisz.