20261118 Test_array_2 - Contenido educativo
Ajuste de pantallaEl ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:
Vale, entonces ha sido listo y se ha parado en la penúltima, porque en cada iteración accede a su siguiente, en la iteración 0 accede a la posición 1 y la 0, en la iteración 1 accede a la posición 2 y la 1, en la iteración 2 accede a la posición 3 y a esta.
00:00:01
entonces ya no puede haber una iteración 3
00:00:23
porque si hubiera una iteración 3 accedería a esta
00:00:26
que no existe, a RAIN desvalor exceptio
00:00:28
y la siguiente
00:00:30
entonces bueno
00:00:30
todo el mundo está de acuerdo en que parece
00:00:34
que la RAI acaba con 4 doses
00:00:36
¿no?
00:00:38
lo que está haciendo es replicar este 2
00:00:40
lo está replicando en todo el RAI
00:00:42
de esta manera tan retorcida
00:00:43
luego AD3 es la última de las posiciones
00:00:44
AD3
00:00:48
y diríamos
00:00:49
que tiene un 2
00:00:51
si alguien
00:00:53
no
00:00:54
está de acuerdo, pues que lo diga
00:00:56
yo diría
00:00:59
esta
00:01:01
¿qué sucede aquí?
00:01:02
aquí
00:01:06
0 y 0
00:01:06
0 excepción, no compila
00:01:10
o excepción directamente
00:01:13
posibilidades
00:01:15
que tenemos aquí
00:01:19
que imprima primero
00:01:21
Primera posibilidad
00:01:24
La posibilidad
00:01:26
Que imprima primero cero
00:01:27
Y luego cero otra vez
00:01:29
Segunda posibilidad
00:01:31
Que imprima primero cero
00:01:33
Y luego pum
00:01:35
Salte una excepción al ejecutarse
00:01:36
Siguiente
00:01:38
Creo que era
00:01:41
No compila
00:01:42
Esto no compila
00:01:45
Y siguiente
00:01:50
Excepción desde el principio
00:01:53
A, B, C o D
00:01:56
¿Alguien podría decir algo desde ya?
00:02:04
Desde luego no parece que tengo
00:02:17
Un error de compilación
00:02:18
Luego esta
00:02:19
Yo la quitaría
00:02:21
Esta tiene una cosa curiosa
00:02:24
Que es, está creando
00:02:32
Un array
00:02:34
Pero con cero posiciones
00:02:35
¿Eso se puede hacer?
00:02:37
Claro que se puede hacer
00:02:39
Está haciendo esto
00:02:40
Variable a dirección de nada
00:02:41
cero posiciones
00:02:45
¿vale?
00:02:48
¿para qué es útil esto? ¿por qué podría serlo?
00:02:50
ya veremos, pero esto
00:02:52
perfectamente se puede
00:02:54
no sólo
00:02:56
declarar
00:02:57
y no va a dar errores de compilación, sino también ejecutar
00:02:59
bueno, pues entonces
00:03:02
sabiendo eso, que crea una caja
00:03:07
es como cuando uno
00:03:09
crea un string así
00:03:11
este string es perfectamente válido
00:03:12
lo que es es que es un string que no tiene nada dentro
00:03:15
es una cadena vacía, es un string perfectamente
00:03:17
válido, pues el array
00:03:19
que es una caja, pues
00:03:21
directamente con la tapa sobre la base
00:03:23
que no hay forma de meter ahí casilleros
00:03:25
no hay casillitas, posiciones
00:03:27
ese array también existe
00:03:29
igual que existe la cadena vacía
00:03:31
bueno, pues sabiendo eso
00:03:33
¿cuál diríais que es?
00:03:35
¿la?
00:03:38
¿tú lo has dicho?
00:03:40
¿lo has dicho?
00:03:41
¿la?
00:03:44
A ver, a.led te va a dar cero, eso sí, porque el tamaño del array es cero.
00:03:47
O sea, a.led va a ser siempre lo que se haya puesto aquí, luego es cero.
00:03:52
Y ahora, la siguiente, va a intentar acceder a la primera posición del array.
00:03:57
¿Va a llegar a algún sitio?
00:04:07
O sea, a.de.cero solo tiene sentido si el array tiene al menos una posición, que sería la cero.
00:04:10
Es decir, si mi array tuviera 1, si yo lo hubiera declarado aquí con 1, si yo lo declaro aquí con 1, apuntolence es 1 y es una cajita de una única posición que se corresponde a la posición 0.
00:04:17
Pero es que mi array tiene 0 posiciones, luego la posición 0 no existe.
00:04:32
Luego, ¿qué opción sería?
00:04:40
Si no es la A, ¿qué opción diríais de esa?
00:04:44
¿La A?
00:04:47
Aquí hemos llegado a que el primer cero lo imprime sin problemas.
00:04:51
A punto led, tamaño de la caja, cero posiciones.
00:04:54
Cero, la imprime sin problemas.
00:04:57
Y ahora aquí, ¿qué creéis que pasaría?
00:04:59
Pues lo que pasa cuando en un array intentamos acceder a una posición que no existe.
00:05:02
El array index va a una excepción, o sea, excepción.
00:05:08
La posición cero del array este no existe, no tiene ninguna posición.
00:05:11
es como si un array de 3 posiciones
00:05:15
0, 1 y 2
00:05:20
intento acceder a la 7
00:05:21
pues me sale array index bound exception
00:05:22
pues en este array
00:05:24
que es como si fuera la cadena vacía
00:05:26
que no tiene ni una sola posición
00:05:28
la 0 no existe
00:05:29
porque la 0 ya sería la primera de todas
00:05:30
la 0 es la primera
00:05:33
entonces yo no puedo acceder a A de 0
00:05:34
en un array que no tiene tamaño
00:05:36
¿vale?
00:05:39
luego está bien esta pregunta
00:05:41
porque nos ha servido
00:05:42
para ver que yo puedo crear un array
00:05:44
sin ninguna
00:05:47
posición, como puedo crear una cadena vacía
00:05:49
¿qué utilidad
00:05:51
es una caja que tiene la tapa
00:05:53
pegada a la base con lo cual no puedo meter
00:05:55
nada? pues bueno, o sea
00:05:57
en procedimientos que van automatizando
00:05:59
irse incrementando a sí mismos
00:06:01
ahí tiene sentido, porque ese sería el array
00:06:03
base, el array
00:06:05
como si fuera el 0 en una suma
00:06:06
acumulativa, pues sería como el array
00:06:09
base, pero bueno, eso ya lo veremos
00:06:11
vale, pues vamos a poner entonces
00:06:13
que la
00:06:17
la B imprime 0
00:06:18
que es esto
00:06:21
y después lanza una excepción
00:06:22
y ya tenemos la 10
00:06:25
las opciones son
00:06:30
6, 2, 10 o error
00:06:33
de compilación
00:06:35
6, 2, 10
00:06:36
o no compila
00:06:45
esta forma rara de hacer
00:06:46
el array ya nos salió arriba
00:06:57
y sí que
00:06:59
la admitía, vamos a asumir que es esto, para que nos entendamos mejor, es como si tuviéramos
00:07:01
esto, un array de tres posiciones, es lo mismo, entonces A inicialmente es 5, 10 y 15, A inicialmente
00:07:07
es esto? Vale, ya está, es esa. Esa es la primera línea. Segunda línea, B. B, ¿qué
00:07:39
le asignamos a? Una caja nueva para él con sus propios valores, con un new o con las
00:07:52
llaves, no. A B no le estamos asignando una caja nueva para él, sino que a B le estamos
00:07:57
asignando a la misma dirección que A, luego B se queda aquí apuntando, una única caja,
00:08:02
dos arrays A y B que le apuntan, ¿vale? Eso es la segunda línea. Ahora, ¿qué hacemos
00:08:10
con la tercera? Estamos creando otra caja nueva, otro array nuevo, otro, cada vez que
00:08:20
yo hago estas llaves, ¿vale? Ah, bueno, vale, perdón, es que esto en función de cómo lo
00:08:28
bueno, es que esta
00:08:34
esta sintaxis
00:08:35
solo la puedes hacer en el primer uso del array
00:08:38
pero bueno, voy a
00:08:40
aprovechar esta pregunta para otra cosa
00:08:42
imaginaos
00:08:44
que
00:08:46
que esto me lo permite el compilador
00:08:47
hacer, que no me lo va a permitir, pero nos interesa
00:08:50
entonces con esto
00:08:52
estaríamos
00:08:53
creando otra caja nueva
00:08:56
1, 2 y 3
00:08:57
y A estaría
00:08:59
apuntando aquí, entonces A
00:09:03
habría perdido
00:09:05
este valor
00:09:08
y A habría ganado este otro valor
00:09:09
la nueva caja que he hecho
00:09:12
¿vale?
00:09:13
entonces cuando yo hago esto
00:09:17
estoy creando una caja nueva
00:09:19
una caja nueva
00:09:20
y su dirección se la doy a A
00:09:22
con lo cual A
00:09:25
ya deja de valer lo que valía
00:09:27
que era apuntar a esta
00:09:29
y ahora tiene esto
00:09:30
la caja nueva que he creado porque se la he asignado a A
00:09:32
y ahora según eso
00:09:35
A de 0 y B de 0
00:09:39
sería
00:09:40
5
00:09:42
que tiene el B de 0
00:09:45
más 1
00:09:47
que tiene el nuevo A de 0
00:09:48
porque ha cambiado aquí
00:09:50
y ha dejado de ser esto para ser esta nueva caja
00:09:52
6
00:09:55
esa es una de las opciones que va a dar
00:09:56
a modo de trampa
00:09:59
pero
00:09:59
si lo dejáramos así sería
00:10:01
no con pila
00:10:05
Entonces, una de las opciones era, sí, la tengo puesta aquí, 6.
00:10:06
Entonces, esto puesto así no compilaría, ¿vale?
00:10:12
Porque cuando yo hago un array con las llaves, solamente lo puedo asignar a una variable que estoy declarando en ese momento.
00:10:18
Solo a una variable que estoy declarando en ese momento, no a una variable ya declarada como aquí.
00:10:29
entonces esto tal y como lo tengo
00:10:35
que sepáis
00:10:37
y os acordáis en el futuro mejor
00:10:39
que solamente
00:10:41
puedo asignar un array directamente
00:10:43
así entre llaves a una variable
00:10:45
array que estoy declarando en ese momento
00:10:47
nunca una que ya estaba declarada
00:10:49
de antes como aquí, si la declaro en este
00:10:51
momento sí, pero si ya estaba
00:10:53
declarada de antes no
00:10:55
y ahora ya mi duda
00:10:56
es como esta manera de declararlos
00:10:58
yo no la conocía
00:11:01
si así sí que puedes
00:11:02
volver a asignar una caja nueva
00:11:05
a una variable a que ya está declarada
00:11:07
seguramente sí y sirva para eso precisamente
00:11:09
seguramente sí
00:11:11
con lo cual es muy probable que la respuesta
00:11:13
sea 6
00:11:16
que no estoy segura
00:11:17
porque esta sintaxis tan rara de aquí
00:11:19
que yo desconocía
00:11:22
si se permita
00:11:23
para reasignar
00:11:24
una variable array que ya estaba asignada
00:11:28
de antes, mientras esto no, esto no se permite
00:11:29
vamos a poner 6
00:11:31
y a ver que explicaciones nos da luego
00:11:34
venga pues esta si que si
00:11:36
os voy a dejar
00:11:52
con un papel
00:11:54
como queréis vosotros
00:11:55
que la penséis el rato que haga falta
00:11:56
para ver que sale
00:11:59
la variable suma final
00:12:01
vale
00:12:02
venga si seguro que lo sabéis
00:12:03
el primer
00:12:20
el primer system out print ln
00:12:27
¿qué creéis que imprimirá?
00:12:29
el incremento está después
00:12:35
con lo cual primero se toma la I
00:12:37
se toma la I para hacer la operación
00:12:39
y luego se la incrementa
00:12:41
entonces la I tiene 2
00:12:43
luego primero se toma la I
00:12:45
para hacer el AD2
00:12:47
y luego ya I se incrementa
00:12:49
pero después
00:12:51
porque este es un post incremento
00:12:52
AD2 existe
00:12:56
sí, AD2 existe, 6
00:12:58
luego primero imprime 6
00:12:59
vale, es que es la opción de todas
00:13:01
hasta allí está claro
00:13:03
y ahora
00:13:05
¿qué intenta imprimir ahora después?
00:13:07
A, B
00:13:11
3
00:13:12
porque ahí se ha quedado valiendo 3
00:13:13
A de 3 existe
00:13:15
¿no?
00:13:17
porque solamente existe la posibilidad de 0, 1 y 2
00:13:19
con lo cual efectivamente
00:13:22
da una excepción de array
00:13:24
luego la opción
00:13:25
C
00:13:27
debería ser
00:13:28
vale
00:13:30
y
00:13:31
vale
00:13:32
pues
00:13:34
si marcamos
00:13:35
la opción
00:13:37
C
00:13:38
C
00:13:39
esto
00:13:42
2, 3, 4 y 5
00:13:42
uy
00:13:48
esto era
00:13:53
así como apuesta rápida
00:13:55
vamos a intentar
00:14:09
pues yo que sé
00:14:10
así pum
00:14:10
dar un vistazo rápido
00:14:11
parece que recorre
00:14:12
el array
00:14:14
pero hasta la mitad solamente
00:14:15
y fijaos
00:14:17
que esta acción está haciendo un intercambio
00:14:21
¿verdad?
00:14:23
recordad que cuando intercambiamos ya hicimos un ejercicio
00:14:25
de intercambiar
00:14:28
los valores de dos variables
00:14:29
en este caso las variables eran a y b
00:14:30
y que lo hacíamos mediante
00:14:33
un auxiliar
00:14:35
al auxiliar le asignábamos primero a
00:14:36
luego a le asignábamos lo que tenía b
00:14:39
y luego a b le asignábamos lo que tenía el aux
00:14:42
de esta manera
00:14:44
Pues esto responde a lo mismo, está intercambiando los valores de a de i con a de led menos 1 menos i, está intercambiando esos dos valores mediante un auxiliar, entonces tiene toda la pinta de que está intercambiando el 0 por el último, el 1 por el penúltimo, ¿verdad?
00:14:45
Por eso se queda en la mitad, ¿verdad? Aquí vemos rápidamente que está intercambiando, que está intercambiando A de I con A de A punto len menos 1, que es la última posición, menos I.
00:15:13
Recordad que esta es la última posición. Luego, para I igual a 0, vamos a suponer, la última posición vamos a suponer que la llamamos n menos 1, lo vemos más fácil, si la raíz tiene n posiciones.
00:15:46
Para i igual a 0, está intercambiando la posición 0 con la posición n-1, es decir, la primera con la última.
00:16:02
Pero cuando i es igual a 1, está intercambiando la posición 1 con la n-2, es decir, la segunda con la penúltima.
00:16:10
Pero cuando i es igual a 2, está intercambiando la posición 2 con la n-3, ¿vale?
00:16:19
Es decir, en la iteración 0 está intercambiando esta con esta.
00:16:26
En la iteración 1 está intercambiando esta con esta.
00:16:32
Y por eso se está quedando en la mitad.
00:16:36
Porque para hacer esos intercambios, con llegar a la mitad es suficiente.
00:16:40
Con llegar a la mitad de la raya es suficiente.
00:16:44
Entonces lo está como invirtiendo en espejo, ¿verdad?
00:16:46
Lo está recorriendo hasta la mitad y en cada posición lo intercambia con su espejo.
00:16:51
Esta posición es el espejo de esta otra.
00:16:57
¿Verdad?
00:17:02
Este es el espejo de esta otra,
00:17:04
que está intercambiando,
00:17:05
que está dando la vuelta.
00:17:06
Entonces, si lo está intercambiando,
00:17:10
cuando esto termina,
00:17:12
AD1, que es esta,
00:17:14
tendrá lo que tenía su espejo,
00:17:16
que es el 4.
00:17:18
¿Verdad?
00:17:20
Tiene toda la pinta.
00:17:20
¿Sí o no?
00:17:22
Entonces yo apostaría por el 4.
00:17:24
Si es que hay alguna opción que sea el 4,
00:17:31
que sí.
00:17:33
Venga, esta tiene pinta de que va a ser más rápida.
00:17:45
Bueno, vamos a ver qué opciones tiene aquí.
00:17:47
1, 2, 3 y 4
00:17:49
las opciones aquí son
00:17:54
1, 2, 3 y 4
00:18:04
entonces A es la cajita
00:18:06
1, 2 y 3
00:18:12
¿B quién es?
00:18:14
exactamente la misma caja
00:18:16
B y A son la misma caja las dos
00:18:17
porque a B le estamos asignando
00:18:20
a lo que apunta B y A son idénticos
00:18:23
lo mismo
00:18:27
y ahora B00
00:18:28
le incrementamos
00:18:31
pues es 2
00:18:34
y a A00 le volvemos a incrementar
00:18:35
luego ahora esto se convierte
00:18:38
primero se ha convertido en 2
00:18:40
luego se ha convertido en 3
00:18:42
¿qué tiene B de 0?
00:18:44
pues yo diría que
00:18:46
3
00:18:48
es decir, me da igual acceder a través de A
00:18:49
que a través de B
00:18:52
estoy accediendo a lo mismo
00:18:53
gracias a esta sentencia de aquí
00:18:55
estoy accediendo a lo mismo
00:18:57
¿vale?
00:18:58
entonces diríamos que 3
00:19:00
que es esta
00:19:03
15, vamos a ver
00:19:07
si las que quedan las podemos hacer
00:19:16
rápido, le damos a corregir
00:19:18
rápido a ver si
00:19:20
vale, esto que significa
00:19:21
esto de aquí, esto
00:19:24
esta palabrita que es la primera vez que nos
00:19:28
aparece, null, es la
00:19:30
palabra que significa objeto
00:19:32
inexistente, aquí no hay
00:19:34
nada, null significa la nada
00:19:36
vale
00:19:38
entonces, esto no es lo mismo
00:19:39
que lo que hemos
00:19:43
silencio
00:19:44
esto no es lo mismo que lo que hemos hecho antes
00:19:48
que hemos hecho aquí
00:19:52
no es lo mismo
00:20:00
esto es un array que existe
00:20:01
existe perfectamente
00:20:04
ese array, lo que pasa es que es una
00:20:06
caja vacía
00:20:08
no puedo meter nada en ella
00:20:10
pero la caja existe
00:20:12
lo que pasa es que es una caja en la que no puedo meter nada
00:20:13
pero existir, existe
00:20:16
¿y cuál es su apunto led?
00:20:17
su apunto led es cero
00:20:20
es decir, ¿cuántas
00:20:21
cositas admite esa caja?
00:20:24
admite cero cosas
00:20:26
pero la caja existe
00:20:28
pero admite cero cosas, es como una cadena vacía
00:20:29
la cadena existe
00:20:32
pero ¿cuántos caracteres tiene?
00:20:34
cero caracteres, no tiene nada
00:20:36
pues esto es una situación
00:20:37
y en ese caso
00:20:39
apunto led imprimiría cero
00:20:42
pero esta es otra, null significa
00:20:44
como ya nos hartaremos de ver
00:20:46
en objetos
00:20:48
esto no existe, esto es la nada
00:20:49
entonces si yo a mi array
00:20:51
le doy null, es que
00:20:54
no tengo ni cajita, o sea aquí es el vacío
00:20:56
universal, no hay nada
00:20:58
no hay ni caja, con lo cual
00:21:00
si yo hago punto led
00:21:02
me va a dar una excepción que es
00:21:03
en particular
00:21:06
la excepción null pointer exception
00:21:08
que es, perdona, de la nada
00:21:09
yo no puedo sacarte la longitud de la nada
00:21:12
es imposible, la nada no tiene
00:21:14
ni el concepto de longitud siquiera
00:21:16
entonces
00:21:18
esto me dará una excepción
00:21:19
sin embargo, si yo lo declaro
00:21:22
así como new int 0
00:21:24
eso no me da excepción porque eso no es la nada
00:21:25
es una caja, pero una caja sin espacio
00:21:28
dentro, ya está
00:21:30
luego de las opciones que me da aquí
00:21:31
habrá una que será excepción
00:21:34
y además la que os acabo
00:21:36
de decir, null pointer excepción
00:21:38
¿vale? pero bueno, esto
00:21:40
Ya iremos trabajando con ello
00:21:43
4, 3, 2, excepción
00:21:46
Esto era
00:21:49
Las opciones posibles creo que eran
00:22:05
4, 3, 2, excepción
00:22:07
Bueno, vamos a hacer esta
00:22:15
Y aquí lo dejamos
00:22:20
Las 4 siguientes pueden ser muy largas
00:22:20
Pues venga, este array
00:22:23
A de 3
00:22:27
Que va a terminar teniendo
00:22:29
4, 3, 2
00:22:30
O me va a saltar una excepción antes
00:22:32
Mi array inicialmente tiene esto
00:22:34
1, 2, 3 y 4
00:22:36
este es mi array inicial
00:22:38
tiene 1, 2, 3 y 4
00:22:40
este es mi array A
00:22:41
tiene toda la pinta de que lo estamos recorriendo
00:22:42
manera estándar
00:22:46
desde 0 hasta el final
00:22:48
de 1 en 1
00:22:50
luego lo estamos recorriendo entero
00:22:51
manera estándar
00:22:53
¿y qué estamos haciendo para cada posición?
00:22:54
para cada posición
00:22:59
si el número es par
00:23:01
le asignamos
00:23:04
el anterior
00:23:08
bueno, pues que creéis que terminará teniendo
00:23:10
A de 3, que A de 3 es esta
00:23:16
porque esta es la posición 3
00:23:19
cuando el bucle termine
00:23:20
o habrá dado una excepción antes
00:23:22
diríamos que 3
00:23:24
vamos a ver
00:23:55
vamos recorriendo
00:23:56
todas y cada una
00:23:59
de las posiciones de la primera
00:24:02
a la última y de uno en uno
00:24:04
vale, para la primera posición
00:24:05
es par
00:24:08
le asigno la anterior
00:24:09
aquí tendría una excepción bien gorda
00:24:12
si en lugar de tener estos valores
00:24:14
el array
00:24:17
diera la puñetera casualidad de que tiene un 2
00:24:18
porque si tiene un 2
00:24:20
al ser par la posición a de 0
00:24:22
trataría de acceder
00:24:25
a la anterior a la de 0
00:24:27
que es la menos 1, esa no existe
00:24:28
luego daría un array y desvanecería
00:24:30
luego si en lugar de inicializar con 1
00:24:32
se hubiera inicializado con 2
00:24:34
aquí me saldría una excepción
00:24:35
pero de casualidad
00:24:37
resulta que está 1
00:24:41
luego AD1 no es par
00:24:42
porque es 1
00:24:45
luego no entra aquí
00:24:46
esa excepción no nos enteramos
00:24:48
y no pasa nada
00:24:49
siguiente iteración
00:24:50
estamos en esta posición
00:24:53
el número que está en esta posición es par
00:24:55
luego le asigno su anterior
00:24:57
pues el 2 desaparece
00:25:00
y se convierte en el 1
00:25:02
siguiente iteración
00:25:03
A de 2 o lo que es lo mismo
00:25:06
3 es par, no es par
00:25:10
luego no hago nada
00:25:12
siguiente
00:25:14
iteración
00:25:16
A de 3 es par, sí es par
00:25:17
luego le asigno a su anterior
00:25:20
3
00:25:22
entonces
00:25:23
A de 3
00:25:25
yo creo que tendrá, a mí las cuentas que me salen
00:25:27
ay perdón, sí
00:25:29
es que tenga 3, porque al ser par
00:25:30
le he asignado el número anterior que era 3
00:25:33
¿vale? no sé si era el que habéis hecho tú
00:25:36
habéis hecho 3, vale, pues eso
00:25:37
pues ya está, esto me daría
00:25:40
en principio 3, ¿vale?
00:25:41
pero
00:25:44
aquí hay un peligro
00:25:44
y es que si
00:25:47
si es igual a 0
00:25:49
este es menos 1, que es a raíz de
00:25:51
logon exception, pero es que nunca entra
00:25:53
aquí si es 0, porque este es
00:25:55
impar, pero si yo cambio los datos de entrada
00:25:57
podría entrar, con lo cual ese código
00:25:59
pues es muy feo
00:26:01
porque tiene ahí escondido una raíz
00:26:02
de zone exception latente
00:26:05
que en cuanto cambie los datos de entrada va a aparecer
00:26:07
en esta ejecución en particular
00:26:09
no ha aparecido de puñetera casualidad
00:26:11
pero en cuanto cambie los datos de entrada
00:26:13
me va a aparecer
00:26:15
¿vale? de ahí la importancia de
00:26:16
los casos de prueba, esta aplicación
00:26:19
si no la probara, tendría que probarla con muchos
00:26:21
casos de prueba, porque si la prueba
00:26:23
con este, dice, ah, funciona
00:26:25
pero ahora métele tú otros datos de prueba
00:26:27
pues ahí tienes una array de zone exception
00:26:29
la aplicación ha fallado
00:26:31
¿vale? de ahí
00:26:33
la importancia de las pruebas
00:26:35
bueno, pues este habíamos dicho que sería un 3
00:26:37
¿vale? y bueno
00:26:39
y las 4 que quedan las dejamos
00:26:41
para mañana
00:26:43
- Materias:
- Programación
- Niveles educativos:
- ▼ Mostrar / ocultar niveles
- Formación Profesional
- Ciclo formativo de grado básico
- Primer Curso
- Segundo Curso
- Ciclo formativo de grado medio
- Primer Curso
- Segundo Curso
- Ciclo formativo de grado superior
- Primer Curso
- Segundo Curso
- Ciclo formativo de grado básico
- Subido por:
- Raquel G.
- Licencia:
- Todos los derechos reservados
- Visualizaciones:
- 1
- Fecha:
- 18 de noviembre de 2026 - 22:49
- Visibilidad:
- Clave
- Centro:
- IES ROSA CHACEL
- Duración:
- 26′ 46″
- Relación de aspecto:
- 1.78:1
- Resolución:
- 1920x1080 píxeles
- Tamaño:
- 918.32 MBytes