GOlang: Slices

Iniciaremos con la definición que se encuentra en la pagina del blog oficial de Go

El tipo Slice de Go provee una manera conveniente y eficiente de trabajar con secuencias de datos tipados. Un slice es un análogo de un arreglo en otros lenguajes de programación, pero con propiedades inusuales.

En este post no hablaremos de los arreglos ya que es un concepto muy viejo y si estudiaste en algún momento algo de programación sabes que son y que se puede hacer con ellos, vamos a los nuestro slices.

Empecemos por lo básico, primero que nada los arreglos no son muy utilizado en Go a diferencia de los slices que están en todos lados y están construidos sobre los arreglos para mas poder y conveniencia.

Como declaro un slice de manera literal es decir en una sola linea ya con la información que contendrá, es decir,  si queremos poner en un slice los días de la semana estos son 7 y nunca serán mas o menos.

semana := []string{"Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado"}

Si embargo también puede declararse con instrucciones construidas en el lenguaje como make

func make([]T, len, cap) []T

Donde T es por el tipo de elemento del slices a crear. Make toma el tipo, longitud y capacidad (opcional), cuando se llama a este asigna un arreglo y regresa un slice con referencia a ese arreglo.

var s []byte
s = make([]byte, 5, 5)
// s == []byte{0, 0, 0, 0, 0}

Cuando el argument de capacidad es omitido, el default es tomado de la longitud especificada.

s := make([]byte, 5)

Esto es suficiente de copy/paste del blog ahora hablemos un poco mas informal de como es el manejo, debemos de recordar que un slices es una referencia a un arreglo entonces cuales son esas diferencias que le dan tanta potencia a un slice sobre un arreglo de la que tanto estamos hablando, si se fijaron en la declaración de un arreglo de debe definir cual es el tamaño que tendrá de elementos y si este es excedido es donde tenemos el famosísimo Overflow que todos odiamos jajaja.

Cuando hablamos de slices esto no sucede lo que hace es que se realiza un calculo interno se incrementa la dimension del slice (que realmente es un arreglo de una dimension nueva y se hacer la referencia a este), veamos este calculo.

t := make([]byte, len(s), (cap(s)+1)*2) // +1 in case cap(s) == 0
for i := range s {
        t[i] = s[i]
}
s = t

Lo anterior esta tomando los campos de slice s y agregandolo a el slice t pero solo era una muestra de como se hace el calculo para incrementar su tamaño, es decir es demostrativo, si de verdad haremos una copia de un slice a otro se hace de la siguiente forma.

t := make([]byte, len(s), (cap(s)+1)*2)
copy(t, s)
s = t

Esto es un resumen, de verdad los incentivo a que se tomen el tiempo de leer acerca de todo lo que se pueda a nivel de internal no solo de slices también de structs, maps y básicamente de Go en general ya que esto hará que sus lineas de código sean mucho mejores, de manera personal les recomiendo leer bien de las tres que les comente. 

Por ultimo pero definitivamente no menos importante es como agregar un valor a un slice ya que si se quiere hacer como un array esto tendrá un grave problema, es decir, sucederá un panic (hablaremos de esto en otro post). Pero entonces como se hace, aquí entra en juego append.

func append(s []T, x ...T) []T

Se ve un poco de susto lo que dice arriba pero ya verán que no lo es aquí podemos ver una implementación y es de lo mas sencillo que pueden pensar.

a := make([]int, 1)
// a == []int{0}
a = append(a, 1, 2, 3)
// a == []int{0, 1, 2, 3}

Eso es en caso de un int, per que pasa cuando el camp es string la respuesta es, absolutamente nada se usa de ma misma manera, solo era para que tuviera mas sabor el post.

a := []string{"John", "Paul"}
b := []string{"George", "Ringo", "Pete"}
a = append(a, b...) // equivalent to "append(a, b[0], b[1], b[2])"
// a == []string{"John", "Paul", "George", "Ringo", "Pete"}

Como pueden ver hacen uso de los tres puntitos (...) es de algo que estaremos hablando en otro post no quisiera mezclar los temas, slo tomen a consideración que es algo muy funcional y que no es difícil de comprender.

Es todo por hoy Steemians y Gophers, me ire no sin antes dejarles una tarea que no esta difícil solo es cuestión de ir a blog y  leerlo, les encargo con sus palabras me digan en los comentarios cual es la diferencia entre Append y AppendByte, Nos queda mucho por ver pero seguiremos a paso tranquilo para terminar de comprender mejor de este lenguaje tan genial.

Les dejo el enlace a mi post anterior que habla acerca de SOLID principles en Go

Saludos.

Now go and code around!