Was sind Typzusicherungen in der Go-Sprache?

Go-Sprache ist eine statisch typisierte Programmiersprache. Die Typzusicherung ist eine der Möglichkeiten, den spezifischen Werttyp zu bestimmen, der in der Schnittstellenvariablen im Programm gespeichert ist. In der Go-Sprache kann eine Schnittstellenvariable jeden Werttyp speichern, die in der Schnittstellenvariablen gespeicherten Typinformationen sind jedoch begrenzt und es können nicht alle Arten von Operationen an der Schnittstellenvariablen ausgeführt werden. Daher müssen wir in tatsächlichen Anwendungen die in Schnittstellenvariablen gespeicherten spezifischen Werttypen beurteilen und konvertieren. Dies ist, was Typzusicherungen bewirken.

Typzusicherungen in der Go-Sprache gibt es in zwei Formen: Werttypzusicherungen und Zeigertypzusicherungen. Werttypzusicherungen und Zeigertypzusicherungen haben leicht unterschiedliche Methoden zur Beurteilung und Konvertierung der Werttypen von Schnittstellenvariablen.

Werttypzusicherung:

Das Syntaxformat der Werttypzusicherung lautet wie folgt:

x.(T)

Wobei x eine Variable vom Schnittstellentyp ist und T einen bestimmten Typ darstellt. Diese Typzusicherung ist wahr, wenn x einen Wert vom Typ T speichert, andernfalls ist sie falsch.

Das Ergebnis der Typzusicherung hat zwei Werte. Der erste Wert ist der Wert nach der Konvertierung von x in den Typ T. Der zweite Wert ist ein boolescher Wert, der angibt, ob das Ergebnis dieser Typzusicherung wahr ist. Die spezifische Codeimplementierung lautet wie folgt:

var x interface{}
x = "hello"

s, ok := x.(string)
if ok {
    fmt.Printf("x 类型为 string，值为 %s。
", s)
} else {
    fmt.Printf("x 不是 string 类型。
")
}

Im obigen Code wird zunächst eine leere Schnittstellentypvariable x definiert und der Variablen x eine Zeichenfolge „Hallo“ zugewiesen. Die Werttypzusicherungsanweisung x.(string) versucht, die Variable x in einen Zeichenfolgentyp zu konvertieren, s stellt die konvertierte Zeichenfolge dar und ok gibt an, ob die Typzusicherung erfolgreich ist. Wenn ok wahr ist, bedeutet dies, dass der in x gespeicherte Werttyp ein Zeichenfolgentyp ist und wir die konvertierte Zeichenfolge s ausgeben können. Wenn ok falsch ist, bedeutet dies, dass x kein Zeichenfolgentyp ist und die entsprechenden Eingabeaufforderungsinformationen ausgegeben werden können.

Zusicherung des Zeigertyps:

Das Syntaxformat der Zusicherung des Zeigertyps ähnelt dem der Zusicherung des Werttyps, mit der Ausnahme, dass der Zeiger bei der Zusicherung manipuliert werden muss.

x.(*T)

Wobei *T den Zeigertyp vom Typ T darstellt. Diese Typzusicherung ist wahr, wenn der in x gespeicherte Wert vom Zeigertyp T ist, andernfalls ist sie falsch.

Ähnlich wie Werttypzusicherungen haben auch Zeigertypzusicherungen zwei Werte. Der erste Wert ist der Wert, nachdem x in einen T-Typ-Zeiger konvertiert wurde. Der zweite Wert ist ein boolescher Wert, der angibt, ob das Ergebnis dieser Typzusicherung wahr ist . . Die spezifische Codeimplementierung lautet wie folgt:

type Foo struct {
    bar string
}

func main() {
    var i interface{} = &Foo{"hello"}

    f, ok := i.(*Foo)
    if ok {
        fmt.Printf("i 是指针类型，指向 Foo 类型的变量，f.bar 的值为 %s。
", f.bar)
    } else {
        fmt.Printf("类型断言失败。
")
    }
}

Im obigen Code wird eine Struktur vom Typ Foo definiert, eine leere Schnittstellenvariable i in der Hauptfunktion definiert und der Variablen ein Zeiger auf eine Struktur vom Typ Foo zugewiesen ich. Zeigertypzusicherung x.(*Foo) versucht, die Variable x in einen Zeigertyp umzuwandeln, der auf eine Struktur vom Typ Foo zeigt, f stellt den konvertierten Zeiger dar und ok gibt an, ob die Typzusicherung erfolgreich ist. Wenn ok wahr ist, bedeutet dies, dass der in x gespeicherte Werttyp ein Zeigertyp ist, der auf eine Struktur vom Typ Foo zeigt, und wir können den Feldwert in der Struktur ausgeben, auf die der Zeiger zeigt. Wenn ok falsch ist, bedeutet dies, dass x kein Zeigertyp ist, der auf eine Struktur vom Typ Foo zeigt, und die entsprechenden Eingabeaufforderungsinformationen können ausgegeben werden.

Zusammenfassung:

Typzusicherung ist eine häufig verwendete Methode zum Betreiben von Schnittstellenvariablen in der Go-Sprache. Typzusicherung kann den in der Schnittstellenvariablen gespeicherten Typ bestimmen und dann entsprechende Operationen daran ausführen. Es gibt zwei Formen von Typzusicherungen in der Go-Sprache: Werttypzusicherungen und Zeigertypzusicherungen. Bei der Verwendung von Typzusicherungen müssen Sie auf die Fehlerbehandlung achten, um Laufzeitfehler zu vermeiden.

Das obige ist der detaillierte Inhalt vonWas sind Typzusicherungen in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!