Na linguagem Go, o slice é mais poderoso, flexível, conveniente do que um array e é uma estrutura de dados leve. A fatia é uma sequência de comprimento variável que armazena elementos de um tipo semelhante; você não tem permissão para armazenar tipos diferentes de elementos na mesma fatia. É como uma array com um valor de índice e comprimento, mas o tamanho da fatia é redimensionado; eles não têm um tamanho fixo como uma array. Internamente, a fatia e uma array estão conectadas entre si, uma fatia é uma referência a uma array subjacente. É permitido armazenar elementos duplicados na fatia. A primeira posição de índice em uma fatia é sempre 0 e a última será (comprimento da fatia - 1) .

Declaração de fatia

Uma fatia é declarada como uma array, mas não contém o tamanho da fatia. Portanto, ele pode aumentar ou diminuir de acordo com a necessidade. 

Sintaxe:  

[]T
or 
[]T{}
or 
[]T{value1, value2, value3, ...value n}

Aqui, T é o tipo dos elementos. Por exemplo: 

var my_slice[]int 

Componentes do Slice

Uma fatia contém três componentes:

• Ponteiro : o ponteiro é usado para apontar para o primeiro elemento da array que pode ser acessado por meio da fatia. Aqui, não é necessário que o elemento apontado seja o primeiro elemento da array.
• Comprimento: o comprimento é o número total de elementos presentes na array.
• Capacidade: A capacidade representa o tamanho máximo até o qual pode se expandir.

Vamos discutir todos esses componentes com a ajuda de um exemplo:

Exemplo: 

// Golang program to illustrate
// the working of the slice components
package main
 
import "fmt"
 
func main() {
 
    // Creating an array
    arr := [7]string{"This", "is", "the", "tutorial",
                         "of", "Go", "language"}
 
    // Display array
    fmt.Println("Array:", arr)
 
    // Creating a slice
    myslice := arr[1:6]
 
    // Display slice
    fmt.Println("Slice:", myslice)
 
    // Display length of the slice
    fmt.Printf("Length of the slice: %d", len(myslice))
 
    // Display the capacity of the slice
    fmt.Printf("\nCapacity of the slice: %d", cap(myslice))
}

Saída: 

Array: [This is the tutorial of Go language]
Slice: [is the tutorial of Go]
Length of the slice: 5
Capacity of the slice: 6

Explicação: No exemplo acima, criamos uma fatia da array fornecida. Aqui, o ponteiro da fatia apontou para o índice 1 porque o limite inferior da fatia é definido como um, de modo que começa a acessar os elementos do índice 1. O comprimento da fatia é 5, o que significa que o número total de elementos presentes na fatia é 5 e a capacidade da fatia 6 significa que pode armazenar um máximo de 6 elementos nela.
 

Como criar e inicializar um Slice?

Na linguagem Go, uma fatia pode ser criada e inicializada das seguintes maneiras:

• Usando o literal de fatia: você pode criar uma fatia usando o literal de fatia. A criação do literal de fatia é como um literal de array, mas com uma diferença, você não tem permissão para especificar o tamanho da fatia entre colchetes []. Conforme mostrado no exemplo abaixo, o lado direito desta expressão é o literal de fatia.

var my_slice_1 = []string{"Geeks", "for", "Geeks"}

Nota: Lembre-se sempre de que ao criar uma fatia usando um literal de string, primeiro ele cria uma array e, depois disso, retorna uma referência de fatia a ela.

Exemplo:

// Golang program to illustrate how
// to create a slice using a slice
// literal
package main
 
import "fmt"
 
func main() {
 
    // Creating a slice
    // using the var keyword
    var my_slice_1 = []string{"Geeks", "for", "Geeks"}
 
    fmt.Println("My Slice 1:", my_slice_1)
 
    // Creating a slice
    //using shorthand declaration
    my_slice_2 := []int{12, 45, 67, 56, 43, 34, 45}
    fmt.Println("My Slice 2:", my_slice_2)
}

Saída: 

My Slice 1: [Geeks for Geeks]
My Slice 2: [12 45 67 56 43 34 45]

