El segmento de lenguaje de Go es más poderoso, flexible y conveniente que una array y es una estructura de datos liviana. Un segmento es una secuencia de longitud variable que almacena elementos de un tipo similar, no está permitido almacenar diferentes tipos de elementos en el mismo segmento. Es como una array que tiene un valor de índice y una longitud, pero el tamaño del segmento cambia de tamaño, no tienen un tamaño fijo como una array.
Como ya sabemos, el segmento es dinámico, por lo que el nuevo elemento se puede agregar a un segmento con la ayuda de la función append(). Esta función agrega el nuevo elemento al final del segmento.
Sintaxis:
func append(s []T, x ...T) []T
Aquí, esta función toma s slice y x…T significa que esta función toma un número variable de argumentos para el parámetro x . Este tipo de función también se conoce como función variadica.
Si el segmento está respaldado por la array y los arreglos tienen una longitud fija, ¿cómo es posible que un segmento tenga una longitud dinámica?
Bueno, la respuesta es cuando los nuevos elementos se agregan al segmento, se crea una nueva array. Ahora, los elementos presentes en la array existente se copian en una nueva array y devuelven una nueva referencia de segmento a esta array (nueva array). Entonces, debido a esto, la capacidad del segmento será el doble de la capacidad anterior (como se muestra en el ejemplo 1). Pero si el segmento existente tiene suficiente capacidad para contener nuevos elementos, entonces no se crea una array nueva y los elementos se almacenan en la array subyacente existente (como se muestra en el ejemplo 2).
Ejemplo 1:
// Go program to illustrate the
// concept of appending slices.
package main
import (
"fmt"
)
func main() {
// Creating and initializing slice
// Using shorthand declaration
s1 := []int{234, 567, 7890, 1234, 234}
s2 := []string{"Geeks", "For", "Geeks"}
// Displaying slices with
// their length and capacity
fmt.Println("Slice_1: ", s1)
fmt.Println("Length of Slice_1: ", len(s1))
fmt.Println("Capacity of Slice_1: ", cap(s1))
fmt.Println()
fmt.Println("Slice_2: ", s2)
fmt.Println("Length of Slice_2: ", len(s2))
fmt.Println("Capacity of Slice_2: ", cap(s2))
// Appending slices
// Using append() function
res1 := append(s1, 1000)
res2 := append(s2, "GFG")
// Displaying results
fmt.Println()
fmt.Println("New slice_1: ", res1)
fmt.Println("New length of slice_1: ", len(res1))
fmt.Println("New capacity of slice_1: ", cap(res1))
fmt.Println()
fmt.Println("New slice_2: ", res2)
fmt.Println("New length of slice_2: ", len(res2))
fmt.Println("New capacity of slice_2: ", cap(res2))
}
Producción:
Slice_1: [234 567 7890 1234 234] Length of Slice_1: 5 Capacity of Slice_1: 5 Slice_2: [Geeks For Geeks] Length of Slice_2: 3 Capacity of Slice_2: 3 New slice_1: [234 567 7890 1234 234 1000] New length of slice_1: 6 New capacity of slice_1: 12 New slice_2: [Geeks For Geeks GFG] New length of slice_2: 4 New capacity of slice_2: 6
Ejemplo 2:
// Go program to illustrate the
// concept of appending slices.
package main
import "fmt"
func main() {
// Creating and initializing slice
// Using make() function
// Here 4 and 6 is the length
// and capacity of the slice
s1 := make([]int, 4, 6)
// Copying the elements in the slice
// Using copy() function
copy(s1, []int{123, 456, 789, 977})
// Displaying slice
fmt.Println("Slice : ", s1)
fmt.Println("Length: ", len(s1))
fmt.Println("Capacity: ", cap(s1))
// Appending slice
// Using append() function
s2 := append(s1, 3454, 678)
// Displaying slice
fmt.Println()
fmt.Println("Slice : ", s2)
fmt.Println("Length: ", len(s2))
fmt.Println("Capacity: ", cap(s2))
}
Producción:
Slice : [123 456 789 977] Length: 4 Capacity: 6 Slice : [123 456 789 977 3454 678] Length: 6 Capacity: 6
Agregando a segmento nulo: Como sabemos, el tipo de segmento de valor cero es nulo y la capacidad y la longitud de dicho tipo de segmento es 0. Pero con la ayuda de la función de agregar, es posible agregar valores a segmento nulo.
Ejemplo:
// Go program to illustrate the
// concept of appending to nil slice.
package main
import "fmt"
func main() {
// Creating nil slice
var s1 []int
// Displaying slice
fmt.Println("Slice : ", s1)
fmt.Println("Length: ", len(s1))
fmt.Println("Capacity: ", cap(s1))
// Appending to nil slice
// Using append() function
s2 := append(s1, 89, 45, 67, 23)
// Displaying slice
fmt.Println()
fmt.Println("Slice : ", s2)
fmt.Println("Length: ", len(s2))
fmt.Println("Capacity: ", cap(s2))
}
Producción:
Slice : [] Length: 0 Capacity: 0 Slice : [89 45 67 23] Length: 4 Capacity: 4
Anexar a otro segmento usando el operador…: Se le permite agregar un segmento a otro con la ayuda del operador ….
Ejemplo:
// Go program to illustrate the concept
// of appending to another slice.
package main
import "fmt"
func main() {
// Creating and initializing slice
// Using shorthand declaration
s1 := []int{234, 567, 7890, 1234, 234}
s2 := []int{10, 100, 1000, 10000}
// Displaying slices with their
// length and capacity
fmt.Println("Slice_1: ", s1)
fmt.Println("Length of Slice_1: ", len(s1))
fmt.Println("Capacity of Slice_1: ", cap(s1))
fmt.Println()
fmt.Println("Slice_2: ", s2)
fmt.Println("Length of Slice_2: ", len(s2))
fmt.Println("Capacity of Slice_2: ", cap(s2))
// Appending to another slice
// Using append() function
res1 := append(s1, s2...)
// Displaying result
fmt.Println()
fmt.Println("New slice_1: ", res1)
fmt.Println("New length of slice_1: ", len(res1))
fmt.Println("New capacity of slice_1: ", cap(res1))
}
Producción:
Slice_1: [234 567 7890 1234 234] Length of Slice_1: 5 Capacity of Slice_1: 5 Slice_2: [10 100 1000 10000] Length of Slice_2: 4 Capacity of Slice_2: 4 New slice_1: [234 567 7890 1234 234 10 100 1000 10000] New length of slice_1: 9 New capacity of slice_1: 12
Publicación traducida automáticamente
Artículo escrito por ankita_saini y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA