Quelle est la différence entre les méthodes et les fonctions en langage Go

Différence : 1. La fonction est un morceau de code avec des fonctions indépendantes qui peuvent être appelées à plusieurs reprises pour réaliser la réutilisation du code ; tandis que la méthode est la fonction comportementale d'une classe et ne peut être appelée que par des objets de cette classe. 2. Les méthodes ont des récepteurs, mais les fonctions n'ont pas de récepteurs. 3. Les fonctions ne peuvent pas avoir le même nom, mais les méthodes peuvent avoir le même nom. 4. Les méthodes d'appel sont différentes. 5. La méthode doit spécifier son type, qui peut être une structure ou un type personnalisé, alors que les fonctions sont universelles. 6. La forme et le type de paramètre de la fonction doivent être cohérents et la méthode peut être modifiée.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Dans le langage Go, les fonctions et les méthodes sont différentes et ont des distinctions conceptuelles claires. Dans d'autres langages, comme Java, de manière générale, une fonction est une méthode, et une méthode est une fonction. Cependant, dans le langage Go, une fonction fait référence à une méthode qui n'appartient à aucune structure ou type. , une fonction n'a pas de récepteur ; les méthodes ont des récepteurs. Les méthodes dont nous parlons appartiennent à une structure ou à un type nouvellement défini.

Fonction

Fonction et méthode, bien que les concepts soient différents, les définitions sont très similaires. L'instruction de définition de fonction n'a pas de récepteur, nous pouvons donc définir l'instruction directement dans le fichier go et sous le package go.

func main() {
    sum := add(1, 2)
    fmt.Println(sum)
}

func add(a, b int) int {
    return a + b
}

Dans l'exemple, nous avons défini add comme une fonction. Sa signature de fonction est func add(a, b int) int. dans Sous un package go, il peut être appelé directement. Par exemple, la fonction main dans l'exemple appelle la fonction add. add就是一个函数，它的函数签名是func add(a, b int) int,没有接收者，直接定义在go的一个包之下，可以直接调用，比如例子中的main函数调用了add函数。

例子中的这个函数名称是小写开头的add，所以它的作用域只属于所声明的包内使用，不能被其他包使用，如果我们把函数名以大写字母开头，该函数的作用域就大了，可以被其他包调用。这也是Go语言中大小写的用处，比如Java中，就有专门的关键字来声明作用域private、protect、public等。

/*
 提供的常用库，有一些常用的方法，方便使用
*/
package lib

// 一个加法实现
// 返回a+b的值
func Add(a, b int) int {
    return a + b
}

如上例子中定义的Add方法就可以被其他包调用。

方法

方法的声明和函数类似，他们的区别是：方法在定义的时候，会在func和方法名之间增加一个参数，这个参数就是接收者，这样我们定义的这个方法就和接收者绑定在了一起，称之为这个接收者的方法。

type person struct {
    name string
}

func (p person) String() string{
    return "the person name is "+p.name
}

留意例子中，func和方法名之间增加的参数(p person),这个就是接收者。现在我们说，类型person有了一个String方法，现在我们看下如何使用它。

func main() {
    p:=person{name:"张三"}
    fmt.Println(p.String())
}

调用的方法非常简单，使用类型的变量进行调用即可，类型变量和方法之前是一个.操作符，表示要调用这个类型变量的某个方法的意思。

Go语言里有两种类型的接收者：值接收者和指针接收者。我们上面的例子中，就是使用值类型接收者的示例。

使用值类型接收者定义的方法，在调用的时候，使用的其实是值接收者的一个副本，所以对该值的任何操作，不会影响原来的类型变量。

func main() {
    p:=person{name:"张三"}
    p.modify() //值接收者，修改无效
    fmt.Println(p.String())
}

type person struct {
    name string
}

func (p person) String() string{
    return "the person name is "+p.name
}

func (p person) modify(){
    p.name = "李四"
}

以上的例子，打印出来的值还是张三，对其进行的修改无效。如果我们使用一个指针作为接收者，那么就会其作用了，因为指针接收者传递的是一个指向原值指针的副本，指针的副本，指向的还是原来类型的值，所以修改时，同时也会影响原来类型变量的值。

func main() {
    p:=person{name:"张三"}
    p.modify() //指针接收者，修改有效
    fmt.Println(p.String())
}

type person struct {
    name string
}

