1
00:00:01,390 --> 00:00:02,320
Hola y bienvenidos.

2
00:00:02,350 --> 00:00:05,560
Vamos a ver a continuación cómo obtener el largo de un arreglo en el lenguaje.

3
00:00:05,980 --> 00:00:06,770
Están listos?

4
00:00:06,850 --> 00:00:07,330
Vamos.

5
00:00:08,070 --> 00:00:08,570
Bien.

6
00:00:08,620 --> 00:00:12,730
Vamos a obtener de manera dinámica la cantidad de elementos que tenemos en este arreglo.

7
00:00:12,850 --> 00:00:18,610
Podemos ver que nuestro ciclo FOR hemos especificado en código duro la cantidad de elementos que tenemos

8
00:00:18,610 --> 00:00:19,900
para recorrer nuestro arreglo.

9
00:00:20,140 --> 00:00:22,660
Así que en este caso, hemos especificado el valor de cinco.

10
00:00:22,840 --> 00:00:26,770
Pero qué pasa si no sabemos exactamente cuántos elementos tiene nuestro arreglo?

11
00:00:27,010 --> 00:00:29,860
Así que vamos a obtener este valor de manera dinámica.

12
00:00:30,070 --> 00:00:34,720
Para ello vamos a definir una variable llamada largo arreglo.

13
00:00:36,110 --> 00:00:40,430
De momento no la voy a inicializar ya que vamos a obtener este valor dinámicamente.

14
00:00:40,700 --> 00:00:48,200
Así que para obtener el largo del arreglo dinámicamente, vamos a hacer una serie de pasos.

15
00:00:48,380 --> 00:00:52,100
En primer lugar, vamos a ver cuántos bytes ocupa todo el arreglo en memoria.

16
00:00:52,520 --> 00:00:57,590
Así que vamos a ver la memoria ocupada por todo el arreglo.

17
00:00:58,160 --> 00:01:00,740
Para ello vamos a utilizar la función Size of.

18
00:01:00,950 --> 00:01:04,460
Así que definimos una variable llamada tamaño arreglo.

19
00:01:04,460 --> 00:01:09,230
No voy a utilizar eñes para evitar cualquier problema con el manejo de caracteres especiales.

20
00:01:09,500 --> 00:01:14,750
Ustedes podrían utilizar la ñ, pero en este caso voy a omitirla para que no tengan problemas en caso

21
00:01:14,750 --> 00:01:16,190
de que descarguen este código.

22
00:01:16,460 --> 00:01:23,270
Así que vamos a utilizar la función seis y vamos a pasar el nombre del arreglo números arreglo.

23
00:01:23,540 --> 00:01:25,460
Si mandamos a imprimir hasta el momento.

24
00:01:27,120 --> 00:01:28,710
Vamos a mandar a imprimir este valor.

25
00:01:29,040 --> 00:01:33,510
El tamaño del arreglo es un valor de tipo entero.

26
00:01:34,950 --> 00:01:36,510
Le imprimimos esta variable.

27
00:01:36,630 --> 00:01:37,650
Vamos a ejecutar.

28
00:01:39,300 --> 00:01:40,560
Vamos a separar las líneas.

29
00:01:40,830 --> 00:01:45,870
Así que en este caso, después de esta impresión, agregamos en primer lugar un salto de línea.

30
00:01:46,050 --> 00:01:51,060
Cuando queremos mandar a imprimir ese texto, reiteramos, para que todo quede en una línea distinta.

31
00:01:51,570 --> 00:01:52,740
Así que el tamaño del arreglo.

32
00:01:52,740 --> 00:01:54,120
Podemos observar que es 20.

33
00:01:54,300 --> 00:01:56,010
Pero vamos a ver por qué es 20.

34
00:01:56,400 --> 00:01:59,610
Recordemos que los tipos enteros ocupan cuatro bytes en memoria.

35
00:01:59,790 --> 00:02:05,670
Por lo tanto, si tenemos cinco elementos, entonces aquí la multiplicación sería son cinco elementos

