English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriel de base Go

Instructions de contrôle Go

Fonction & méthode Go

Structure Go

Coupe & tableau Go

Chaîne Go (String)

Pointeur Go

Interface Go

Concurrence Go

Exception Go (Error)

Autres outils Go

Méthode Go (Method)

Le langage Go supporte les méthodes. Les méthodes Go sont similaires aux fonctions Go, mais avec une différence notable : elles incluent un paramètre receveur. Grâce à ce paramètre receveur, la méthode peut accéder aux attributs du receveur. Ici, le receveur peut être de type structure ou de type non structure. Lorsque vous créez une méthode dans le code, le receveur et le type du receveur doivent se trouver dans le même paquet. De plus, il n'est pas permis de créer une méthode où le type du receveur a été défini dans un autre paquet, y compris les types intégrés tels que int, string, etc. Si vous essayez de le faire, le compilateur lancera une erreur.

Syntaxe :

func(reciver_name Type) method_name(parameter_list)(return_type){
    // Code
}

Ici, vous pouvez accéder au receveur à l'intérieur de la méthode.

méthode de receveur de type structure

En langage Go, il est permis de définir des méthodes avec un receveur de type structure. Vous pouvez accéder à ce receveur à l'intérieur de la méthode, comme dans l'exemple suivant :

package main 
  
import "fmt"
  
//Structure Author
type author struct { 
    name string 
    branch string 
    particles int
    salary int
} 
  
//méthode du destinataire 
func (a author) show() { 
  
    fmt.Println("Nom de l'auteur: ", a.name) 
    fmt.Println("Nom du branche: ", a.branch) 
    fmt.Println("Articles publiés: ", a.particles) 
    fmt.Println("Salaire: ", a.salary) 
} 
  
func main() { 
  
    //Valeur d'initialisation
    //Structure Author
    res := author{ 
        nom: "Sona", 
        branche: "CSE", 
        particles: 203, 
        salaire:    34000, 
    } 
  
    //Appel de la méthode
    res.show() 
}

Sortie :

Nom de l'auteur: Sona
Nom de la branche: CSE
Articles publiés:  203
Salaire:  34000

Méthode du récepteur de type non structuré

Dans le langage Go, il est possible d'utiliser le récepteur de type non structuré pour créer une méthode tant que le type et la définition de méthode existent dans le même paquet. S'ils existent dans des paquets différents tels que int, string, etc., le compilateur lancera une erreur car ils sont définis dans des paquets différents.

package main 
  
import "fmt"
  
//Définition de type
type data int
//Définir une méthode
//Récepteur de type non structuré 
func (d1 data) multiply(d2 data) data { 
    return d1 * d2 
} 
  
/* 
//Si vous essayez d'exécuter ce code,
//Ensuite, le compilateur lancera une erreur 
func(d1 int)multiply(d2 int)int{ 
return d1 * d2 
} 
*/
  
func main() { 
    value1 := data(23) 
    value2 := data(20) 
    res := value1.multiply(value2) 
    fmt.Println("Résultat final: ", res) 
}

Sortie :

Résultat final:  460

Méthode Go avec récepteur pointeur

En langage Go, il est permis d'utiliserPointeurCréation de méthode du récepteur. Avec l'aide du récepteur pointeur, si les modifications apportées dans la méthode seront reflétées dans l'appelant, ce qui est impossible pour le récepteur de valeur.

Syntaxe :

func (p *Type) méthode_nom(...Type) Type {
    // Code
}
package main 
  
import "fmt"
  
// Structure Author
type author struct { 
    name string 
    branch string 
    particles int
} 
  
//Méthode, utilisant le récepteur de type author
func (a *author) show(abranch string) { 
    (*a.branch = abranch 
} 
  
// Fonction principale 
func main() { 
  
    //Initialisation de la structure author
    res := author{ 
        name: "Sona", 
        branch: "CSE", 
    } 
  
    fmt.Println("Nom de l'auteur: ", res.name) 
    fmt.Println("Nom de la branche (Avant) : ", res.branch) 
  
    //Création d'un pointeur
    p := &res 
  
    //Appel de la méthode show
    p.show("ECE") 
    fmt.Println("Nom de l'auteur: ", res.name) 
    fmt.Println("Nom de la branche (Après) : ", res.branch) 
}

Sortie :

Nom de l'auteur : Sona
Nom de la branche (Avant) : CSE
Nom de l'auteur : Sona
Nom de la branche (Après) : ECE

Les méthodes peuvent accepter des pointeurs et des valeurs

Il est bien connu que dans Go, lorsqu'une fonction a des paramètres de valeur, elle ne prend que la valeur des paramètres, si vous essayez de passer un pointeur à une fonction de valeur, elle ne le recevra pas, et vice versa. Cependant, les méthodes Go peuvent accepter des valeurs et des pointeurs, que ce soit avec un récepteur de pointeur ou de valeur défini. Voici un exemple :

package main 
  
import "fmt"
  
// Structure Author
type author struct { 
    name string 
    branch string 
} 
  
//Méthode avec pointeur
//Récepteur de type author
func (a *author) show_1(abranch string) { 
    (*a.branch = abranch 
} 
  
//Méthode avec valeur
//Récepteur de type auteur 
func (a author) show_2() { 
    a.name = "Gourav"
    fmt.Println("Nom de l'auteur (Avant) : ", a.name) 
} 
  
func main() { 
  
     //Valeur d'initialisation
     //Structure de l'auteur
    res := author{ 
        name: "Sona", 
        branch: "CSE", 
    } 
  
    fmt.Println("Nom de la branche (Avant) : ", res.branch) 
  
     //Appel de show_1Méthode
     //Méthode (pointeur) avec valeur
    res.show_1("ECE") 
    fmt.Println("Nom de la branche (Après) : ", res.branch) 
  
     //Appel de show_2Méthode
     //Méthode (valeur) avec pointeur
    (&res).show_2()) 
    fmt.Println("Nom de l'auteur (Après) : ", res.name) 
}

Sortie :

Nom de la branche (Avant) : CSE
Nom de la branche (Après) : ECE
Nom de l'auteur (Avant) : Gourav
Nom de l'auteur (Après) : Sona

Différences entre méthodes et fonctions

MéthodeFonction

Il contient un récepteur.

Il ne contient pas de récepteur.

Il peut accepter des pointeurs et des valeurs.

Il ne peut pas accepter à la fois des pointeurs et des valeurs.

Il est possible de définir des méthodes de noms identiques mais de types différents dans le programme.

Il n'est pas permis de définir des fonctions de noms identiques mais de types différents dans le programme.