Pourquoi l’affirmation Golang échoue-t-elle ? Comment l'éviter ?

Golang est un langage de programmation en développement rapide. Sa syntaxe est concise et ses performances de concurrence sont supérieures. Il est apprécié et utilisé par de plus en plus de développeurs. Cependant, même avec un langage aussi efficace, des problèmes inattendus surgiront inévitablement. Dans Golang, l'un des problèmes courants est l'échec de l'assertion (Assertion Failed).

L'échec d'une assertion signifie que lors de l'exécution du programme, certaines conditions ne sont pas remplies, provoquant le crash du programme. Par exemple, si vous utilisez une assertion pour déterminer la longueur d'une certaine tranche, le programme ne parviendra pas à affirmer lorsque la longueur de la tranche est inférieure à une limite connue. À ce moment-là, le programme affichera un message d'erreur de panique, empêchant le programme de poursuivre son exécution.

Bien que ce problème ne semble pas facile à survenir, il peut en fait faire planter votre programme. Par conséquent, nous devons comprendre pourquoi les assertions échouent et comment l’éviter.

Cause de l'échec de l'assertion

1. Variable non initialisée

Dans Golang, si une variable n'est pas explicitement initialisée, sa valeur par défaut est la valeur zéro du type. Pour certaines valeurs (telles que les types entiers), la valeur zéro est 0, et pour d'autres valeurs, elle est nulle ou une tranche vide.

Par conséquent, si vous opérez sur une variable non initialisée, telle qu'une tranche ou un tableau, l'assertion échouera. La valeur par défaut de ces variables étant nulle, il n’existe aucun moyen d’obtenir leur longueur ou leur index. Dans ce cas, pour éviter les échecs d'assertion, vous devez vous assurer d'initialiser ou d'attribuer une structure de données ou un élément de tableau de longueur variable avant de le lire.

2. Plage de tableaux ou de tranches hors limites

Dans Golang, l'accès aux tableaux et aux tranches est basé sur des indices. Cela signifie que si vous accédez à un tableau ou à une tranche en utilisant un indice non valide, l'assertion échouera. Cette situation est très courante et est particulièrement sujette aux erreurs lors de l'utilisation de plusieurs variables d'index dans une boucle.

Pour éviter l'échec de l'assertion, vous devez vérifier si la variable est hors limites avant d'accéder au tableau ou à la tranche. Vous pouvez utiliser des opérateurs de comparaison pour vérifier si elle est supérieure ou égale à la longueur ou inférieure à 0.

Par exemple, l'extrait de code suivant montre comment parcourir une tranche en toute sécurité :

slice := []int{1, 2, 3, 4, 5}
for i := 0; i < len(slice); i++ {
    if i >= len(slice) || i < 0 {
        // 索引越界
        break
    }
    // 访问数据
    fmt.Println(slice[i])
}

3. Échec de l'assertion de type

Dans Golang, nous devons souvent convertir un type d'interface en un type réel. En règle générale, nous utilisons des assertions de type pour effectuer cette conversion de type. Cependant, si le jugement de type échoue, l’assertion échouera.

Il peut y avoir de nombreuses raisons à l'échec du jugement de type. Par exemple, si vous essayez de convertir un pointeur en entier en chaîne, l'assertion échoue. Alternativement, si vous essayez de convertir un type d'interface en un type qui ne peut pas être converti, l'assertion échouera.

Pour éviter cela, vous devez vous assurer que vous effectuez une détermination correcte du type et toujours utiliser la réflexion pour vérifier si le type d'interface correspond au type cible.

Comment éviter l'échec d'une assertion

1. Assurer des valeurs valides des variables via l'initialisation et l'affectation

Dans Golang, les variables non initialisées ont généralement une valeur par défaut de zéro. Par conséquent, pour éviter les échecs d'assertion, vous devez initialiser ou attribuer une valeur valide à la variable avant de l'utiliser.

Par exemple, voici la déclaration et l'initialisation d'une tranche :

// 声明切片
var slice []int

// 初始化切片
slice = make([]int, 0)

Alternativement, vous pouvez déclarer et initialiser une variable à l'aide d'une courte déclaration de variable :

slice := make([]int, 0)

2. Vérification des limites sur l'index

Pour éviter de déclarer et initialisation d'un tableau ou d'une tranche La plage est hors limites et vous devez effectuer une vérification des limites sur l'index. Vous pouvez utiliser des opérateurs de comparaison pour vérifier si l'index est supérieur ou égal à zéro et inférieur à la longueur du tableau ou de la tranche.

Par exemple, ce qui suit est un parcours de tranche sécurisé :

// 安全获取数组元素的值
func safeGet(slice []int, index int) int {
    if index >= len(slice) || index < 0 {
        return -1
    }
    return slice[index]
}

func main() {
    slice := []int{1, 2, 3, 4, 5}

    // 遍历切片元素
    for i := 0; i < len(slice); i++ {
        fmt.Println(safeGet(slice, i))
    }
}

3. Avant d'utiliser des assertions de type, vérifiez que le type correspond

Enfin, lorsque vous utilisez des assertions de type, assurez-vous qu'avant de faire l'assertion, vérifiez que l'interface le type correspond à la correspondance du type cible. Sinon, vous risquez de rencontrer des échecs d’assertion.

Pour éviter cette situation, vous pouvez utiliser le mécanisme de réflexion pour détecter le type. Par exemple, l'extrait de code suivant montre comment utiliser la réflexion pour vérifier si une valeur est de type chaîne :

// 判断一个值是否是字符串类型
func isString(val interface{}) bool {
    tt := reflect.TypeOf(val)
    if tt.Kind() == reflect.String {
        return true
    }
    return false
}

func main() {
    fmt.Println(isString("Hello, world!"))  // 输出 true 
    fmt.Println(isString(123))  // 输出 false 
}

Conclusion

Les assertions Golang échouées sont un problème courant, mais c'est aussi un problème qui est facilement négligé. Pour éviter cela, vous devez initialiser et attribuer des variables, effectuer des vérifications de limites sur des tableaux ou des tranches et vous assurer que les types de variables correspondent avant de faire des assertions de type. Ce n'est qu'ainsi que vous pourrez garantir que votre programme ne plante pas en raison d'un échec d'assertion.

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!