• Usando uma Array: Como já sabemos que a fatia é a referência da array , você pode criar uma fatia a partir da array fornecida. Para criar uma fatia da array fornecida, primeiro você precisa especificar os limites inferior e superior, o que significa que a fatia pode receber elementos da array, começando do limite inferior até o limite superior. Não inclui os elementos acima do limite superior. Conforme mostrado no exemplo abaixo:
  Sintaxe: 

array_name[low:high]

Esta sintaxe retornará uma nova fatia.

Observação: o valor padrão do limite inferior é 0 e o valor padrão do limite superior é o número total de elementos presentes na array fornecida.

Exemplo:

// Golang program to illustrate how to
// create slices from the array
package main
 
import "fmt"
 
func main() {
 
    // Creating an array
    arr := [4]string{"Geeks", "for", "Geeks", "GFG"}
 
    // Creating slices from the given array
    var my_slice_1 = arr[1:2]
    my_slice_2 := arr[0:]
    my_slice_3 := arr[:2]
    my_slice_4 := arr[:]
 
    // Display the result
    fmt.Println("My Array: ", arr)
    fmt.Println("My Slice 1: ", my_slice_1)
    fmt.Println("My Slice 2: ", my_slice_2)
    fmt.Println("My Slice 3: ", my_slice_3)
    fmt.Println("My Slice 4: ", my_slice_4)
}

Saída:

My Array:  [Geeks for Geeks GFG]
My Slice 1:  [for]
My Slice 2:  [Geeks for Geeks GFG]
My Slice 3:  [Geeks for]
My Slice 4:  [Geeks for Geeks GFG]

• Usando uma fatia já existente: Também é permitido criar uma fatia a partir de uma determinada fatia. Para criar uma fatia a partir de uma determinada fatia, primeiro você precisa especificar os limites inferior e superior, o que significa que a fatia pode levar elementos de uma determinada fatia, começando do limite inferior até o limite superior. Não inclui os elementos acima do limite superior. Conforme mostrado no exemplo abaixo:
  Sintaxe: 

slice_name[low:high]

Esta sintaxe retornará uma nova fatia.

Observação: o valor padrão do limite inferior é 0 e o valor padrão do limite superior é o número total de elementos presentes em uma determinada fatia. 

Exemplo:

// Golang program to illustrate how to
// create slices from the slice
package main
 
import "fmt"
 
func main() {
 
    // Creating s slice
    oRignAl_slice := []int{90, 60, 40, 50,
        34, 49, 30}
 
    // Creating slices from the given slice
    var my_slice_1 = oRignAl_slice[1:5]
    my_slice_2 := oRignAl_slice[0:]
    my_slice_3 := oRignAl_slice[:6]
    my_slice_4 := oRignAl_slice[:]
    my_slice_5 := my_slice_3[2:4]
 
    // Display the result
    fmt.Println("Original Slice:", oRignAl_slice)
    fmt.Println("New Slice 1:", my_slice_1)
    fmt.Println("New Slice 2:", my_slice_2)
    fmt.Println("New Slice 3:", my_slice_3)
    fmt.Println("New Slice 4:", my_slice_4)
    fmt.Println("New Slice 5:", my_slice_5)
}

Saída: 

Original Slice: [90 60 40 50 34 49 30]
New Slice 1: [60 40 50 34]
New Slice 2: [90 60 40 50 34 49 30]
New Slice 3: [90 60 40 50 34 49]
New Slice 4: [90 60 40 50 34 49 30]
New Slice 5: [40 50]

• Usando a função make(): Você também pode criar uma fatia usando a função make() que é fornecida pela biblioteca go. Essa função leva três parâmetros, ou seja, tipo, comprimento e capacidade. Aqui, o valor da capacidade é opcional. Ele atribui uma array subjacente com um tamanho que é igual à capacidade fornecida e retorna uma fatia que se refere à array subjacente. Geralmente, a função make() é usada para criar uma fatia vazia. Aqui, fatias vazias são aquelas fatias que contêm uma referência de array vazia.
  Sintaxe: 

func make([]T, len, cap) []T

Exemplo:

// Go program to illustrate how to create slices
// Using make function
package main
 
