Was ist die Typzusicherung in der Go-Sprache?

In der Go-Sprache ist die Typzusicherung eine Operation, die für Schnittstellenwerte verwendet wird. Sie wird verwendet, um zu überprüfen, ob der von der Schnittstellentypvariablen gehaltene Wert die erwartete Schnittstelle oder einen bestimmten Typ implementiert. (T)". Was kann durch Typzusicherungen getan werden: 1. Überprüfen Sie, ob i Null ist. 2. Überprüfen Sie, ob der in i gespeicherte Wert von einem bestimmten Typ ist.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Was ist die Behauptung?

Behauptung ist ein Programmierbegriff, der als boolescher Ausdruck ausgedrückt wird. Beim Schreiben von Code gehen wir immer von einigen Annahmen aus, und Behauptungen werden verwendet, um diese Annahmen im Code zu erfassen. Um eine Behauptung einfach zu verstehen, bedeutet sie ein Urteil. In Go können wir Typbehauptungen also als Typurteile verstehen.

Einführung in die Typzusicherung

Typzusicherung ist eine Operation, die für Schnittstellenwerte verwendet wird, um zu überprüfen, ob der von der Schnittstellentypvariablen gehaltene Wert die erwartete Schnittstelle oder einen bestimmten Typ implementiert.

Das Syntaxformat der Typzusicherung in der Go-Sprache lautet wie folgt:

value, ok := x.(T)

wobei x den Typ einer Schnittstelle darstellt und T einen bestimmten Typ darstellt (kann auch ein Schnittstellentyp sein).

Dieser Behauptungsausdruck gibt den Wert von x (d. h. value) und einen booleschen Wert (d. h. ok) zurück. Sie können diesen booleschen Wert verwenden, um zu bestimmen, ob x vom Typ T ist:

• Wenn T ist Ein bestimmter Typ. Die Typzusicherung prüft, ob der dynamische Typ von x gleich dem konkreten Typ T ist. Wenn die Prüfung erfolgreich ist, gibt die Typzusicherung einen dynamischen Wert von x zurück, dessen Typ T ist.

• Wenn T ein Schnittstellentyp ist, prüft die Typzusicherung, ob der dynamische Typ von x T erfüllt. Wenn die Prüfung erfolgreich ist, wird der dynamische Wert von x nicht extrahiert und der Rückgabewert ist ein Schnittstellenwert vom Typ T.

• Egal um welchen Typ T es sich handelt, wenn x ein Null-Schnittstellenwert ist, schlägt die Typzusicherung fehl.

Es gibt zwei Hauptformen von Typzusicherungen in Go

• Variable.(type). Zum Beispiel: i.(int)变量.(类型)。例如：i.(int)

• 变量,bool = 变量.(类型)。例如：num,ok = i.(int)。ok表示判断类型是否成功的意思。

类型断言的用法

通过类型断言可以做到以下几件事情

• 检查 i 是否为 nil

• 检查 i 存储的值是否为某个类型

具体的使用方式有两种：

第一种：

t := i.(T)

这个表达式可以断言一个接口对象（i）里不是 nil，并且接口对象（i）存储的值的类型是 T，如果断言成功，就会返回值给 t，如果断言失败，就会触发 panic。

来写段代码试验一下

package main

import "fmt"

func main() {
    var i interface{} = 10
    t1 := i.(int)
    fmt.Println(t1)

    fmt.Println("=====分隔线=====")

    t2 := i.(string)
    fmt.Println(t2)
}

运行后输出如下，可以发现在执行第二次断言的时候失败了，并且触发了 panic

10
=====分隔线=====
panic: interface conversion: interface {} is int, not string

goroutine 1 [running]:
main.main()
        E:/GoPlayer/src/main.go:12 +0x10e
exit status 2

如果要断言的接口值是 nil，那我们来看看也是不是也如预期一样会触发panic

package main

func main() {
    var i interface{} // nil
    var _ = i.(interface{})
}

输出如下，确实是会 触发 panic

panic: interface conversion: interface is nil, not interface {}

goroutine 1 [running]:
main.main()
        E:/GoPlayer/src/main.go:5 +0x34
exit status 2

第二种

t, ok:= i.(T)

和上面一样，这个表达式也是可以断言一个接口对象（i）里不是 nil，并且接口对象（i）存储的值的类型是 T，如果断言成功，就会返回其类型给 t，并且此时 ok 的值 为 true，表示断言成功。

如果接口值的类型，并不是我们所断言的 T，就会断言失败，但和第一种表达式不同的事，这个不会触发 panic，而是将 ok 的值设为 false ，表示断言失败，此时t 为 T 的零值。

稍微修改下上面的例子，如下

package main

import "fmt"

