No voy a escribir un conjunto de post de go que permitan iniciarse en el lenguaje por que para ser sincero, no me gusta. A mi forma de ver las cosas, es un c mejorado, es decir es bastante de bajo nivel, que esta bien para hacer un montón de cosas, salvo las que hago. Por lo tanto, voy a hablar de las características del lenguaje que me llamaron la atención. Ahora voy a ver Slice.
Slice es como vectores dinámicos de c pero con muchas más utilidades.
Slice es flexible y de tamaño dinámico. En la práctica, Slice son mucho más comunes que los vectores, dado que no necesitan una cantidad fija de elementos.
El tipo [] T es un Slice con elementos del tipo T.
Se puede definir un Slice con dos índices, el inicio y el final, separados por dos puntos:
a [bajo: alto]
Esto selecciona un rango que incluye el primer elemento, pero excluye el último.
La siguiente expresión crea un Slice que incluye los elementos 1 a 3 :
a [1: 4]
Veamos un ejemplo:
package main
import "fmt"
func main() {
primes := [6]int{2, 3, 5, 7, 11, 13}
var s []int = primes[1:4]
fmt.Println(s)
}
Lo que esta en negrita es la declaración del Slice.
Un Slice no almacena ningún dato, solo describe una sección de un vector subyacente. Se puede ver como un puntero o referencia.
Cambiar los elementos de un segmento modifica los elementos correspondientes del vector subyacente. Otros Slice que comparten el mismo vector subyacente verán esos cambios.
Veamos un ejemplo:
package main
import "fmt"
func main() {
names := [4]string{
"John",
"Paul",
"George",
"Ringo",
}
fmt.Println(names)
a := names[0:2]
b := names[1:3]
fmt.Println(a, b)
b[0] = "XXX"
fmt.Println(a, b)
fmt.Println(names)
}
También podemos crear nuestros Slice por defecto usando { }, por ejemplo:
[] bool {verdadero, verdadero, falso}
Al cortar, puede omitir los límites superior o inferior para utilizar sus valores predeterminados.
El valor predeterminado es cero para el límite inferior y la longitud del segmento para el límite superior.
Para vector
var a [10] int
Estas expresiones de corte son equivalentes:
a [0:10]
a [: 10]
a [0:]
una[:]
Un Slice tiene tanto una longitud como una capacidad.
La longitud de un Slice es la cantidad de elementos que contiene.
La capacidad es el número de elementos en el vector subyacente (como tener un vector de respaldo para no tener que pedir memoria cada vez que necesitamos agregar un elemento) , contando desde el primer elemento del Slice.
La longitud y la capacidad de un Slice se pueden obtener utilizando las expresiones len y cap.
El valor cero de un slice es nulo. Y un slice nulo tiene una longitud y capacidad de 0 y no tiene un vector subyacente.
Se pueden crear Slices con una función de creación llamada make; así es como se crean vectores de tamaño dinámico.
La función make crea un Slice con valores 0:
a: = make ([] int, 5) // len (a) = 5
Para especificar una capacidad, pase un tercer argumento para hacer:
b: = make ([] int, 0, 5) // len (b) = 0, cap (b) = 5
b = b [: cap (b)] // len (b) = 5, cap (b) = 5
b = b [1:] // len (b) = 4, cap (b) = 4
Y por ahora eso es todo, continuará....