func (p person) String() string{
    return "the person name is "+p.name
}

func (p *person) modify(){
    p.name = "李四"
}

只需要改动一下，变成指针的接收者，就可以完成了修改。

在调用方法的时候，传递的接收者本质上都是副本，只不过一个是这个值副本，一是指向这个值指针的副本。指针具有指向原有值的特性，所以修改了指针指向的值，也就修改了原有的值。我们可以简单的理解为值接收者使用的是值的副本来调用方法，而指针接收者使用实际的值来调用方法。

在上面的例子中，有没有发现，我们在调用指针接收者方法的时候，使用的也是一个值的变量，并不是一个指针，如果我们使用下面的也是可以的。

p:=person{name:"张三"}
(&p).modify() //指针接收者，修改有效

这样也是可以的。如果我们没有这么强制使用指针进行调用，Go的编译器自动会帮我们取指针，以满足接收者的要求。

同样的，如果是一个值接收者的方法，使用指针也是可以调用的，Go编译器自动会解引用，以满足接收者的要求，比如例子中定义的String()

Le nom de la fonction dans l'exemple commence par add minuscule, donc sa portée n'appartient qu'au package déclaré et ne peut pas être utilisée par d'autres packages. Si nous commençons le nom de la fonction par une lettre majuscule, la portée. de la fonction est plus grande et peut être appelée par d’autres packages. C'est aussi l'utilisation des majuscules et des minuscules dans le langage Go. Par exemple, en Java, il existe des mots-clés spéciaux pour déclarer la portée private, protect, . public attendez.

p:=person{name:"张三"}
fmt.Println((&p).String())

La méthode Add définie dans l'exemple ci-dessus peut être appelée par d'autres packages. 🎜

🎜method🎜🎜🎜La déclaration de la méthode est similaire à celle de la fonction La différence est que lorsque la méthode est définie, un paramètre sera ajouté entre func et le nom de la méthode , ce paramètre est le récepteur, donc la méthode que nous définissons est liée au récepteur et est appelée la méthode du récepteur. 🎜<pre class="brush:js;toolbar:false"> ``` var p testMethod.Person p.Name = &quot;tom&quot; p.Age = 123 p.ShowInfo()</pre>🎜Faites attention au paramètre <code>(p person) ajouté entre func et le nom de la méthode dans l'exemple. Il s'agit du récepteur. Maintenant, nous disons que le type person a une méthode String, voyons maintenant comment l'utiliser. 🎜

```
func (person Person) ShowInfo(形参) 返回值{

   person.Name = "123"
   person.Age = 12
   fmt.Printf("name=%v,age=%v",person.Name,person.Age)
}
```
 
person为类型的形参，类型为Person

🎜La méthode d'appel est très simple, il suffit d'utiliser la variable de type pour appeler. La variable de type et la méthode sont précédées d'un opérateur ., ce qui signifie qu'une certaine méthode de ce type de variable doit être appelé. 🎜🎜Il existe deux types de récepteurs en langage Go : les récepteurs de valeurs et les récepteurs de pointeurs. Dans notre exemple ci-dessus, nous utilisons un récepteur de type valeur. 🎜🎜Utilisez la méthode définie par le récepteur de type valeur. Lorsqu'elle est appelée, une copie du récepteur de valeur est réellement utilisée, donc toute opération sur la valeur n'affectera pas la variable de type d'origine. 🎜

     ```
func (person *Person) ShowInfo(形参) 返回值{

   person.Name = "123"
   person.Age = 12
   fmt.Printf("name=%v,age=%v",person.Name,person.Age)
}

🎜Dans l'exemple ci-dessus, la valeur imprimée est toujours 张三 et les modifications qui y sont apportées ne sont pas valides. Si nous utilisons un pointeur comme récepteur, cela fonctionnera, car le récepteur du pointeur transmet une copie du pointeur à la valeur d'origine. La copie du pointeur pointe toujours vers la valeur du type d'origine, donc lorsqu'elle est modifiée, elle. affectera également la valeur de la variable de type d'origine. 🎜

func (person Person) ShowInfo(形参) 返回值{

   person.Name = "123"
   person.Age = 12
   fmt.Printf("name=%v,age=%v",person.Name,person.Age)
}

