Comment les types « fmt.Printf » et pointeur de Go interagissent-ils, et pourquoi produisent-ils des sorties différentes pour différents types de pointeurs ?

Évaluation des différences entre les pointeurs Go

Dans Go, les pointeurs sont essentiels pour travailler avec des variables. Cependant, comprendre les nuances entre les différents types de pointeurs peut s’avérer difficile. Cet article explore un scénario spécifique qui présente les distinctions entre les pointeurs et comment ils affectent la sortie lors de l'utilisation du formatage par défaut dans le package fmt.

Le code en question

L'extrait de code suivant démontre le problème :

type Test struct {
    Test string
}

var Models = map[string]interface{}{
    "test": newTest(),
}

func main() {
    test1 := Test{}
    fmt.Println("Test 1: ")
    fmt.Printf("%v", test1)
    fmt.Println()
    fmt.Println("Test 1 as pointer: ")
    fmt.Printf("%v", &test1)
    fmt.Println()
    test2 := Models["test"]
    fmt.Println("Test 2: ")
    fmt.Printf("%v", test2)
    fmt.Println()
    fmt.Println("Test 2 as pointer: ")
    fmt.Printf("%v", &test2)
}

func newTest() Test {
    var model Test
    return model
}

Le problème

Lors de l'exécution du code, vous remarquerez une différence dans le sortie lors de l’impression de test2 par rapport à test1 en tant que pointeur. La sortie de test1 en tant que pointeur est une chaîne vide, tandis que la sortie de test2 en tant que pointeur est une représentation hexadécimale de l'adresse.

Explication

La fonction fmt.Printf utilise le %v verbe pour le formatage par défaut, qui sélectionne un format spécifique en fonction du type de valeur à imprimer. Pour les pointeurs, le format par défaut est la représentation hexadécimale de l'adresse.

Dans le premier cas (test1 comme pointeur), la valeur en cours d'impression est un pointeur vers une structure Test. Cependant, puisque la structure a été initialisée avec des valeurs nulles, la sortie est vide.

Dans le deuxième cas (test2 comme pointeur), la valeur en cours d'impression est un pointeur vers une interface{}. Avant d'atteindre le verbe %v, la valeur a subi un emballage supplémentaire dans une autre interface{}, qui pointe ensuite vers Models["test"]. Étant donné que la valeur finalement imprimée est un pointeur vers une interface{}, le formatage par défaut des pointeurs s'applique et vous obtenez la représentation hexadécimale de l'adresse.

Solution

Pour résoudre ce problème, il faut utiliser l'assertion de type pour extraire la structure Test réelle de test2. Ceci peut être réalisé par :

t2 := Models["test"]
test2 := t2.(Test) // test2 is now of type Test

Avec l'assertion de type, la variable test2 pointe maintenant vers la structure Test, et vous pouvez l'imprimer comme test1.

Alternativement, on peut travailler avec pointeurs vers Test directement en stockant les valeurs *Test dans la carte :

var Models = map[string]*Test{
    "test": newTest(),
}

Cette approche élimine le besoin d'assertion de type et l'emballage dans interface{}, évitant ainsi la représentation hexadécimale de l'adresse.

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!