func main() {
    var i interface{} = 10
    t1, ok := i.(int)
    fmt.Printf("%d-%t\n", t1, ok)

    fmt.Println("=====分隔线1=====")

    t2, ok := i.(string)
    fmt.Printf("%s-%t\n", t2, ok)

    fmt.Println("=====分隔线2=====")

    var k interface{} // nil
    t3, ok := k.(interface{})
    fmt.Println(t3, "-", ok)

    fmt.Println("=====分隔线3=====")
    k = 10
    t4, ok := k.(interface{})
    fmt.Printf("%d-%t\n", t4, ok)

    t5, ok := k.(int)
    fmt.Printf("%d-%t\n", t5, ok)
}

运行后输出如下，可以发现在执行第二次断言的时候，虽然失败了，但并没有触发了 panic。

10-true
=====分隔线1=====
-false
=====分隔线2=====
<nil> - false
=====分隔线3=====
10-true
10-true

上面这段输出，你要注意的是第二个断言的输出在-false  之前并不是有没有输出任何 t2 的值，而是由于断言失败，所以 t2 得到的是 string 的零值也是 "" ，它是零长度的，所以你看不到其输出。

Type Switch

如果需要区分多种类型，可以使用 type switch 断言，这个将会比一个一个进行类型断言更简单、直接、高效。

package main

import "fmt"

func findType(i interface{}) {
    switch x := i.(type) {
    case int:
        fmt.Println(x, "is int")
    case string:
        fmt.Println(x, "is string")
    case nil:
        fmt.Println(x, "is nil")
    default:
        fmt.Println(x, "not type matched")
    }
}

func main() {
    findType(10)      // int
    findType("hello") // string

    var k interface{} // nil
    findType(k)

    findType(10.23) //float64
}

输出如下

10 is int
hello is string
<nil> is nil
10.23 not type matched

额外说明一下：

• 如果你的值是 nil，那么匹配的是 case nil
• Variable, bool = variable.(type). Zum Beispiel: num,ok = i.(int). ok bedeutet, festzustellen, ob der Typ erfolgreich ist.

Verwendung der Typzusicherung

🎜Mit der Typzusicherung können Sie Folgendes tun:🎜🎜🎜🎜Überprüfen Sie iOb code> Null ist🎜🎜🎜🎜Überprüfen Sie, ob der in <code>i gespeicherte Wert von einem bestimmten Typ ist🎜🎜🎜🎜Es gibt zwei spezifische Möglichkeiten, ihn zu verwenden:🎜🎜🎜Die erste:🎜🎜 rrreee🎜this Der Ausdruck kann behaupten, dass ein Schnittstellenobjekt (i) nicht Null ist und der Typ des im Schnittstellenobjekt (i) gespeicherten Werts T ist. Wenn die Behauptung erfolgreich ist, wird der Wert an t zurückgegeben Schlägt die Behauptung fehl, wird Panik ausgelöst. 🎜🎜Lassen Sie uns einen Code schreiben, um ihn zu testen Werfen Sie einen Blick darauf. Löst es wie erwartet auch Panik aus? Die Ausgabe ist tatsächlich wie folgt: Es löst tatsächlich Panik aus. Der zweite Typ ist derselbe wie oben Objekt (i) ist nicht Null und der Typ des im Schnittstellenobjekt (i) gespeicherten Werts ist T. Wenn die Behauptung erfolgreich ist, wird sein Typ an t zurückgegeben und der Wert von ok ist zu diesem Zeitpunkt wahr , was anzeigt, dass die Behauptung erfolgreich ist. 🎜🎜Wenn der Typ des Schnittstellenwerts nicht der von uns behauptete T ist, schlägt die Behauptung fehl, aber im Gegensatz zum ersten Ausdruck löst dies keine Panik aus, sondern setzt den Wert von ok auf „false“, was auf einen Fehler hinweist Diesmal ist t der Nullwert von T. 🎜🎜Ändern Sie das obige Beispiel leicht wie folgt: 🎜rrreee🎜Die Ausgabe nach dem Ausführen ist wie folgt. Es kann festgestellt werden, dass die Ausführung der zweiten Behauptung zwar fehlschlug, aber keine Panik auslöste. 🎜rrreee🎜In der obigen Ausgabe sollten Sie darauf achten, dass die Ausgabe der zweiten Behauptung vor -false nicht darin besteht, ob es einen Wert von t2 gibt, sondern weil die Behauptung fehlgeschlagen ist, also hat t2 erhalten Der Nullwert der Zeichenfolge ist ebenfalls "", was einer Länge von Null entspricht, sodass Sie die Ausgabe nicht sehen können. 🎜

🎜Typwechsel🎜🎜🎜Wenn Sie mehrere Typen unterscheiden müssen, können Sie Typwechselzusicherungen verwenden Wenn Sie dies einzeln tun, sind Typzusicherungen einfacher, direkter und effizienter. 🎜rrreee🎜Die Ausgabe ist wie folgt🎜rrreee🎜Zusätzliche Erklärung:🎜

🎜Wenn Ihr Wert Null ist, dann ist die Übereinstimmung case nil🎜🎜Wenn Ihr Wert nicht im Switch-Case-Match vorliegt Geben Sie den entsprechenden Typ ein und nehmen Sie dann den Standardzweig

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