A linguagem Go suporta métodos, mesmo que esse conceito pertença a linguagens orientadas a objetos.

Os métodos em Go são funções que contém um receptor de tipo de dados a qual um método será associado. Uma vez associado podemos utilizá-lo como método de um determinado tipo. Os métodos possuem as mesmas características das funções.

Para acompanhar esta parte do tutorial é necessário ter conhecimento de Go: Funções, exceto pela associação mencionada acima.

Para a declaração de um método em Go, utilizamos a sintaxe mostrada abaixo:

Sintaxe : Declaração

func(param_receptor tipo_receptor) nome_metodo(parametros)(tipo_retorno){
//corpo
}

Sintaxe: Uso

nome_variavel.nome_metodo(parametros)

Onde

param_receptor: nome do parâmetro receptor
tipo_receptor: tipo de dado do receptor
parametros: lista de parâemetros do método
tipo_retorno: lista de tipos de dados de retorno

Tanto o tipo de dado receptor quanto o método devem estar codificados em mesmo package.

Exemplo 1

package main
import "fmt"

type meu_tipo struct {
	valor string
	id    int
}

func (val meu_tipo) Show() {
	fmt.Printf("%s / %d", val.valor, val.id)
}

func main() {

	teste := meu_tipo{"Teste", 999}
	teste.Show()
}

Saída

Teste / 999

Um método não pode ser criado e associado aos tipos de dados primitivos da Linguagem Go ou tipos incluídos em outras packages. Para utilizar os tipos primitivos, será necessário criar um novo tipo utilizando o comando type.

Exemplo 2

type meu_tipo uint8 //novo tipo criado

func (val meu_tipo) ToBinary(p int){
  fmt.Printf("b:%b", val)  //impressão em binário
}

func main() {
  teste:=meu_tipo(0xaa)
  teste.ToBinary(10)
}

Saída

b:10101010

É possível criarmos métodos com o mesmo nome, porém, devem ter o tipo de dado do receptor diferentes como pode ser visto no exemplo abaixo.

Exemplo 3

package main

import (
	"fmt"
)

type meu_tipo uint8 //novo tipo criado
type meu_tipo2 uint8

func (val meu_tipo) ToBinary() {
	fmt.Printf("b:%b", val) //impressão em binário
}

func (val meu_tipo2) ToBinary() {
	fmt.Printf("b:%b", val) //impressão em binário
}

func main() {
	teste := meu_tipo(0xaa)
	teste.ToBinary()
	fmt.Println()
	teste2 := meu_tipo2(0xaa)
	teste2.ToBinary()
}

Saída

b:10101010

Um método em Go permite que seja possível declará-lo de forma a aceitar um número variável de parâmetros. Isso é feito com auxílio do operador (...) que deve ser usado como prefixo que tem como objetivo armazenar os parâmetros em um array ou vetor.

Sintaxe

func  (val meu_tipo) nome_metodo( nome_parametro ...tipo_dado) tipo_retorno {
//corpo função
}

Caso seja necessário adicionar outros parâmetros à função, o parâmetro contendo o operador (...) deve ser o último.

Sintaxe

func (val meu_tipo) nome_metodo( nome_parametro1 tipo_dado1, nome_parametroN ...tipo_dadoN) tipo_retorno {
//corpo função
}

No exemplo abaixo, vamos utilizar o comando de repetição for e a função range para percorrer a lista parâmetros demonstrando o que foi discutido nesta parte do tutorial:

Exemplo 4

package main
import "fmt"

type meu_tipo struct {
	valor string
	id    int
}

func (val meu_tipo) Show(desc string, nums ...int) {
    fmt.Println(desc);
	for _,i := range nums{
	    fmt.Print(i)
	}
}

func main() {
	teste := meu_tipo{"Teste", 999}
	teste.Show("teste",1,2,3,4,5,6,7)
}

Saída

1234567

Por padrão, Go não permite o uso do operador (...) para diferentes tipos de dados. Para tal, é necessário utilizar uma interface:

Sintaxe

func (val meu_tipo) nome_metodo(nome_parametro ...interface{}){
//corpo
}

No exemplo abaixo, vamos utilizar o comando de repetição for e a função range para percorrer a lista parâmetros demonstrando o que foi discutido acima:

Exemplo 5

package main
import "fmt"

type meu_tipo struct {
	valor string
	id    int
}

func (val meu_tipo) Show(params ...interface{}) {
	for _,i := range params{
	    fmt.Print(i)
	}
}

func main() {
	teste := meu_tipo{"Teste", 999}
	teste.Show("teste",1,2,3,4,5,6,7)
}

Saída

teste1234567

O assunto interface foi visto com mais informações em POO: Interface.

Como um método é uma função associada a um tipo de dados. Os métodos também podem retornar mais de um valor bem como associar um nome a valor de retorno:

Sintaxe

func (val meu_tipo) nome_metodo(parametros) tipo_retorno1, tipo_retorno2 {
//corpo função
  return valor1, valor2
}

Exemplo 6

package main
import "fmt"

type meu_tipo struct {
	valor string
	id    int
}

func (val meu_tipo) Show(p int, s string) (int, string) {
    //corpo omitido
    return p,s
}
//retorno nomeado
func (val meu_tipo) Show2(p int, s string) (reti int, rets string) {
    //corpo omitido
    reti = p
    rets = s 
    return
}

func main() {
	teste := meu_tipo{"Teste", 999}
	val,desc := teste.Show(1,"teste");
	fmt.Println(val,desc)
	fmt.Print(teste.Show2(1,"teste"))
}

Saída

1 teste
1teste

O assunto interface foi visto com mais informações em POO: Interface.

1. 09/04/2025 - revisão 3 - Parâmetros variáveis/diferentes tipos, retornando mais de um valor
2. 17/09/2024 - revisão 2 - Correção em sintaxe Declaração/Uso; pequenos ajustes gramaticais
3. 03/10/2023 - revisão 1 - Correção em referências e erros gramaticais
4. 21/08/2023 - versão inicial