Conversion de découpage de l'interface du langage GO: mise en page de la mémoire et analyse du système de type

En langue go, des tranches de type [] ne peuvent pas être attribuées directement à des tranches d'interface de type [], même si la structure de structure implémente l'interface correspondante. En effet, il existe des différences fondamentales dans la façon dont les deux sont disposés en mémoire. Les tranches de type struct stockent les valeurs de structure continue, tandis que les tranches de type d'interface stockent des valeurs d'interface continues (chaque valeur d'interface se compose d'informations de type et de pointeurs / valeurs de données). Pour atteindre cette transformation, une nouvelle tranche d'interface doit être construite en traversant explicitement l'élément de conversion de tranche et de type par élément. De plus, la compréhension de la différence entre le type * [] et le type [] * est essentielle pour la bonne manipulation des tranches de go et des interfaces.

Comprendre la différence de mémoire entre [] struct et interface []

Le système de type de langue GO est fortement typé et les types de tranches ne font pas exception. [] La personne (une tranche de structure de personne) et le modèle [] (une tranche d'interface du modèle) sont deux types complètement différents, et ils sont essentiellement différents en mémoire.

1. Structure Slice ([] personne) : Lors de la définition d'une tranche de [] personne, Go alloue une zone continue en mémoire pour stocker des instances de structures de personne. La taille de la structure de chaque personne est fixée, déterminée par ses champs internes. Par conséquent, [] la personne est essentiellement un bloc continu de données de structure de personne.

2. Slice d'interface ([] modèle) : Contrairement aux structures, les valeurs d'interface dans GO (telles que le type de modèle) sont généralement composées de deux «mots» en mémoire:

   • Type Word : stocke les informations sur le type de la valeur réelle (telle que * personne ou personne).
   • Mot de données : stocke la valeur réelle elle-même (si la valeur est petite) ou un pointeur vers la valeur réelle (si la valeur est grande ou est d'un type de référence). Lorsque vous définissez une tranche de modèle [], ALL alloue une zone continue en mémoire pour stocker les valeurs d'interface du modèle. Cela signifie que chaque élément de tranche est une valeur d'interface d'une structure à double mot, plutôt qu'une structure de personne directe.

Étant donné que [] la personne stocke une série de structures de personne et [] le modèle stocke une série de valeurs d'interface d'une structure à double mot, leur disposition de mémoire est complètement incompatible. Le compilateur Go ne peut pas interpréter ou convertir directement un bloc continu de structures de personne en un bloc continu de valeurs d'interface modèle sans effectuer des opérations supplémentaires. Cette conversion nécessite l'encapsulation de chaque élément, qui est une opération O (n), et GO ne permet pas de conversions implicites pour les performances et la sécurité des types.

Implémentez correctement la conversion de [] structure en [] interface

Pour convertir une tranche [] de personne en une tranche de modèle [], vous devez explicitement traverser la tranche d'origine et encapsuler l'instance de structure dans l'élément de valeur d'interface par élément, puis créer une nouvelle tranche d'interface.

Supposons que nous ayons l'interface du modèle et la structure du modèle suivantes:

 package principal

Importer "FMT"

// Interface de définition de l'interface Type d'interface modèle {
    GetName () String
}

// Structure de la personne implémente le type d'interface type struct personne {
    Chaîne de noms
    Âge int
}

func (p personne) getName () String {
    retour p.name
}

// NewPerson renvoie un pointeur vers une personne structure func newperson (nom de nom, âge int) * personne {
    retour et personne {nom: nom, âge: âge}
}

// NewModel renvoie une valeur d'interface modèle contenant * personne
Func NewModel (C String) Modèle {
    commutateur c {
    cas "personne":
        return newperson ("personne par défaut", 30) //, la valeur d'interface du modèle tiendra * la personne
    }
    retour nil
}

Maintenant, si nous avons une tranche [] de la personne et que nous voulons le convertir en un modèle []:

 // Supposons que les rendements des NewPersons []
func newpersons () [] personne {
    return [] personne {
        {Nom: "Alice", âge: 25},
        {Nom: "Bob", âge: 30},
    }
}

// Si vous essayez de convertir directement, une erreur sera signalée: Impossible d'utiliser NewPersons () (type [] personne) comme modèle de type []
/ *
func getModelsDirectly () [] modèle {
    Renvoie NewPersons ()
}
* /

// Méthode de conversion correcte: Traversez et convertit explicitement Func getModelSExplicitly () [] modèle {
    Personnes: = NewPersons ()
    Modèles: = Make ([] Modèle, Len (Persons)) // Créer une nouvelle tranche de modèle [] pour I, P: = Range Persons {
        // Attribuez une valeur de structure de chaque personne à l'interface du modèle.
        // Remarque: ici p est une copie de la personne.
        // Si la méthode d'interface du modèle nécessite un récepteur de pointeur ou doit modifier la structure d'origine,
        // Vous devez utiliser et les personnes [i] pour obtenir l'adresse de la structure d'origine.
        modèles [i] = p
    }
    modèles de retour
}

