1
00:00:01,030 --> 00:00:02,290
Hola y bienvenidos nuevamente.

2
00:00:02,470 --> 00:00:05,920
Vamos a ver a continuación cómo iterar los elementos de un arreglo.

3
00:00:06,070 --> 00:00:06,860
Están listos?

4
00:00:06,970 --> 00:00:07,450
Vamos.

5
00:00:08,500 --> 00:00:08,920
Bien.

6
00:00:08,920 --> 00:00:11,410
Ya tenemos definido los elementos de nuestro arreglo.

7
00:00:11,650 --> 00:00:16,450
En este caso, vamos a trabajar con este arreglo que ya hemos definido utilizando la notación simplificada.

8
00:00:16,720 --> 00:00:21,910
De momento, no vamos a modificar los valores después de la definición, así que nos vamos a quedar

9
00:00:21,910 --> 00:00:23,320
con estos valores iniciales.

10
00:00:23,560 --> 00:00:27,820
Sin embargo, podemos observar que para leer cada uno de los valores del arreglo lo estamos haciendo

11
00:00:27,820 --> 00:00:28,630
manualmente.

12
00:00:28,870 --> 00:00:35,200
Así que estamos leyendo los valores 1234, etcétera Incluso hemos agregado 1/6 valor, pero ya sabemos

13
00:00:35,200 --> 00:00:38,920
que en este caso estamos fuera de los elementos definidos para nuestro arreglo.

14
00:00:39,160 --> 00:00:41,620
Así que esta línea ya no tendríamos por qué tenerla.

15
00:00:41,980 --> 00:00:47,440
Ahora, para evitar precisamente este tipo de problemas, podemos utilizar un ciclo para leer los elementos

16
00:00:47,440 --> 00:00:48,220
de nuestro arreglo.

17
00:00:48,520 --> 00:00:54,550
En este caso, vamos a utilizar un ciclo FOR, así que vamos a iterar o recorrer cada uno de los elementos

18
00:00:54,550 --> 00:00:55,360
de nuestro arreglo.

19
00:00:55,630 --> 00:00:56,530
Así que vamos.

20
00:00:58,170 --> 00:00:59,610
El arreglo que hemos definido.

21
00:00:59,820 --> 00:01:04,620
Para ello, En primer lugar, vamos a mandar a imprimir un mensaje para que sepamos qué es lo que vamos

22
00:01:04,620 --> 00:01:05,040
a hacer.

23
00:01:05,400 --> 00:01:06,660
Agregamos un salto de línea.

24
00:01:08,060 --> 00:01:11,240
Y te damos los valores del arreglo.

25
00:01:12,680 --> 00:01:17,180
Y posteriormente vamos a utilizar un ciclo for para poder iterar cada uno de los elementos.

26
00:01:17,510 --> 00:01:23,130
Abrimos nuestro bloque de código y entre paréntesis vamos a indicando cada una de las secciones.

27
00:01:23,180 --> 00:01:26,900
Ya sabemos que la primera sección es para definir nuestras variables de tipo contador.

28
00:01:27,110 --> 00:01:31,820
En este caso vamos a tener una de las primeras excepciones respecto al nombre de las variables, ya

29
00:01:31,820 --> 00:01:36,610
que habíamos comentado que los nombres de las variables tienen que ser lo más específicas posibles,

30
00:01:36,620 --> 00:01:41,240
tienen que ser descriptivas para que en cuanto leamos el nombre de la variable, sepamos cuál es su

31
00:01:41,240 --> 00:01:41,870
función.

32
00:01:41,900 --> 00:01:46,640
Sin embargo, cuando vamos a iterar un arreglo o cualquier colección de datos, en este caso vamos a

33
00:01:46,640 --> 00:01:52,880
definir simplemente una variable que se llame, y en este caso la i significa que es el valor del índice

34
00:01:52,880 --> 00:01:53,870
que queremos recorrer.

35
00:01:54,050 --> 00:02:00,980
Recordemos que según nuestra figura, vamos a recorrer los índices desde el índice 0123 y cuatro.

36
00:02:01,280 --> 00:02:03,300
Así que esos son los índices que queremos recorrer.

37
00:02:03,350 --> 00:02:08,660
Por lo tanto, la I simplemente significa que va a ser el valor del índice que vamos a estar recorriendo

38
00:02:08,660 --> 00:02:10,970
cada vez que estemos iterando nuestro arreglo.

