Funções

Em Go, uma função é declarada com a palavra-chave func. Sua estrutura básica é:

func executar() {
    // corpo da função
}

Os componentes de uma função são:

1. A palavra-chave func inicia a declaração.
2. O nome da função (exemplo: executar) segue as regras de identificadores de Go (não pode começar com número).
3. Os parênteses () são obrigatórios; neles, definimos os parâmetros (vazios aqui).
4. Após os parênteses, pode vir o tipo de retorno (omitido quando não há).
5. As chaves {} delimitam o corpo onde a lógica é implementada.

Declaração Completa

func nomeDaFuncao(parametros) tipoRetorno {
    // código
}

Uma assinatura de função inclui: palavra-chave func, nome, parâmetros (opcionias), tipo(s) de retorno (oppcionais) e corpo.

Funções com Múltiplos Retornos

// Múltiplos retornos são agrupados entre parênteses
func calcular(a int, b int) (int, error) {
    if a < 0 || b < 0 {
        return -1, errors.New("valores negativos não permitidos")
    }
    return a + b, nil
}

func main() {
    resultado, erro := calcular(-1, -1)
    if erro != nil {
        fmt.Println(erro)
    } else {
        fmt.Println(resultado)
    }
}

// Retornos nomeados: não precisam ser explicitados no return
func calcularSoma(a int, b int) (soma int, erro error) {
    soma = a + b
    erro = nil
    return
}

Parâmetros Variádicos

func somar(valores ...int) int {
    total := 0
    for _, v := range valores {
        total += v
    }
    return total
}

Se houver parâmetros comuns e variádicos, o parâmetro variádico deve ser o último:

func processar(prefixo string, valores ...int) int {
    total := 0
    for _, v := range valores {
        total += v
    }
    return total
}

Visibilidade (Exportada vs Não Exportada)

• Funções com nome iniciendo em minúscula são privadas ao pacote.
• Funções com nome iniciando em maiúscula são públicas e podem ser usadas por outros pacotes.
• Go não usa public/private; o caso da primeira letra define a visibilidade.

// Função pública
func Somar(a int, b int) int {
    return a + b
}

Funções Anônimas e Closures

func exemplo() {
    somar := func(a int, b int) int {
        return a + b
    }
    fmt.Println(somar(1, 2))
}

Funções anônimas podem ser atribuídas a variáveis e usadas como closures, capturando variáveis do escopo externo.

Métodos vs Funções

Em Go, métodos são funções associadas a um tipo específico por meio de um receiver. O receiver conecta a função ao tipo, tornando-a um método desse tipo.

No exemplo abaixo, criamos um novo tipo Nome baseado em string e um método que age sobre ele:

type Nome string

func (n Nome) exibir() {
    fmt.Println("O nome é:", n)
}

// Uso
var nomeVar Nome = "João"
nomeVar.exibir()