Golang: Funções. (Parte 8)

Tem algumas opções legais para funções em Go. Vamos começar com o básico, segue alguns exemplos de funções simples.

package main
import "fmt"

func main() {
    // Função sem parâmetros e sem retorno
    funcSemParametrosSemRetorno()

    // Função com parâmetros
    resultado := funcComParametros(5, 10)
    fmt.Println("Resultado da função com parâmetros:", resultado)

    // Função com parametros e retorno
    soma := funcComRetorno(5, 10)
    fmt.Println("Resultado da função com retorno:", soma)

    // Função anônima
    funcAnonima := func(x, y int) int {
        return x + y
    }
    resultadoAnonimo := funcAnonima(5, 10)
    fmt.Println("Resultado da função anônima:", resultadoAnonimo)
}

// Função sem parâmetros e sem retorno
func funcSemParametrosSemRetorno() {
    fmt.Println("Esta é uma função sem parâmetros e sem retorno.")
}
// Função com parâmetros e sem retorno
func funcComParametros(a, b int) int {
    return a + b
}
// Função com retorno
func funcComRetorno(a, b int) int {
    return a + b
}
// Função anônima
func funcAnonima(x, y int) int {
    return x + y
}

Funções Variádicas, Múltiplos Retornos e Retorno Nomeado

Funções variádicas, funções com múltiplos retornos e funções com retorno nomeado. São recursos muito legais que o Go tem. É bem simples de entender, mas são bem úteis. Um reusmo rápido:

• Funções Variádicas: Permitem passar um número variável de argumentos para a função.
• Funções com Múltiplos Retornos: Retornam mais de um valor, útil para fornecer resultados adicionais ou erros.
• Funções com Retorno Nomeado: Facilitam a leitura e manutenção do código ao nomear os valores de retorno.

Segue exemplos dessas funcionalidades:

package main
import "fmt"

func main() {
    // Função variádica
    resultadoVariadico := funcVariadico(1, 2, 3, 4, 5)
    fmt.Println("Resultado da função variádica:", resultadoVariadico)

    // Função com múltiplos retornos
    soma, subtracao := funcComMultiplosRetornos(10, 5)
    fmt.Println("Resultado da função com múltiplos retornos:")
    fmt.Println("Soma:", soma)
    fmt.Println("Subtração:", subtracao)

    // Função com retorno nomeado
    somaNomeada, subtracaoNomeada := funcComRetornoNomeado(10, 5)
    fmt.Println("Resultado da função com retorno nomeado:")
    fmt.Println("Soma:", somaNomeada)
    fmt.Println("Subtração:", subtracaoNomeada)
}

// Função variádica
func funcVariadico(nums ...int) int {
    soma := 0
    for _, num := range nums {
        soma += num
    }
    return soma
}
// Função com múltiplos retornos
func funcComMultiplosRetornos(a, b int) (int, int) {
    return a + b, a - b
}
// Função com retorno nomeado
func funcComRetornoNomeado(a, b int) (soma int, subtracao int) {
    soma = a + b
    subtracao = a - b
    return
}

Closures

Golang também tem suporte a closures. É um conceito um pouco mais avançado, mas nada demais. O conceito é simples: uma função que retorna outra função, e essa função interna tem acesso a variáveis da função externa.

Exemplo simples:

package main
import "fmt"
func main() {
    
    proximoInt := gerarProximoInt()
    fmt.Println(proximoInt()) // Saída: 0
    fmt.Println(proximoInt()) // Saída: 1
    fmt.Println(proximoInt()) // Saída: 2
    proximoInt2 := gerarProximoInt()
    fmt.Println(proximoInt2()) // Saída: 0
    fmt.Println(proximoInt2()) // Saída: 1
}

func gerarProximoInt() func() int {
    i := 0
    return func() int {
        i++
        return i - 1
    }
}

Explicando o código:

• A função gerarProximoInt cria uma variável i inicializada como 0.
• Retorna uma função anônima que incrementa i e retorna o valor anterior ao incremento (i - 1).
• Cada chamada de proximoInt() usa a mesma instância de i, enquanto proximoInt2() cria uma nova instância independente.

Saída: proximoInt() gera 0, 1, 2 porque compartilha o mesmo i. proximoInt2() reinicia o contador, gerando 0, 1.

Tem mais tópicos interessantes sobre funções, como o uso de goroutines e a palavra-chave defer. Porém, esses assuntos vou entrar a fundo mais pra frente.