func main () {
    Modèles: = getModelSExplicitly ()
    pour _, m: = modèles de plage {
        fmt.printf ("Nom du modèle:% s \ n", m.getName ())
    }

    // Exemple: NewModel Renvoie * Personne, si vous voulez que la tranche d'interface contienne également des pointeurs fmt.println ("\ nmodels de points:")
    Personsptrs: = [] * Personne {
        NewSerson ("Charlie", 35),
        NewPerson ("David", 40),
    }
    ModèlesFromptrs: = Make ([] Modèle, Len (Personsptrs))
    pour i, p: = range Personsptrs {
        ModelsFroptrs [i] = p // p est déjà * personne, attribue directement}
    pour _, m: = range modèlesfRomptrs {
        fmt.printf ("Nom du modèle (PTR):% s \ n", m.getName ())
    }
}

Dans la fonction GetModelSExplicitly ci-dessus, nous créons d'abord une nouvelle tranche de modèle [] avec la même longueur que la tranche des personnes. Ensuite, nous itérons dans la tranche des personnes, et pour chaque instance de personne p, attribuez-la aux modèles [i]. Au cours de ce processus d'attribution, la valeur de la structure de la personne est encapsulée dans une valeur d'interface modèle et stockée dans une nouvelle tranche.

Remarques: la différence entre * [] type et [] * type

Dans GO, la façon dont les tranches et les pointeurs sont combinés peuvent parfois être déroutants, en particulier le type * [] et [] *. Comprendre leur sens est essentiel pour écrire un code clair et efficace.

1. * ` [] Type (pointeur pour trancher) **: Cela représente un pointeur vers la tête de la tranche. La tranche elle-même est une structure contenant un pointeur, une longueur et une capacité vers le réseau sous-jacent. [] Le type est un pointeur de cette structure. Dans GO, il n'est généralement pas nécessaire d'utiliser [] le type, car lorsqu'une tranche est passée en tant que paramètre de fonction, elle transmet elle-même ses informations d'en-tête par valeur, mais son tableau sous-jacent est partagé. La modification du contenu de la tranche affecte la tranche d'origine, mais la modification de la longueur ou de la capacité de la tranche (comme la réallocation) ne le fait pas. Si vous devez modifier l'en-tête de tranche (comme les tranches de réaffectation), vous pouvez utiliser * [] type`.

    // Exemple: * [] Personne (rarement utilisé)
   Var PersonSlice [] Personne
   var ptrtopersonsslice * [] person = & Personslice // ptrtopersonsslice est un pointeur vers la variable Personslice

2. * `[] Type` (tranche à un pointeur de type) **: Cela représente une tranche dont les éléments sont un pointeur vers une instance d'un type spécifique. Il s'agit d'un modèle très courant et utile en Go, en particulier dans les scénarios suivants:

   • Évitez de copier les grandes structures : si les structures sont grandes, le stockage de leurs pointeurs en tranches peut éviter une copie coûteuse pendant les opérations de tranche ou les appels de fonction.
   • Implémentation d'une interface : Si la méthode d'interface est définie par le récepteur du pointeur (par exemple, Func (P * personne) getName () String), alors seule * la personne implémente l'interface. À l'heure actuelle, [] * la personne est un choix plus approprié, car chaque élément est déjà de type de personne et peut être directement attribué à l'interface du modèle.
   • Modifier les données sous-jacentes : via des pointeurs dans la tranche, vous pouvez modifier directement l'instance de structure sous-jacente.

    // Exemple: [] * Personne
   Personsptrs: = [] * Personne {
       NewPerson ("Grace", 28),
       NewPerson ("Heidi", 32),
   }
   // convertir [] * personne en [] modèle
   ModèlesFromptrs: = Make ([] Modèle, Len (Personsptrs))
   pour i, p: = range Personsptrs {
       ModelsfRomptrs [i] = p // p est déjà * personne et peut être affecté directement au modèle
   }

   Si votre interface modèle est conçue pour accepter * la personne comme l'implémentateur (c'est-à-dire que la méthode d'interface a un récepteur de pointeur), la conversion de [] * personne en [] est plus naturelle et évite la copie inutile.

Résumer

En langage GO, [] Struct ne peut pas être converti directement en interface [] en raison de la différence fondamentale dans sa disposition de mémoire sous-jacente. Pour terminer cette transformation, une nouvelle tranche d'interface doit être construite en traversant et en encapsulation explicitement l'élément par élément. Lorsque vous concevez des tranches et des interfaces, vous devez peser l'utilisation de tranches de type valeur ([] struct) ou de tranches de type pointeur ([] * struct) basées sur les besoins réels, en particulier en ce qui concerne les grandes structures, les méthodes d'implémentation d'interface (récepteurs de valeur ou les récepteurs de pointeur) et le besoin de modifications de données sous-jacentes. Comprendre ces détails est essentiel pour écrire du code GO robuste et haute performance.

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!