Múltiplos valores devolvidos em

Sobre Múltiplos valores devolvidos

As funções e os métodos em Go podem devolver vários valores:

func GetCard() (Card, error) { ... }

Cada valor devolvido tem de ser atribuído por ordem e separado por vírgulas:

card, err := GetCard()

O identificador em branco

Cada posição na atribuição declara uma variável. Em Go, não é permitido declarar uma variável sem a usar. Usa o identificador em branco _ no lugar de um nome de variável para ignorar esse valor devolvido.

card, _ := GetCard() // error intentionally ignored
_, err := GetCard()  // card ignored, only checking for error

Tratamento de erros

error é uma interface incorporada. Um erro nil significa que não ocorreu nenhum erro; qualquer valor que não seja nil significa que algo correu mal. Por convenção, as funções que podem falhar devem devolver um error como último valor. Quem chama tem de o verificar antes de usar quaisquer outros valores devolvidos:

card, err := GetCard()
if err != nil {
    // unsafe to use card here
    return err
}
// safe to use card here

O padrão vírgula-ok

O padrão de atribuição de dois valores também aparece fora do tratamento de error. As consultas a mapas, as asserções de tipo e as receções de canais usam todas um segundo valor booleano, a que se chama ok por convenção, para indicar sucesso ou a presença de dados:

m := map[string]int{"a": 1}
v, ok := m["a"] // ok is true
v, ok = m["z"]  // ok is false

var i interface{} = "hello"
v, ok := i.(string) // ok is true
v, ok = i.(int)     // ok is false

v, ok := <-ch // ok is false if ch is closed and empty

Valores devolvidos com nome

Os valores devolvidos também podem receber nomes na assinatura da função. Essas variáveis ficam então acessíveis dentro do corpo.

func divide(a, b int) (quotient, remainder int) {
    quotient = a / b
    remainder = a % b
    return quotient, remainder
}

Os valores devolvidos com nome documentam o significado de cada posição de retorno. Também podem ser usados com um retorno nu, escrito sem valores. Os retornos nus devolvem implicitamente os valores atuais das variáveis com nome:

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}

Em funções mais longas, os retornos nus prejudicam muitas vezes a legibilidade, porque não é claro o que está a ser devolvido. Prefere valores devolvidos explícitos, a menos que a função seja suficientemente curta para que a assinatura esteja sempre à vista.

Para saberes mais, consulta Go by Example: Multiple Return Values, Effective Go: Multiple Returns ou o Tour of Go.