Trucos con cartas

Slices

Los slices en Go son similares a los arrays de otros lenguajes. Guardan varios elementos de un tipo específico (o de una interfaz).

Los slices en Go se basan en arrays. Los arrays tienen un tamaño fijo. Un slice, en cambio, es una vista flexible y de tamaño dinámico de los elementos de un array.

Un slice se escribe como []T, donde T es el tipo de los elementos del slice:

var empty []int                 // an empty slice
withData := []int{0,1,2,3,4,5}  // a slice pre-filled with some data

Puedes obtener o asignar un elemento en un índice determinado que empieza en cero usando la notación de corchetes:

withData[1] = 5
x := withData[1] // x is now 5

Puedes crear un slice nuevo a partir de un slice existente tomando un rango de elementos. De nuevo con la notación de corchetes, pero especificando tanto un índice inicial (inclusive) como uno final (exclusive). Si no especificas un índice inicial, su valor predeterminado es 0. Si no especificas un índice final, su valor predeterminado es la longitud del slice.

newSlice := withData[2:4]
// => []int{2,3}
newSlice := withData[:2]
// => []int{0,1}
newSlice := withData[2:]
// => []int{2,3,4,5}
newSlice := withData[:]
// => []int{0,1,2,3,4,5}

Puedes agregar elementos a un slice con la función append. A continuación agregamos 4 y 2 al slice a.

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

append siempre devuelve un slice nuevo, y cuando solo queremos agregar elementos a un slice existente, es común reasignarlo a la variable del slice que pasamos como primer argumento, como hicimos arriba.

append también se puede usar para fusionar dos slices:

nextSlice := []int{100,101,102}
newSlice  := append(withData, nextSlice...)
// => []int{0,1,2,3,4,5,100,101,102}

Funciones variádicas

Por lo general, las funciones en Go solo aceptan una cantidad fija de argumentos. Sin embargo, también es posible escribir funciones variádicas en Go.

Una función variádica es una función que acepta una cantidad variable de argumentos.

Si el tipo del último parámetro en la definición de una función lleva el prefijo de puntos suspensivos ..., entonces la función puede aceptar cualquier cantidad de argumentos para ese parámetro.

func find(a int, b ...int) {
    // ...
}

En la función anterior, el parámetro b es variádico y podemos pasarle 0 o más argumentos a b.

find(5, 6)
find(5, 6, 7)
find(5)

Las funciones variádicas funcionan convirtiendo la cantidad variable de argumentos en un slice del tipo del parámetro variádico.

Aquí tienes un ejemplo de la implementación de una función variádica.

func find(num int, nums ...int) {
    fmt.Printf("type of nums is %T\n", nums)

    for i, v := range nums {
        if v == num {
            fmt.Println(num, "found at index", i, "in", nums)
            return
        }
    }

    fmt.Println(num, "not found in ", nums)
}

func main() {
    find(89, 90, 91, 95)
    // =>
    // type of nums is []int
    // 89 not found in  [90 91 95]

    find(45, 56, 67, 45, 90, 109)
    // =>
    // type of nums is []int
    // 45 found at index 2 in [56 67 45 90 109]

    find(87)
    // =>
    // type of nums is []int
    // 87 not found in  []
}

En la línea find(89, 90, 91, 95) del programa anterior, los argumentos variables de la función find son 90, 91 y 95. La función find espera un parámetro int variádico después de num. Por lo tanto, el compilador convertirá estos tres argumentos en un slice de tipo int, []int{90, 91, 95}, y luego lo pasará a la función find como nums.

A veces ya tienes un slice y quieres pasarlo a una función variádica. Puedes lograrlo pasando el slice seguido de .... Eso le indica al compilador que use el slice tal cual dentro de la función variádica. En este caso, simplemente se omite el paso descrito arriba en el que se crea un slice.

list := []int{1, 2, 3}
find(1, list...) // "find" defined as shown above