39
00:02:11,960 --> 00:02:17,450
Así que esta variable de índice vamos a definirla con el valor inicial de cero, el cual corresponde

40
00:02:17,450 --> 00:02:20,330
precisamente con el índice cero de nuestro arreglo.

41
00:02:21,230 --> 00:02:23,480
Esa es la primera sección de nuestro ciclo for.

42
00:02:23,780 --> 00:02:29,160
La siguiente parte recordemos que tiene la condición en la cual si esta condición es verdadera, entonces

43
00:02:29,160 --> 00:02:31,160
se ejecuta de nueva cuenta a nuestro ciclo for.

44
00:02:31,370 --> 00:02:37,160
Para ello, entonces vamos a hacer lo siguiente Vamos a iterar nuestro índice desde cero hasta la cantidad

45
00:02:37,160 --> 00:02:38,990
de elementos de nuestro arreglo.

46
00:02:39,260 --> 00:02:41,330
En este caso la cantidad de elementos de nuestro arreglo.

47
00:02:41,330 --> 00:02:46,730
Podemos observar que son cinco elementos, por lo tanto vamos a iterar desde cero hasta cinco, pero

48
00:02:46,730 --> 00:02:48,260
no vamos a incluir este valor.

49
00:02:48,380 --> 00:02:52,040
Recordemos que la cantidad de elementos, en este caso del arreglo, son cinco elementos.

50
00:02:52,040 --> 00:02:58,600
Por lo tanto se dice que este arreglo es de n elementos y donde n vale cinco, ya que son cinco elementos

51
00:02:58,640 --> 00:03:03,230
y recordemos que el último elemento de nuestro arreglo sería n -1.

52
00:03:03,290 --> 00:03:06,680
Por lo tanto ese valor de cinco -1 obtenemos el valor de cuatro.

53
00:03:07,010 --> 00:03:13,040
Y entonces en este caso exactamente lo mismo, vamos a iterar desde el valor de cero hasta el índice

54
00:03:13,070 --> 00:03:15,710
cuatro, ya que es el último valor que queremos iterar.

55
00:03:15,950 --> 00:03:21,170
Por lo tanto, no utilizamos el operador de menor o igual que, sino simplemente el operador de menor,

56
00:03:21,170 --> 00:03:24,070
ya que no vamos a incluir el valor cinco, el índice cinco.

57
00:03:24,350 --> 00:03:28,910
Ahora también, si quisiéramos utilizar este operador de menor o igual, podríamos hacerlo, pero entonces

58
00:03:28,910 --> 00:03:31,670
el valor de cinco tenemos que restarle el valor de uno.

59
00:03:31,850 --> 00:03:34,310
Cualquiera de las dos opciones es exactamente lo mismo.

60
00:03:34,850 --> 00:03:40,190
Bien, de momento voy a utilizar la sintaxis más simple, que es utilizar el operador de menor que bien.

61
00:03:40,370 --> 00:03:44,390
Y por último, la última sección es para incrementar las variables de tipo contador.

62
00:03:44,570 --> 00:03:47,150
En este caso incrementamos la variable de índice.

63
00:03:47,840 --> 00:03:53,180
Y con esto prácticamente ya tenemos configurado todo el ciclo for para ir iterando cada uno de los elementos

64
00:03:53,180 --> 00:03:53,990
de nuestro arreglo.

65
00:03:54,260 --> 00:03:58,460
Y ahora lo que vamos a hacer es mandar a imprimir cada uno de los elementos de nuestro arreglo.

66
00:03:58,730 --> 00:04:03,500
Así que vamos a mandar a imprimir un valor de tipo numérico, ya que es lo que contiene cada uno de

67
00:04:03,500 --> 00:04:08,510
los elementos de nuestro arreglo y posteriormente especificamos el nombre del arreglo.

68
00:04:09,730 --> 00:04:13,960
Números arreglo y especificamos cuál es el índice que vamos a iterar.

69
00:04:14,170 --> 00:04:19,090
En este caso, la variable de I es precisamente la que contiene el índice que vamos a ir iterando,

70
00:04:19,090 --> 00:04:22,810
que vamos a ir modificando cada vez que vamos avanzando en el ciclo for.

71
00:04:23,140 --> 00:04:28,450
Así que la primera vez esta variable y ya sabemos que vale cero, así que vamos a acceder al índice

72
00:04:28,450 --> 00:04:28,710
cero.

73
00:04:28,720 --> 00:04:33,220
Por lo tanto, tendríamos que recuperar el valor de 100, pero la siguiente vez que se itera nuestro

