Uma função permite agrupar código em uma unidade reutilizável.
Ela é composta pela palavra-chave func, pelo nome da função e por uma lista separada por vírgulas de zero ou mais parâmetros e tipos entre parênteses.
Parâmetros de função
Todos os parâmetros precisam ter tipo explícito; não existe inferência de tipo para parâmetros.
Não há valores padrão para parâmetros, então todos os parâmetros de função são obrigatórios.
import "fmt"
// No parameters
func PrintHello() {
fmt.Println("Hello")
}
// Two parameters
func PrintGreetingName(greeting string, name string) {
fmt.Println(greeting + " " + name)
}
Parâmetros do mesmo tipo podem ser declarados juntos, seguidos de uma única declaração de tipo.
import "fmt"
func PrintGreetingName(greeting, name string) {
fmt.Println(greeting + " " + name)
}
Parâmetros vs. argumentos
Vamos ver rapidamente dois termos que costumam ser confundidos: parameters e arguments.
Os parâmetros de função são os nomes definidos na assinatura da função, como greeting e name na função PrintGreetingName acima.
Os argumentos de função são os valores concretos passados aos parâmetros da função quando invocamos a função.
Por exemplo, no exemplo abaixo, "Hello" e "Katrina" são os argumentos passados aos parâmetros greeting e name:
PrintGreetingName("Hello", "Katrina")
Valores de retorno
Os parâmetros da função são seguidos por zero ou mais valores de retorno, que também precisam ter tipo explícito.
Valores de retorno únicos ficam sem parênteses, e múltiplos valores de retorno ficam entre parênteses.
Os valores são retornados ao código que fez a chamada por meio da palavra-chave return.
Pode haver várias instruções return em uma função.
A execução da função termina assim que ela encontra uma dessas instruções return.
Se uma função precisar retornar vários valores, eles são separados por vírgulas.
func Hello(name string) string {
return "Hello " + name
}
func HelloAndGoodbye(name string) (string, string) {
return "Hello " + name, "Goodbye " + name
}
Chamando funções
Para invocar uma função, você especifica o nome dela e passa argumentos para cada um de seus parâmetros entre parênteses.
import "fmt"
// No parameters, no return value
func PrintHello() {
fmt.Println("Hello")
}
// Called like this:
PrintHello()
// One parameter, one return value
func Hello(name string) string {
return "Hello " + name
}
// Called like this:
greeting := Hello("Dave")
// Multiple parameters, multiple return values
func SumAndMultiply(a, b int) (int, int) {
return a+b, a*b
}
// Called like this:
aplusb, atimesb := SumAndMultiply(a, b)
Valores de retorno nomeados e retorno nu
Assim como os parâmetros, os valores de retorno podem ter nomes, opcionalmente.
Se valores de retorno nomeados forem usados, uma instrução return sem argumentos retornará esses valores.
Isso é conhecido como retorno 'nu'.
func SumAndMultiplyThenMinus(a, b, c int) (sum, mult int) {
sum, mult = a+b, a*b
sum -= c
mult -= c
return
}
Passagem por valor vs. passagem por referência
Também é importante esclarecer o conceito de passagem por valor e de passagem por referência.
Primeiro, vamos esclarecer a passagem por valor.
No exemplo abaixo, quando passamos a variável val para a função MultiplyByTwo, passamos uma cópia de val.
Por causa disso, newVal tem o valor atualizado 4, mas a variável original val continua sendo 2.
Por baixo dos panos, o Go basicamente faz uma cópia do valor original, de modo que apenas essa cópia, também chamada de v, é modificada pela função.
val := 2
func MultiplyByTwo(v int) int {
v = v * 2
return v
}
newVal := MultiplyByTwo(val)
// newval is 4, val is still 2 because only a copy of its value was passed into the function
A rigor, todos os argumentos são passados por valor em Go, ou seja, é feita uma cópia do valor ou dos dados fornecidos à função.
Mas se você não quiser fazer uma cópia dos dados passados para uma função e quiser alterar esses dados dentro dela, então deve usar pointers como argumentos, o que também é chamado de passagem por referência.
Ponteiros
Usamos um pointer para conseguir a passagem por referência.
Ao passar argumentos pointer para uma função, podemos modificar os dados subjacentes que foram passados para ela em vez de operar apenas sobre uma cópia desses dados.
Por enquanto, basta saber que os tipos ponteiro podem ser reconhecidos pelo * na frente do tipo na assinatura da função.
func HandlePointers(x, y *int) {
// Some logic to handle integer values referenced by pointers x and y
}
Se o conceito de pointer parecer confuso, não se preocupe.
Temos uma seção dedicada mais adiante no programa de estudos para ajudar você a dominar ponteiros.
Exceções
Observe que slices e maps são exceções à regra mencionada acima.
Quando passamos um slice ou um map como argumentos para uma função, eles são tratados como tipos ponteiro, mesmo que não haja um * explícito no tipo.
Isso significa que, se passarmos um slice ou map para uma função e modificarmos os dados subjacentes, as mudanças serão refletidas no slice ou map original.
Exercício de aprendizagem
