Assertion de type Go

En Go, l'assertion de type est un mécanisme permettant de vérifier le type réel d'une valeur d'interface.

L'assertion de type est un outil important en Go pour gérer les types d'interface ; elle nous permet d'extraire un type concret d'une valeur d'interface et d'opérer dessus.

L'assertion de type est souvent utilisée pour gérer des variables de type interface, car une variable d'interface peut stocker n'importe quelle valeur d'un type concret qui implémente cette interface.

Syntaxe de base

La syntaxe de base des assertions de type est la suivante :

value, ok := interfaceValue.(Type)
  • interfaceValueest une variable d'un type interface.
  • Typeest le type que vous voulez asserter.
  • valueest la valeur du type spécifique après la réussite de l'assertion.
  • okIl s'agit d'une valeur booléenne indiquant si l'assertion a réussi.

Si l'assertion réussit,valueserainterfaceValuela valeur réelle,okesttrue; si l'assertion échoue,valueseraTypela valeur zéro,okestfalse。

Exemple

package main

import "fmt"

func main() {
    var i interface{} = "Hello, Go!"

    // Essayez d'asserter i comme type string
    s, ok := i.(string)
    if ok {
        fmt.Println("Assertion réussie :", s)
    } else {
        fmt.Println("Échec de l'assertion")
    }

    // Essayer d'effectuer une assertion de type sur i comme int
    n, ok := i.(int)
    if ok {
        fmt.Println("Assertion réussie :", n)
    } else {
        fmt.Println("Échec de l'assertion")
    }
}

Résultat de sortie

断言成功: Hello, Go!
断言失败

Une autre forme d'assertion de type

En plus de ce qui précède,value, ok := interfaceValue.(Type)En plus de cette forme, Go prend également en charge une autre forme d'assertion de type qui ne renvoie pas de valeur booléenne, mais déclenche directement un panic lorsque l'assertion échoue.

La syntaxe de cette forme est la suivante :

value := interfaceValue.(Type)

Exemple de code

Exemple

package main

import "fmt"

func main() {
    var i interface{} = "Hello, Go!"

    // Effectuer directement une assertion de type string
    s := i.(string)
    fmt.Println("Assertion réussie :", s)

    // Effectuer directement une assertion de type int (provoquera un panic)
    n := i.(int)
    fmt.Println("Assertion réussie :", n)
}

Résultat de sortie

断言成功: Hello, Go!
panic: interface conversion: interface {} is string, not int

Utilisations courantes des assertions de type

1. Gestion des valeurs d'interface avec plusieurs types

Go fournit également une syntaxe spéciale detype switchpour tester plusieurs types :

switch v := i.(type) {
case T1:
    // v的类型是T1
case T2:
    // v的类型是T2
default:
    // 默认情况
}

Lorsqu'une variable d'interface peut stocker des valeurs de plusieurs types, les assertions de type peuvent nous aider à effectuer différentes opérations en fonction du type réel.

Exemple

func printType(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Println("Ceci est un entier :", v)
    case string:
        fmt.Println("Ceci est une chaîne :", v)
    default:
        fmt.Println("type inconnu")
    }
}

2. Extraction d'un type concret à partir d'une interface

Lorsqu'on manipule des variables de type interface, nous pouvons avoir besoin de les convertir en un type concret pour d'autres opérations.

Exemple

func processInterface(i interface{}) {
    if s, ok := i.(string); ok {
        fmt.Println("Traitement de la chaîne :", s)
    } else if n, ok := i.(int); ok {
        fmt.Println("Traitement de l'entier :", n)
    } else {
        fmt.Println("Type non géré")
    }
}

Notes

  1. Les assertions de type ne peuvent être utilisées que sur des types d'interfaceRemarque : une assertion de type ne peut être utilisée que sur des variables de type interface, et non sur des variables de type non-interface.
  2. Éviter le panicRemarque : lorsque vous utilisez une assertion de type qui ne renvoie pas de valeur booléenne, assurez-vous que l'assertion ne va pas échouer, sinon elle provoquera un panic.
  3. Performance des assertions de type: Les assertions de type effectuent des vérifications de type à l'exécution, ce qui peut entraîner une certaine surcharge de performance. Elles doivent être utilisées avec prudence dans les scénarios sensibles aux performances.
autres extensions