Aula 10 – Tutorial Golang – Slices

More videos
   

Aula 10 – Tutorial Golang – Slices

Tutorial Golang - Slices

Tutorial Golang – Slices

Página principal do blog

Todas as aulas desse curso

Aula 09                        Aula 11

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook

Esse é o link do código fluente no Pinterest

Meus links de afiliados:

Hostinger

Digital Ocean

One.com

Melhore seu NETWORKING

https://digitalinnovation.one/

Participe de comunidades de desenvolvedores:

Fiquem a vontade para me adicionar ao linkedin.

E também para me seguir no https://github.com/toticavalcanti.

Código final da aula:

https://github.com/toticavalcanti

Toti:

https://www.youtube.com/channel/UCUEtjLuDpcOvR3mIUr-viOA

Backing track / Play-along:

https://www.youtube.com/channel/UCT3TryVMqTqYBjf5g5WAHfA

Código Fluente

https://www.youtube.com/channel/UCgn-O-88XBAwdG9gUWkkb0w

Putz!

https://www.youtube.com/channel/UCZXop2-CECwyFYmHbhnAkAw

Aula 10 – Tutorial Golang – Slices

Slices

Slice é um tipo de dado chave em Go, fornecendo uma interface mais poderosa para sequências do que arrays.

Ao contrário dos arrays, os Slices são tipados apenas pelos elementos que contêm (não pelo número de elementos).

Para criar um Slice vazio com comprimento diferente de zero, use o comando make embutido.

Aqui, fazemos um slice de strings de comprimento 3 (inicialmente vazio).


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

Podemos definir e obter da mesma forma que os arrays.


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

A len() retorna o tamanho do Slice.


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

Além dessas operações básicas, os Slices suportam várias outras que os tornam mais ricos do que os arrays.

Um é o método append, que retorna um Slice contendo um ou mais novos valores.

Observe que precisamos aceitar um valor de retorno de append, pois podemos obter um novo valor de Slice.


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

Os Slices também podem ser copiados.

Aqui, criamos um Slice c vazio, do mesmo tamanho de s e copiamos o conteúdo de s para c.


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

Os Slices oferecem suporte a um operador “fatia – slice” com a sintaxe [baixo: alto].

Por exemplo, para obter uma fatia com os elementos s[2], s[3] e s[4].


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

Isso fatia até s[4] excluindo s[5].


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

E isso fatia do s[2] até o fim.


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

Podemos declarar e inicializar um slice em uma única linha também.


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

Os Slices podem ser compostos em estruturas de dados multidimensionais.

O comprimento dos Slices internos pode variar, ao contrário de matrizes multidimensionais.


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)

Observe que, embora os slices sejam de tipos diferentes dos arrays, eles são renderizados de maneira semelhante por fmt.Println().

Código Completo


// _Slices_ are a key data type in Go, giving a more
// powerful interface to sequences than arrays.

package main

import "fmt"

func main() {

    // Unlike arrays, slices are typed only by the
    // elements they contain (not the number of elements).
    // To create an empty slice with non-zero length, use
    // the builtin `make`. Here we make a slice of
    // `string`s of length `3` (initially zero-valued).
    s := make([]string, 3)
    fmt.Println("emp:", s)

    // We can set and get just like with arrays.
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

    // `len` returns the length of the slice as expected.
    fmt.Println("len:", len(s))

    // In addition to these basic operations, slices
    // support several more that make them richer than
    // arrays. One is the builtin `append`, which
    // returns a slice containing one or more new values.
    // Note that we need to accept a return value from
    // `append` as we may get a new slice value.
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

    // Slices can also be `copy`'d. Here we create an
    // empty slice `c` of the same length as `s` and copy
    // into `c` from `s`.
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    // Slices support a "slice" operator with the syntax
    // `slice[low:high]`. For example, this gets a slice
    // of the elements `s[2]`, `s[3]`, and `s[4]`.
    l := s[2:5]
    fmt.Println("sl1:", l)

    // This slices up to (but excluding) `s[5]`.
    l = s[:5]
    fmt.Println("sl2:", l)

    // And this slices up from (and including) `s[2]`.
    l = s[2:]
    fmt.Println("sl3:", l)

    // We can declare and initialize a variable for slice
    // in a single line as well.
    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

    // Slices can be composed into multi-dimensional data
    // structures. The length of the inner slices can
    // vary, unlike with multi-dimensional arrays.
    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)
}

E pra executar é só entrar na pasta onde tá o arquivo switch.go e digitar:

go run slices.go

É isso pessoal, fico por aqui.

Nos vemos na próxima aula, até mais. 🙂

Página principal do blog

Todas as aulas desse curso

Aula 09                        Aula 11

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook

Esse é o link do código fluente no Pinterest

Meus links de afiliados:

Hostinger

Digital Ocean

One.com

Obrigado e bons estudos. 😉

About The Author
-

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>