Go por Exemplo: Slices

Slices são tipos de dados fundamentais no Go, fornecendo uma interface mais poderosa para seqüências de matrizes.

 
package main

import "fmt"

func main() {

Ao contrário das matrizes, os slices são digitados apenas pelos elementos que eles contêm (não o número de elementos). Para criar um slice vazio com tamanho diferente de zero, use o padrão make. Aqui nós fizemos um slice de uma string de tamanho 3 (inicialmente com valor zero).

 
    s := make([]string, 3)
    fmt.Println("emp:", s)

Podemos definir e obter assim como as matrizes.

 
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

len retorna o tamanho do slice, como esperado.

 
    fmt.Println("len:", len(s))

Além destas operações básicas, os slices suportam muito mais, o que os tornam mais ricos do que as matrizes. Uma é o padrão append, na qual retorna um slice contendo um ou mais novos valores. Note que precisamos aceitar um valor de retorno do append assim como podemos obter um novo valor do slice.

 
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

Slices também podem ser copiados. Aqui nós criamos um slice vazio c do mesmo tamanho que s e copiamos o s no c.

 
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

Slices suportam um operador "slice" com a sintaxe slice[min:max]. Por exemplo, este pega um slice dos elementos s[2], s[3], e s[4].

 
    l := s[2:5]
    fmt.Println("sl1:", l)

Esses slices são até (mas excluíndo) s[5].

 
    l = s[:5]
    fmt.Println("sl2:", l)

E esses slices são do (e incluindo) s[2].

 
    l = s[2:]
    fmt.Println("sl3:", l)

Nós também podemos declarar e inicializar uma variável para o slice em uma única linha.

 
    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

Slices podem ser compostas em estruturas de dados multi-dimensionais. O tamanho dos slices interiores pode variar, ao contrário das matrizes multi-dimensionais.

 
    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

Note que enquanto os slices são tipos diferentes das matrizes, eles são processados da mesma forma por fmt.Println.

 
$ go run slices.go
emp: [  ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d:  [[0] [1 2] [2 3 4]]

Confira este ótimo artigo do blog da equipe Go para maiores detalhes de design e implementação dos slices no Go.

Agora que já vimos as matrizes e slices, nós iremos ver outra chave fundamental das estruturas de dados do Go: maps.

Próximo exemplo: Maps.

golangbr | feedback | código-fonte | licença