[] String kann nicht in [] Schnittstelle {} konvertiert werden

Ich schreibe Code, und ich brauche ihn, um die Argumente fmt.Println
abzufangen und durchzuleiten (ich möchte das Standardverhalten, um durch Leerzeichen getrennte Argumente zu schreiben, gefolgt von einer neuen Zeile). Es dauert []interface {}jedoch aber flag.Args()gibt a zurück []string.
Hier ist das Codebeispiel:

package main

import (
    "fmt"
    "flag"
)

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

Dies gibt den folgenden Fehler zurück:

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

Ist das ein Fehler? Sollte nicht fmt.Printlnnehmen jede Array? Übrigens habe ich auch versucht, dies zu tun:

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

aber ich bekomme folgenden Fehler:

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

Gibt es einen "Go" Weg, um dies zu umgehen?

Dies ist kein Fehler. fmt.Println()erfordert einen []interface{}Typ. Das heißt, es muss ein Werteschnitt sein interface{}und nicht "irgendein Teil". Um das Slice zu konvertieren, müssen Sie jedes Element durchlaufen und kopieren.

old := flag.Args()
new := make([]interface{}, len(old))
for i, v := range old {
    new[i] = v
}
fmt.Println(new...)

Der Grund, warum Sie kein Slice verwenden können, ist, dass für die Konvertierung zwischen a []stringund a []interface{}das Speicherlayout geändert werden muss und dies in O (n) -Zeit erfolgt. Das Konvertieren eines Typs in einen Typ interface{}erfordert O (1) Zeit. Wenn sie diese for-Schleife unnötig machen würden, müsste der Compiler sie trotzdem einfügen.

Wenn es sich nur um ein Stück Zeichenfolgen handelt, die Sie drucken möchten, können Sie die Konvertierung vermeiden und durch Verbinden genau dieselbe Ausgabe erhalten:

package main

import (
    "fmt"
    "flag"
    "strings"
)

func main() {
    flag.Parse()
    s := strings.Join(flag.Args(), " ")
    fmt.Println(s)
}

In diesem Fall ist eine Typkonvertierung nicht erforderlich. Übergeben Sie einfach den flag.Args()Wert an fmt.Println.

Frage:

[] String kann nicht in [] Schnittstelle {} konvertiert werden

Ich schreibe Code, und ich brauche ihn, um die Argumente abzufangen und durch fmt.Println zu übergeben (ich möchte sein Standardverhalten, um Argumente zu schreiben, die durch Leerzeichen getrennt sind und von einer neuen Zeile gefolgt werden).

Hier ist das Codebeispiel:

package main

import (
    "fmt"
    "flag"
)

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

Paketflagge

import "flag"

func Args

func Args() []string

Args Gibt die Nicht-Flag-Befehlszeilenargumente zurück.

Paket fmt

import "fmt"

func Println

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

PrintlnFormate, die die Standardformate für ihre Operanden verwenden und in die Standardausgabe schreiben. Zwischen Operanden werden immer Leerzeichen hinzugefügt und eine neue Zeile angehängt. Es gibt die Anzahl der geschriebenen Bytes und alle aufgetretenen Schreibfehler zurück.

In diesem Fall ist eine Typkonvertierung nicht erforderlich. Übergeben Sie einfach den flag.Args()Wert an fmt.Println, der den Wert mithilfe der Reflexion als Typ interpretiert []string. Das Paket reflectimplementiert die Laufzeitreflexion, sodass ein Programm Objekte mit beliebigen Typen bearbeiten kann. Beispielsweise,

args.go::

package main

import (
    "flag"
    "fmt"
)

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

Ausgabe:

$ go build args.go
$ ./args arg0 arg1
[arg0 arg1]
$ 

In Go kann eine Funktion nur Argumente der in der Parameterliste in der Funktionsdefinition angegebenen Typen akzeptieren. Die Sprachfunktion für verschiedene Parameter erschwert dies ein wenig, folgt jedoch genau definierten Regeln.

Die Funktionssignatur für fmt.Printlnlautet:

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

Per der Sprache specific ,

Der letzte eingehende Parameter in einer Funktionssignatur kann einen Typ haben, dem ... vorangestellt ist. Eine Funktion mit einem solchen Parameter wird als variadisch bezeichnet und kann mit null oder mehr Argumenten für diesen Parameter aufgerufen werden.

Dies bedeutet, dass Sie Printlneine Liste von Argumenten vom interface{}Typ übergeben können. Da alle Typen die leere Schnittstelle implementieren, können Sie eine Liste von Argumenten eines beliebigen Typs übergeben. So können Sie Println(1, "one", true)beispielsweise fehlerfrei aufrufen . Siehe den Abschnitt "Übergeben von Argumenten an ... Parameter" der Sprachspezifikation:

Der übergebene Wert ist eine neue Schicht vom Typ [] T mit einem neuen zugrunde liegenden Array, dessen aufeinanderfolgende Elemente die tatsächlichen Argumente sind, die alle T zugewiesen werden müssen.

Der Teil, der Ihnen Probleme bereitet, steht direkt danach in der Spezifikation:

Wenn das endgültige Argument einem Slice-Typ [] T zugewiesen werden kann, kann es unverändert als Wert für einen ... T-Parameter übergeben werden, wenn auf das Argument ... folgt. In diesem Fall wird kein neues Slice erstellt.

flag.Args()ist Typ []string. Da Tin Printlnist interface{}, []Tist []interface{}. Es stellt sich also die Frage, ob ein String-Slice-Wert einer Variablen vom Schnittstellen-Slice-Typ zugewiesen werden kann. Sie können dies einfach in Ihrem Go-Code testen, indem Sie eine Zuweisung versuchen, zum Beispiel:

s := []string{}
var i []interface{}
i = s

Wenn Sie eine solche Zuweisung versuchen, gibt der Compiler die folgende Fehlermeldung aus:

cannot use s (type []string) as type []interface {} in assignment

Und deshalb können Sie die Auslassungspunkte nach einem String-Slice nicht als Argument dafür verwenden fmt.Println. Es ist kein Fehler, es funktioniert wie beabsichtigt.

Es gibt immer noch viele Möglichkeiten , können Sie drucken flag.Args()mit Println, wie

fmt.Println(flag.Args())

(wird [elem0 elem1 ...]gemäß der Dokumentation des FMT-Pakets ausgegeben )

oder

fmt.Println(strings.Join(flag.Args(), ` `)

(wodurch die String-Slice-Elemente ausgegeben werden, die jeweils durch ein einzelnes Leerzeichen getrennt sind) Verwenden Sie beispielsweise die Join-Funktion im Strings-Paket mit einem String-Trennzeichen.

Ich denke, es ist möglich, Reflexion zu verwenden, aber ich weiß nicht, ob es eine gute Lösung ist

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

Ausgabe:

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

fmt.Printlnnimmt variadic Parameter

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

Es ist möglich zu drucken, flag.Args()ohne in zu konvertieren[]interface{}

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