Concatenar dos slices en marcha

  1. Declaración de Slice
  2. Concatenación de Slices
  3. Funcionamiento de la función append()

En Go, una slice es la estructura de datos dinámica que almacena múltiples elementos del mismo tipo de datos. También se puede pensar en ellos como matrices de tamaño variable que tienen indexación a partir del array, pero su tamaño no es fijo ya que se pueden redimensionar. Como los slices son de naturaleza dinámica, podemos añadir un nuevo elemento para rebanar o concatenar dos o más slices usando la función append.

Declaración de Slice

La declaración de los Slice es similar a los arrays, pero no se especifica el tamaño.

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])

}

Producción:

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

Concatenación de Slices

Usamos la función incorporada apend() para añadir elementos a la lista o concatenar dos o más slices juntas. Si hay suficiente capacidad, el destino es rebanado para acomodar los nuevos elementos. Si no hay suficiente capacidad, se asigna un nuevo subyacente y se copia el contenido. Por último, la función append devuelve la slice actualizada.

Añadir un solo elemento a la slice

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)

}

Producción:

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

Agregar múltiples elementos a una slice

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)

}

Producción:

slice_3: [1 2 3 4 5 6]

Concentrar dos slices

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)

}

Producción:

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

Un punto importante a tener en cuenta mientras se concatenan dos slices en un intento es que ... es esencial después de rebanada_4 ya que append() es una función variádica, al igual que otras funciones variádicas. ... te permite pasar múltiples argumentos a una función desde una rebanada. Aquí la función append se llama recursivamente para cada elemento de slice_4.

Añadir una cadena a una slice de bytes

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

Producción:

slice: [97 98 99 32 100 101 102]

Aquí los caracteres se codifican en UTF-8 usando 3 bytes que representan el valor ASCII de los caracteres. El byte de corte puede ser convertido de nuevo a cadena como:

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

Producción:

Slice: abc def

Funcionamiento de la función append()

La función incorporada append() toma una porción, añade todos los elementos al final de una porción de entrada y finalmente devuelve la porción concatenada. Si la rebanada de destino tiene suficiente capacidad, la rebanada es rebanada para acomodar los nuevos elementos añadidos. Pero si el destino no tiene suficiente capacidad, se crea una nueva array y los elementos presentes en las slices existentes se copian en la nueva array y, finalmente, la función devuelve una nueva array.

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))

}

Producción:

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

Aquí slice_1 no tiene suficiente capacidad para añadir nuevos elementos, por lo que se crea una nueva rebanada de capacidad 6 y todos los elementos presentes en las slices existentes se copian en la rebanada recién creada.

Sin embargo, slice_2 tiene suficiente capacidad para añadir nuevos elementos y por lo tanto los elementos se añaden en la rebanada existente.

Artículo relacionado - Go Slice

  • Cómo borrar un elemento de una rebanada en el Golang
  • Comprobar si un Slice contiene un elemento en Golang
  • Crear un Slice vacío en Go
  • Diferencia entre []String y ...String en Go