Concatenar duas fatias em Go

1. Declaração da fatia
2. Concatenação de fatias
3. Trabalho de Go append() Função

Em Go, uma slice é a estrutura de dados dinâmica que armazena múltiplos elementos do mesmo tipo de dados. Eles também podem ser pensados como arrays de tamanho variável que têm indexação como de array, mas seu tamanho não é fixo, pois podem ser redimensionados. Como as fatias são dinâmicas por natureza, podemos acrescentar um novo elemento para fatiar ou concatenar duas ou mais fatias utilizando a função append.

Declaração da fatia

A declaração de um Slice é semelhante à declaração de arrays, mas o tamanho não é especificado.

package main

import "fmt"

func main() {
    var Slice1 = []int{1, 2, 3, 4}
    fmt.Printf("Length of Slice: %v\n",len(Slice1))
    fmt.Printf("First Element: %v\n",Slice1[0])
    fmt.Printf("Second Element: %v\n",Slice1[1])
    fmt.Printf("Third Element: %v\n",Slice1[2])
    fmt.Printf("Fourth Element: %v\n",Slice1[3])

}

Resultado:

Length of Slice: 4
First Element: 1
Second Element: 2
Third Element: 3
Fourth Element: 4

Concatenação de fatias

Utilizamos a função integrada append() para adicionar elementos para listar ou concatenar duas ou mais fatias juntas. Se houver capacidade suficiente, o destino é re-slicado para acomodar os novos elementos. Se não houver capacidade suficiente, um novo subjacente é alocado e o conteúdo é copiado. Finalmente, a função append retorna a fatia atualizada.

Anexar um único elemento à fatia

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)  
    fmt.Printf("slice_1: %v\n", slice_1)
    fmt.Printf("slice_2: %v\n", slice_2)

}

Resultado:

slice_1: [1 2]
slice_2: [1 2 3]

Anexar vários elementos a uma fatia

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)
    slice_3 := append(slice_2, 4,5,6)   
    fmt.Printf("slice_3: %v\n", slice_3)

}

Resultado:

slice_3: [1 2 3 4 5 6]

Concatenar duas fatias

package main

import "fmt"

func main() {
    var slice_3 = []int{1, 2, 3, 4, 5, 6}
    var slice_4 = []int{7,8}
    
    slice_5 := append(slice_3,slice_4...) 
    fmt.Printf("slice_4: %v\n", slice_4)
    fmt.Printf("slice_5: %v\n", slice_5)

}

Resultado:

slice_4: [7 8]
slice_5: [1 2 3 4 5 6 7 8]

Um ponto importante a ser notado ao concatenar duas fatias de uma vez é que ... é essencial após slice_4 como append() é uma função variádica, assim como outras funções variádicas. ... permite passar múltiplos argumentos para uma função a partir de uma fatia. Aqui a função append é chamada recursivamente para cada elemento em slice_4.

Anexar uma string a uma fatia de byte

var slice []byte = append([]byte("abc "), "def"...)
fmt.Printf("slice: %v\n", slice)

Resultado:

slice: [97 98 99 32 100 101 102]

Aqui os caracteres são codificados em UTF-8 usando 3 bytes que representam o valor ASCII dos caracteres. O byte da fatia pode ser convertido de volta para string como:

slice_str := string(slice)
fmt.Printf("String: %v\n", slice_str)

Resultado:

Slice: abc def

Trabalho de Go append() Função

A função append() embutida leva uma fatia, anexa todos os elementos ao final de uma fatia de entrada e finalmente retorna a fatia concatenada. Se a fatia de destino tiver capacidade suficiente, a fatia é re-slicada para acomodar os novos elementos anexados. Mas se a fatia de destino não tiver capacidade suficiente, uma nova array é criada e os elementos presentes nas fatias existentes são copiados para a nova array e, finalmente, uma nova array é devolvida pela função.

package main

import "fmt"

func main() {

    slice_1 := []int{0, 1, 2}
    fmt.Println("slice_1 : ", slice_1)
    fmt.Println("Capacity of slice_1: ", cap(slice_1))

    res_1 := append(slice_1, 3)
    fmt.Println("res_1 : ", res_1)
    fmt.Println("Capacity of res_1: ", cap(res_1))

    slice_2 := make([]int, 3, 5)  //Create slice_1 with length 3 and capacity 5
    copy(slice_2, []int{0, 1, 2}) //Copy elements into slice_1
    fmt.Println("slice_2 : ", slice_2)
    fmt.Println("Capacity of slice_2: ", cap(slice_2))

    res_2 := append(slice_2, 3)
    fmt.Println("res_2 : ", res_2)
    fmt.Println("Capacity of res_2: ", cap(res_2))

}

Resultado:

slice_1 :  [0 1 2]
Capacity of slice_1:  3
res_1 :  [0 1 2 3]
Capacity of res_1:  6
slice_2 :  [0 1 2]
Capacity of slice_2:  5
res_2 :  [0 1 2 3]
Capacity of res_2:  5

Aqui slice_1 não tem capacidade suficiente para anexar novos elementos, então uma nova fatia de capacidade 6 é criada e todos os elementos presentes nas fatias existentes são copiados para a nova fatia criada.

Entretanto, a slice_2 tem capacidade suficiente para anexar novos elementos e, portanto, os elementos são anexados à fatia existente.