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 que um método é associado a um tipo podemos podemos invocá-lo utilizando o nome da variável declarada desse tipo.

Os métodos possuem as mesmas características das funções, exceto pela associação a um tipo de dado, sendo necessário conhecimento de para acompanhar esta parte do tutorial.

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( <lista_parametros> )(<tipos_retorno){
//corpo
}

Sintaxe: Uso

nome_variavel.nome_metodo(<lista_parametros>)

Onde

param_receptor: nome do parâmetro receptor
tipo_receptor: tipo de dado do receptor do método
<parametros>: lista de parâemetros do método
<tipos_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 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 de um parâmetro para informar que um array será usado.

Sintaxe

func (val meu_tipo) nome_metodo( nome_parametro ...tipo_dado) {
//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) {
//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 detalhes e exemplo 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_retornoN {
 //...

  return <lista_valores_retorno>
}

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/09/2025 - revisão 4 - Ajustes: pontuais, objetivos e sintaxes
2. 09/04/2025 - revisão 3 - Parâmetros variáveis/diferentes tipos, retornando mais de um valor
3. 17/09/2024 - revisão 2 - Correção em sintaxe Declaração/Uso; pequenos ajustes gramaticais
4. 03/10/2023 - revisão 1 - Correção em referências e erros gramaticais
5. 21/08/2023 - versão inicial