import "fmt"
 
func main() {
 
    // Creating an array of size 7
    // and slice this array  till 4
    // and return the reference of the slice
    // Using make function
    var my_slice_1 = make([]int, 4, 7)
    fmt.Printf("Slice 1 = %v, \nlength = %d, \ncapacity = %d\n",
                   my_slice_1, len(my_slice_1), cap(my_slice_1))
 
    // Creating another array of size 7
    // and return the reference of the slice
    // Using make function
    var my_slice_2 = make([]int, 7)
    fmt.Printf("Slice 2 = %v, \nlength = %d, \ncapacity = %d\n",
                   my_slice_2, len(my_slice_2), cap(my_slice_2))
     
}

Saída:

Slice 1 = [0 0 0 0], 
length = 4, 
capacity = 7
Slice 2 = [0 0 0 0 0 0 0], 
length = 7, 
capacity = 7

Como iterar em uma fatia?

Você pode iterar sobre a fatia usando as seguintes maneiras: 

• Usando o loop for: é a maneira mais simples de iterar a fatia, conforme mostrado no exemplo a seguir:
  Exemplo:

// Golang program to illustrate the
// iterating over a slice using
// for loop
package main
 
import "fmt"
 
func main() {
 
    // Creating a slice
    myslice := []string{"This", "is", "the", "tutorial",
        "of", "Go", "language"}
 
    // Iterate using for loop
    for e := 0; e < len(myslice); e++ {
        fmt.Println(myslice[e])
    }
}

Saída: 

This
is
the
tutorial
of
Go
language

• Usando intervalo no loop for: É permitido iterar sobre uma fatia usando intervalo no loop for. Usando intervalo no loop for, você pode obter o índice e o valor do elemento conforme mostrado no exemplo:
  Exemplo:

// Golang program to illustrate the iterating
// over a slice using range in for loop
package main
 
import "fmt"
 
func main() {
 
    // Creating a slice
    myslice := []string{"This", "is", "the", "tutorial",
                                 "of", "Go", "language"}
 
    // Iterate slice
    // using range in for loop
    for index, ele := range myslice {
        fmt.Printf("Index = %d and element = %s\n", index+3, ele)
    }
}

Saída: 

Index = 3 and element = This
Index = 4 and element = is
Index = 5 and element = the
Index = 6 and element = tutorial
Index = 7 and element = of
Index = 8 and element = Go
Index = 9 and element = language

• Usando um identificador em branco no loop for: no loop for intervalo, se você não quiser obter o valor do índice dos elementos, você pode usar um espaço em branco (_) no lugar da variável de índice, conforme mostrado no exemplo abaixo:
  Exemplo :

// Golang program to illustrate the iterating over
// a slice using range in for loop without an index
package main
 
import "fmt"
 
func main() {
 
    // Creating a slice
    myslice := []string{"This", "is", "the",
        "tutorial", "of", "Go", "language"}
 
    // Iterate slice
    // using range in for loop
    // without index
    for _, ele := range myslice {
        fmt.Printf("Element = %s\n", ele)
    }
}

Saída: 

Element = This
Element = is
Element = the
Element = tutorial
Element = of
Element = Go
Element = language

Pontos importantes sobre o Slice

• Fatia de valor zero: na linguagem Go, você tem permissão para criar uma fatia nula que não contém nenhum elemento. Portanto, a capacidade e o comprimento desta fatia é 0. A fatia nula não contém uma referência de array, conforme mostrado no exemplo abaixo:
  Exemplo:

// Go program to illustrate a zero value slice
package main
 
import "fmt"
 
func main() {
 
    // Creating a zero value slice
    var myslice []string
    fmt.Printf("Length = %d\n", len(myslice))
    fmt.Printf("Capacity = %d ", cap(myslice))
 
}

Saída:

Length = 0
Capacity = 0

• Modificando a fatia: Como já sabemos que a fatia é um tipo de referência, ela pode se referir a um array subjacente. Portanto, se alterarmos alguns elementos na fatia, as alterações também deverão ocorrer na array referenciada. Ou, em outras palavras, se você fez alguma alteração na fatia, ela também se refletirá na array, conforme mostrado no exemplo abaixo:
  Exemplo:

