Comment appeler une méthode sur une instance de structure en Go?

Dans le langage GO, l'appel d'une méthode de structure nécessite d'abord de définir la structure et la méthode qui lie le récepteur et l'accès à l'aide d'un numéro de point. Après avoir défini le rectangle de structure, la méthode peut être déclarée via le récepteur de valeur ou le récepteur de pointeur; 1. Utilisez le récepteur de valeur tel que Func (R rectangle) zone () int, et il est appelé directement via rect.area (); 2. Si vous avez besoin de modifier la structure, utilisez le récepteur de pointeur tel que SetWidth (R * rectangle) de Func (R * R * 3. Lors de l'intégration de la structure, la méthode de structure intégrée sera promue et peut être appelée directement par la structure extérieure; 4. GO n'a pas besoin de forcer Getter / Setter, et les champs sont accessibles directement à moins que le contrôle logique ne soit requis. Ces mécanismes rendent les appels de méthode concis et flexibles.

Dans Go, appeler une méthode sur une instance de structure est simple - vous utilisez la notation de points, tout comme l'accès aux champs. La clé est de comprendre comment les méthodes sont définies avec des récepteurs liés à des types spécifiques.

Définissez la structure et la méthode

Définissez d'abord un type de structure, puis déclarez une méthode avec un récepteur de ce type:

 type rectangle struct {
    Largeur, hauteur int
}

func (r rectangle) Area () int {
    retour R.Width * R.Height
}

Ici, Area est une méthode sur Rectangle . La partie (r Rectangle) signifie qu'il s'agit d'un récepteur de valeur - la méthode obtient une copie de l'instance Rectangle sur laquelle elle est appelée.

Pour l'appeler:

 rect: = rectangle {largeur: 3, hauteur: 4}
fmt.println (rect.area ()) // sortie: 12

Cela fonctionne car GO gère automatiquement le pointeur par rapport aux récepteurs de valeur pour vous - plus à ce sujet ci-dessous.

Utilisez des récepteurs de pointeur lorsque vous devez modifier l'instance

Si votre méthode doit modifier la structure, utilisez un récepteur de pointeur:

 func (r * rectangle) setWidth (Newwidth int) {
    R.Width = Newwidth
}

Ensuite, appelez-le comme ceci:

 rect: = & rectangle {largeur: 3, hauteur: 4}
rect.setwidth (5)
Fmt.println (rect.width) // Sortie: 5

Quelques choses à noter:

• Si vous avez un pointeur vers une structure, Go vous permet d'appeler à la fois la valeur et les méthodes de pointeur.
• Si vous avez une valeur, vous ne pouvez appeler les méthodes de valeur que si aller prend automatiquement son adresse.

Donc, si vous écrivez:

 rectval: = rectangle {3, 4}
rectval.setwidth (5) // fonctionne toujours!

GO convertira automatiquement rectVal en un pointeur lors de l'appel SetWidth , vous n'avez donc pas à vous soucier des types de correspondance dans la plupart des cas.

Méthodes d'appel sur les structures intégrées

GO prend en charge les structures d'intégration à l'intérieur d'autres structures, et leurs méthodes sont promues:

 Tapez une structure intérieure {
    Valeur int
}

func (i inner) printValue () {
    fmt.println (i.value)
}

Tapez la structure externe {
    Intérieur // intégré
}

Vous pouvez maintenant appeler la méthode directement sur la structure extérieure:

 o: = exter {inner {valeur: 10}}
O.printValue () // Sortie: 10

Cela évite d'avoir à écrire o.Inner.PrintValue() à chaque fois.

Gardez les choses simples: pas besoin de Getters ou de Setters

Contrairement à certaines langues, GO ne nécessite pas de getters et de setters. Étant donné que tous les champs sont publics s'ils sont capitalisés, vous pouvez y accéder directement, sauf si vous avez besoin de logique autour de la définition d'une valeur.

Par exemple:

 // Attribuez simplement directement
rect.width = 6

// n'utilise qu'une méthode si la validation est nécessaire
func (r * rectangle) setWidthSafe (w int) {
    Si w <0 {
        panique ("la largeur doit être non négative")
    }
    R.Width = W
}

Appeler ceci n'est pas différent de toute autre méthode:

 rect: = & rectangle {}
rect.setwidthsafe (5)

Appeler une méthode sur une structure en Go est simple une fois que vous comprenez les récepteurs. Que vous travailliez avec des récepteurs de valeur ou de pointeur, des types intégrés ou un accès direct sur le terrain, GO vous donne une flexibilité sans passe-partout supplémentaire.

Fondamentalement, c'est tout.

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!