36
00:02:05,670 --> 00:02:07,920
por la cantidad de bytes que ocupa cada uno.

37
00:02:08,190 --> 00:02:11,370
Entonces la función de seis regresa el valor de twenty.

38
00:02:11,550 --> 00:02:13,710
Podemos llevar que este es el valor que está regresando.

39
00:02:13,920 --> 00:02:19,590
No significa que es la cantidad de elementos, sino la cantidad total de memoria que ocupa este arreglo.

40
00:02:19,800 --> 00:02:23,190
Por lo tanto, tenemos cinco elementos por cuatro bytes.

41
00:02:23,430 --> 00:02:26,790
Por lo tanto, indica que está ocupando 20 bytes en memoria.

42
00:02:27,150 --> 00:02:31,290
Bien, este valor obviamente no nos sirve para iterar nuestros elementos de nuestro arreglo.

43
00:02:31,530 --> 00:02:33,090
Sin embargo, tenemos que continuar.

44
00:02:33,480 --> 00:02:34,890
Ese sería el primer paso.

45
00:02:35,040 --> 00:02:37,440
Obtener la memoria ocupada por todo el arreglo.

46
00:02:37,710 --> 00:02:40,200
Ahora vamos a obtener la memoria ocupada.

47
00:02:42,050 --> 00:02:43,550
Por un solo elemento.

48
00:02:43,910 --> 00:02:48,350
Recordemos que si este elemento es de tipo entero, entonces todos los demás elementos también son de

49
00:02:48,350 --> 00:02:48,980
tipo entero.

50
00:02:49,370 --> 00:02:54,890
Así que con un elemento que sepamos cuál es la cantidad de memoria que utiliza todos los demás elementos,

51
00:02:54,890 --> 00:02:56,420
va a ser exactamente lo mismo.

52
00:02:57,650 --> 00:03:05,420
Así que definimos la variable tamaño de un elemento y para ello utilizamos la función size of de nueva

53
00:03:05,420 --> 00:03:05,870
cuenta.

54
00:03:06,290 --> 00:03:11,360
Pero en lugar de proporcionar todo el nombre del arreglo, solamente vamos a proporcionar un valor.

55
00:03:11,600 --> 00:03:16,730
Para ello indicamos cualquier índice, en este caso el índice cero y vamos a mandar a imprimir.

56
00:03:18,640 --> 00:03:23,170
Primero un salto de línea y va a ser el tamaño de un elemento.

57
00:03:27,230 --> 00:03:29,900
Del arreglo es un valor de tipo entero.

58
00:03:30,890 --> 00:03:35,600
Imprimimos esta variable tamaño, pero solamente de un elemento.

59
00:03:36,080 --> 00:03:41,690
Vamos a mandar a imprimir y entonces tenemos que el tamaño total del arreglo ocupa 20 bytes y en este

60
00:03:41,690 --> 00:03:47,330
caso el tamaño de un solo elemento ocupa cuatro bytes, ya que como sabemos, el tipo entero en memoria

61
00:03:47,330 --> 00:03:48,320
utiliza cuatro bytes.

62
00:03:48,350 --> 00:03:49,910
Por ello el valor de cuatro.

63
00:03:50,240 --> 00:03:54,650
Ahora por último, para saber la cantidad de elementos de nuestro arreglo, ya simplemente tenemos que

64
00:03:54,650 --> 00:03:55,700
hacer una división.

65
00:03:56,030 --> 00:04:01,640
La división entre la cantidad de bytes que ocupa en memoria todo el arreglo dividido entre la cantidad

66
00:04:01,640 --> 00:04:04,040
de bytes que utiliza solamente un elemento.

67
00:04:04,400 --> 00:04:10,010
Así que para ello hacemos lo siguiente Vamos a utilizar nuestra variable largo del arreglo o la cantidad

68
00:04:10,010 --> 00:04:11,480
de elementos de nuestro arreglo.

