Was ist der Unterschied zwischen Methoden und Funktionen in der Go-Sprache?

Unterschied: 1. Eine Funktion ist ein Teil des Codes mit unabhängigen Funktionen, der viele Male wiederholt aufgerufen werden kann, um eine Wiederverwendung des Codes zu erreichen, während die Methode die Verhaltensfunktion einer Klasse ist und nur von Objekten dieser Klasse aufgerufen werden kann. 2. Methoden haben Empfänger, aber Funktionen haben keine Empfänger. 3. Funktionen können nicht denselben Namen haben, Methoden können jedoch denselben Namen haben. 4. Die Aufrufmethoden sind unterschiedlich. 5. Die Methode muss ihren Typ angeben, der eine Struktur oder ein benutzerdefinierter Typ sein kann, während Funktionen universell sind. 6. Die Form und der Parametertyp der Funktion müssen konsistent sein und die Methode kann geändert werden.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

In der Go-Sprache sind Funktionen und Methoden unterschiedlich und weisen klare konzeptionelle Unterschiede auf. In anderen Sprachen wie Java ist eine Funktion im Allgemeinen eine Methode, und eine Methode ist eine Funktion. In der Go-Sprache bezieht sich eine Funktion jedoch auf eine Methode, die keiner Struktur oder keinem Typ angehört , eine Funktion hat keinen Empfänger; Methoden haben Empfänger. Die Methoden, über die wir sprechen, gehören entweder zu einer Struktur oder zu einem neu definierten Typ.

Funktion

Funktion und Methode, obwohl die Konzepte unterschiedlich sind, sind die Definitionen sehr ähnlich. Die Funktionsdefinitionsanweisung hat keinen Empfänger, daher können wir die Anweisung direkt in der Go-Datei und unter dem Go-Paket definieren.

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

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

Im Beispiel haben wir add als Funktion definiert. Ihre Funktionssignatur ist func add(a, b int) int. Sie hat keinen Empfänger und ist direkt definiert In einem Go-Paket kann es beispielsweise direkt aufgerufen werden. Die Funktion main im Beispiel ruft die Funktion add auf. 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()

Der Funktionsname im Beispiel beginnt mit dem Kleinbuchstaben add, sodass sein Gültigkeitsbereich nur zum deklarierten Paket gehört und nicht von anderen Paketen verwendet werden kann. Wenn wir den Funktionsnamen mit einem Großbuchstaben beginnen, ist der Gültigkeitsbereich der Funktion ist größer und kann von anderen Paketen aufgerufen werden. Dies ist auch die Verwendung von Groß- und Kleinschreibung in der Go-Sprache. Beispielsweise gibt es in Java spezielle Schlüsselwörter, um den Bereich private, protect, zu deklarieren öffentlich warten.

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

Die im obigen Beispiel definierte Methode Add kann von anderen Paketen aufgerufen werden. 🎜

🎜method🎜🎜🎜Die Deklaration der Methode ähnelt der der Funktion. Der Unterschied besteht darin, dass beim Definieren der Methode ein Parameter zwischen funchinzugefügt wird > und der Methodenname, dieser Parameter ist der Empfänger, daher ist die von uns definierte Methode an den Empfänger gebunden und wird als Methode des Empfängers bezeichnet. 🎜

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

🎜Achten Sie auf den Parameter (p person), der im Beispiel zwischen func und dem Methodennamen hinzugefügt wurde. Jetzt sagen wir, dass der Typ person eine String-Methode hat. Nun wollen wir sehen, wie man sie verwendet. 🎜

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

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

🎜Die aufrufende Methode ist sehr einfach. Verwenden Sie zum Aufrufen einfach die Typvariable. Der Typvariablen und der Methode wird ein .-Operator vorangestellt, was bedeutet, dass eine bestimmte Methode dieser Typvariable sein soll angerufen. 🎜🎜In der Go-Sprache gibt es zwei Arten von Empfängern: Wertempfänger und Zeigerempfänger. In unserem obigen Beispiel verwenden wir einen Empfänger vom Typ Wert. 🎜🎜Verwenden Sie die vom Werttypempfänger definierte Methode. Beim Aufruf wird tatsächlich eine Kopie des Wertempfängers verwendet, sodass sich jede Operation am Wert nicht auf die ursprüngliche Typvariable auswirkt. 🎜

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

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

🎜Im obigen Beispiel ist der gedruckte Wert immer noch 张三 und Änderungen daran sind ungültig. Wenn wir einen Zeiger als Empfänger verwenden, funktioniert es, da der Zeigerempfänger eine Kopie des Zeigers auf den ursprünglichen Wert übergibt. Die Kopie des Zeigers zeigt immer noch auf den Wert des ursprünglichen Typs, also wenn er geändert wird will Beeinflusst auch den Wert der ursprünglichen Typvariablen. 🎜

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

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

🎜 Ändern Sie es einfach und werden Sie zum Empfänger des Zeigers, und die Änderung ist abgeschlossen. 🎜🎜🎜Beim Aufrufen einer Methode sind die übergebenen Empfänger im Wesentlichen Kopien, aber einer ist eine Kopie des Werts und der andere ist eine Kopie des Zeigers, der auf den Wert zeigt. Der Zeiger hat die Eigenschaft, auf den ursprünglichen Wert zu zeigen. Wenn Sie also den Wert ändern, auf den der Zeiger zeigt, wird auch der ursprüngliche Wert geändert. Wir können einfach verstehen, dass der Wertempfänger eine Kopie des Werts verwendet, um die Methode aufzurufen, während der Zeigerempfänger den tatsächlichen Wert verwendet, um die Methode aufzurufen. 🎜🎜🎜Haben Sie im obigen Beispiel festgestellt, dass wir beim Aufrufen der Zeigerempfängermethode auch eine Wertvariable und keinen Zeiger verwenden? Es ist auch in Ordnung, wenn wir Folgendes verwenden. 🎜

func test01(i *int) {


}

🎜Das ist auch möglich. Wenn wir die Verwendung von Zeigern für Aufrufe nicht erzwingen, hilft uns der Go-Compiler automatisch dabei, die Zeiger so zu erhalten, dass sie den Anforderungen des Empfängers entsprechen. 🎜🎜Wenn es sich um eine Methode eines Wertempfängers handelt, kann sie auch mithilfe eines Zeigers aufgerufen werden. Der Go-Compiler dereferenziert automatisch, um die Anforderungen des Empfängers zu erfüllen, z. B. den in definierten String()Das Beispiel >Methoden können auch so aufgerufen werden: 🎜rrreee🎜Kurz gesagt, Methodenaufrufe können entweder Werte oder Zeiger verwenden. Der Go-Sprachcompiler wird automatisch entkommen Für uns Entwickler sehr praktisch. 🎜

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

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视频教程、编程教学】

Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen Methoden und Funktionen in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!