Maison > Article > développement back-end > 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.
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.
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
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.
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 :
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")
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.
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.
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!