Explication détaillée de la différence entre les méthodes et les fonctions dans Go

                                                     

Ce qui suit est une explication détaillée de la différence entre les méthodes et les fonctions dans Go de la colonne tutoriel golang j'espère que ce sera le cas. utile aux amis dans le besoin !

Cet article présentera les principales différences entre les fonctions et les méthodes de Go, et comment les utiliser au mieux.

Les fonctions et méthodes sont largement utilisées dans Go pour fournir des abstractions qui rendent nos programmes plus faciles à lire et à raisonner. En apparence, les fonctions et les méthodes se ressemblent, mais il existe des différences sémantiques importantes qui peuvent grandement affecter la lisibilité de votre code.

Syntaxe

Syntaxe de déclaration

Déclarer une fonction en précisant les types de paramètres, la valeur de retour et le corps de la fonction :

type Person struct {
  Name string
  Age int
}

// 这个函数返回一个新的对象`Person`
func NewPerson(name string, age int) *Person {
  return &Person{
    Name: name,
    Age: age,
  }
}

Par contre, par en spécifiant un "récepteur" supplémentaire (qui en termes de POO serait la "classe" à laquelle appartient la méthode) pour déclarer la méthode :

// `Person`指针类型接收者的`isAdult方法
func (p *Person) isAdult() bool {
  return p.Age > 18
}

Dans la déclaration de méthode ci-dessus, nous avons déclaré *Person sur le isAdult méthode de saisie.

Syntaxe d'exécution

Les appels de fonction utilisent des paramètres indépendants et les appels de méthode utilisent le type de récepteur.

p := NewPerson("John", 21)

fmt.Println(p.isAdult())
// true

Interchangeabilité

Les fonctions et méthodes sont théoriquement interchangeables. Par exemple, nous pouvons convertir une méthode isAdult en fonction et avoir une fonction NewPerson comme méthode :

type PersonFactory struct {}

// NewPerson现在是PersonFactory结构的方法
func (p *PersonFactory) NewPerson(name string, age int) *Person {
  return &Person{
    Name: name,
    Age: age,
  }
}

// 现在，isAdult是一个函数，在该函数中，我们将`Person`作为参数而不是接收者进行传递
func isAdult(p *Person) bool {
  return p.Age > 18
}

Dans ce cas, la syntaxe d'exécution semble un peu bizarre :

factory := &PersonFactory{}

p := factory.NewPerson("John", 21)

fmt.Println(isAdult(p))
// true

ci-dessus Le code semble beaucoup plus complexe qu'il ne devrait l'être. Cela nous montre que la différence entre les méthodes et les fonctions est principalement d'ordre syntaxique et qu'une abstraction appropriée doit être utilisée en fonction du scénario.

Cas d'utilisation

Examinons quelques cas d'utilisation courants rencontrés dans les applications Go, ainsi que l'abstraction (fonction ou méthode) appropriée pour chaque application :

Chaînes de méthodes

Une fonctionnalité très utile des méthodes

est la possibilité de les enchaîner tout en gardant le code propre. Prenons l'exemple de la définition de Person en utilisant certaines propriétés d'un lien :

type Person struct {
    Name string
    Age  int
}

func (p *Person) withName(name string) *Person {
    p.Name = name
    return p
}

func (p *Person) withAge(age int) *Person {
    p.Age = age
    return p
}

func main() {
    p := &Person{}

    p = p.withName("John").withAge(21)

  fmt.Println(*p)
  // {John 21}
}

Cela aurait l'air vraiment effrayant si nous utilisions une fonction pour la même chose :

p = withName(withAge(p, 18), "John")

avoir un état vs. Exécution

Dans l'exemple d'Interchangeabilité, nous avons vu l'utilisation d'un objet PersonFactory pour créer une nouvelle instance de Person. Il s’avère qu’il s’agit d’un anti-modèle et qu’il doit être évité.

Il est préférable d'utiliser des fonctions comme NewPerson les fonctions précédemment déclarées pour une exécution sans état.

"Apatride" fait ici référence à tout code qui renvoie toujours la même sortie pour la même entrée

Le corollaire est que si vous constatez qu'une fonction lit et modifie plusieurs type spécifique, il devrait probablement être défini comme une méthode de ce type.

Sémantique

La sémantique fait référence à la façon dont le code est lu. Qu’est-ce qui a plus de sens si vous lisez le code à haute voix dans un langage parlé ?

Jetons un coup d'œil à la fonction et à la mise en œuvre de la méthode de isAdult

customer := NewPerson("John", 21)

// Method
customer.isAdult()

// Function
isAdult(customer)

Ici, customer.isAdult() comprend bien mieux la question "Le client est-il un adulte ?" . De plus, lorsque vous demandez « Est-ce que x est un adulte ? », la question vous sera toujours posée dans le contexte de isAdult(customer)x.

Conclusion

Bien que nous ayons discuté de quelques différences clés et de cas d'utilisation de fonctions et de méthodes dans Go, il y a toujours des exceptions ! Il est important de ne considérer aucune de ces règles comme des principes fondamentaux.

Enfin, la différence entre les fonctions et les méthodes réside dans la façon dont le code résultant est lu. Si vous ou votre équipe pensez qu’une approche est meilleure qu’une autre, alors c’est la bonne abstraction !

Adresse originale : https://www.sohamkamani.com/golang/functions-vs-methods/

Adresse de traduction : https://learnku.com/go/t /52424

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!