Base de Conhecimento

Introdução

Uma função é uma seção de código que, uma vez definida, pode ser reutilizada. As funções são usadas para facilitar a compreensão do código, dividindo-o em tarefas pequenas e compreensíveis que podem ser usadas mais de uma vez em todo o programa.

Navegue com uma poderosa biblioteca padrão que possui muitas funções predefinidas. Os que você provavelmente já conhece do pacote fmt são:

• fmt.Println() que imprimirá objetos para padronizar (provavelmente seu terminal).
• fmt.Printf() o que permitirá que você formate sua saída impressa.

Os nomes das funções incluem parênteses e podem incluir parâmetros.

Neste tutorial, veremos como definir suas próprias funções para usar em seus projetos de codificação.

Definindo uma Função

Vamos começar transformando o programa clássico "Olá, mundo!" Em uma função.

Criaremos um novo arquivo de texto em nosso editor de texto preferido e chamaremos o programa hello.go. Então, definiremos a função.

Uma função é definida usando a funcpalavra - chave Em seguida, é seguido por um nome de sua escolha e um conjunto de parênteses que contém todos os parâmetros que a função usará (eles podem estar vazios). As linhas do código de função estão entre colchetes {}.

Nesse caso, definiremos uma função denominada hello():

func hello() {}

Isso configura a instrução inicial para criar uma função.

A partir daqui, adicionaremos uma segunda linha para fornecer as instruções para o que a função faz. Nesse caso, imprimiremos Hello, World!no console:

func hello() {
    fmt.Println("Hello, World!")
}

Nossa função agora está totalmente definida, mas se executarmos o programa neste momento, nada acontecerá desde que não chamamos a função.

Então, dentro do nosso main()bloco de funções, vamos chamar a função com hello():

package main

import "fmt"

func main() {
    hello()
}

func hello() {
    fmt.Println("Hello, World!")
}

Agora, vamos executar o programa:

• go run hello.go

Você receberá a seguinte saída:

Hello, World!

Observe que também introduzimos uma função chamada main(). A main()função é uma função especial que informa ao compilador que é aqui que o programa deve iniciar . Para qualquer programa que você queira que seja executável (um programa que pode ser executado na linha de comando), você precisará de uma main()função. A main()função deve aparecer apenas uma vez, estar no main() pacote e receber e retornar nenhum argumento. Isso permite a execução do programa em qualquer programa Go. Conforme o exemplo a seguir:

package main

import "fmt"

func main() {
    fmt.Println("this is the main section of the program")
}

Funções podem ser mais complicadas do que a hello()função que definimos. Podemos usar forloops , instruções condicionais e muito mais dentro do nosso bloco de funções.

Por exemplo, a função a seguir usa uma instrução condicional para verificar se a entrada da namevariável contém uma vogal e, em seguida, usa um forloop para iterar sobre as letras na namesequência.

package main

import (
    "fmt"
    "strings"
)

func main() {
    names()
}

func names() {
    fmt.Println("Enter your name:")

    var name string
    fmt.Scanln(&name)
    // Check whether name has a vowel
    for _, v := range strings.ToLower(name) {
        if v == 'a' || v == 'e' || v == 'i' || v == 'o' || v == 'u' {
            fmt.Println("Your name contains a vowel.")
            return
        }
    }
    fmt.Println("Your name does not contain a vowel.")
}

A names()função que definimos aqui configura uma namevariável com entrada e, em seguida, configura uma instrução condicional dentro de um forloop. Isso mostra como o código pode ser organizado dentro de uma definição de função. No entanto, dependendo do que pretendemos com nosso programa e como queremos configurar nosso código, podemos definir a instrução condicional e o forloop como duas funções separadas.

Definir funções dentro de um programa torna nosso código modular e reutilizável, para que possamos chamar as mesmas funções sem reescrevê-las.

Trabalhando com parâmetros

Até agora, examinamos funções com parênteses vazios que não aceitam argumentos, mas podemos definir parâmetros nas definições de funções entre parênteses.

Um parâmetro é uma entidade nomeada em uma definição de função, especificando um argumento que a função pode aceitar. No Go, você deve especificar o tipo de dados para cada parâmetro.

Vamos criar um programa que repita uma palavra um número especificado de vezes. Será necessário um stringparâmetro chamado worde um intparâmetro chamado repspelo número de vezes para repetir a palavra.

package main

import "fmt"

func main() {
    repeat("Sammy", 5)
}

func repeat(word string, reps int) {
    for i := 0; i < reps; i++ {
        fmt.Print(word)
    }
}

Passamos o valor Sammypara o wordparâmetro e 5para o repsparâmetro Esses valores correspondem a cada parâmetro na ordem em que foram fornecidos. A repeatfunção possui um forloop que iterará o número de vezes especificado pelo repsparâmetro. Para cada iteração, o valor do wordparâmetro é impresso.

Aqui está a saída do programa:

SammySammySammySammySammy

Se você tiver um conjunto de parâmetros com o mesmo valor, poderá omitir a especificação do tipo a cada vez. Vamos criar um pequeno programa que leva em parâmetros x, ye zque são todos os intvalores. Criaremos uma função que adiciona os parâmetros em diferentes configurações. As somas destes serão impressas pela função. Em seguida, chamaremos a função e passaremos os números para a função.

package main

import "fmt"

func main() {
    addNumbers(1, 2, 3)
}

func addNumbers(x, y, z int) {
    a := x + y
    b := x + z
    c := y + z
    fmt.Println(a, b, c)
}

