Escrevendo funções em GO

Hoje vamos falar um pouco sobre um dos itens mais básico e importante de qualquer linguagem de programação, funções.

Funções nos ajudam a dividir o código de forma a ser reutilizável, diminuindo a quantidade de escrita de um bloco de código e facilitando a manutenção do programa. É claro que se alguém fizer uma função com 17 mil linhas de código, toda bagunçada e confusa, nada do que eu disse antes se torna verdade, mas sabemos que ninguém aqui faz ou já fez isso, certo? 😀

Assim como em qualquer outra linguagem, a premissa de uma função em Go é que ela execute somente aquilo que ela nasceu para executar. Dessa forma diminuímos a complexidade da função e aumentamos a possibilidade de reutilização da mesma.

A assinatura básica de uma função em Go segue o seguinte padrão:

func NOME_DA_FUNCAO(PARAMETROS) RETORNO_CASO_TENHA {
    // linhas com alguns bugs :D
}

Para ficar mais fácil de entender, vamos para um exemplo prático. Abaixo vamos iniciar uma função que tem objetivo somar valores.

func soma(a int, b int) int {
    return a + b
}

Simples não?! Porém podemos simplificá-la ainda mais! Sempre que temos dois ou mais parâmetros do mesmo tipo em sequência, podemos escrever todos os parâmetros e só colocar o tipo no final da lista.

func soma(a, b int) int {
    return a + b
}

Agora, e se eu quiser somar 3 valores? E 4? 10?…

Da forma como ela está escrita, teríamos que somar os 2 primeiros e usar o resultado para somar o próximo, até chegar ao fim da lista, ou seja, complexo e chato.

Para facilitar a vida de quem for utilizar essa função, vamos fazer uma pequena mudança nela.

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

// chamada da função
soma(2, 2, 3)

Quando adicionamos o ... logo após o nome de uma variável, o interpretador Go aceita de 0 à N valores, e transforma os valores passados em um array.

Existe mais uma mudança bacana que podemos fazer. Os retornos da função podem ser nomeados. Quando eles são, o interpretador inicia essa variáveis com seus valores default, o que no nossa caso seria o mesmo que fazer um var total int.

func soma(valores... int) (total int) {
    for _, valor := range valores {
        total += valor
    }
    return
}

// chamada da função
soma(2, 2, 3)

Outro detalhe que devemos prestar atenção, é que quando temos os retornos nomeados, o return no final da função não precisa ter as variáveis que ela vai retornar.

Sei que não faz muito sentido, mas só para questão de conhecimento, vamos dizer que nossa função vai retornar a soma de todos os valores e a quantidade de valores que foi passado para ela, ou seja, nossa função agora terá múltiplos retornos.

func soma(valores... int) (total int, qtde int) {
    qtde = len(valores)
    for _, valor := range valores {
        total += valor
    }
    return
}

// chamada da função
total, qtde := soma(2, 2, 3)
total, _ := soma(2, 3, 5) // para ignorar a quantidade de valores

Por último, mas não menos importante, como explicamos no post Nem private, nem public… Como trabalhar com visibilidade, essa função está fechada para ser usada somente dentro do package onde ela foi escrita.

Como queremos que ela seja utilizada em qualquer parte da nossa aplicação, vamos deixa pública.

func Soma(valores... int) (total int, qtde int) {
    qtde = len(valores)
    for _, valor := range valores {
        total += valor
    }
    return
}

Deixem suas dúvidas nos comentários.

Até a próxima!


Subscreva

Fique por dentro de tudo o que acontece no mundo Go.

Deixe uma resposta