Qu’est-ce que l’assertion de type dans le langage Go ?

Dans le langage Go, l'assertion de type est une opération utilisée sur les valeurs d'interface. Elle est utilisée pour vérifier si la valeur détenue par la variable de type d'interface implémente l'interface attendue ou le type spécifique. (T)”. Que peut-on faire via les assertions de type : 1. Vérifiez si i est nul ; 2. Vérifiez si la valeur stockée dans i est d'un certain type ;

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Quelle est l'affirmation ?

L'assertion est un terme de programmation exprimé sous la forme d'une expression booléenne. Lors de l'écriture du code, nous faisons toujours certaines hypothèses, et des assertions sont utilisées pour capturer ces hypothèses dans le code. Pour comprendre simplement une affirmation, cela signifie un jugement. Ainsi, en Go, nous pouvons comprendre les assertions de type comme des jugements de type.

Introduction à l'assertion de type

L'assertion de type est une opération utilisée sur les valeurs d'interface pour vérifier si la valeur détenue par la variable de type d'interface implémente l'interface attendue ou un type spécifique.

Le format syntaxique de l'assertion de type dans le langage Go est le suivant :

value, ok := x.(T)

où, x représente le type d'une interface et T représente un type spécifique (peut également être un type d'interface).

Cette expression d'assertion renverra la valeur de x (c'est-à-dire la valeur) et une valeur booléenne (c'est-à-dire ok). Vous pouvez utiliser cette valeur booléenne pour déterminer si x est de type T :

• Si T est). un type spécifique, l'assertion de type vérifie si le type dynamique de x est égal au type concret T. Si la vérification réussit, l'assertion de type renvoie une valeur dynamique de x dont le type est T.

• Si T est un type d'interface, l'assertion de type vérifie si le type dynamique de x satisfait T. Si la vérification réussit, la valeur dynamique de x ne sera pas extraite et la valeur de retour est une valeur d'interface de type T.

• Peu importe le type T, si x est une valeur d'interface nulle, l'assertion de type échouera.

Il existe deux formes principales d'assertions de type dans Go

• Variable.(type). Par exemple : 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). Par exemple : num,ok = i.(int). ok signifie déterminer si le type réussit.

Utilisation de l'assertion de type

🎜Vous pouvez faire les choses suivantes via l'assertion de type🎜🎜🎜🎜Vérifiez iSi le code> est nul🎜🎜🎜🎜Vérifiez si la valeur stockée dans <code>i est d'un certain type🎜🎜🎜🎜Il existe deux manières spécifiques de l'utiliser :🎜🎜🎜La première :🎜🎜 rrreee🎜this L'expression peut affirmer qu'un objet d'interface (i) n'est pas nul et que le type de la valeur stockée dans l'objet d'interface (i) est T. Si l'assertion réussit, la valeur sera renvoyée à t. Si l’affirmation échoue, la panique sera déclenchée. 🎜🎜Écrivons un morceau de code pour le tester🎜rrreee🎜Le résultat après l'exécution est le suivant. On peut constater que la deuxième assertion a échoué et que la panique s'est déclenchée🎜rrreee🎜Si la valeur de l'interface à affirmer est nulle, alors allons-y. jetez un œil Est-ce que cela déclenche également la panique🎜rrreee🎜 comme prévu ? Le résultat est le suivant. Il déclenche effectivement la panique🎜rrreee🎜🎜Le deuxième type🎜🎜rrreee🎜 est le même que ci-dessus. l'objet (i) n'est pas nil et le type de la valeur stockée dans l'objet d'interface (i) est T. Si l'assertion réussit, son type sera renvoyé à t et la valeur de ok à ce moment est vraie. , indiquant que l'assertion est réussie. 🎜🎜Si le type de valeur d'interface n'est pas le T que nous avons affirmé, l'assertion échouera, mais contrairement à la première expression, cela ne déclenchera pas de panique, mais définira la valeur de ok sur false, indiquant un échec d'assertion, à. cette fois t est la valeur nulle de T. 🎜🎜Modifiez légèrement l'exemple ci-dessus, comme suit 🎜rrreee🎜Le résultat après l'exécution est le suivant. On peut constater que lorsque la deuxième assertion a été exécutée, même si elle a échoué, elle n'a pas déclenché de panique. 🎜rrreee🎜Dans la sortie ci-dessus, vous devez faire attention au fait que la sortie de la deuxième assertion avant -false n'indique pas s'il y a une valeur de sortie t2, mais parce que l'assertion a échoué, donc t2 a obtenu La valeur zéro de la chaîne est également "", qui est de longueur nulle, vous ne pouvez donc pas voir sa sortie. 🎜

🎜Type Switch🎜🎜🎜Si vous devez distinguer plusieurs types, vous pouvez utiliser des assertions de type switch Ce sera mieux que. en le faisant une par une, les assertions de type sont plus simples, plus directes et plus efficaces. 🎜rrreee🎜Le résultat est le suivant🎜rrreee🎜Explication supplémentaire :🎜

🎜Si votre valeur est nulle, alors la correspondance est case nulle🎜🎜Si votre valeur n'est pas en switch-case Match le type correspondant, puis prenez la branche par défaut🎜🎜🎜[Recommandations associées : 🎜Go tutoriel vidéo🎜, 🎜Enseignement de la programmation🎜]🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!