One place for hosting & domains

      matrices

      Cómo renderizar matrices en React


      Introducción

      Este artículo le enseñará a renderizar una matriz en React y cuáles son las mejores prácticas para renderizar diferentes elementos dentro de los componentes.

      Una de las ventajas de usar un lenguaje web moderno como JavaScript es que puede automatizar rápidamente la generación de los fragmentos HTML.

      Usar algo similar a un bucle, en vez de una matriz o un objeto, significa que solo debe escribir el HTML para cada elemento una sola vez. Mejor aún, las futuras ediciones solo deben aplicarse una vez.

      Cómo renderizar múltiples elementos

      Para renderizar múltiples elementos JSX en React, puede ejecutar un bucle en una matriz con el método .map() y devolver un solo elemento.

      A continuación, ejecute un bule en la matriz reptiles y devuelva un elemento li para cada elemento en la matriz. Puede usar este método cuando desee mostrar un solo elemento para cada elemento de la matriz:

      function ReptileListItems() {
        const reptiles = ["alligator", "snake", "lizard"];
      
        return reptiles.map((reptile) => <li>{reptile}</li>);
      }
      

      El resultado tendrá el siguiente aspecto:

      Output

      - alligator - snake - lizard

      En el siguiente ejemplo, examinará por qué es recomendable añadir una key única a una lista de elementos renderizados por una matriz.

      Cómo renderizar una colección de elementos dentro de un componente

      En este ejemplo, ejecutará un bucle en una matriz y creará una serie de componentes de elemento de lista, como en el ejemplo anterior.

      Para comenzar, actualice el código para usar el componente <ol> para mantener los elementos <li>. El componente <ol> creará una lista ordenada de los elementos:

      function ReptileList() {
        const reptiles = ["alligator", "snake", "lizard"];
      
        return (
          <ol>
            {reptiles.map((reptile) => (
              <li>{reptile}</li>
            ))}
          </ol>
        );
      }
      

      Sin embargo, si observa la consola, verá una advertencia indicando que cada elemento secundario en una matriz o iterador debe tener una key única.

      Advertencia en la consola

      La advertencia aparece porque, al intentar renderizar una colección dentro de un componente, debe agregar una key.

      En React, se utiliza una key única para determinar cuáles de los componentes de una colección deben volverse a renderizar. Añadir una key única evita que React tenga que volver a renderizar todo el componente cada vez que haya una actualización.

      En este paso, renderizará múltiples elementos en un componente y añadirá una key única. Actualice el código para incluir una key en los elementos de la lista para resolver la advertencia:

      function ReptileList() {
        const reptiles = ['alligator', 'snake', 'lizard'];
      
        return (
          <ol>
            {reptiles.map(reptile => (
              <li key={reptile}>{reptile}</li>
            ))}
          </ol>
        );
      }
      
      

      Ahora que añadió una key, la advertencia ya no aparecerá en la consola.

      En el siguiente ejemplo, verá cómo renderizar elementos adyacentes sin encontrar un error de sintaxis común.

      Cómo renderizar elementos adyacentes

      En JSX, para renderizar más de un elemento en un componente, debe agregar un contenedor alrededor de ellos.

      En este ejemplo, primero devolverá una lista de elementos sin ejecutar un bucle en una matriz:

      function ReptileListItems() {
        return (
          <li>alligator</li>
          <li>snake</li>
          <li>lizard</li>
        );
      }
      

      Esto generará un error grave en la consola:

      Error grave de React para elementos JSX adyacentes

      Para solucionar este error, deberá encapsular el bloque de elementos li en un contenedor. Para obtener una lista, puede encapsularlos en un elemento ol o ul:

      function ReptileListItems() {
        return (
        <ol>
          <li>alligator</li>
          <li>snake</li>
          <li>lizard</li>
        </ol>
        );
      }
      

      Los elementos <li> adyacentes ahora están encapsulados en una etiqueta <ol>, y ya no se visualizará el error.

      En la siguiente sección, renderizará una lista en un contenedor usando un componente fragment.

      Cómo renderizar elementos adyacentes con React.fragment

      Antes de React v16.2, un bloque de componentes se podía encapsular en un elemento <div>. Esto daba como resultado a una aplicación llena de divs, a menudo denominada “div soup”.

      Para solucionar este problema, React lanzó un nuevo componente conocido como fragment:

      Cuando necesite renderizar una lista dentro de una etiqueta cerrada, pero quiera evitar tener que usar un div, puede usar React.Fragment en su lugar:

      function ReptileListItems() {
        return (
        <React.Fragment>
           <li>alligator</li>
           <li>snake</li>
           <li>lizard</li>
        </React.Fragment>
        );
      }
      

      El código renderizado solo incluirá los elementos li, y el componente React.Fragment no aparecerá en el código.

      Elementos JSX renderizados dentro de un contenedor React.Fragment

      Además, tenga en cuenta que con React.fragment no necesita añadir una key.

      Notará que escribir React.fragment es más tedioso que añadir un <div>. Por suerte, el equipo de React desarrolló una sintaxis más corta para representar este componente. Puede usar <> </> en lugar de <React.Fragment></React.Fragment>:

      function ReptileListItems() {
        return (
       <>
          <li>alligator</li>
          <li>snake</li>
          <li>lizard</li>
       </>
        );
      }
      

      Conclusión

      En este artículo, analizó varios ejemplos para renderizar matrices en una aplicación React.

      Al renderizar un elemento dentro de otro componente, debe usar una key única y encapsular los elementos dentro de un elemento contenedor.

      Dependiendo de su caso de uso, puede crear listas simples encapsuladas en un componente fragment que no necesite una key.

      Para obtener más información sobre las mejores prácticas en React, siga la serie completa Cómo codificar en React.js en DigitalOcean.



      Source link

      Cuatro métodos para realizar búsqueda a través de matrices en JavaScript


      En JavaScript, hay muchas maneras útiles de encontrar elementos en matrices. Siempre puede recurrir al bucle básico for, pero con ES6+ hay muchos métodos para recorrer la matriz y encontrar lo que necesita con facilidad.

      Con tantos métodos diferentes, ¿cuál se debería utilizar y en qué caso? Por ejemplo, al realizar una búsqueda en una matriz, ¿quiere saber si un elemento específico está en la matriz? ¿Necesita el índice del elemento o el elemento en sí?

      Con cada método diferente que cubriremos, es importante comprender que todos estos métodos están integrados en Array.prototype. Eso significa que simplemente necesita encadenarlos a cualquier matriz con notación de punto. Esto también significa que estos métodos no están disponibles en objetos o cualquier otra cosa que no sean matrices (aunque hay superposición con cadenas).

      Observemos los siguientes métodos de matriz:

      includes

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout"];
      
      alligator.includes("thick scales"); // returns true
      

      El método .includes() devuelve un valor booleano y es ideal para indicarle si un elemento existe o no en una matriz. Da una simple respuesta de verdadero true o falso false. Esta es la sintaxis básica:

      arr.includes(valueToFind, [fromIndex]);
      

      Como ve en nuestro ejemplo, solo obtuvimos un parámetro: valueToFind. Este es el valor que debe coincidir en la matriz. El valor opcional fromIndex es un número que indica qué índice debería comenzar a buscar (por defecto es 0, por lo que realiza una búsqueda en toda la matriz). Por lo tanto, dado que en nuestro ejemplo el elemento ‘thick scales’ está en el índice 0, lo siguiente sería falso: alligator.includes('thick scales', 1); ya que comienza a buscar desde el índice 1 en adelante.

      Ahora, hay algunas cosas importantes a tener en cuenta. Este método .includes() utiliza una comparación estricta. Eso significa que, del ejemplo anterior, lo siguiente debería devolver falso: alligator.includes('80'); eso se debe a que aunque 80 == '80' es verdadero, 80 === '80' es falso: diferentes tipos no pasarán la comparación estricta.

      find

      ¿Cuál es la diferencia entre los métodos .find() e includes()? Si en nuestro ejemplo solo cambiamos el texto “includes” por “find”, obtendremos este error:

      Uncaught TypeError: thick scales is not a function
      

      Eso se debe a que el método find requiere una función para ser aprobado. Esto se debe a que el método find no usa solo el operador de comparación simple como en el caso del método “includes()”. En vez de eso, pasará cada elemento a su función y verá si devuelve verdadero o falso. Aunque esto funcione: alligator.find(() => 'thick scales');, probablemente sea recomendable poner su propio operador de comparación en la función para que devuelva cualquier valor relevante.

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout"];
      
      alligator.find(el => el.length < 12); // returns '4 foot tail'
      

      Esta sencilla función en nuestro método find busca cada elemento de la matriz, con el alias de ‘el’ que se le asigne y se detiene cuando encuentra el primero que sea verdadero. En nuestro caso, verdadero tiene una propiedad de longitud inferior a 12 (los números no tienen una propiedad de longitud). Por supuesto, puede hacer que esta función sea tan compleja como sea necesario, haciendo que su condición de verdadero se ajuste a sus necesidades.

      Observe también que esto no devolvió true. El método find no devuelve un booleano, pero en vez de eso devuelve el primer elemento que coincida. Si no hay un elemento que coincida, ya que no hay nada que cumpla con los criterios definidos en su función, devolverá undefined. También tenga en cuenta que devuelve solo la primera coincidencia, por lo que si hay más de un elemento en la matriz que cumpla con los criterios, solo obtendrá la primera de ellas. En nuestro ejemplo, si hubiera otra cadena de longitud inferior a 12 después de ‘4 foot tall’, no cambiaría nuestro resultado.

      En nuestro ejemplo, solo usamos la devolución de llamada con un parámetro. También puede añadir parámetros para hacer referencia al índice del elemento actual. Otro parámetro puede ser toda la matriz por sí misma, pero se usa de manera muy poco frecuente. Aquí hay un ejemplo usando el índice:

      alligator.find((el, idx) => typeof el === "string" && idx === 2); // returns '4 foot tall'
      

      Sabemos que en nuestra matriz, hay 3 elementos diferentes que cumplen la primera condición (typeof el === ‘string’). Si esa fuera nuestra única condición, devolverá la primera, ‘thick scales’. Pero la diferencia es que solo uno tiene el índice de 2, es decir ‘4 foot tall’.

      Hablando de índices, un método de matriz similar es .findIndex(). Este método también recibe una función, pero como se podrá imaginar, devuelve el índice del elemento que coincida en vez del elemento en sí.

      indexOf

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout"];
      
      alligator.indexOf("rounded snout"); // returns 3
      

      Al igual que el método .includes(), .indexOf() utiliza una comparación estricta, no una función como en el caso del método .find(). Pero, a diferencia de includes(), devuelve el índice del elemento, en vez de un booleano. También puede indicar a partir de qué índice en la matriz comenzar a buscar.

      indexOf() es un método muy útil. Es rápido y fácil, puede decirle dónde se encuentra el elemento en la matriz y puede indicar si dicho elemento existe. ¿Cómo le indica si el elemento existe? Básicamente, podemos saber que el elemento existe si devuelve un número positivo y si devuelve -1, indicaría que el elemento no existe.

      alligator.indexOf("soft and fluffy"); // returns -1
      alligator.indexOf(80); // returns 1
      alligator.indexOf(80, 2); // returns -1
      

      Como se puede ver, si bien podríamos usar los métodos find() o findIndex() para darnos la misma información, en este método se escribe mucho menos. No tenemos que escribir una función para realizar la comparación, ya que ya está dentro del método indexOf.

      Al igual que los demás métodos, indexOf() también devuelve el índice del primer elemento que encuentra. JavaScript nos proporciona un método de matriz alternativo .lastIndexOf(). Como se podrá imaginar, este método hace lo mismo que indexOf(), pero a partir del último índice de la matriz y funciona al revés. También puede especificar un segundo parámetro, pero recuerde que los índices no cambian solo por el hecho de usar un método diferente.

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout", 80];
      
      alligator.indexOf(80); // returns 1
      alligator.lastIndexOf(80); // returns 4
      alligator.indexOf(80, 2); // returns 4
      alligator.lastIndexOf(80, 4); // returns 4
      alligator.lastIndexOf(80, 3); // returns 1
      

      Bonus: filter

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout", 80];
      
      alligator.filter(el => el === 80); //returns [80, 80]
      

      El método filter() es como el método find(), en el sentido de que requiere una función pasada y una condición para lo que se devolverá. La principal diferencia es que filter() siempre devuelve una matriz, incluso si solo hay un elemento que coincida. Pero devolverá todos los elementos que coincidan, mientras que find() solo devuelve la primera coincidencia.

      Lo importante de filter es que devuelve todos los elementos que coinciden con sus criterios. Podría ser mi punto de vista, pero uno se podría confundir pensando “estos son los elementos que quiero filtrar out”, cuando realmente está indicando los elementos que desea filtrar in.

      Conclusión

      El método que me parece más sencillo de utilizar al realizar una búsqueda es el método find(), pero, como podrá ver, en realidad depende de su caso.

      • ¿Solo necesita saber si existe? Utilice .includes().
      • ¿Necesita obtener el elemento en sí? Utilice .find() o .filter() para buscar varios elementos.
      • ¿Necesita encontrar el índice del elemento? Utilice .indexOf() o findIndex() para realizar una búsqueda más compleja.

      Las matrices en los ejemplos presentados aquí fueron muy sencillas. Es posible que se encuentre con una matriz de objetos. A continuación, presentamos algunos ejemplos básicos para navegar por la jungla de objetos anidados:

      const jungle = [
        { name: "frog", threat: 0 },
        { name: "monkey", threat: 5 },
        { name: "gorilla", threat: 8 },
        { name: "lion", threat: 10 }
      ];
      
      // break the object down in order to use .includes() or .indexOf()
      const names = jungle.map(el => el.name); // returns ['frog', 'monkey', 'gorilla', 'lion']
      console.log(names.includes("gorilla")); // returns true
      console.log(names.indexOf("lion")); // returns 3 - which corresponds correctly assuming no sorting was done
      
      // methods we can do on the array of objects
      console.log(jungle.find(el => el.threat == 5)); // returns object - {name: "monkey", threat: 5}
      console.log(jungle.filter(el => el.threat > 5)); // returns array - [{name: "gorilla", threat: 8}, {name: 'lion', threat: 10}]
      



      Source link

      Información sobre matrices y segmentos en Go


      Introducción

      En Go, las matrices y los segmentos son estructuras de datos que consisten en una secuencia ordenada de elementos. Estas colecciones de datos son muy útiles cuando se necesita trabajar con muchos valores relacionados. Permiten mantener en un mismo lugar los datos que deben ir juntos, condensar su código y aplicar los mismos métodos y las mismas operaciones en varios valores a la vez.

      Aunque las matrices y los segmentos de Go son secuencias ordenadas de elementos, existen grandes diferencias entre ambos. Una matriz de Go es una estructura de datos que consta de una secuencia ordenada de elementos con su capacidad definida en el momento de su creación. Una vez que se asigna el tamaño a una matriz, este ya no se puede cambiar. Por otra parte, un segmento es una versión de extensión variable de una matriz, lo que ofrece mayor flexibilidad a los desarrolladores que usan estas estructuras de datos. Los segmentos representan lo que se podría considerar como matrices en otros lenguajes.

      Dadas estas diferencias, existen situaciones específicas en las que se usará uno en vez del otro. Si recién comienza a usar Go, determinar el momento en que se usarán puede ser confuso: aunque la versatilidad de los segmentos los convierte en la opción más apropiada en la mayoría de los casos, existen casos específicos en los que las matrices pueden optimizar el rendimiento de su programa.

      En este artículo se abordarán en detalle las matrices y los segmentos, que le proporcionarán la información necesaria para hacer la elección adecuada cuando tenga que decidirse por uno de estos tipos de datos. Además, verá las formas más comunes de declarar matrices y segmentos, y de trabajar con ellos. En el tutorial se brindará primero una descripción de las matrices y la manera de manipularlas, y luego una explicación de los segmentos y las diferencias entre ellos.

      Matrices

      Las matrices son estructuras de conjuntos de datos con un número determinado de elementos. Debido a que el tamaño de una matriz es estático, la estructura de datos solo debe asignar memoria una vez, a diferencia de una estructura de datos de extensión variable que debe asignar memoria de forma dinámica para que pueda ser mayor o menor en el futuro. Aunque la extensión fija de las matrices puede hacer que sea complicado trabajar con ellas, la asignación de memoria por única vez puede aumentar la velocidad y el rendimiento de su programa. Debido a esto, los desarrolladores suelen usar matrices cuando optimizan programas en instancias en las cuales la estructura de datos nunca necesitará una cantidad variable de elementos.

      Definir una matriz

      Las matrices se definen declarando su tamaño entre corchetes [], seguido del tipo de datos de los elementos. Todos los elementos de una matriz de Go deben tener el mismo tipo de datos. Después del tipo de datos, puede declarar los valores individuales de los elementos de la matriz entre llaves { }.

      A continuación, se muestra el esquema general para declarar una matriz:

      [capacity]data_type{element_values}
      

      Nota: Es importante recordar que con cada declaración de una nueva matriz se crea un tipo distinto. Por lo tanto, aunque [2]int y [3]int tienen elementos enteros, sus extensiones diferentes hacen que sus tipos de datos sean incompatibles.

      Si no declara los valores de los elementos de la matriz, el valor predeterminado es cero, lo cual significa que los elementos de la matriz estarán vacíos. Para los enteros, esto se representa con 0 y para cadenas con una cadena vacía.

      Por ejemplo, la siguiente matriz numbers tiene tres elementos enteros que aún no tienen valor:

      var numbers [3]int
      

      Si imprime numbers, obtendrá el siguiente resultado:

      Output

      [0 0 0]

      Si desea asignar los valores de los elementos cuando cree la matriz, disponga los valores entre llaves. Una matriz de cadenas con valores determinados tiene el siguiente aspecto:

      [4]string{"blue coral", "staghorn coral", "pillar coral", "elkhorn coral"}
      

      Puede almacenar una matriz en una variable e imprimirla:

      coral := [4]string{"blue coral", "staghorn coral", "pillar coral", "elkhorn coral"}
      fmt.Println(coral)
      

      Si ejecuta un programa con las líneas anteriores, obtendrá el siguiente resultado:

      Output

      [blue coral staghorn coral pillar coral elkhorn coral]

      Observe que no hay delineación entre los elementos de la matriz cuando se imprime. Esto hace que resulte difícil saber dónde termina un elemento y comienza otro. Debido a esto, a veces es útil usar la función fmt.Printf en su lugar, la cual le puede dar formato a las cadenas antes de imprimirlas en la pantalla. Proporcione el verbo %q con este comando para indicar a la función que disponga los valores entre comillas:

      fmt.Printf("%qn", coral)
      

      Esto dará como resultado lo siguiente:

      Output

      ["blue coral" "staghorn coral" "pillar coral" "elkhorn coral"]

      Ahora cada elemento está entre comillas. El verbo n indica al formateador que añada un salto de línea al final.

      Con una idea general sobre cómo declarar matrices y en qué consisten, ahora podrá aprender a especificar elementos en una matriz con un número de índice.

      Indexar matrices (y segmentos)

      Cada elemento de una matriz (y también de un segmento) puede invocarse de forma individual mediante indexación. Cada elemento corresponde a un número de índice, que es un valor int a partir del número de índice 0 en adelante.

      Usaremos una matriz en los siguientes ejemplos, pero también podría utilizar un segmento, ya que la forma en la que se indexan es igual para ambos.

      Para la matriz coral, el desglose del índice tiene este aspecto:

      “blue coral” “staghorn coral” “pillar coral” “elkhorn coral”
      0 1 2 3

      El primer elemento, la cadena “blue coral”, comienza en el índice 0, y el segmento termina en el índice 3 con el elemento “elkhorn coral”.

      Debido a que cada elemento en un segmento o matriz tiene un número de índice correspondiente, podemos acceder a ellos y manipularlos como a otros tipos de datos secuenciales.

      Ahora, podemos invocar un elemento discreto del segmento haciendo referencia a su número de índice:

      fmt.Println(coral[1])
      

      Output

      staghorn coral

      Los números de índice para este segmento tienen un intervalo 0-3, como se muestra en la tabla anterior. Por lo tanto, para llamar a cualquiera de los elementos individualmente, nos referiremos a los números de índice de la siguiente manera:

      coral[0] = "blue coral"
      coral[1] = "staghorn coral"
      coral[2] = "pillar coral"
      coral[3] = "elkhorn coral"
      

      Si invocamos la matriz coral con cualquier número de índice superior a 3, estará fuera de rango porque no será válido:

      fmt.Println(coral[18])
      

      Output

      panic: runtime error: index out of range

      Al indexar una matriz o un segmento, siempre debe usar un número positivo. A diferencia de algunos lenguajes que le permiten aplicar indexación en sentido inverso con un número negativo, hacer eso en Go producirá un error:

      fmt.Println(coral[-1])
      

      Output

      invalid array index -1 (index must be non-negative)

      Podemos concatenar elementos de cadenas de una matriz o un segmento con otras cadenas usando el operador +:

      fmt.Println("Sammy loves " + coral[0])
      

      Output

      Sammy loves blue coral

      Pudimos concatenar el elemento de la cadena en el índice de número 0 con la cadena “Sammy loves”.

      Con los números de índice que corresponden a elementos dentro de una matriz o segmento, podemos acceder a cada elemento con discreción y trabajar con ellos. Para demostrar esto, a continuación veremos cómo modificar un elemento en un índice determinado.

      Modificar elementos

      Podemos usar la indexación para cambiar elementos dentro de una matriz o segmento configurando un elemento numerado con un índice igual a un valor diferente. Esto nos proporciona un mayor control sobre los datos de nuestros segmentos y matrices, y nos permitirá manipular mediante programación elementos individuales.

      Si queremos cambiar el valor de la cadena del elemento en el índice 1 de la matriz coral, de “staghorn coral” a “foliose coral ”, podemos hacerlo de la siguiente manera:

      coral[1] = "foliose coral"
      

      Ahora cuando imprimamos coral, la matriz será diferente:

      fmt.Printf("%qn", coral)
      

      Output

      ["blue coral" "foliose coral" "pillar coral" "elkhorn coral"]

      Ahora que ya sabe manipular elementos individuales de una matriz o un segmento, veamos algunas funciones que le darán mayor flexibilidad al trabajar con tipos de datos de colección.

      Contar elementos con len()

      En Go, len() es una función integrada creada para ayudarlo a trabajar con matrices y segmentos. Al igual que con las cadenas, puede calcular la extensión de una matriz o un segmento usando len() y pasar la matriz o segmento como parámetro.

      Por ejemplo, para encontrar la cantidad elementos de la matriz coral, utilizaría lo siguiente:

      len(coral)
      

      Si imprime la longitud de la matriz coral, obtendrá el siguiente resultado:

      Output

      4

      Esto proporciona 4 a la extensión de la matriz en el tipo de datos int, lo cual es correcto porque la matriz coral tiene cuatro elementos:

      coral := [4]string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral"}
      

      Si crea una matriz de enteros con más elementos, podrá usar la función len() también:

      numbers := [13]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
      fmt.Println(len(numbers))
      

      Esto daría como resultado lo siguiente:

      Output

      13

      Aunque estas matrices de ejemplo tienen relativamente pocos elementos, la función len() es particularmente útil para determinar la cantidad de elementos disponibles en matrices muy grandes.

      A continuación, veremos cómo añadir un elemento a un tipo de datos de coleccción y a demostrar cómo, debido a la extensión fija de las matrices, añadir estos tipos de datos estáticos provocará un error.

      Añadir elementos con append()

      append() es un método incorporado en Go que añade elementos a un tipo de datos de colección. Sin embargo, este método no funcionará cuando se utilice con una matriz. Como se mencionó anteriormente, la principal diferencia entre las matrices y los segmentos es que el tamaño de una matriz no se puede modificar. Esto significa que si bien se pueden cambiar los valores de los elementos de una matriz, no es posible expandirla o reducirla matriz una vez que se haya definido.

      Analicemos su matriz coral:

      coral := [4]string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral"}
      

      Supongamos que quiere añadir el elemento “black coral” a esta matriz. Si intenta usar la función append() con la matriz escribiendo lo siguiente:

      coral = append(coral, "black coral")
      

      Como resultado, verá un error:

      Output

      first argument to append must be slice; have [4]string

      Para corregir esto, veamos más sobre el tipo de datos de segmento, cómo definir un segmento y cómo realizar la conversión de una matriz a un segmento.

      Segmentos

      Un segmento es un tipo de datos en Go que es una secuencia ordenada mutable o modificable de elementos. Debido a que el tamaño de un segmento es variable, existe mucha mayor flexibilidad al usarlos; al trabajar con colecciones de datos que podrían necesitar expandirse o contraerse en el futuro, utilizar un segmento garantizará que su código no tenga errores cuando intente manipular la extensión del conjunto. En la mayoría de los casos, esta mutabilidad hace que valga la pena la posible reasignación de memoria que a veces requieren los segmentos en comparación con las matrices. Cuando necesite almacenar muchos elementos o iterarlos y desee ser capaz de modificar fácilmente esos elementos, es probable que desee trabajar con el tipo de datos de segmento.

      Definir un segmento

      Los segmentos se definen declarando el tipo de datos precedido por un conjunto vacío de corchetes ([]) y una lista de elementos entre llaves ({}). Observará que, a diferencia de las matrices que requieren un int entre los corchetes para declarar una extensión específica, un segmento no contiene nada entre corchetes, lo que representa su extensión variable.

      Crearemos un segmento que contenga elementos del tipo de datos de cadena:

      seaCreatures := []string{"shark", "cuttlefish", "squid", "mantis shrimp", "anemone"}
      

      Cuando imprimimos el segmento, podemos observar los elementos que están en el segmento:

      fmt.Printf("%qn", seaCreatures)
      

      Esto dará como resultado lo siguiente:

      Output

      ["shark" "cuttlefish" "squid" "mantis shrimp" "anemone"]

      Si desea crear un segmento de una extensión determinada sin completar aún los elementos del grupo, puede usar la función integrada make():

      oceans := make([]string, 3)
      

      Si imprimiera este segmento, obtendría lo siguiente:

      Output

      ["" "" ""]

      Si desea asignar previamente la memoria a una capacidad determinada, puede pasar un tercer argumento a make():

      oceans := make([]string, 3, 5)
      

      Con esto, se crearía un segmento con una extensión de 3, valor cero y una capacidad previamente asignada de 5 elementos.

      Ahora sabe cómo declarar un segmento. Sin embargo, esto aún no resuelve el error que se produjo antes con la matriz coral. Para usar la función append() con coral, primero tendrá que aprender a quitar secciones de una matriz.

      Dividir matrices en segmentos

      Usando números de índice para determinar los puntos de inicio y final, puede invocar un apartado de los valores dentro de una matriz. Esto se conoce como segmentación de la matriz y puede hacerlo creando un rango de números de índice separados por dos puntos con la forma [first_index:second_index]. Sin embargo, es importante observar que cuando se divide una matriz, el resultado es un segmento, no una matriz.

      Digamos que desea imprimir solo los elementos centrales de la matriz coral, sin el primer y último elemento. Puede realizarlo creando un segmento que empiece en el índice 1 y termine justo antes del índice 3:

      fmt.Println(coral[1:3])
      

      La ejecución de un programa con esta línea produciría el siguiente resultado:

      Output

      [foliose coral pillar coral]

      Al crear una división, como en [1:3], el primer número marca el inicio del segmento (incluido) y el segundo es la suma del primer número y del número total de elementos que desea obtener:

      array[starting_index : (starting_index + length_of_slice)]
      

      En este caso, llamó al segundo elemento (o índice 1) como el punto de inicio y llamó dos elementos en total. Así es como se vería el cálculo:

      array[1 : (1 + 2)]
      

      Esto le permitió obtener la siguiente notación:

      coral[1:3]
      

      Si desea establecer el inicio o el final de la matriz como un punto de inicio o final de la división, puede omitir uno de los números de la sintaxis array[first_index:second_index]. Por ejemplo, si desea imprimir los primeros tres elementos de la matriz coral, que serían “blue coral”, “foliose coral” y “pillar coral”, puede hacerlo al escribiendo lo siguiente:

      fmt.Println(coral[:3])
      

      Con esto se imprimirá lo siguiente:

      Output

      [blue coral foliose coral pillar coral]

      Esto imprimió el principio de la matriz y se detuvo justo antes del índice 3.

      Para incluir todos los elementos al final de una matriz, invertiría la sintaxis:

      fmt.Println(coral[1:])
      

      De esto surgiría el siguiente segmento:

      Output

      [foliose coral pillar coral elkhorn coral]

      En esta sección se explicó la manera de invocar partes individuales de una matriz mediante la eliminación de apartados. A continuación, aprenderá a usar la segmentación para convertir matrices enteras en segmentos.

      Convertir una matriz en un segmento

      Si creó una matriz y decide que necesita que tenga una extensión variable, puede convertirla en un segmento. Para convertir una matriz en un segmento, utilice el proceso de segmentación que aprendió en el paso Dividir matrices en segmentos de este tutorial. Como excepción, esta vez seleccione el segmento completo omitiendo los dos números de índice que determinan los extremos:

      coral[:]
      

      Tenga en cuenta que no puede convertir la variable coral en un segmento en sí, ya que una vez que una variable se define en Go, no se puede cambiar su tipo. Para evitar esto, puede copiar todo el contenido de la matriz en una nueva variable como segmento:

      coralSlice := coral[:]
      

      Si imprimió coralSlice, obtendría el siguiente resultado:

      Output

      [blue coral foliose coral pillar coral elkhorn coral]

      Ahora, intente añadir el elemento black coral como lo hizo en la sección de matrices, usando append() con el segmento recién convertido:

      coralSlice = append(coralSlice, "black coral")
      fmt.Printf("%qn", coralSlice)
      

      Esto mostrará el segmento con el elemento añadido:

      Output

      ["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral"]

      También podemos añadir más de un elemento en una sola instrucción append():

      coralSlice = append(coralSlice, "antipathes", "leptopsammia")
      

      Output

      ["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral" "antipathes" "leptopsammia"]

      Para combinar dos segmentos, puede usar append(), pero debe ampliar el segundo argumento para la anexión usando la sintaxis de expansión ...:

      moreCoral := []string{"massive coral", "soft coral"}
      coralSlice = append(coralSlice, moreCoral...)
      

      Output

      ["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral" "antipathes" "leptopsammia" "massive coral" "soft coral"]

      Ahora que aprendió a anexar un elemento a su segmento, veremos la manera de eliminar uno.

      Eliminar un elemento de un segmento

      A diferencia de otros lenguajes, Go no cuenta con funciones incorporadas para eliminar un elemento de un segmento. Los elementos deben eliminarse de un segmento mediante segmentación.

      Para eliminar un elemento, debe retirar los elementos anteriores y posteriores a este, luego anexar estos dos nuevos segmentos sin el elemento que desee eliminar.

      Si i es el índice del elemento que se eliminará, el formato de este proceso sería el siguiente:

      slice = append(slice[:i], slice[i+1:]...)
      

      De coralSlice, eliminaremos el elemento “elkhorn coral”. Este elemento se encuentra en la posición de índice 3.

      coralSlice := []string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral", "black coral", "antipathes", "leptopsammia", "massive coral", "soft coral"}
      
      coralSlice = append(coralSlice[:3], coralSlice[4:]...)
      
      fmt.Printf("%qn", coralSlice)
      

      Output

      ["blue coral" "foliose coral" "pillar coral" "black coral" "antipathes" "leptopsammia" "massive coral" "soft coral"]

      Ahora, el elemento de la posición de índice 3, la cadena “elkhorn coral”, ya no se encuentra en nuestro segmento coralSlice.

      También podemos eliminar un rango utilizando el mismo enfoque. Supongamos que no solo queremos eliminar el elemento “elkhorn coral”, sino también “ black coral ” y “ antipathes ”. Podemos usar un rango en la expresión para lograr esto:

      coralSlice := []string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral", "black coral", "antipathes", "leptopsammia", "massive coral", "soft coral"}
      
      coralSlice = append(coralSlice[:3], coralSlice[6:]...)
      
      fmt.Printf("%qn", coralSlice)
      

      En este código, se eliminarán los índices 3, 4 y 5 del segmento:

      Output

      ["blue coral" "foliose coral" "pillar coral" "leptopsammia" "massive coral" "soft coral"]

      Ahora que sabe añadir elementos y eliminarlos de un segmento, veremos la manera de medir la cantidad de datos que un segmento puede contener en un momento determinado.

      Medir la capacidad de un segmento con cap()

      Debido a que los segmentos tienen una extensión variable, el método len() no es la mejor opción para determinar el tamaño de este tipo de datos. En lugar de esto, puede usar la función cap() para conocer la capacidad de un segmento. Esto le mostrará la cantidad de elementos que un segmento puede contener, lo cual se determina por la cantidad de memoria ya asignada al segmento.

      Nota: Debido a que la extensión y la capacidad de una matriz siempre son iguales, la función cap() no funcionará en matrices.

      Una aplicación común para cap() consiste en crear un segmento con un número de elementos predeterminado y luego completar estos elementos mediante programación. Esto evita asignaciones innecesarias que podrían producirse al usar append() para añadir elementos que superen la capacidad actualmente asignada.

      Consideraremos una situación en la que queramos realizar una lista de números del 0 a 3. Podemos usar append() en un bucle para hacerlo, o primero podemos asignar previamente el segmento y usar cap() en un bulce para llenar los valores.

      Primero, analicemos el uso de append():

      numbers := []int{}
      for i := 0; i < 4; i++ {
          numbers = append(numbers, i)
      }
      fmt.Println(numbers)
      

      Output

      [0 1 2 3]

      En este ejemplo, creamos un segmento y luego un bucle for que haría cuatro iteraciones. Cada iteración anexó el valor actual de la variable del bucle i en el índice del segmento numbers. Sin embargo, esto podría provocar asignaciones de memoria innecesarias que podrían ralentizar su programa. Al añadir a un segmento vacío, cada vez que realice una invocación para una anexión, el programa verificará la capacidad del segmento. Si el elemento añadido hace que el segmento supere esta capacidad, el programa asignará memoria adicional para compensarlo. Esto crea una sobrecarga adicional en su programa y puede ralentizar la ejecución.

      Ahora, completaremos el segmento sin usar append() asignando previamente una extensión y una capacidad determinadas:

      numbers := make([]int, 4)
      for i := 0; i < cap(numbers); i++ {
          numbers[i] = i
      }
      
      fmt.Println(numbers)
      
      

      Output

      [0 1 2 3]

      En este ejemplo, usamos make() para crear un segmento e indicar a este que asigne previamente 4 elementos. Luego usamos la función cap() en el bucle para iterar cada elemento con cero y completar cada uno hasta que cada uno alcanzara la capacidad previamente asignada. En cada bucle, dispusimos el valor actual de la variable de bucle i en el índice del segmento numbers.

      Si bien las estrategias append() y cap() tienen un funcionamiento equivalente, en el ejemplo de cap() se evita cualquier asignación de memoria adicional que hubiera sido necesaria si se utilizaba la función append().

      Crear segmentos multidimensionales

      También puede definir segmentos que consistan en otros segmentos como elementos y disponga cada una de las listas entre llaves, dentro de las llaves más amplias del segmento principal. Los grupos de segmentos como estos se conocen como segmentos multidimensionales. Se puede pensar que representan coordenadas multidimensionales; por ejemplo, un conjunto de cinco segmentos de seis elementos de extensión cada uno podría representar una cuadrícula de bidimensional con una extensión horizontal de cinco y una altura vertical de seis.

      Analicemos el siguiente segmento multidimensional:

      seaNames := [][]string{{"shark", "octopus", "squid", "mantis shrimp"}, {"Sammy", "Jesse", "Drew", "Jamie"}}
      

      Para acceder a un elemento dentro de este segmento, debemos usar varios índices, uno para cada dimensión de la construcción:

      fmt.Println(seaNames[1][0])
      fmt.Println(seaNames[0][0])
      

      En el código anterior, identificamos primero el elemento del índice 0 del segmento del índice 1, luego indicamos el elemento del índice 0 del segmento del índice 0. Con esto, se mostrará lo siguiente:

      Output

      Sammy shark

      Los siguientes son los valores de índice para el resto de los elementos individuales:

      seaNames[0][0] = "shark"
      seaNames[0][1] = "octopus"
      seaNames[0][2] = "squid"
      seaNames[0][3] = "mantis shrimp"
      
      seaNames[1][0] = "Sammy"
      seaNames[1][1] = "Jesse"
      seaNames[1][2] = "Drew"
      seaNames[1][3] = "Jamie"
      

      Al trabajar con segmentos multidimensionales, es importante tener en cuenta que deberá hacer referencia a más de un número de índice para poder acceder a elementos específicos dentro del segmento anidado correspondiente.

      Conclusión

      A través de este tutorial, aprendió aspectos básicos del uso de matrices y segmentos en Go. Realizó varios ejercicios para demostrar que las matrices tienen una extensión fija, mientras que los segmentos no, y descubrió el efecto de esta diferencia en el uso de estas estructuras de datos en cada caso.

      Para continuar estudiando estructuras de datos en Go, consulte nuestro artículo Información sobre mapas en Go o toda la serie Cómo aplicar codificación en Go.



      Source link