Golang-Basisanleitung

Golang-Kontrollanweisungen

Golang-Funktion & Methode

Golang-Struktur

Golang-Schnittstelle & Array

Golang-String

Golang-Pfeil

Golang-Schnittstelle

Golang-Parallelität

Golang-Ausnahmen (Error)

Andere Golang-Bereiche

Go Namensgleiche Methoden Go Defer Schlüsselwort

Go-Methode (Method)

Go unterstützt Methoden. Go-Methoden sind ähnlich wie Go-Funktionen, aber mit einem Unterschied: Methoden enthalten einen Receiver-Parameter. Mit Hilfe dieses Receiver-Parameters kann die Methode auf die Eigenschaften des Receivers zugreifen. Hier kann der Receiver ein Strukturtyp oder ein nicht strukturierter Typ sein. Beim Erstellen von Methoden in der Code must der Receiver und der Receiver-Typ im selben Paket vorhanden sein. Und es ist nicht erlaubt, eine Methode zu erstellen, deren Receiver-Typ bereits in einem anderen Paket definiert ist, einschließlich der eingebauten Typen wie int, string und so weiter. Wenn Sie dies tun, wirft der Compiler einen Fehler aus.

Syntax:

func(reciver_name Type) method_name(parameter_list)(return_type){
　　　　//　Code
}

Hier kann der Receiver innerhalb der Methode aufgerufen werden.

Methode des Strukturtyp-Receivers

In der Programmiersprache Go ist es erlaubt, Methoden mit Strukturtyp-Receiver zu definieren. Innerhalb der Methode kann dieser Receiver wie im folgenden Beispiel gezeigt werden aufgerufen werden:

Example

package main　
　　
import "fmt"
　　
//Author structure
type author struct {　
　　　　name string　
　　　　branch string　
　　　　particles int
　　　　salary int
}　
　　
//Methode des Empfängers　
func (a author) show() {　
　　
　　　　fmt.Println("Author's Name: ", a.name)　
　　　　fmt.Println("Branch Name: ", a.branch)　
　　　　fmt.Println("Veröffentlichte Artikel: ", a.particles)　
　　　　fmt.Println(" Gehalt: ", a.salary)　
}　
　　
func main() {　
　　
　　　　//Initialization values
　　　　//Author-Struktur
　　　　res := author{　
　　　　　　　　Name: 		"Sona",　
　　　　　　　　Abteilung: 	"CSE",　
　　　　　　　　Teilchen:　203,　
　　　　　　　　Gehalt:　　　　34000,　
　　　　}　
　　
　　　　//Methode aufrufen
　　　　res.show()　
}

Output:

Autor's Name: 	Sona
Abteilung Name: 	CSE
Veröffentlichte Artikel:　　203
Gehalt:　　34000

Methoden mit nicht strukturartigen Typen als Receiver

In der Programmiersprache Go kann man Methoden mit nicht strukturartigen Typen als Receiver erstellen, solange der Typ und die Methodendefinition im selben Paket existieren. Falls sie in verschiedenen Paketen wie int, string usw. existieren, wirft der Compiler einen Fehler, da sie in verschiedenen Paketen definiert sind.

Example

package main　
　　
import "fmt"
　　
//Typedefinition
type data int
//Definieren Sie eine Methode
//Receiver für nicht strukturartige Typen　
func (d1　data) multiply(d2　data) data {　
　　　　return d1　*　d2　
}　
　　
/*　
//Wenn Sie versuchen, diesen Code auszuführen,
//Dann wirft der Compiler einen Fehler　
func(d1　int)multiply(d2　int)int{　
return d1　*　d2　
}　
*/
　　
func main() {　
　　　　value1　:= data(23)　
　　　　value2　:= data(20)　
　　　　res := value1.multiply(value2)　
　　　　fmt.Println("Endliches Ergebnis: ", res)　
}

Output:

Endliches Ergebnis:　　460

Go-Methode mit Zeigerreceiver

In der Programmiersprache Go ist es Ihnen erlaubt,ZeigerErstellung von Methodenreceivern. Unter Verwendung von Zeigerreceivern, falls die im Methodenaufruf durchgeführten Änderungen im Aufrufer reflektiert werden sollen, was bei Wertreceivern unmöglich ist.

Syntax:

func (p　*Type) method_name(...Type) Type {
　　　　//　Code
}

Example

package main　
　　
import "fmt"
　　
//　Author structure
type author struct {　
　　　　name string　
　　　　branch string　
　　　　particles int
}　
　　
//Methode, die einen Receiver vom Typ author verwendet
func (a　*author) show(abranch string) {　
　　　　(*a).branch = abranch　
}　
　　
//　Hauptfunktion　
func main() {　
　　
　　　　//Initialisierung des author-Strukturentyps
　　　　res := author{　
　　　　　　　　name: "Sona",　
　　　　　　　　branch: "CSE",　
　　　　}　
　　
　　　　fmt.Println("Autor's name: ", res.name)　
　　　　fmt.Println("Branch Name (Before): ", res.branch)　
　　
　　　　//Erstellung eines Zeigers
　　　　p := &res　
　　
　　　　//Aufruf der show-Methode
　　　　p.show("ECE")　
　　　　fmt.Println("Autor's name: ", res.name)　
　　　　fmt.Println("Branch Name (After): ", res.branch)　
}

Output:

Author's name: Sona
Branch Name (Before): CSE
Author's name: Sona
Branch Name (After): ECE

Methods can accept pointers and values

As everyone knows, in Go, when a function has a value parameter, it will only accept the value of the parameter. If you try to pass a pointer to a value function, it will not accept it, and vice versa. However, Go methods can accept both values and pointers, regardless of whether they are defined with a pointer or value receiver. As shown in the following example:

Example

package main　
　　
import "fmt"
　　
//　Author structure
type author struct {　
　　　　name string　
　　　　branch string　
}　
　　
//Method with pointer
//Receiver of author type
func (a　*author) show_1(abranch string) {　
　　　　(*a).branch = abranch　
}　
　　
//Method with value
//Receiver of author type　
func (a author) show_2() {　
　　　　a.name = "Gourav"
　　　　fmt.Println("Author's name (Before): ", a.name)　
}　
　　
func main() {　
　　
　　　　　//Initialization values
　　　　　//Author structure
　　　　res := author{　
　　　　　　　　name: "Sona",　
　　　　　　　　branch: "CSE",　
　　　　}　
　　
　　　　fmt.Println("Branch Name (Before): ", res.branch)　
　　
　　　　　//Call show_1Method
　　　　　//Method with value (pointer method)
　　　　res.show_1("ECE")　
　　　　fmt.Println("Branch Name (After): ", res.branch)　
　　
　　　　　//Call show_2Method
　　　　　//Method with pointer (value method)
　　　　(&res).show_2()　
　　　　fmt.Println("Author's name (After): ", res.name)　
}

Output:

Branch Name (Before): CSE
Branch Name (After): ECE
Author's name (Before): Gourav
Author's name (After): Sona

Differences between methods and functions

Method	Function
It contains a receiver.	It does not contain a receiver.
It can accept pointers and values.	It cannot accept pointers and values at the same time.
You can define methods with the same name but different types in the program.	In the program, it is not allowed to define functions with the same name but different types.

Go Namensgleiche Methoden Go Defer Schlüsselwort