Hola y bienvenidos nuevamente.
Vamos a ver a continuación cómo iterar los elementos de un arreglo.
Están listos?
Vamos.
Bien.
Ya tenemos definido los elementos de nuestro arreglo.
En este caso, vamos a trabajar con este arreglo que ya hemos definido utilizando la notación simplificada.
De momento, no vamos a modificar los valores después de la definición, así que nos vamos a quedar
con estos valores iniciales.
Sin embargo, podemos observar que para leer cada uno de los valores del arreglo lo estamos haciendo
manualmente.
Así que estamos leyendo los valores 1234, etcétera Incluso hemos agregado 1/6 valor, pero ya sabemos
que en este caso estamos fuera de los elementos definidos para nuestro arreglo.
Así que esta línea ya no tendríamos por qué tenerla.
Ahora, para evitar precisamente este tipo de problemas, podemos utilizar un ciclo para leer los elementos
de nuestro arreglo.
En este caso, vamos a utilizar un ciclo FOR, así que vamos a iterar o recorrer cada uno de los elementos
de nuestro arreglo.
Así que vamos.
El arreglo que hemos definido.
Para ello, En primer lugar, vamos a mandar a imprimir un mensaje para que sepamos qué es lo que vamos
a hacer.
Agregamos un salto de línea.
Y te damos los valores del arreglo.
Y posteriormente vamos a utilizar un ciclo for para poder iterar cada uno de los elementos.
Abrimos nuestro bloque de código y entre paréntesis vamos a indicando cada una de las secciones.
Ya sabemos que la primera sección es para definir nuestras variables de tipo contador.
En este caso vamos a tener una de las primeras excepciones respecto al nombre de las variables, ya
que habíamos comentado que los nombres de las variables tienen que ser lo más específicas posibles,
tienen que ser descriptivas para que en cuanto leamos el nombre de la variable, sepamos cuál es su
función.
Sin embargo, cuando vamos a iterar un arreglo o cualquier colección de datos, en este caso vamos a
definir simplemente una variable que se llame, y en este caso la i significa que es el valor del índice
que queremos recorrer.
Recordemos que según nuestra figura, vamos a recorrer los índices desde el índice 0123 y cuatro.
Así que esos son los índices que queremos recorrer.
Por lo tanto, la I simplemente significa que va a ser el valor del índice que vamos a estar recorriendo
cada vez que estemos iterando nuestro arreglo.
Así que esta variable de índice vamos a definirla con el valor inicial de cero, el cual corresponde
precisamente con el índice cero de nuestro arreglo.
Esa es la primera sección de nuestro ciclo for.
La siguiente parte recordemos que tiene la condición en la cual si esta condición es verdadera, entonces
se ejecuta de nueva cuenta a nuestro ciclo for.
Para ello, entonces vamos a hacer lo siguiente Vamos a iterar nuestro índice desde cero hasta la cantidad
de elementos de nuestro arreglo.
En este caso la cantidad de elementos de nuestro arreglo.
Podemos observar que son cinco elementos, por lo tanto vamos a iterar desde cero hasta cinco, pero
no vamos a incluir este valor.
Recordemos que la cantidad de elementos, en este caso del arreglo, son cinco elementos.
Por lo tanto se dice que este arreglo es de n elementos y donde n vale cinco, ya que son cinco elementos
y recordemos que el último elemento de nuestro arreglo sería n -1.
Por lo tanto ese valor de cinco -1 obtenemos el valor de cuatro.
Y entonces en este caso exactamente lo mismo, vamos a iterar desde el valor de cero hasta el índice
cuatro, ya que es el último valor que queremos iterar.
Por lo tanto, no utilizamos el operador de menor o igual que, sino simplemente el operador de menor,
ya que no vamos a incluir el valor cinco, el índice cinco.
Ahora también, si quisiéramos utilizar este operador de menor o igual, podríamos hacerlo, pero entonces
el valor de cinco tenemos que restarle el valor de uno.
Cualquiera de las dos opciones es exactamente lo mismo.
Bien, de momento voy a utilizar la sintaxis más simple, que es utilizar el operador de menor que bien.
Y por último, la última sección es para incrementar las variables de tipo contador.
En este caso incrementamos la variable de índice.
Y con esto prácticamente ya tenemos configurado todo el ciclo for para ir iterando cada uno de los elementos
de nuestro arreglo.
Y ahora lo que vamos a hacer es mandar a imprimir cada uno de los elementos de nuestro arreglo.
Así que vamos a mandar a imprimir un valor de tipo numérico, ya que es lo que contiene cada uno de
los elementos de nuestro arreglo y posteriormente especificamos el nombre del arreglo.
Números arreglo y especificamos cuál es el índice que vamos a iterar.
En este caso, la variable de I es precisamente la que contiene el índice que vamos a ir iterando,
que vamos a ir modificando cada vez que vamos avanzando en el ciclo for.
Así que la primera vez esta variable y ya sabemos que vale cero, así que vamos a acceder al índice
cero.
Por lo tanto, tendríamos que recuperar el valor de 100, pero la siguiente vez que se itera nuestro
ciclo for Si esta condición sigue siendo verdadera, entonces ahora vamos a acceder al siguiente elemento,
al int S1 y recuperaríamos el valor de 200 y así con cada una de las iteraciones de nuestro ciclo for.
Bien, vamos a quitar este código ya que de momento ya no vamos a leer los valores manualmente, sino
que vamos a crearlo utilizando precisamente el ciclo for que ya hemos configurado.
Bien, vamos a ejecutar y de momento estamos imprimiendo los valores en la misma línea.
Vamos a agregar un formato, agregamos un salto de línea para cada uno de los elementos y entonces podemos
observar.
Se muestra primero el mensaje y tenemos los valores del arreglo.
Y entonces, según cada valor que vamos a iterando en nuestro ciclo for, vamos a mandar a imprimir
el primero el valor de 100, que es el índice cero.
Posteriormente el valor de 200, el valor de 300, según estamos recuperando el valor de 400 y finalmente
el valor de 500.
Así que con esto estamos comprobando que estamos accediendo correctamente a cada uno de los índices
de nuestro arreglo.
De momento, este primer salto de línea lo voy a quitar.
Podemos agregar más información.
Por ejemplo, en este caso indicar cuál es el índice que estamos accediendo, por ejemplo, de nuestro
arreglo.
Esto simplemente es un texto.
Estamos accediendo al índice respectivo.
Y posteriormente imprimimos el valor del que estamos accediendo, pero nos falta agregar la variable
de I y posteriormente el valor del índice que queremos acceder.
Así que lo que sucede es lo siguiente se va a imprimir el arreglo en el índice respectivo que estamos
iterando.
Se manda a imprimir el valor almacenado en el índice respectivo.
Así que vamos a ir recuperando cada uno de los valores.
Eso simplemente para que quede un poco más claro cada uno de las impresiones, cada uno de los elementos.
Pero ya sabemos que ya está funcionando correctamente nuestro código.
Solamente es para que visualmente podamos entender que en nuestro arreglo, en el índice cero, estamos
recuperando el valor de 100, tal como lo podemos visualizar también en nuestra animación.
Y así continuamos con los demás elementos 200 300 400 y 500.
Pero también podemos observar cada uno de los índices de nuestro arreglo desde el inicio cero hasta
el índice cuatro.
Así que de esta forma es como vamos a acceder a los elementos de un arreglo utilizando un ciclo.
Pongan en práctica lo que hemos visto y continuamos en la siguiente lección.
Saludos.