Truques com cartas

Slices

Slices em Go são parecidos com listas ou arrays de outras linguagens. Eles guardam vários elementos de um tipo específico (ou interface).

Os slices em Go são baseados em arrays. Arrays têm tamanho fixo. Já um slice é uma visão flexível e de tamanho dinâmico dos elementos de um array.

Um slice é escrito como []T, em que T é o tipo dos elementos do slice:

var empty []int                 // an empty slice
withData := []int{0,1,2,3,4,5}  // a slice pre-filled with some data

Você pode obter ou definir um elemento em um determinado índice com base zero usando a notação de colchetes:

withData[1] = 5
x := withData[1] // x is now 5

Você pode criar um novo slice a partir de um slice existente obtendo um intervalo de elementos. De novo usando a notação de colchetes, mas especificando tanto um índice inicial (inclusivo) quanto um final (exclusivo). Se você não especificar um índice inicial, ele será 0 por padrão. Se você não especificar um índice final, ele será o comprimento do slice por padrão.

newSlice := withData[2:4]
// => []int{2,3}
newSlice := withData[:2]
// => []int{0,1}
newSlice := withData[2:]
// => []int{2,3,4,5}
newSlice := withData[:]
// => []int{0,1,2,3,4,5}

Você pode adicionar elementos a um slice usando a função append. Abaixo, acrescentamos 4 e 2 ao slice a.

a := []int{1, 3}
a = append(a, 4, 2)
// => []int{1,3,4,2}

append sempre retorna um novo slice e, quando queremos apenas acrescentar elementos a um slice existente, é comum atribuí-lo de volta à variável de slice que passamos como primeiro argumento, como fizemos acima.

append também pode ser usado para juntar dois slices:

nextSlice := []int{100,101,102}
newSlice  := append(withData, nextSlice...)
// => []int{0,1,2,3,4,5,100,101,102}

Funções variádicas

Normalmente, as funções em Go aceitam apenas um número fixo de argumentos. No entanto, também é possível escrever funções variádicas em Go.

Uma função variádica é uma função que aceita um número variável de argumentos.

Se o tipo do último parâmetro em uma definição de função for precedido por reticências ..., a função poderá aceitar qualquer número de argumentos para esse parâmetro.

func find(a int, b ...int) {
    // ...
}

Na função acima, o parâmetro b é variádico e podemos passar 0 ou mais argumentos para b.

find(5, 6)
find(5, 6, 7)
find(5)

As funções variádicas funcionam convertendo o número variável de argumentos em um slice do tipo do parâmetro variádico.

Veja um exemplo de implementação de uma função variádica.

func find(num int, nums ...int) {
    fmt.Printf("type of nums is %T\n", nums)

    for i, v := range nums {
        if v == num {
            fmt.Println(num, "found at index", i, "in", nums)
            return
        }
    }

    fmt.Println(num, "not found in ", nums)
}

func main() {
    find(89, 90, 91, 95)
    // =>
    // type of nums is []int
    // 89 not found in  [90 91 95]

    find(45, 56, 67, 45, 90, 109)
    // =>
    // type of nums is []int
    // 45 found at index 2 in [56 67 45 90 109]

    find(87)
    // =>
    // type of nums is []int
    // 87 not found in  []
}

Na linha find(89, 90, 91, 95) do programa acima, os argumentos em número variável para a função find são 90, 91 e 95. A função find espera um parâmetro int variádico depois de num. Assim, esses três argumentos serão convertidos pelo compilador em um slice do tipo int, []int{90, 91, 95}, e então passados à função find como nums.

Às vezes você já tem um slice e quer passá-lo para uma função variádica. Isso pode ser feito passando o slice seguido de .... Isso dirá ao compilador para usar o slice como está dentro da função variádica. A etapa descrita acima, em que um slice é criado, simplesmente será omitida nesse caso.

list := []int{1, 2, 3}
find(1, list...) // "find" defined as shown above