74
00:04:33,220 --> 00:04:38,740
ciclo for Si esta condición sigue siendo verdadera, entonces ahora vamos a acceder al siguiente elemento,

75
00:04:38,740 --> 00:04:44,950
al int S1 y recuperaríamos el valor de 200 y así con cada una de las iteraciones de nuestro ciclo for.

76
00:04:45,640 --> 00:04:50,500
Bien, vamos a quitar este código ya que de momento ya no vamos a leer los valores manualmente, sino

77
00:04:50,500 --> 00:04:54,430
que vamos a crearlo utilizando precisamente el ciclo for que ya hemos configurado.

78
00:04:55,060 --> 00:04:59,380
Bien, vamos a ejecutar y de momento estamos imprimiendo los valores en la misma línea.

79
00:04:59,620 --> 00:05:06,310
Vamos a agregar un formato, agregamos un salto de línea para cada uno de los elementos y entonces podemos

80
00:05:06,310 --> 00:05:06,850
observar.

81
00:05:07,030 --> 00:05:09,700
Se muestra primero el mensaje y tenemos los valores del arreglo.

82
00:05:10,000 --> 00:05:14,020
Y entonces, según cada valor que vamos a iterando en nuestro ciclo for, vamos a mandar a imprimir

83
00:05:14,020 --> 00:05:16,180
el primero el valor de 100, que es el índice cero.

84
00:05:16,510 --> 00:05:25,510
Posteriormente el valor de 200, el valor de 300, según estamos recuperando el valor de 400 y finalmente

85
00:05:25,510 --> 00:05:26,680
el valor de 500.

86
00:05:27,190 --> 00:05:32,530
Así que con esto estamos comprobando que estamos accediendo correctamente a cada uno de los índices

87
00:05:32,530 --> 00:05:33,400
de nuestro arreglo.

88
00:05:33,850 --> 00:05:36,220
De momento, este primer salto de línea lo voy a quitar.

89
00:05:36,550 --> 00:05:38,020
Podemos agregar más información.

90
00:05:38,020 --> 00:05:42,010
Por ejemplo, en este caso indicar cuál es el índice que estamos accediendo, por ejemplo, de nuestro

91
00:05:42,010 --> 00:05:42,460
arreglo.

92
00:05:43,240 --> 00:05:44,530
Esto simplemente es un texto.

93
00:05:45,040 --> 00:05:48,040
Estamos accediendo al índice respectivo.

94
00:05:49,050 --> 00:05:54,390
Y posteriormente imprimimos el valor del que estamos accediendo, pero nos falta agregar la variable

95
00:05:54,510 --> 00:05:57,810
de I y posteriormente el valor del índice que queremos acceder.

96
00:05:58,200 --> 00:06:03,690
Así que lo que sucede es lo siguiente se va a imprimir el arreglo en el índice respectivo que estamos

97
00:06:03,690 --> 00:06:04,200
iterando.

98
00:06:04,770 --> 00:06:08,520
Se manda a imprimir el valor almacenado en el índice respectivo.

99
00:06:08,910 --> 00:06:11,040
Así que vamos a ir recuperando cada uno de los valores.

100
00:06:11,190 --> 00:06:16,320
Eso simplemente para que quede un poco más claro cada uno de las impresiones, cada uno de los elementos.

101
00:06:16,890 --> 00:06:19,590
Pero ya sabemos que ya está funcionando correctamente nuestro código.

102
00:06:19,800 --> 00:06:25,140
Solamente es para que visualmente podamos entender que en nuestro arreglo, en el índice cero, estamos

103
00:06:25,140 --> 00:06:29,370
recuperando el valor de 100, tal como lo podemos visualizar también en nuestra animación.

104
00:06:29,640 --> 00:06:34,920
Y así continuamos con los demás elementos 200 300 400 y 500.

105
00:06:35,130 --> 00:06:40,680
Pero también podemos observar cada uno de los índices de nuestro arreglo desde el inicio cero hasta

106
00:06:40,680 --> 00:06:41,610
el índice cuatro.

107
00:06:42,540 --> 00:06:47,220
Así que de esta forma es como vamos a acceder a los elementos de un arreglo utilizando un ciclo.

108
00:06:47,460 --> 00:06:50,810
Pongan en práctica lo que hemos visto y continuamos en la siguiente lección.

109
00:06:50,820 --> 00:06:51,390
Saludos.
