Tutorial di base Go

Controllo delle istruzioni Go

Funzione & Metodo Go

Struttura Go

Taglia Go & Array

Stringa Go (String)

Puntatore Go

Interfaccia Go

Concordanza Go (Concurrency)

Eccezioni Go (Error)

Altri argomenti Go

Metodo同名 Go Parola chiave Defer Go

Metodo (Method) in Go Linguaggio

Go supporta i metodi. I metodi Go sono simili ai funzioni Go, ma hanno una differenza: contengono un parametro ricevente. Con l'aiuto del parametro ricevente, questo metodo può accedere alle proprietà del ricevente. In questo caso, il ricevente può essere di tipo struttura o non struttura. Quando si crea un metodo nel codice, il ricevente e il tipo del ricevente devono apparire nello stesso pacchetto. Non è permesso creare un metodo con un tipo ricevente già definito in un altro pacchetto, inclusi i tipi nativi come int, string e altri. Se si tenta di fare questo, il compilatore genererà un errore.

Sintassi:

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

In questo caso, è possibile accedere al ricevente all'interno del metodo.

Metodo del ricevente di tipo struttura

In Go, è possibile definire metodi con il ricevente di tipo struttura. All'interno del metodo, è possibile accedere a questo ricevente, come mostrato nell'esempio seguente:

Esempio

package main　
　　
import "fmt"
　　
//Struttura Author
type author struct {　
　　　　name string　
　　　　branch string　
　　　　particles int
　　　　salary int
}　
　　
//Metodo del ricevente　
func (a author) show() {　
　　
　　　　fmt.Println("Nome dell'autore: ", a.name)　
　　　　fmt.Println("Nome ramo: ", a.branch)　
　　　　fmt.Println("Articoli pubblicati: ", a.particles)　
　　　　fmt.Println("Stipendio: ", a.salary)　
}　
　　
func main() {　
　　
　　　　//Valori iniziali
　　　　//Struttura Author
　　　　res := author{　
　　　　　　　　nome: "Sona",　
　　　　　　　　ramo: "CSE",　
　　　　　　　　particelle: 203,　
　　　　　　　　stipendio: 34000,　
　　　　}　
　　
　　　　//Chiamata al metodo
　　　　res.show()　
}

Output:

Nome dell'autore: Sona
Nome del ramo: CSE
Articoli pubblicati: 203
Stipendio: 34000

Metodi con ricevitore non strutturato

In Go, è possibile utilizzare i ricevitori di tipo non strutturato per creare metodi, purché il tipo e la definizione del metodo esistano nello stesso pacchetto. Se esistono in pacchetti diversi come int, string, ecc., il compilatore genererà un errore perché sono definiti in pacchetti diversi.

Esempio

package main　
　　
import "fmt"
　　
//Definizione del tipo
type data int
//Definisci un metodo
//Ricevitore non strutturato　
func (d1 data) multiply(d2 data) data {　
　　　　return d1 * d2　
}　
　　
/*　
//Se provi a eseguire questo codice:
//Il compilatore genererà un errore　
func(d1 int)multiply(d2 int)int{　
return d1 * d2　
}　
*/
　　
func main() {　
　　　　value1 := data(23)　
　　　　value2 := data(20)　
　　　　res := value1.multiply(value2)　
　　　　fmt.Println("Risultato finale: ", res)　
}

Output:

Risultato finale: 460

Metodi Go con ricevitore puntatore

In Go, è permesso utilizzarePuntatoreCreazione del metodo ricevitore. Con l'aiuto del ricevitore puntatore, se le modifiche fatte nel metodo si riflettono nel chiamante, questo è impossibile per i ricevitori di valore.

Sintassi:

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

Esempio

package main　
　　
import "fmt"
　　
//Struttura Author
type author struct {　
　　　　name string　
　　　　branch string　
　　　　particles int
}　
　　
//Metodo, utilizza il ricevitore di tipo author
func (a *author) show(abranch string) {　
　　　　(*a).branch = abranch　
}　
　　
//Funzione principale　
func main() {　
　　
　　　　//Inizializzazione della struttura author
　　　　res := author{　
　　　　　　　　name: "Sona",　
　　　　　　　　branch: "CSE",　
　　　　}　
　　
　　　　fmt.Println("Nome dell'autore: ", res.name)　
　　　　fmt.Println("Nome del ramo (Prima): ", res.branch)　
　　
　　　　//Creazione di un puntatore
　　　　p := &res　
　　
　　　　//Chiamata al metodo show
　　　　p.show("ECE")　
　　　　fmt.Println("Nome dell'autore: ", res.name)　
　　　　fmt.Println("Nome del ramo (Dopo): ", res.branch)　
}

Output:

Nome dell'autore: Sona
Nome del ramo (Prima): CSE
Nome dell'autore: Sona
Nome del ramo (Dopo): ECE

I metodi possono accettare sia valori che puntatori

Notoriamente, in Go, quando una funzione ha un parametro di valore, accetta solo il valore del parametro. Se tenti di passare un puntatore a una funzione di valore, non lo accetterà, e viceversa. Ma i metodi Go possono accettare sia valori che puntatori, indipendentemente dal fatto che siano definiti con un ricevitore di valore o di puntatore. come mostrato nell'esempio seguente:

Esempio

package main　
　　
import "fmt"
　　
//Struttura Author
type author struct {　
　　　　name string　
　　　　branch string　
}　
　　
//Metodo con puntatore
//Ricevitore del tipo autore
func (a *author) show_1(abranch string) {　
　　　　(*a).branch = abranch　
}　
　　
//Metodo con valore
//Ricevitore del tipo autore　
func (a author) show_2() {　
　　　　a.name = "Gourav"
　　　　fmt.Println("Nome dell'autore (Prima) : ", a.name)　
}　
　　
func main() {　
　　
　　　　　//Valori iniziali
　　　　　//Struttura dell'autore
　　　　res := author{　
　　　　　　　　name: "Sona",　
　　　　　　　　branch: "CSE",　
　　　　}　
　　
　　　　fmt.Println("Nome del ramo (Prima): ", res.branch)　
　　
　　　　　//Chiamata al metodo show_1
　　　　　//Metodo con valore (valore di puntatore)
　　　　res.show_1("ECE")　
　　　　fmt.Println("Nome del ramo (Dopo): ", res.branch)　
　　
　　　　　//Chiamata al metodo show_2
　　　　　//Metodo con valore (valore di puntatore)
　　　　(&res).show_2()　
　　　　fmt.Println("Nome dell'autore (Dopo): ", res.name)　
}

Output:

Nome del ramo (Prima): CSE
Nome del ramo (Dopo): ECE
Nome dell'autore (Prima): Gourav
Nome dell'autore (Dopo): Sona

Differenze tra metodo e funzione

Metodo	Funzione
Contiene un ricevitore.	Non contiene un ricevitore.
Può accettare sia puntatori che valori.	Non può accettare contemporaneamente puntatori e valori.
È possibile definire metodi con lo stesso nome ma di tipo diverso nel programma.	Non è permesso definire funzioni con lo stesso nome ma di tipo diverso nel programma.

Metodo同名 Go Parola chiave Defer Go