Les méthodes de GO sont des fonctions avec un récepteur, ce qui leur permet d'être associée à un type spécifique, tel qu'une structure, permettant un comportement spécifique au type. 2. Contrairement aux fonctions, les méthodes ont un récepteur, utilisent la notation de points pour l'invocation sur les instances, peuvent utiliser des récepteurs de valeur ou de pointeur pour contr?ler la modification et la copie et favoriser l'encapsulation en gardant la logique liée aux types. 3. Utiliser des méthodes lorsque la logique appartient à un type, tel que la mise en ?uvre du comportement ou des interfaces, et utilisez des fonctions pour les opérations génériques, autonomes ou utilitaires. 4. Une analogie du monde réel est que les méthodes représentent les actions effectuées par une instance, comme file.read (), tandis que les fonctions représentent des opérations indépendantes, comme os.open (). En résumé, les méthodes attachent le comportement aux types et sont au c?ur du style orienté objet de Go, favorisant la composition, donc si une opération ressemble à quelque chose qu'un type fait, ce devrait être une méthode.

Dans GO, les méthodes sont des fonctions qui ont un récepteur - un paramètre spécial qui associe la fonction à un type spécifique. Cela vous permet de définir le comportement pour un type particulier, similaire à la fa?on dont les objets ont des méthodes dans les langues orientées objet.

1. Quelles sont les méthodes en Go?

Une méthode est comme une fonction, mais elle appartient à un type. Le récepteur peut être une structure, un type de base ou même un pointeur vers un type. Voici un exemple simple:

 type rectangle struct {
    Largeur float64
    Hauteur float64
}

// Méthode avec un récepteur de valeur
func (r rectangle) zone () float64 {
    retour R.Width * R.Height
}

Ici, Area est une méthode de Rectangle . La partie (r Rectangle) est la déclaration du récepteur.

Vous l'appelez comme ceci:

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

2. Méthodes vs fonctions: différences clés

Bien que les méthodes et les fonctions effectuent une logique réutilisable, il existe des différences importantes:

? 1. Récepteur vs pas de récepteur

• Les fonctions n'ont pas de récepteur.
• Les méthodes ont un récepteur, qui les attache à un type.

 // fonction (pas de récepteur)
func CalculateAaa (W, H float64) float64 {
    retour w * h
}

// Méthode (a un récepteur)
func (r rectangle) zone () float64 {
    retour R.Width * R.Height
}

La méthode semble plus naturelle lorsque vous travaillez avec des types de données, en particulier les structures.

? 2. Syntaxe et invocation

• Les fonctions sont appelées directement: CalculateArea(3, 4)
• Les méthodes sont appelées dans des cas: rect.Area()

Cela rend les méthodes plus intuitives lors de la modélisation de la logique du domaine.

? 3. Valeur vs récepteurs du pointeur

Les méthodes peuvent avoir des récepteurs de valeur ou des récepteurs de pointeur:

 // Récepteur de valeur (fonctionne sur une copie)
func (r rectangle) zone () float64 {...}

// Récepteur de pointeur (peut modifier l'original)
func (r * rectangle) échelle (factor float64) {
    R.Width * = Factor
    R.Height * = Factor
}

Les récepteurs du pointeur sont utilisés lorsque vous souhaitez modifier le récepteur ou éviter de copier de grandes structures.

Les fonctions ne peuvent pas le faire directement - ils auraient besoin de prendre un pointeur comme argument explicite.

? 4. Encapsulation et comportement de type

Les méthodes vous permettent de définir un comportement logiquement lié à un type, favorisant un code plus propre et plus organisé.

Par exemple, les règles de validation, de mise en forme ou de commerce peuvent vivre avec le type:

 func (r rectangle) isvalid () bool {
    Retour R.Width> 0 && r.height> 0
}

Avec des fonctions, vous disperseriez une telle logique autour.

3. Quand utiliser les méthodes vs fonctions

Utilisez des méthodes lorsque:

• La logique est étroitement liée à un type.
• Vous modélisez le comportement d'une structure de données.
• Vous souhaitez implémenter une interface (par exemple, Stringer , error ).

Utilisez des fonctions lorsque:

• L'opération est générique ou s'applique à plusieurs types.
• Il n'appartient pas naturellement à un type.
• Vous écrivez une utilité ou une logique d'assistance.

Par exemple, une fonction comme Max(a, b int) n'a pas besoin d'appartenir à un type.

4. Une analogie réelle

Pensez à un type File :

• file.Read() → a du sens en tant que méthode (comportement d'un fichier)
• os.Open("path") → a du sens en tant que fonction (crée un fichier, non lié à une instance)

Donc:

• Méthodes = actions sur ou par une instance.
• Fonctions = opérations autonomes.

Conclusion:
Les méthodes sont des fonctions avec un récepteur, vous permettant d'attacher un comportement aux types. Ils sont centraux de l'approche de Go de la conception orientée objet - simple, explicite et basée sur la composition plut?t que sur l'héritage.

Il ne s'agit pas de mieux, mais qui correspond au contexte . Utilisez des méthodes pour donner le comportement de vos types et des fonctions pour la logique à usage général.

Fondamentalement, si cela ressemble à quelque chose que le type fait , faites-en une méthode.

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!