🎜 Il suffit de le changer et de devenir le récepteur du pointeur, et la modification est terminée. 🎜🎜🎜Lors de l'appel d'une méthode, les récepteurs transmis sont essentiellement des copies, mais l'un est une copie de la valeur et l'autre est une copie du pointeur pointant vers la valeur. Le pointeur a pour caractéristique de pointer vers la valeur d'origine, donc modifier la valeur pointée par le pointeur modifie également la valeur d'origine. Nous pouvons simplement comprendre que le récepteur de valeur utilise une copie de la valeur pour appeler la méthode, tandis que le récepteur du pointeur utilise la valeur réelle pour appeler la méthode. 🎜🎜🎜Dans l'exemple ci-dessus, avez-vous constaté que lorsque nous appelons la méthode du récepteur de pointeur, nous utilisons également une variable de valeur, pas un pointeur. C'est également correct si nous utilisons ce qui suit. 🎜

func test01(i *int) {


}

🎜C'est également possible. Si nous ne forçons pas l'utilisation de pointeurs pour les appels, le compilateur Go nous aidera automatiquement à obtenir que les pointeurs répondent aux exigences du destinataire. 🎜🎜De même, s'il s'agit d'une méthode de réception de valeur, elle peut également être appelée à l'aide d'un pointeur. Le compilateur Go déréférencera automatiquement pour répondre aux exigences du récepteur, telles que String()défini dans l'exemple >Méthodes. peut également être appelé comme ceci : 🎜rrreee🎜En bref, les appels de méthode peuvent utiliser soit des valeurs, soit des pointeurs. Nous n'avons pas besoin de les respecter strictement. Le compilateur du langage Go s'échappera automatiquement pour nous, ce qui est très pratique pour nous. développeurs. 🎜

不管是使用值接收者，还是指针接收者，一定要搞清楚类型的本质：对类型进行操作的时候，是要改变当前值，还是要创建一个新值进行返回？这些就可以决定我们是采用值传递，还是指针传递。

Go语言中方法和函数的区别

1、含义不同

函数function是一段具有独立功能的代码，可以被反复多次调用，从而实现代码复用。而方法method是一个类的行为功能，只有该类的对象才能调用。

2、方法有接受者，而函数无接受者

• Go语言的方法method是一种作用于特定类型变量的函数，这种特定类型变量叫做Receiver（接受者、接收者、接收器）； 

• 接受者的概念类似于传统面向对象语言中的this或self关键字；

• Go语言的接受者强调了方法具有作用对象，而函数没有作用对象； 

• 一个方法就是一个包含了接受者的函数； 

• Go语言中， 接受者的类型可以是任何类型，不仅仅是结构体， 也可以是struct类型外的其他任何类型。

3、函数不可以重名，而方法可以重名

只要接受者不同，则方法名可以一样。

4、调用方式不一样

方法是struct对象通过.点号+名称来调用，而函数是直接使用名称来调用。

方法的调用需要指定类型变量调用，函数则不需要

 ```
var p testMethod.Person
p.Name = "tom"
p.Age = 123
p.ShowInfo()

注：方法和函数的访问权限都受大小写影响，小写本包，大写全局

5、方法需要指定所属类型，可以是结构体也可以是自定义type，函数则通用

```
func (person Person) ShowInfo(形参) 返回值{

   person.Name = "123"
   person.Age = 12
   fmt.Printf("name=%v,age=%v",person.Name,person.Age)
}
```
 
person为类型的形参，类型为Person

6、函数的形参与传参类型需要一致，方法可以改变

     ```
func (person *Person) ShowInfo(形参) 返回值{

   person.Name = "123"
   person.Age = 12
   fmt.Printf("name=%v,age=%v",person.Name,person.Age)
}

（1）这里方法的类型形参为指针，调用时可以使用 p.ShowInfo()或者 (&p).ShowInfo(),本质上都是后者，只不过Go的设计者对于方法的调用做了底层优化

func (person Person) ShowInfo(形参) 返回值{

   person.Name = "123"
   person.Age = 12
   fmt.Printf("name=%v,age=%v",person.Name,person.Age)
}

（2）这里方法的形参类型为数值型，默认为值传递，而在调用时可以使用p.ShowInfo()或者 (&p).ShowInfo()，但依旧是值拷贝

func test01(i *int) {


}

（3）对于函数则需保持一致，需要的形参为指针，则传入的形参需为地址值，否则编译无法通过

【相关推荐：Go视频教程、编程教学】

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!