// Golang program to illustrate
// how to modify the slice
package main
 
import "fmt"
 
func main() {
 
    // Creating a zero value slice
    arr := [6]int{55, 66, 77, 88, 99, 22}
    slc := arr[0:4]
 
    // Before modifying
 
    fmt.Println("Original_Array: ", arr)
    fmt.Println("Original_Slice: ", slc)
 
    // After modification
    slc[0] = 100
    slc[1] = 1000
    slc[2] = 1000
 
    fmt.Println("\nNew_Array: ", arr)
    fmt.Println("New_Slice: ", slc)
}

Saída:

Original_Array:  [55 66 77 88 99 22]
Original_Slice:  [55 66 77 88]

New_Array:  [100 1000 1000 88 99 22]
New_Slice:  [100 1000 1000 88]

• Comparação do Slice: No Slice, você só pode usar o operador == para verificar se o slice fornecido é nulo ou não. Se você tentar comparar duas fatias com a ajuda do operador == , ocorrerá um erro conforme mostrado no exemplo abaixo:
  Exemplo:

// Golang program to check if
// the slice is nil or not
package main
 
import "fmt"
 
func main() {
 
    // creating slices
    s1 := []int{12, 34, 56}
    var s2 []int
 
    // If you try to run this commented
    // code compiler will give an error
    /*s3:= []int{23, 45, 66}
      fmt.Println(s1==s3)
    */
 
    // Checking if the given slice is nil or not
    fmt.Println(s1 == nil)
    fmt.Println(s2 == nil)
}

Saída: 

false
true

Nota: Se você deseja comparar duas fatias, então use range for loop para combinar cada elemento ou você pode usar a função DeepEqual . 

• Fatia multidimensional: Fatia multidimensional são como a array multidimensional, exceto que a fatia não contém o tamanho. 
  Exemplo:

// Go program to illustrate the multi-dimensional slice
package main
 
import "fmt"
 
func main() {
 
    // Creating multi-dimensional slice
    s1 := [][]int{{12, 34},
        {56, 47},
        {29, 40},
        {46, 78},
    }
 
    // Accessing multi-dimensional slice
    fmt.Println("Slice 1 : ", s1)
 
    // Creating multi-dimensional slice
    s2 := [][]string{
        []string{"Geeks", "for"},
        []string{"Geeks", "GFG"},
        []string{"gfg", "geek"},
    }
 
    // Accessing multi-dimensional slice
    fmt.Println("Slice 2 : ", s2)
 
}

Saída: 

Slice 1 :  [[12 34] [56 47] [29 40] [46 78]]
Slice 2 :  [[Geeks for] [Geeks GFG] [gfg geek]]

• Classificação da fatia: Na linguagem Go, você pode classificar os elementos presentes na fatia. A biblioteca padrão da linguagem Go fornece o pacote de classificação que contém diferentes tipos de métodos de classificação para classificar a fatia de ints , float64s e strings . Essas funções sempre classificam os elementos disponíveis em fatias em ordem crescente.
  Exemplo:

// Go program to illustrate how to sort
// the elements present in the slice
package main
 
import (
    "fmt"
    "sort"
)
 
func main() {
 
    // Creating Slice
    slc1 := []string{"Python", "Java", "C#", "Go", "Ruby"}
    slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89}
 
    fmt.Println("Before sorting:")
    fmt.Println("Slice 1: ", slc1)
    fmt.Println("Slice 2: ", slc2)
 
    // Performing sort operation on the
    // slice using sort function
    sort.Strings(slc1)
    sort.Ints(slc2)
 
    fmt.Println("\nAfter sorting:")
    fmt.Println("Slice 1: ", slc1)
    fmt.Println("Slice 2: ", slc2)
 
}

Saída: 

Before sorting:
Slice 1:  [Python Java C# Go Ruby]
Slice 2:  [45 67 23 90 33 21 56 78 89]

After sorting:
Slice 1:  [C# Go Java Python Ruby]
Slice 2:  [21 23 33 45 56 67 78 89 90]