Warum kann ich in Go ein Stück „Foo“ nicht in ein Stück „Bar“ umwandeln?

Warum Go die Konvertierung von Slice-Typen nicht zulässt (z. B. []Foo in []Bar)

Einführung

In Go ist das Zuweisen eines Werts zu einer Variablen eines anderen Typs aufgrund von Typsicherheits- und Konvertierungsregeln im Allgemeinen nicht zulässig. Wie Sie festgestellt haben, können Sie ein Segment von Strukturen eines Typs (z. B. []Foo) nicht in ein Segment eines anderen Typs (z. B. []Bar) konvertieren. Dieser Artikel soll klären, warum diese Konvertierung nicht möglich ist, obwohl die zugrunde liegenden Typen von Foo und Bar möglicherweise identisch sind.

Konvertierungsregeln

Gemäß der Go-Spezifikation , ein nicht konstanter Wert x kann nur dann in den Typ T konvertiert werden, wenn eines der folgenden Kriterien erfüllt ist:

• x ist T zuweisbar.
• Die zugrunde liegenden Typen von x und T sind identisch.
• x und T sind unbenannte Zeigertypen mit identischen Basistypen.
• x und T sind beide Ganzzahl-, Gleitkomma- oder komplexe Typen.
• x ist eine Ganzzahl oder ein Byte-/Runen-Slice und T ist ein String-Typ.
• x ist ein String und T ist ein Byte-/Runen-Slice.

Zugrunde liegende Slices-Typen

Der zugrunde liegende Typ eines Slices ist ein Zeiger auf den Elementtyp. Beispielsweise ist der zugrunde liegende Typ von []Foo []Foo und der zugrunde liegende Typ von []Bar ist []Bar. Obwohl der zugrunde liegende Typ von Foo derselbe ist wie der zugrunde liegende Typ von Bar, führt dies nicht zu identischen zugrunde liegenden Typen für Abschnitte von Foo und Bar.

Grund für die Nichtkonvertierung

Der Grund, warum Go keine Konvertierung zwischen Slices unterschiedlicher Elementtypen zulässt, selbst wenn die zugrunde liegenden Typen gleich sind, liegt daher darin, dass die zugrunde liegenden Typen der Slices nicht identisch sind. Daher ist eine Typkonvertierung wie []Bar(foos) nicht zulässig.

Alternative Lösung

Eine mögliche Lösung für dieses Problem ist die Definition ein benutzerdefinierter Typalias für ein Foo-Segment, z. B. Foos. Dadurch können Sie aus einem Segment von Foos ein Segment von Bars erstellen, wie im folgenden Code dargestellt:

<code class="go">type Foo struct{ A int }
type Foos []Foo
type Bars Foos

func main() {
    foos := []Foo{Foo{1}, Foo{2}}
    bars := Bars(foos)

    fmt.Println(bars)
}</code>

In diesem Fall sind die zugrunde liegenden Typen von Foos und Bars identisch und die Konvertierung funktioniert wie folgt erwartet.

Überlegungen zu unsicheren Paketen

Während Go generell unsichere Vorgänge verbietet, ist es möglich, das unsichere Paket zu verwenden, um die Konvertierungsbeschränkung zu umgehen. Dies sollte jedoch mit Vorsicht und Verständnis für mögliche Konsequenzen erfolgen, da es die Typsicherheit gefährden kann.

Fazit

Das Verständnis der Konvertierungsregeln und der zugrunde liegenden Slice-Typen ist erforderlich entscheidend für die Handhabung von Typkonvertierungen in Go. Während eine direkte Konvertierung zwischen Slices verschiedener Elementtypen nicht zulässig ist, gibt es alternative Lösungen, wie z. B. die Definition benutzerdefinierter Typaliase, um die gewünschte Funktionalität zu erreichen und gleichzeitig die Typsicherheit aufrechtzuerhalten.

Das obige ist der detaillierte Inhalt vonWarum kann ich in Go ein Stück „Foo“ nicht in ein Stück „Bar“ umwandeln?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!