Tutorial básico do Golang

Controle de fluxo do Golang

Função & método do Golang

Estrutura do Golang

fatia & array do Golang

String do Golang

Ponteiro do Golang

Interface do Golang

Concorrência do Golang

Exceção do Golang (Error)

Outros itens do Golang

Métodos com Mesmo Nome do Go Palavra-chave Defer do Go

Método do Go (Go Method)

O Go suporta métodos. Os métodos do Go são semelhantes aos funções do Go, mas há uma diferença, que é que os métodos contêm um parâmetro de receptor. Com a ajuda do parâmetro de receptor, este método pode acessar os atributos do receptor. Aqui, o receptor pode ser do tipo estrutura ou do tipo não estrutural. Ao criar métodos no código, o receptor e o tipo do receptor devem estar no mesmo pacote. E não é permitido criar um método cujo tipo do receptor já foi definido em outro pacote, incluindo tipos internos como int, string, etc. Se você tentar fazer isso, o compilador lançará um erro.

Sintaxe:

func(reciver_name Type) method_name(parameter_list)(return_type){
　　　　//　Código
}

Aqui, você pode acessar o receptor dentro do método.

Método do receptor do tipo estrutura

No Go, você pode definir métodos cujo receptor seja do tipo de estrutura. Você pode acessar este receptor dentro do método, como mostrado no exemplo a seguir:

Exemplo

package main　
　　
import "fmt"
　　
//Estrutura Author
type author struct {　
　　　　name string　
　　　　branch string　
　　　　particles int
　　　　salary int
}　
　　
//Método do receptor　
func (a author) show() {　
　　
　　　　fmt.Println("Author's Name: ", a.name)　
　　　　fmt.Println("Branch Name: ", a.branch)　
　　　　fmt.Println("Artigos publicados: ", a.particles)　
　　　　fmt.Println("Salário: ", a.salary)　
}　
　　
func main() {　
　　
　　　　//Valores iniciais
　　　　//Estrutura Author
　　　　res := author{　
　　　　　　　　nome: "Sona",　
　　　　　　　　ramificação: "CSE",　
　　　　　　　　partículas:　203,　
　　　　　　　　salário:　　　　34000,　
　　　　}　
　　
　　　　//Chamada do método
　　　　res.show()　
}

Saída:

Nome do autor: Sona
Nome da ramificação: CSE
Artigos publicados:　　203
Salário:　　34000

Métodos do receptor de tipo não estruturado

No idioma Go, desde que o tipo e a definição do método estejam no mesmo pacote, é possível criar métodos com receptors de tipo não estruturado. Se eles existirem em pacotes diferentes, como int, string, etc., o compilador lançará um erro, pois eles são definidos em pacotes diferentes.

Exemplo

package main　
　　
import "fmt"
　　
//Definição de tipo
type data int
//Definir um método
//Receptor de tipo não estruturado　
func (d1　data) multiply(d2　data) data {　
　　　　return d1　*　d2　
}　
　　
/*　
//Se você tentar executar este código,
//Aí o compilador lançará um erro　
func(d1　int)multiply(d2　int)int{　
return d1　*　d2　
}　
*/
　　
func main() {　
　　　　value1　:= data(23)　
　　　　value2　:= data(20)　
　　　　res := value1.multiply(value2)　
　　　　fmt.Println("Resultado final: ", res)　
}

Saída:

Resultado final:　　460

Métodos do Go com receptor de ponteiro

No idioma Go, permite que você usePonteiroCriação de métodos de receptor. Com a ajuda de receptors de ponteiros, se as alterações feitas no método refletirão no chamador, isso é impossível para receptors de valor.

Sintaxe:

func (p　*Type) método_nome(...Type) Type {
　　　　//　Código
}

Exemplo

package main　
　　
import "fmt"
　　
//　Estrutura Author
type author struct {　
　　　　name string　
　　　　branch string　
　　　　particles int
}　
　　
//Método, usando receptor do tipo author
func (a　*author) show(abranch string) {　
　　　　(*a.branch = abranch　
}　
　　
//　Função principal　
func main() {　
　　
　　　　//Inicialização da estrutura author
　　　　res := author{　
　　　　　　　　name: "Sona",　
　　　　　　　　branch: "CSE",　
　　　　}　
　　
　　　　fmt.Println("Nome do autor: ", res.name)　
　　　　fmt.Println("Nome da ramificação (Antes): ", res.branch)　
　　
　　　　//Criação de um ponteiro
　　　　p := &res　
　　
　　　　//Chamada do método show
　　　　p.show("ECE")　
　　　　fmt.Println("Nome do autor: ", res.name)　
　　　　fmt.Println("Nome da ramificação (Depois): ", res.branch)　
}

Saída:

Nome do autor: Sona
Nome da ramificação (Antes): CSE
Nome do autor: Sona
Nome da ramificação (Depois): ECE

Métodos podem aceitar ponteiros e valores

Conhecido, em Go, quando uma função tem parâmetros de valor, ela aceita apenas o valor do parâmetro, se tentar passar um ponteiro para uma função de valor, ela não aceita, e vice-versa. Mas os métodos de Go podem aceitar valores e ponteiros, independentemente de serem definidos com receptor de ponteiro ou de valor. Como exemplo a seguir:

Exemplo

package main　
　　
import "fmt"
　　
//　Estrutura Author
type author struct {　
　　　　name string　
　　　　branch string　
}　
　　
//Método com ponteiro
//Receptor do tipo author
func (a　*author) show_1(abranch string) {　
　　　　(*a.branch = abranch　
}　
　　
//Método com valor
//Receptor do tipo autor　
func (a author) show_2() {　
　　　　a.name = "Gourav"
　　　　fmt.Println("Nome do autor (Antes): ", a.name)　
}　
　　
func main() {　
　　
　　　　　//Valores iniciais
　　　　　//Estrutura de autor
　　　　res := author{　
　　　　　　　　name: "Sona",　
　　　　　　　　branch: "CSE",　
　　　　}　
　　
　　　　fmt.Println("Nome da ramificação (Antes): ", res.branch)　
　　
　　　　　//Chamada de show_1Método
　　　　　//Método com valor (método de ponteiro)
　　　　res.show_1("ECE")　
　　　　fmt.Println("Nome da ramificação (Depois): ", res.branch)　
　　
　　　　　//Chamada de show_2Método
　　　　　//Método com ponteiro (método de valor)
　　　　(&res).show_2()　
　　　　fmt.Println("Nome do autor (Depois): ", res.name)　
}

Saída:

Nome da ramificação (Antes): CSE
Nome da ramificação (Depois): ECE
Nome do autor (Antes): Gourav
Nome do autor (Depois): Sona

Diferenças entre métodos e funções

Método	Função
Ele contém um receptor.	Ele não contém um receptor.
Ele pode aceitar tanto ponteiros quanto valores.	Ele não pode aceitar tanto ponteiros quanto valores ao mesmo tempo.
É possível definir métodos com o mesmo nome mas de diferentes tipos no programa.	A definição de funções com o mesmo nome mas de tipos diferentes não é permitida no programa.

Métodos com Mesmo Nome do Go Palavra-chave Defer do Go