69
00:04:11,510 --> 00:04:12,710
Es exactamente lo mismo.

70
00:04:12,930 --> 00:04:17,030
Ya simplemente hacemos la división del tamaño total del arreglo.

71
00:04:17,090 --> 00:04:22,040
Cuántos bytes ocupa en memoria todo el arreglo dividido entre la cantidad de bytes que utiliza?

72
00:04:22,040 --> 00:04:23,390
Solamente un elemento.

73
00:04:23,720 --> 00:04:26,720
Y con esto obtenemos la cantidad de elementos que tiene nuestro arreglo.

74
00:04:26,960 --> 00:04:28,670
Es decir, el largo de nuestro arreglo.

75
00:04:29,420 --> 00:04:31,280
Bien, vamos a mandar a imprimir entonces.

76
00:04:32,380 --> 00:04:33,550
Primero un salto de línea.

77
00:04:35,690 --> 00:04:38,210
Y ahora imprimimos el largo del arreglo.

78
00:04:39,530 --> 00:04:45,200
Una vez que ya hemos hecho esta operación, ya simplemente mandamos a imprimir esta variable largo arreglo

79
00:04:45,770 --> 00:04:51,050
y entonces podemos observar que dividir 20 entre cuatro obtenemos el resultado de cinco, ya que son

80
00:04:51,050 --> 00:04:53,450
cinco elementos que tiene nuestro arreglo.

81
00:04:53,900 --> 00:04:58,400
En otros lenguajes de programación podríamos obtener directamente este valor simplemente utilizando

82
00:04:58,400 --> 00:05:03,110
una función, pero en el caso del lenguaje, tenemos que hacer algunas otras operaciones para obtener

83
00:05:03,110 --> 00:05:06,920
dinámicamente el largo o la cantidad de elementos de un arreglo.

84
00:05:07,100 --> 00:05:12,170
Pero una vez que ya tenemos este valor, entonces ya lo podemos utilizar en nuestro ciclo FOR.

85
00:05:12,440 --> 00:05:16,280
Así que ya de manera dinámica simplemente especificamos la variable.

86
00:05:16,490 --> 00:05:20,990
Vamos a iterar desde cero hasta la cantidad de elementos que tengamos en nuestro arreglo.

87
00:05:21,260 --> 00:05:23,960
El largo de nuestro arreglo ejecutamos.

88
00:05:24,380 --> 00:05:28,910
Y entonces, ahora sí, de manera dinámica, estamos iterando cada uno de los valores de nuestro arreglo

89
00:05:29,150 --> 00:05:30,740
desde 100 hasta 500.

90
00:05:30,950 --> 00:05:37,910
Y ahora sí, ya podríamos agregar más elementos o quitar más elementos y de manera dinámica estaríamos

91
00:05:37,910 --> 00:05:42,170
obteniendo la cantidad de elementos que tiene nuestro arreglo y recorriendo exactamente la cantidad

92
00:05:42,170 --> 00:05:45,290
de elementos que tiene nuestro arreglo, ya sin ningún tipo de error.

93
00:05:45,500 --> 00:05:49,880
Y tampoco tenemos que especificar en código esta variable de largo arreglo.

94
00:05:50,090 --> 00:05:53,180
Así que este valor ya lo estamos obteniendo dinámicamente.

95
00:05:53,810 --> 00:05:56,180
Así que ese es el código para obtener el largo de un arreglo.

96
00:05:56,330 --> 00:06:01,640
La cantidad de elementos que tenemos en nuestro arreglo de manera dinámica pongo en práctica, ya que

97
00:06:01,640 --> 00:06:06,650
en ocasiones vamos a necesitar obtener este dato de manera dinámica tal como lo hemos visto.

98
00:06:06,980 --> 00:06:10,250
Pongan en práctica este ejercicio y nos vemos en el siguiente vídeo.

99
00:06:10,280 --> 00:06:10,850
Saludos.
