Array y Slice en Go (Golang)

Es tiempo de continuar con la serie de publicaciones dedicadas al lenguaje Go. Sé que hace más de una semana que publiqué el último, me disculpo por eso, ahora a compensar el retraso.

<h2>Arreglos <p dir="auto"><br /> <blockquote> <p dir="auto">En programación se conoce vector o arreglo​ a una zona de almacenamiento contiguo que contiene una serie de elementos del mismo tipo, los elementos de la matriz.​ Desde el punto de vista lógico una matriz se puede ver como un conjunto de elementos ordenados en fila (o filas y columnas si tuviera dos dimensiones).<br /> Fuente: <a href="https://es.wikipedia.org/wiki/Vector_(inform%C3%A1tica)" target="_blank" rel="nofollow noreferrer noopener" title="This link will take you away from hive.blog" class="external_link">Wikipedia <p dir="auto">Si no conocen los arreglos, recomiendo investigar un poco más al respecto para sacar el mayor provecho de esta publicación, debido a que me limitaré a explicar como funciona específicamente en el lenguaje Go.<br /> Hasta ahora hemos visto tipos de datos sencillos como Números enteros, Decimales, Cadenas de texto y Booleanos, abordando, con estos, algunas características del lenguaje. Pero en ocasiones es necesario agrupar valores con cierta relación, por ejemplo un conjunto de nombres; basado en lo que hemos aprendido podríamos hacer algo como lo siguiente. <pre><code>var nombre1 = "Ana" var nombre2 = "José" var nombre3 = "Daniel" var nombre4 = "María" var nombre5 = "Carlos" <p dir="auto"><br /><br /> Bueno, eso podría funcionar, pero quizás necesiten 10 valores, o 20, o no conozcan exactamente cuantos valores van a necesitar. En esos casos los arreglos son muy útiles. Retomemos el ejemplo anterior. <pre><code>var nombres [5]string nombres[0] = "Ana" nombres[1] = "José" nombres[2] = "Daniel" nombres[3] = "María" nombres[4] = "Carlos" <p dir="auto"><br /><br /> Es posible que estén pensando que es prácticamente lo mismo y ahora hasta toca escribir una línea más. En parte tienen razón, en este caso quizás una sintaxis como las siguiente resulte más práctica. <p dir="auto"><code>nombres := [5]string{"Ana", "José", "Daniel", "María", "Carlos"} <p dir="auto">Supongo que ya conocen las declaración corta; en ambos casos estamos declarando una variable con el identificador <code>nombres que contiene un arreglo de 5 elementos de tipo <code>string. Es importante saber que los arreglos en <strong>Go sólo pueden contener elementos de un mismo tipo, en este caso cadenas de texto, además que su tamaño es fijo. Veámos un ejemplo para comprobarlo. <pre><code>var numeros [10]int fmt.Println(numeros) // [0 0 0 0 0 0 0 0 0 0] <p dir="auto"><br /><br /> Si recuerdan, al declarar una variable <strong>Go le da su valor <em>cero como valor inicial, en este caso, al ser un arreglo de 10 elementos de tipo <code>int, se crea un arreglo con 10 ceros, siendo 0 el valor <em>cero, valga la redundancia, de las variables de tipo <code>int; tal como en el primer ejemplo, podemos acceder y modificar cada valor en el Arreglo a través de su indice, el cual comienza a enumerarse desde el 0, es decir, siendo este un arreglo de 10 valores, el indice del último valor sería 9. Veamos un ejemplo de esto. <pre><code>numeros[0] = 6 numeros[2] = 9 numeros[5] = 18 numeros[9] = 15 n := numeros[5] fmt.Println("El valor de n es", n) // El valor de n es 18 fmt.Println(numeros) // [6 0 9 0 0 18 0 0 0 15] <p dir="auto"><br /><br /> Como pueden ver, a través de la sintaxis de corchetes podemos acceder al valor en la posición correspondiente en el arreglo tanto para asignar un nuevo valor como para realizar una operación con él, como asignarlo a otra variable. Otra característica interesante es que podemos acceder tanto a la longitud de un arreglo como a su capacidad (hablaré un poco mas al respecto en la siguiente parte) haciendo uso de las funciones integradas <code>len y <code>cap respectivamente. <pre><code>fmt.Println(len(numeros)) // 10 fmt.Println(cap(numeros)) // 10 <p dir="auto"><br /><br /> Esto es muy útil, por ejemplo, para acceder al último elemento en un arreglo, sin importar su longitud sabemos que su último indice coincide con el valor de su longitud menos uno, en el caso del presente ejemplo: <code>len(numeros) – 1. <h1>Slices <p dir="auto">Ahora que ya sabemos lo que es un <code>array en <strong>Go entender lo que es un <code>slice no debería suponer problema alguno. Si recuerdas, en el apartado anterior aclaraba que los arreglos tienen un tamaño fijo, y pudieron notar que su capacidad y longitud coincidían, por lo posiblemente se estén cuestionando la utilidad de conocer el valor de capacidad. Los slices pueden verse como arreglos de longitud dinámica, siendo un poco más técnicos, un slice apunta a un array, claro que aún no hablamos de punteros, estoy preparando una publicación específica para ellos, por el momento no se preocupen. Veamos un ejemplo. <pre><code>nombresArray := [5]string{"Ana", "José", "Daniel", "María", "Carlos"} nombresSlice := nombresArray[0:3] fmt.Println(nombresSlice) // [Ana José Daniel] fmt.Println(len(nombresSlice)) // 3 fmt.Println(cap(nombresSlice)) // 5 <p dir="auto"><br /><br /> Con excepción del nombre el arreglo en la primera línea , se trata del mismo arreglo que vimos antes, la parte interesante es la siguiente línea, a la variable <code>nombresSlice se le asigna una <em>porción de <code>nombresArray; la regla de los indices es la misma, el valor 0 hace referencia a la primera posición en el arreglo, el número 3 que se encuentra después de los dos puntos indican la posición final a la que deseamos acceder, sin embarco, esta no incluye al valor en dicha posición sino al anterior a este; por tal motivo, el valor en el indice 3, María, no se incluye en el <code>nombresSlice.<br /> Si observamos ahora la salida de las últimas dos líneas, notaremos que, a diferencia del ejemplo con arreglos, los valores de longitud y capacidad no son iguales. Es decir, el valor de longitud es el esperado (3), pero la capacidad es de 5. Me parece que esto es más fácil de entender con un ejemplo. <pre><code>nombresArray := [5]string{"Ana", "José", "Daniel", "María", "Carlos"} nombresSlice := nombresArray[0:3] fmt.Println(nombresSlice) // [Ana José Daniel] fmt.Printf("len %d - cap %d\n", len(nombresSlice), cap(nombresSlice)) // len 3 - cap 5 nombresSlice = append(nombresSlice, "Antonio") fmt.Printf("len %d - cap %d\n", len(nombresSlice), cap(nombresSlice)) // len 4 - cap 5 nombresSlice = append(nombresSlice, "Daniela") fmt.Printf("len %d - cap %d\n", len(nombresSlice), cap(nombresSlice)) // len 5 - cap 5 nombresSlice = append(nombresSlice, "Carmen") fmt.Printf("len %d - cap %d\n", len(nombresSlice), cap(nombresSlice)) // len 6 - cap 10 fmt.Println(nombresSlice) // [Ana José Daniel Antonio Daniela Carmen] <p dir="auto"><br /><br /> Por una parte estamos conociendo la función <code>append, creo que podrán suponer lo que hace, toma como primer argumento un <code>slice y por segundo a un valor o valores a ser añadidos al <code>slice y retorna un nuevo <code>slice con todos los valores del anterior además del nuevo valor. Por otra parte notamos que a medida que añadimos elementos al <code>slice su longitud se incrementa pero su capacidad se mantiene hasta que la longitud la supera, llegado a ese punto la capacidad del <code>slice se duplica. Ese es básicamente el comportamiento natural de los <code>slice. Perfecto, ahora sabemos que podemos crear un <code>slice a partir de un <code>array existente, pero esa no es la única manera, veamos otras opciones. <pre><code>var numeros1 []int numeros2 := []int{1, 2, 3, 4, 5, 6} numeros3 := make([]int, 5) fmt.Println(numeros1) // [] fmt.Println(numeros2) // [1 2 3 4 5 6] fmt.Println(numeros3) // [0 0 0 0 0] <p dir="auto"><br /><br /> Analicemos un poco el código anterior, en el primer caso declaramos una variable <code>numeros1 como un <code>slice de elementos <code>int, es muy similar a como declaramos un <code>array en casos anteriores con la única diferencia de que no pasamos ningún valor en los corchetes, por lo que se inicializa como un <code>slice vacío. En el segundo caso usamos la declaración corta, pasando directamente un grupo de valores entre llaves, nuevamente es muy similar a la declaración de un <code>array con la ausencia de un valor entre los corchetes. Finalmente tenemos la declaración de un <code>slice utilizando la función <code>make, esta función no solo permite construir <code>slice pero por el momento es suficiente con entender que estamos creando un <code>slice de números enteros con una capacidad inicial de 10, también es posible establecer explícitamente un valor inicial para la longitud del <code>slice pasando otro valor numérico a la función <code>make. <h1>Recorriendo Arreglos y Slices <p dir="auto">En una <a href="https://steemit.com/cervantes/@orlmicron/estructuras-de-control-de-flujo-en-go" target="_blank" rel="nofollow noreferrer noopener" title="This link will take you away from hive.blog" class="external_link">publicación pasada conocimos los ciclos en <strong>Go, más específicamente el ciclo <code>for y sus variantes. Como en muchos lenguajes de programación los ciclos permiten recorrer los valores de un arreglo, y de un <code>slice en este caso, de manera bastante sencilla. <pre><code>nombresArray := [5]string{"Ana", "José", "Daniel", "María", "Carlos"} for i := 0; i < len(nombresArray); i++ { fmt.Println(nombresArray[i]) } // Ana // José // Daniel // María // Carlos <p dir="auto"><br /><br /> Nada raro, muy sencillo. Tomamos lo que ya sabemos del ciclo <code>for y lo combinamos con lo que acabamos de aprender de los arreglos/slices y el resultado parece bastante natural. Inicializamos la variable <code>i con el valor 0, comprobamos la condición, que el valor actual de <code>i sea menor a la longitud del arreglo, realizamos la impresión de cada valor del arreglo accediendo ellos por medio de su indice, el cual introducimos de manera dinámica gracias a la variable <code>i que comenzará en 0 e irá incrementándose hasta que alcance el valor de la longitud del arreglo, 10 en nuestro caso, en ese momento la condición deja de cumplirse y el ciclo termina. Sin embargo <strong>Go nos proporciona una forma aún mas sencilla para recorrer un arreglo/slice, otra variación del ciclo <code>for que también fue explicada con anterioridad, así que me limitaré a mostrar su uso. <pre><code>nombresArray := [5]string{"Ana", "José", "Daniel", "María", "Carlos"} for i, v := range nombresArray { fmt.Printf("Indice %d valor %s\n", i, v) } // Indice 0 valor Ana // Indice 1 valor José // Indice 2 valor Daniel // Indice 3 valor María // Indice 4 valor Carlos <p dir="auto"><br /><br /> Esta variación del ciclo <code>for que me gusta llamar for-range, es muy parecida a lo que se conoce como <code>foreach en otros lenguajes de programación. El resultado es el mismo, prácticamente, pero no requiere conocer explícitamente la longitud el arreglo, el ciclo comenzará en el indice 0 del arreglo y lo recorrerá hasta el final. Otro detalle importante es que el <code>range retorna dos valores, el primero es el indice y el segundo el valor. <p dir="auto"><center><br /> <img src="https://images.hive.blog/768x0/https://cdn.steemitimages.com/DQmXF55A7pDHvVu4K73h6TgCoH5UpC1WUHFAFhn76NUVgUC/separator.png" alt="separator orlando monteverde" srcset="https://images.hive.blog/768x0/https://cdn.steemitimages.com/DQmXF55A7pDHvVu4K73h6TgCoH5UpC1WUHFAFhn76NUVgUC/separator.png 1x, https://images.hive.blog/1536x0/https://cdn.steemitimages.com/DQmXF55A7pDHvVu4K73h6TgCoH5UpC1WUHFAFhn76NUVgUC/separator.png 2x" /><br /> <center> <h2>Publicaciones relacionadas <ol> <li><p dir="auto"><a href="https://steemit.com/cervantes/@orlmicron/de-python-a-go-golang" target="_blank" rel="nofollow noreferrer noopener" title="This link will take you away from hive.blog" class="external_link">De Python a Go (Golang) <li><p dir="auto"><a href="https://steemit.com/cervantes/@orlmicron/introduccion-al-lenguaje-de-programacion-go-golang" target="_blank" rel="nofollow noreferrer noopener" title="This link will take you away from hive.blog" class="external_link">Introducción al lenguaje de programación Go (Golang) <li><p dir="auto"><a href="https://steemit.com/cervantes/@orlmicron/estructuras-de-control-de-flujo-en-go" target="_blank" rel="nofollow noreferrer noopener" title="This link will take you away from hive.blog" class="external_link">Estructuras de control de flujo en Go <p dir="auto">Gracias por leer, espero que este articulo te resultara de provecho. Si así fue, no dudes en dejar un <strong>comentario, <strong>compartirlo y <strong>votar. Te invito a comentar cualquier <strong>duda o <strong>sugerencia, te aseguro que las leo todas. Así que, por favor, ayúdame a mejorar y continuar compartiendo contenido de calidad. Hasta la próxima. <p dir="auto"><img src="https://images.hive.blog/768x0/https://cdn.steemitimages.com/DQmQU5fep6GDnVe1KD4jRgxwD6DcBNvwWPTx82DKBWeciew/banner-steemit.jpg" alt="banner orlando monteverde.jpg" srcset="https://images.hive.blog/768x0/https://cdn.steemitimages.com/DQmQU5fep6GDnVe1KD4jRgxwD6DcBNvwWPTx82DKBWeciew/banner-steemit.jpg 1x, https://images.hive.blog/1536x0/https://cdn.steemitimages.com/DQmQU5fep6GDnVe1KD4jRgxwD6DcBNvwWPTx82DKBWeciew/banner-steemit.jpg 2x" />