Quando criamos a assinatura da função addNumbers, não precisamos especificar o tipo de cada vez, mas apenas no final.

Passamos o número 1para o xparâmetro, 2para o yparâmetro e 3para o zparâmetro. Esses valores correspondem a cada parâmetro na ordem em que são fornecidos.

O programa está fazendo as seguintes contas com base nos valores que passamos para os parâmetros:

a = 1 + 2
b = 1 + 3
c = 2 + 3

A função também será impressa a, be c, com base nessa matemática que seria de esperar apara ser igual 3, bpara ser 4e cestar 5. Vamos executar o programa:

• go run add_numbers.go

3 4 5

Quando passamos 1, 2e 3como parâmetros para a addNumbers()função, recebemos a saída esperada.

Parâmetros são argumentos que normalmente são definidos como variáveis ​​nas definições de função. Eles podem receber valores quando você executa o método, passando os argumentos para a função.

Retornando um valor

Você pode passar um valor de parâmetro para uma função, e uma função também pode produzir um valor.

Uma função pode produzir um valor com a returninstrução, que sairá de uma função e, opcionalmente, passará uma expressão de volta para o chamador. O tipo de dados de retorno também deve ser especificado.

Até agora, usamos a fmt.Println()declaração em vez da returndeclaração em nossas funções. Vamos criar um programa que, em vez de imprimir, retorne uma variável.

Em um novo arquivo de texto chamado double.go, criaremos um programa que dobra o parâmetro xe retorna a variável y. Emitimos uma chamada para imprimir a resultvariável, que é formada executando a double()função com 3passada para ela:

package main

import "fmt"

func main() {
    result := double(3)
    fmt.Println(result)
}

func double(x int) int {
    y := x * 2
    return y
}

Podemos executar o programa e ver a saída:

• go run double.go

6

O número inteiro 6é retornado como saída, que é o que esperaríamos multiplicando 3por 2.

Se uma função especificar um retorno, você deverá fornecer um retorno como parte do código. Caso contrário, você receberá um erro de compilação.

Podemos demonstrar isso comentando a linha com a declaração de retorno:

package main

import "fmt"

func main() {
    result := double(3)
    fmt.Println(result)
}

func double(x int) int {
    y := x * 2
    // return y
}

Agora, vamos executar o programa novamente:

• go run double.go

./double.go:13:1: missing return at end of function

Sem usar a returninstrução aqui, o programa não pode compilar.

As funções são encerradas imediatamente quando atingem uma returninstrução, mesmo que não estejam no final da função:

package main

import "fmt"

func main() {
    loopFive()
}

func loopFive() {
    for i := 0; i < 25; i++ {
        fmt.Print(i)
        if i == 5 {
            // Stop function at i == 5
            return
        }
    }
    fmt.Println("This line will not execute.")
}

Aqui, iteramos por um forloop e dizemos ao loop para executar 25iterações. No entanto, dentro do forloop, temos uma ifdeclaração condicional que verifica se o valor de ié igual a 5. Se for, emitimos uma returndeclaração. Como estamos na loopFivefunção, qualquer pessoa returnem qualquer ponto da função sairá da função. Como resultado, nunca chegamos à última linha nesta função para imprimir a instrução This line will not execute..

O uso da returninstrução dentro do forloop encerra a função, para que a linha que está fora do loop não seja executada. Se, em vez disso, tivéssemos usado uma breakdeclaração , apenas o loop teria saído naquele momento e a última fmt.Println()linha seria executada.

A returninstrução sai de uma função e pode retornar um valor se especificado na assinatura da função.

Retornando vários valores

Mais de um valor de retorno pode ser especificado para uma função. Vamos examinar o repeat.goprograma e fazê-lo retornar dois valores. O primeiro será o valor repetido e o segundo será um erro se o repsparâmetro não for um valor maior que 0:

package main

import "fmt"

func main() {
    val, err := repeat("Sammy", -1)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(val)
}

func repeat(word string, reps int) (string, error) {
    if reps <= 0 {
        return "", fmt.Errorf("invalid value of %d provided for reps. value must be greater than 0.", reps)
    }
    var value string
    for i := 0; i < reps; i++ {
        value = value + word
    }
    return value, nil
}

A primeira coisa que a repeatfunção faz é verificar se o repsargumento é um valor válido. Qualquer valor que não seja maior que 0causará um erro. Desde que passamos o valor de -1, esse ramo de código será executado. Observe que, quando retornamos da função, precisamos fornecer os valores de retorno stringe error. Como os argumentos fornecidos resultaram em um erro, retornaremos uma string em branco para o primeiro valor de retorno e o erro para o segundo valor de retorno.

Na main()função, podemos receber os dois valores de retorno declarando duas novas variáveis, valuee err. Como pode haver um erro no retorno, queremos verificar se recebemos um erro antes de continuar com o nosso programa. Neste exemplo, recebemos um erro. Imprimimos o erro e returnsaímos da main()função para sair do programa.

Se não houvesse um erro, imprimiríamos o valor de retorno da função.

Nota: É considerado uma boa prática retornar apenas dois ou três valores. Além disso, você sempre deve retornar todos os erros como o último valor de retorno de uma função.

A execução do programa resultará na seguinte saída:

invalid value of -1 provided for reps. value must be greater than 0.

Nesta seção, revisamos como podemos usar a returninstrução para retornar vários valores de uma função.

Conclusão

Funções são blocos de código de instruções que executam ações dentro de um programa, ajudando a tornar nosso código reutilizável e modular.