Impossible de convertir []string en []interface {}

Question

J'écris un code, et j'ai besoin qu'il récupère les arguments et les passe à travers fmt.Println
(Je veux son comportement par défaut, pour écrire les arguments séparés par des espaces et suivis d'une nouvelle ligne). Cependant, il prend []interface {} mais flag.Args() renvoie un []string .
Voici l'exemple de code :

package main

import (
    "fmt"
    "flag"
)

func main() {
    flag.Parse()
    fmt.Println(flag.Args()...)
}

Cela renvoie l'erreur suivante :

./example.go:10: cannot use args (type []string) as type []interface {} in function argument

Est-ce un bug ? Ne devrait-on pas fmt.Println prendre tout tableau ? Au fait, j'ai également essayé de faire cela :

var args = []interface{}(flag.Args())

mais je reçois l'erreur suivante :

cannot convert flag.Args() (type []string) to type []interface {}

Existe-t-il un moyen de contourner ce problème ?

Answer 1

Je pense que c'est possible en utilisant la réflexion, mais je ne sais pas si c'est une bonne solution.

package main

import (
    "fmt"
    "reflect"
    "strings"
)

type User struct {
    Name string
    Age  byte
}

func main() {
    flag.Parse()
    fmt.Println(String(flag.Args()))
    fmt.Println(String([]string{"hello", "world"}))
    fmt.Println(String([]int{1, 2, 3, 4, 5, 6}))
    u1, u2 := User{Name: "John", Age: 30},
        User{Name: "Not John", Age: 20}
    fmt.Println(String([]User{u1, u2}))
}

func String(v interface{}) string {
    val := reflect.ValueOf(v)
    if val.Kind() == reflect.Array || val.Kind() == reflect.Slice {
        l := val.Len()
        if l == 0 {
            return ""
        }
        if l == 1 {
            return fmt.Sprint(val.Index(0))
        }
        sb := strings.Builder{}
        sb.Grow(l * 4)
        sb.WriteString(fmt.Sprint(val.Index(0)))
        for i := 1; i < l; i++ {
            sb.WriteString(",")
            sb.WriteString(fmt.Sprint(val.Index(i)))
        }
        return sb.String()
    }

    return fmt.Sprintln(v)
}

Sortie :

$ go run .\main.go arg1 arg2
arg1,arg2
hello,world
1,2,3,4,5,6
{John 30},{Not John 20}

Answer 2

fmt.Println prend paramètre variable

func Println(a ...interface{}) (n int, err error)

Il est possible d'imprimer flag.Args() sans se convertir en []interface{}

func main() {
    flag.Parse()
    fmt.Println(flag.Args())
}