Go
Rebanadas

Introducción

Sintaxis

• slice: = make ([] type, len, cap) // crea un nuevo slice
• slice = append (slice, item) // agregar un elemento a una división
• slice = append (slice, items ...) // anexar slice of items a una porción
• len: = len (slice) // obtiene la longitud de un segmento
• cap: = cap (slice) // obtiene la capacidad de un slice
• elNum: = copy (dst, slice) // copia el contenido de un sector a otro sector

Anexando a rebanar

slice = append(slice, "hello", "world")

Sumando dos rebanadas juntas

slice1 := []string{"!"}
slice2 := []string{"Hello", "world"}
slice  := append(slice1, slice2...)

Correr en el patio de juegos ir

Eliminando elementos / "rebanando" rodajas

Si necesita eliminar uno o más elementos de una división, o si necesita trabajar con una subdivisión de otra existente; Puedes usar el siguiente método.

Los siguientes ejemplos usan slice de int, pero eso funciona con todo tipo de slice.

Entonces para eso necesitamos una porción, de donde eliminaremos algunos elementos:

slice := []int{1, 2, 3, 4, 5, 6} 
// > [1 2 3 4 5 6]

Necesitamos también los índices de elementos para eliminar:

// index of first element to remove (corresponding to the '3' in the slice)
var first = 2

// index of last element to remove (corresponding to the '5' in the slice)
var last = 4 

Y así podemos "cortar" la porción, eliminando elementos no deseados:

// keeping elements from start to 'first element to remove' (not keeping first to remove), 
// removing elements from 'first element to remove' to 'last element to remove'
// and keeping all others elements to the end of the slice
newSlice1 := append(slice[:first], slice[last+1:]...)
// > [1 2 6]

// you can do using directly numbers instead of variables
newSlice2 := append(slice[:2], slice[5:]...)
// > [1 2 6]

// Another way to do the same
newSlice3 := slice[:first + copy(slice[first:], slice[last+1:])]
// > [1 2 6]

// same that newSlice3 with hard coded indexes (without use of variables)
newSlice4 := slice[:2 + copy(slice[2:], slice[5:])]
// > [1 2 6]

Para eliminar solo un elemento, solo hay que colocar el índice de este elemento como el primer Y como el último índice que se eliminará, así:

var indexToRemove = 3
newSlice5 := append(slice[:indexToRemove], slice[indexToRemove+1:]...)
// > [1 2 3 5 6]

// hard-coded version:
newSlice5 := append(slice[:3], slice[4:]...)
// > [1 2 3 5 6]

Y también puedes eliminar elementos desde el principio de la división:

newSlice6 := append(slice[:0], slice[last+1:]...)
// > [6]

// That can be simplified into
newSlice6 := slice[last+1:]
// > [6]

También puedes eliminar algunos elementos del final de la división:

newSlice7 := append(slice[:first], slice[first+1:len(slice)-1]...)
// > [1 2]

// That can be simplified into
newSlice7 := slice[:first]
// > [1 2]

Si la nueva división tiene que contener exactamente los mismos elementos que la primera, puede usar la misma cosa pero con la last := first-1 .
(Esto puede ser útil en caso de que sus índices se hayan calculado previamente)

Longitud y capacidad

Las rebanadas tienen tanto longitud como capacidad. La longitud de una división es el número de elementos que hay actualmente en la división, mientras que la capacidad es la cantidad de elementos que la división puede contener antes de que sea necesario reasignarla.

Al crear una división utilizando la función integrada make() , puede especificar su longitud y, opcionalmente, su capacidad. Si la capacidad no se especifica explícitamente, será la longitud especificada.

var s = make([]int, 3, 5) // length 3, capacity 5

Puede verificar la longitud de un sector con la función len() incorporada:

var n = len(s) // n == 3

Puede verificar la capacidad con la función cap() incorporada:

var c = cap(s) // c == 5

Los elementos creados por make() se establecen en el valor cero para el tipo de elemento de la división:

for idx, val := range s {
    fmt.Println(idx, val)
}
// output:
// 0 0
// 1 0
// 2 0

Ejecutalo en play.golang.org

No puede acceder a elementos más allá de la longitud de una porción, incluso si el índice está dentro de la capacidad:

var x = s[3] // panic: runtime error: index out of range

Sin embargo, siempre que la capacidad exceda la longitud, puede agregar nuevos elementos sin reasignar:

var t = []int{3, 4}
s = append(s, t) // s is now []int{0, 0, 0, 3, 4}
n = len(s) // n == 5
c = cap(s) // c == 5

Si se agrega a una porción que carece de la capacidad para aceptar los nuevos elementos, la matriz subyacente se reasignará para usted con suficiente capacidad:

var u = []int{5, 6}
s = append(s, u) // s is now []int{0, 0, 0, 3, 4, 5, 6}
n = len(s) // n == 7
c = cap(s) // c > 5

Por lo tanto, generalmente es una buena práctica asignar suficiente capacidad al crear una porción, si sabe cuánto espacio necesitará, para evitar reasignaciones innecesarias.

Copiando contenidos de una rebanada a otra rebanada

Si desea copiar el contenido de un sector en un sector inicialmente vacío, se pueden seguir los siguientes pasos para lograrlo:

1. Crear la porción de origen:

var sourceSlice []interface{} = []interface{}{"Hello",5.10,"World",true}

2. Crea la porción de destino, con:

• Longitud = longitud de sourceSlice

var destinationSlice []interface{} = make([]interface{},len(sourceSlice))

3. Ahora que la matriz subyacente de la porción de destino es lo suficientemente grande para acomodar todos los elementos de la porción de origen, podemos proceder a copiar los elementos utilizando la copy incorporada:

copy(destinationSlice,sourceSlice)

Creando Rebanadas

Los segmentos son la forma típica en que los programadores almacenan las listas de datos.

Para declarar una variable de división, use la sintaxis de []Type .

var a []int

Para declarar e inicializar una variable de división en una línea, use la sintaxis de []Type{values} .

var a []int = []int{3, 1, 4, 1, 5, 9}

Otra forma de inicializar un sector es con la función make . Tiene tres argumentos: el Type de sector (o mapa ), la length y la capacity .

a := make([]int, 0, 5)

Puedes agregar elementos a tu nueva rebanada usando el append .

a = append(a, 5)

Verifique el número de elementos en su porción usando len .

length := len(a)

Verifica la capacidad de tu rebanada usando la cap . La capacidad es el número de elementos asignados actualmente para estar en la memoria para el sector. Siempre se puede agregar a una porción a capacidad, ya que Go creará automáticamente una porción más grande para usted.

capacity := cap(a)

Puede acceder a los elementos de un sector utilizando la sintaxis de indexación típica.

a[0]  // Gets the first member of `a`

También puede utilizar un bucle for sobre segmentos con range . La primera variable es el índice en la matriz especificada, y la segunda variable es el valor para el índice.

for index, value := range a {
    fmt.Println("Index: " + index + " Value: " + value)  // Prints "Index: 0 Value: 5" (and continues until end of slice)
}

Ir al patio de recreo

Filtrando una rebanada

Para filtrar una porción sin asignar una nueva matriz subyacente:

// Our base slice
slice := []int{ 1, 2, 3, 4 }
// Create a zero-length slice with the same underlying array
tmp := slice[:0]

for _, v := range slice {
  if v % 2 == 0 {
    // Append desired values to slice
    tmp = append(tmp, v)
  }
}

// (Optional) Reassign the slice
slice = tmp // [2, 4]

Valor cero de la rebanada

El valor cero de slice es nil , que tiene la longitud y la capacidad 0 . Una porción nil no tiene una matriz subyacente. Pero también hay segmentos no nulos de longitud y capacidad 0 , como []int{} o make([]int, 5)[5:] .

Cualquier tipo que tenga valores nulos se puede convertir en un segmento nil :

s = []int(nil)

Para probar si una rebanada está vacía, use:

if len(s) == 0　{
    fmt.Ptintf("s is empty.")
}