Saltar navegación

Estructuras de control: Condicional 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 3 de octubre de 2024 por Stefano C.

27 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, voy a grabar esta clase, si habláis me dais consentimiento para que pueda grabar vuestra voz 00:00:00
Entonces, aquí, hoy vamos a ver una cosa nueva que son las estructuras de control 00:00:05
Hasta ahora, en todos los ejercicios que nosotros hemos visto, hemos hecho ejercicios secuenciales 00:00:11
Es decir, que voy instrucción por instrucción y hago todas las instrucciones desde la primera hasta la última 00:00:18
Puede que hemos visto el operador ternario 00:00:24
Que es el operador un poquito más complejo 00:00:28
Y que nos da un poquito más de juego 00:00:31
Que hoy sustancialmente sustituiremos con una cosa más eficaz 00:00:33
Que es el if 00:00:39
Pero aún cuando ejecuto un ternario 00:00:40
Estoy ejecutando toda esa expresión 00:00:46
Estoy evaluando toda esa expresión 00:00:48
Y se hace paso por paso una instrucción tras instrucción tras instrucción, ¿vale? 00:00:49
Las estructuras de control, sostancialmente, son elementos del lenguaje que permiten cambiar la forma con que se ejecutan las instrucciones. 00:00:56
Nos permiten cambiar el flujo lógico, la secuencia con que hago las instrucciones de alguna forma, ¿vale? 00:01:08
En vez de hacerlas en secuencial, como ahora, una tras otra, puedo llegar a momentos de decir, un bloque me lo ejecutas y otro no, entonces me salto un bloque, ¿vale? 00:01:17
O podría decirle, este bloque lo ejecutas varias veces, o le podría decir, cuando llegas a esta instrucción, párate allí, vete a otro lado, a otro fichero donde tengo algo de código allí, ejecutas ese código de allí, y cuando has acabado ese código de allí, vuelves a este. 00:01:29
Esto, por lo general, las estructuras de control. 00:01:50
Cuando se habla de flujo de ejecución, se entiende el orden con que se ejecutan un conjunto de instrucciones 00:01:54
Normalmente secuenciales, uno tras otro, pero repito, con esto lo puedo romper 00:02:02
¿Qué tipos de sentencias de control existen? 00:02:06
Tres tipos, condicionales, iterativas y llamadas a métodos 00:02:12
Los condicionales son ejecuto un trozo de código si una condición es verdadera 00:02:19
Parecido, muy parecido al ternario 00:02:28
Pero os recuerdo que el ternario es una instrucción 00:02:33
Es una expresión, perdón 00:02:35
Es algo que evalúo y al final me vale algo 00:02:38
Hago todo este ternario y al final es un char lo que sale 00:02:42
Es un string lo que sale 00:02:48
Pero es una operación, es un operador, de hecho, el tornario. 00:02:49
Sin embargo, aquí no estamos hablando de una operación, estamos hablando de un conjunto de operaciones, 00:02:53
de una serie de instrucciones que se ejecutan si una condición es verdadera. 00:02:58
En otra versión está el switch, ¿vale? Veremos los dos con calma. 00:03:05
En el que ejecuto distintas instrucciones en base al valor de una determinada variable 00:03:10
Si la variable vale 1 hago esto, si vale 2 hago esto, si vale 3 hago otra cosa 00:03:20
Las sentencias iterativas son las que me permiten repetir un trozo de código varias veces 00:03:25
¿os acordáis cuando antes hablábamos de tengo una palabra y quiero cambiar cada uno de los carácteres de esta palabra 00:03:35
y por ejemplo ponerla mayúscula? 00:03:44
pues con un iterativo yo puedo decir empieza desde el principio de la palabra 00:03:47
llega hasta el final de la palabra y por cada carácter de esta palabra haz algo 00:03:51
repetiré el código que hace algo, en nuestro caso es que cambia mayúscula 00:03:57
por cada una de las letras de esta palabra. 00:04:04
Independientemente de si la palabra son tres letras, son cinco, son veinticinco. 00:04:08
Entonces, las sentencias de control iterativa me permiten pillar un trocito de código 00:04:14
y repetirlo varias veces. 00:04:18
Pensad a una calculadora. 00:04:21
Yo hago una calculadora que me dice, dame un número, dame otro número, y lo suma. 00:04:23
Ya está. 00:04:27
Podría ser que al final de esta suma le diga, 00:04:28
¿Y quieres volver a hacer otra suma? 00:04:32
Y si me dice que sí, pues vuelve al principio y me vuelve a pedir un número, otro número, y lo suma. 00:04:35
Y me dice, ¿quieres hacer otra operación? 00:04:43
Y si tú le dices que sí, vuelve al principio y lo hace. 00:04:45
Hasta que tú le digas que no, entonces sale. 00:04:47
Eso sería iterativo. 00:04:50
¿Sí? Lo veremos. 00:04:53
Y luego las llamadas a métodos. 00:04:55
Nosotros las llamadas a métodos ya las hemos usado. 00:04:57
¿Cuándo hemos usado llamadas a métodos? 00:04:59
Por ejemplo, cuando hago scan.nexint, pues ese es un método. ¿Qué quiere decir? Que yo estoy ejecutando mi programita, llego al scan.nexint y lo que hace es pararse mi programita en un cierto sentido, se va a un código que no he escrito yo, que está en la clase scanner y que ha escrito otra persona, ejecuto ese código que me permite leer de teclado, 00:05:06
Y cuando he hecho este código allí 00:05:32
Vuelvo a mi programa 00:05:34
Y sigo adelante 00:05:36
Otro método que hemos usado 00:05:37
System.out no es un método 00:05:40
Pero 00:05:47
Pero 00:05:48
Length es un método 00:05:51
Println si es un método 00:05:54
System.out 00:05:56
Es el objeto sobre lo que llamo 00:05:58
Y println si que es un método 00:06:00
Todo lo que tiene paréntesis 00:06:02
Sostancialmente redondas 00:06:04
Punto no se que paréntesis 00:06:05
Pues esos han sido métodos 00:06:08
El length, el uppercase, el charat 00:06:09
Son todos trozos de códigos que no tengo allí 00:06:13
Que ha escrito otra persona 00:06:18
Que cuando mi flujo de información llega a esa llamada 00:06:19
Suspende el código que he escrito yo 00:06:23
Se va a otro lado 00:06:27
Hace las instrucciones del otro lado 00:06:28
Y luego vuelve 00:06:30
Pues esas son llamadas a métodos 00:06:31
rompen con la normal secuencialidad de las instrucciones 00:06:33
porque cuando llego a esa instrucción no sigo con la siguiente sino me voy a otro lado 00:06:38
¿Se entiende? 00:06:42
Entonces, estos son los tres tipos de sentencias que me permiten 00:06:45
modificar, cambiar el flujo de información 00:06:49
y hacer más complejos y más completos mis programas 00:06:53
Condicionales 00:06:59
Los condicionales sirven para proporcionar distintos caminos lógicos, es decir, distintas opciones en una ejecución. 00:07:03
Dependiendo de una cierta condición, el camino que tengo que seguir puede ser este bloque o un bloque distinto. 00:07:12
Se evaluará una condición, es decir, que habrá una condición booleana, se evalúa, esta condición me dará true o false. 00:07:22
Si es true, haré una cosa 00:07:31
Si es false, haré otra cosa distinta 00:07:33
¿Dudas hasta aquí? 00:07:35
Vale 00:07:39
Esta es un esquemita 00:07:39
En flujo de 00:07:42
Diagrama de flujo 00:07:43
De cómo funciona el if 00:07:45
Y su hermano el if-else 00:07:46
¿Vale? 00:07:49
El if tiene una condición 00:07:51
Si esta condición es verdadera 00:07:53
Ejecuta un bloque de instrucciones 00:07:55
Si es falsa 00:07:58
Este bloque de instrucción se lo salta 00:07:59
Ya está 00:08:01
Entonces es un comando 00:08:03
Que me dice que este bloque de aquí 00:08:05
Se ejecutará si solo si 00:08:08
Se verifica una condición 00:08:10
Si no se verifica me la salto 00:08:11
Hay una versión 00:08:13
Con esto sería suficiente 00:08:18
Podría hacer dos if 00:08:22
Uno que verifica 00:08:24
Una condición y uno que verifica 00:08:26
El opuesto de esta condición 00:08:27
y podría hacer todo lo que me interesa, ¿vale? 00:08:29
Pero por comodidad, los lenguajes proporcionan un constructo que se llama IFELS, ¿vale? 00:08:32
El IFELS funciona que hay una condición, si esta condición es verdadera, hago un bloque, 00:08:39
si no, ELS, ¿vale? ELS quiere decir, en otro caso, hago un bloque distinto, ¿sí? 00:08:46
Entonces la condición se evaluará en verdadero o falso 00:08:55
Si es verdadero ejecuto el bloque a la izquierda 00:08:59
Si es falso ejecuto el bloque a la derecha 00:09:02
Y luego sigue adelante 00:09:03
Más o menos la idea 00:09:04
¿Sí? 00:09:07
¿Cómo se hace en Java? 00:09:10
¿Vale? 00:09:12
Pongamos entre x igual a 5 00:09:13
Una variable 00:09:15
Si x es menor que 5 00:09:16
Esta cosa de aquí 00:09:19
Luego 00:09:21
sin este punto println, en fin 00:09:23
si yo ejecuto 00:09:25
este código, ¿qué obtengo? 00:09:28
solo esto 00:09:34
¿por qué? 00:09:34
porque esta instrucción de aquí 00:09:37
se ejecuta 00:09:39
si, solo si, x es menor que 5 00:09:41
como x no es 00:09:43
menor que 5 00:09:47
porque es igual a 5 00:09:48
pues entonces esto me lo salto 00:09:50
y voy directamente a este 00:09:53
¿dudas? 00:09:54
switch no lo hemos dado 00:10:01
Otro ejemplo de if, int x es igual a 5, si x es menor o igual a 6, abro un bloque, digo estas cosas, cierro el bloque, fin 00:10:02
¿Qué me escribe? Pues evalúa esta expresión, 5 es menor que 6, sí, por lo tanto va a ejecutar este bloque entero 00:10:15
Es decir, que escribirá resultado y luego escribirá menor que 6 y luego después habrá acabado este bloque, llega aquí y ejecuta fin. 00:10:27
Entonces aparecerá resultado menor que 6 y fin. 00:10:39
Algo que nos torna, os parezca complejo o no entendáis. 00:10:46
Si x es igual a 5 00:10:51
Si x es igual a 5 00:11:00
Si x es menor que 5 00:11:02
Este bloque 00:11:04
Else este bloque 00:11:05
System.auto.println 00:11:08
Fin 00:11:10
¿Qué escribe? 00:11:11
¿Qué escribe? Perdón 00:11:19
El else 00:11:20
Verifica esto 00:11:22
Esto es falso 00:11:24
Se salta este bloque 00:11:25
Hay un comando else 00:11:27
Por lo tanto dice 00:11:29
Si esta es falsa, es esto lo que tienes que hacer 00:11:30
Escribe mayor o igual a 5 00:11:33
Y luego ha acabado el bloque if 00:11:36
Y por lo tanto ejecuta este de aquí que está detrás 00:11:39
Tú das int x es igual a 5 00:11:42
Si x es menor que 5, hace esta cosa de aquí 00:11:51
Si no, si x es igual a 5, hace esta cosa de aquí 00:11:54
Y si no, esta cosa de aquí 00:12:00
Esta es otra cosa que se puede hacer, que es un else if 00:12:02
Que sustancialmente me permite hacer tres opciones 00:12:13
Si es menor que 5, si es igual 00:12:17
Y si llega a este de aquí 00:12:20
Es que no es ni menor que 5, ni igual a 5 00:12:22
Por lo tanto será mayor que 5 00:12:26
Este bloque aquí 00:12:28
Este es sintaxis 00:12:30
¿Vale? 00:12:34
Por ahora este el shift no lo usamos 00:12:35
Usamos solo if-else 00:12:38
Luego un poquito más adelante empezamos con este shift 00:12:39
Pero para que sepáis que existe 00:12:42
¿Qué escribe esto? 00:12:44
Miro este if, el if azul 00:13:07
¿X es menor que 5? 00:13:09
Por lo tanto voy al bloque else 00:13:13
Entro aquí dentro 00:13:15
Llego al if 00:13:17
Moral 00:13:18
Si, X es igual a 5 00:13:20
X es igual a 5 00:13:23
Si, por lo tanto 00:13:24
Esto lo ejecuto 00:13:26
Y esto me lo salto 00:13:28
Ejecuto esta cosa aquí 00:13:29
Y luego escribo fin 00:13:32
Entonces pondría igual a 5 y fin 00:13:33
¿Sí? 00:13:36
Y si aquí pongo 4, ¿qué escribe? 00:13:39
Entraría aquí 00:13:48
Se salta todo el else azul 00:13:49
¿Vale? 00:13:52
Y luego aquí escribiría fin 00:13:53
¿Claro? 00:13:55
Entonces, ¿esto qué hace? 00:14:02
Esto es un problema 00:14:37
¿Vale? 00:14:38
Porque yo no sé si este else es de este if 00:14:39
O de este if 00:14:44
Los bloques no son necesarios 00:14:46
Si hago un if así, quiere decir que dentro del bloque está solo esta 00:14:55
O sea, este if solo se refiere a esta instrucción, a la siguiente instrucción 00:15:03
Ahora, como consejo, usad siempre los bloques, siempre 00:15:07
Hasta si hay una sola instrucción 00:15:13
Para que se quede claro y no haya situaciones como estas 00:15:17
Pues este de aquí depende 00:15:22
Porque si este if está aquí, no escribiría nada 00:15:32
Ni tú ni nadie 00:15:35
Eso depende de cómo funciona el lenguaje 00:15:40
Y cómo interpreta esta cosa de aquí 00:15:44
Y como no lo sabemos, y es complejo 00:15:46
Lo más probable es que no escriba nada 00:15:49
Que salte todo esto 00:15:51
Pero como no lo sabemos, pues entonces ponemos las paréntesis 00:15:52
dudas hasta aquí, entonces vamos a hacer un par de ejemplos con if, hagamos un ejemplo de un ejercicio 00:15:56
por ejemplo de dame un número y dime si es positivo o negativo, entonces scanner, scan es igual a new 00:16:15
Scanner de 00:16:32
System.in 00:16:34
Si so 00:16:36
Dame 00:16:44
Un número 00:16:46
Int 00:16:48
N es igual a 00:16:50
Scan.nextint 00:16:52
He leído un número 00:16:54
Ahora tengo que decir si es positivo 00:16:57
O negativo 00:17:02
Nosotros esto lo sabemos ya hacer con 00:17:03
Operador ternario 00:17:06
Vamos a hacerlo con el if 00:17:07
Si n es mayor o igual que 0, asumamos que 0 sea positivo 00:17:09
String resultado es igual positivo 00:17:21
El c, string resultado es negativo 00:17:31
Si so, res 00:17:45
¿Os gusta? 00:17:53
en informatikese 00:17:56
¿vale? 00:18:16
o sea, usando lenguaje informático 00:18:18
me decís por qué esto se enfada 00:18:21
es un problema de 00:18:25
pero eso no es informatikese 00:18:42
es un problema de 00:19:00
es un problema de 00:19:03
que no estudiáis en casa 00:19:12
Es un problema de ámbito de variables 00:19:14
Esta variable aquí, ¿dónde existe? 00:19:25
Dentro de este bloque 00:19:31
Y esta, aquí 00:19:32
Por lo tanto, cuando llego aquí e intento imprimirla, me dice no existe 00:19:35
¿Cómo lo puedo resolver? 00:19:40
Fijaos que ahora se enfada aquí, porque estoy creando una variable que ya existe 00:19:43
Por lo tanto lo quito así 00:19:56
Podría hacer así, mira 00:19:58
Asumo que ha habido un error 00:20:02
Si me entrará aquí o aquí 00:20:07
Lo sobrescribirá 00:20:10
Entonces todo habrá funcionado bien 00:20:11
Si por alguna razón 00:20:13
Explot, no sé qué, no pasa por aquí 00:20:14
Y llega a imprimirla 00:20:17
Pues me dirá que ha habido un error 00:20:18
Nunca pasará 00:20:19
Pero como idea 00:20:23
Vamos a ver si funciona 00:20:24
Lanzo esto 00:20:27
Le doy 5 00:20:29
Y me dice positivo 00:20:30
Alzo esto, menos 4, me dice negativo 00:20:31
Perfecto 00:20:36
Ahora, la cosa interesante del if 00:20:39
Es que nosotros aquí lo hemos usado un poquito pensando al 00:20:41
¿Cómo se llama esto? 00:20:45
Lo diré 00:20:47
Al operador ternario 00:20:49
Es decir, hacemos operaciones para que esto me dé un resultado 00:20:51
Pero ahora con el if 00:20:56
yo puedo directamente 00:20:59
usar comandos 00:21:03
aquí dentro, ¿sí? 00:21:06
El if ahora, mientras en el condicional, en el ternario 00:21:22
los dos ramas que tenía, que al fin y al cabo era 00:21:27
sí, este es verdadero y este es falso, pero tienen que ser expresiones 00:21:31
evaluables, ahora yo aquí dentro puedo meter 00:21:35
uno o varios 00:21:39
o mil 00:21:41
instrucciones distintas 00:21:42
esto en el ternario 00:21:45
no lo puede hacer, yo no puedo hacer 00:21:51
en el ternario 00:21:53
n mayor o igual a cero 00:21:54
interrogación 00:21:57
si sostén punto out 00:21:59
punto println 00:22:02
porque 00:22:03
esto 00:22:15
es un valor 00:22:16
y esto no es un valor 00:22:18
¿qué valor es este? no lo entiendo 00:22:20
no es un valor, no es una expresión 00:22:22
es un 00:22:28
comando, pero no es una instrucción 00:22:30
no es una suma, no es un 00:22:32
no tiene operadores 00:22:33
¿qué es esto? 00:22:34
¿dónde lo guardo esto? ¿qué tipo tiene esta cosa aquí? 00:22:38
¿vale? y entonces es problemático 00:22:43
sin embargo ahora sí puede hacerlo 00:22:45
¿vale? 00:22:47
¿dudas? 00:22:53
si la quieres usar fuera o algo así 00:23:04
Si tú quieres 00:23:07
La variable 00:23:10
Si la usas solo aquí dentro 00:23:11
Pero no solo los del if 00:23:13
Cualquier bloque es independiente de los otros 00:23:22
Vamos a hacer otro ejercicio 00:23:24
Otro ejercicio que puede ser 00:23:27
Dame una palabra 00:23:30
De dos letras 00:23:35
¿Vale? 00:23:36
Y si esta palabra 00:23:37
De dos letras 00:23:39
Te la transformo en mayúscula 00:23:40
suena de algo, dame una palabra de dos letras, ¿sí?, intern es igual a, no, string, S, he leído una palabra de dos letras, ¿vale?, primero me pregunto, si S, ¿cómo me puedo preguntar si es de verdad de dos letras?, ¿sí?, 00:23:43
Si la longitud de este string es igual a 2, entonces vemos ahora qué hacemos. 00:24:30
Si no, imprimo palabra no válida. 00:24:40
¿Qué hago aquí? 00:24:56
Ahora sé que son dos letras, no tengo un iterativo. 00:25:00
Aquí sería bonito poder hacer lo mismo dos veces con un iterativo 00:25:04
Pero todavía no tengo ni while, ni for, ni nada 00:25:08
Por lo tanto, tengo que hacer dos veces lo mismo 00:25:11
¿Vale? 00:25:13
Entonces, ahora puedo hacer char 00:25:15
Usando char 00:25:17
Char letra 1 es igual a s.charAt 0 00:25:24
Hagamos charL 0 00:25:34
Y char L1 es igual a S.charAt1, ¿sí? 00:25:36
Ahora me puedo preguntar, si L0 como int es mayor que 65 00:25:51
Y este señor de aquí lo mismo 00:26:19
Y siempre la letra como int es menor o igual que 90 00:26:27
Quiere decir que 00:26:34
Si este es verdadero, ¿qué quiere decir? 00:26:40
Que es mayúscula 00:26:46
¿Vale? 00:26:53
Si no, es minúscula 00:26:54
Nosotros hemos dicho que el objetivo es 00:26:59
Dame una palabra y te la escribo toda en mayúscula 00:27:02
¿Vale? 00:27:05
Entonces fijaos que si esto es verdadero 00:27:05
¿Qué tengo que hacer? 00:27:08
Sustantemente nada 00:27:16
Y si no, transformar 00:27:17
El L1 00:27:20
El L0 en mayúscula 00:27:22
Su correspondiente mayúscula 00:27:25
¿Vale? 00:27:26
Entonces lo voy a hacer un poquito distinto 00:27:27
Como aquí no lo toco L0 00:27:29
Si entro aquí dentro y no lo toco 00:27:33
No haría nada 00:27:35
Me quedaría con L0 00:27:36
Pues lo que puedo hacer es esto 00:27:38
He invertido 00:27:40
He puesto un NOT 00:27:50
NOT 00:27:53
Mayúscula 00:27:55
Si no hay mayúscula 00:27:57
Ahora la converto a mayúscula 00:28:00
¿Cómo la converto a mayúscula? 00:28:02
Es igual 00:28:05
Menos 32 00:28:14
Ah, espera 00:28:14
si no es 00:28:38
una letra mayúscula 00:28:45
porque está 00:28:48
fuera de este rango 00:28:50
aquí me estoy preguntando 00:28:51
si está dentro de este rango 00:28:53
de 65 a 90, pero le he metido un no 00:28:55
delante 00:28:58
si no es esta cosa aquí 00:28:58
pues entonces píllate 00:29:02
esa letra, transformala 00:29:03
en un entero, quítale 32 00:29:06
y el resultado 00:29:08
lo transformas en un char, y lo guardas 00:29:09
¿dónde? en la misma 00:29:14
¿cómo se llama esta? en la misma variable, es decir 00:29:17
que pasado esto, ¿qué tendré en el 0? 00:29:22
siempre, si era mayúscula 00:29:28
porque esto se lo ha saltado y se queda mayúscula, y si era minúscula 00:29:32
porque ha entrado aquí dentro y lo ha cambiado a mayúscula, entonces pasado esto 00:29:36
Dentro del L0 tengo la letra en mayúscula 00:29:40
¿Lo veis? 00:29:43
Pues hago lo mismo, pero con L1 00:29:47
Me pregunto si L1 es una mayúscula 00:29:50
Si no es una mayúscula 00:29:57
Y si no es una mayúscula, en L1 hago la conversión 00:30:00
Ahora, cuando estoy aquí 00:30:03
En este punto 00:30:09
L0 y L1 00:30:14
Contienen 00:30:17
Letras 00:30:19
Mayúsculas 00:30:21
¿Sí o no? 00:30:24
Sí 00:30:30
¿Dónde? 00:30:31
Ahora que estamos en if 00:30:49
A ver, no te cambia el hecho 00:30:50
El discurso es que yo aquí estoy en if 00:30:53
Pero estoy trabajando con carácteres 00:30:56
¿Vale? 00:30:58
Entonces, no, no tengo un método 00:31:00
Porque carácter no tiene método 00:31:01
y es lo de siempre 00:31:03
¿por qué yo uso esto si tengo 00:31:05
tu uppercase? 00:31:07
porque tú estás aprendiendo a programar 00:31:10
y no te puedo 00:31:12
poner ahora ejercicios 00:31:14
de hazme un aeropuerto 00:31:16
porque no lo vas a saber hacer 00:31:17
entonces vamos a manejar las cosas sencillas 00:31:19
este de aquí 00:31:22
te hace razonar sobre 00:31:23
tipos de datos distintos 00:31:25
te hace razonar sobre casting 00:31:27
te hace razonar sobre 00:31:30
cuando puedes hacer una operación 00:31:32
con 00:31:33
me explico 00:31:34
y luego 00:31:36
ok, esto es un método 00:31:38
que funciona, vale, o sea 00:31:41
y tengo tu upper string 00:31:43
tu upper case 00:31:44
y si ahora quiero un método que la primera letra 00:31:46
me la pone en mayúscula, segunda en minúscula 00:31:49
tercera en mayúscula, cuarta en minúscula 00:31:51
eso no lo tienes, y que haces 00:31:53
no lo sé hacer 00:31:54
tendrá que saber hacer también esas cosas 00:31:56
no, no, no 00:31:59
Pilla el punto 00:32:02
¿Sí? 00:32:05
Entonces, ahora tengo L, C, R, L, 1 00:32:07
Que son mayúsculas, ¿qué hago? 00:32:09
Sí 00:32:26
Ya está 00:32:26
Si lanzo esto y pongo 00:32:35
Más grande 00:32:46
No me deja 00:32:49
Si lanzo esto y lo pongo más pequeño 00:32:51
No me deja 00:32:55
Y fijaos que 00:32:55
No obstante esto se mantenga 00:32:59
engorroso 00:33:01
porque lo es engorroso 00:33:02
¿vale? pero es 00:33:06
un poquito más leíble con respecto a antes 00:33:07
y ahora sí que puedo hacer 00:33:10
estas declaraciones aquí 00:33:11
dentro, ¿os acordáis que 00:33:13
antes, en el ejercicio que hemos hecho antes 00:33:15
es esto 00:33:17
aquí dentro, cuando estoy 00:33:18
en el 00:33:23
operador ternario 00:33:25
no puedo declarar variables 00:33:28
aquí dentro, aquí dentro va una 00:33:29
expresión, no 00:33:31
instrucciones, sin embargo ahora 00:33:33
tengo la libertad de dentro 00:33:35
de un bloque if, hacer todas las 00:33:37
instrucciones que yo quiera 00:33:39
es un poco engorroso trabajar con char 00:33:40
pues si 00:33:54
vale, pero si ahora yo pillo 00:33:55
esto, lo ejecuto 00:34:01
y le pongo 00:34:04
esta cosa aquí 00:34:06
pues me dice que es una palabra no válida 00:34:07
pero no dos 00:34:09
pongo esta cosa aquí 00:34:10
pues me sale esto 00:34:12
¿cómo podría yo hacer 00:34:14
algo 00:34:22
por aquí 00:34:25
para estar seguro que 00:34:27
esto funcione 00:34:32
que no me dé cosas raras 00:34:34
vale, ¿y cómo puedo 00:34:36
decirle, oye mira 00:34:58
hazme esto 00:34:59
pero solo 00:35:01
si es una letra minúscula, entendamos, no 00:35:05
ahora mismo, este de aquí, ¿qué hace? hace esta operación 00:35:19
siempre que no sea 00:35:23
una mayúscula, ¿sí? porque la condición que he 00:35:26
elegido usar es, si no es mayúscula, ahora 00:35:33
uno, es una mayúscula, no 00:35:37
y por lo tanto me hará esta operación 00:35:41
No, hay una forma mejor o una condición distinta 00:35:42
Que podría poner aquí 00:35:48
Para que luego no me haga esta cosa rara aquí 00:35:50
Pongamos que la palabra sea 12, esta cosa de aquí 00:35:54
¿Qué me esperaría que ponga? ¿Cómo es 1 en mayúscula? 00:35:58
1, sería igual 00:36:07
Entonces, ¿no podría cambiar un poco el algoritmo que he escrito 00:36:09
para hacer de tal forma que esta conversión me las haga 00:36:14
solo cuando es necesario hacer esa conversión. 00:36:18
¿Sabéis cuando os digo, razonad sobre los algoritmos 00:36:37
y buscad el algoritmo que os convenga? 00:36:42
Pues aquí la idea es hacer esto solo cuando esto es minúscula. 00:36:44
Solo cuando esto representa una palabra minúscula. 00:36:51
Una letra minúscula. Por lo tanto, cambio y ¿qué condición pongo? Aquí no estamos con objetos. Es más sencillo, es eso. Es simplemente que en vez de ir a buscar si no es una mayúscula, voy a buscar si es una minúscula. 00:36:55
O sea, entre 97 y 122 00:37:22
Si es mayor que 97 y menor que 122 00:37:26
Entonces me la conviertes 00:37:33
Cualquier otra me la dejas como está 00:37:35
Si es mayúscula me la dejas como está 00:37:37
Si es un número me la dejas como está 00:37:39
Si es un punto me lo dejas como está 00:37:40
¿Lo entendéis? 00:37:41
O sea, cuidado 00:37:51
Porque lo que tendéis a hacer es complicaros la vida 00:37:51
O sea, vosotros tendéis a pillar esto 00:37:57
Y ahora meter otro if fuera 00:38:00
Que comprobara que no fuera 00:38:02
Pues está más sencillo 00:38:03
Y debería funcionar 00:38:06
Ahora miro 00:38:08
A A me lo escribe en mayúscula 00:38:10
Si pongo 12 00:38:12
Es que 12 00:38:14
Ahora lo bonito aquí sería 00:38:15
Que yo escribiera esto 00:38:21
Una vez sola 00:38:23
Y que el L en automático me hiciera esto varias veces 00:38:24
Una vez para L0 00:38:27
Una vez para L1, una vez para L2, una vez para L3 00:38:29
Pero todavía no lo sabemos hacer 00:38:31
Guay 00:38:34
Esto necesita un iterativo 00:38:39
Un for probablemente 00:38:42
Necesitas algo que te diga 00:38:45
Si es larga 5 00:38:54
Hazlo de 0 al 4 00:38:56
Eso es un iterativo 00:38:57
¿Dudas hasta aquí? 00:38:59
Y no sé 00:39:11
Hacemos otro de otro tipo 00:39:13
¿Qué queréis hacer? 00:39:15
Bueno, estamos trabajando 00:39:26
Todo el tiempo 00:39:27
Hagamos un clásico, me das dos números y te digo si el primero es múltiplo del segundo. 00:39:29
Dame el primer número, leo un número, leo otro número. 00:39:39
¿Cómo puedo decirte si el primer número es múltiplo del segundo? 00:40:11
Quiero, tengo n1, n2, dos números 00:40:18
Quiero saber si n1 es un múltiplo de n2 00:40:31
Es decir, si existe un número x, que si hago n2 por x me da n1 00:40:35
A ver, dime, entre paréntesis 00:40:40
Luego que, if, así 00:41:08
No, n1 es múltiplo de n2 00:41:44
Y si no 00:41:47
Dos y cuatro 00:41:55
Dos no es múltiplo de cuatro 00:42:13
Bueno 00:42:16
Cuatro y dos 00:42:16
Cuatro es múltiplo de dos 00:42:20
Fácil el if 00:42:21
¿Sí? 00:42:28
A nivel de sintaxi 00:42:30
Fácil 00:42:31
Lo único ahora es 00:42:34
Luchar un poco con esto 00:42:35
¿Queréis hacer uno con string? 00:42:38
Vale 00:42:40
Leo una palabra 00:42:41
dame tu nombre 00:42:56
lo que quiero es 00:43:02
si el nombre es de una persona 00:43:10
autorizada 00:43:12
que son la persona autorizada 00:43:13
Stefano 00:43:16
Marta 00:43:17
Antonio 00:43:21
y Sara 00:43:24
entonces 00:43:27
listas de rey que son 00:43:35
en febrero 00:43:38
si tengo esto 00:43:39
Si lo que he leído es uno de estos 00:43:42
Entonces dirá 00:43:47
Estás autorizado 00:43:48
Si no, no 00:43:50
¿Qué hago? 00:43:51
Señores 00:43:55
No lo sé 00:44:00
Decidme vosotros 00:44:23
Poneos de acuerdo 00:44:24
¿Qué hago? 00:44:25
No, no he entendido 00:44:44
Así 00:44:44
Scan.next 00:44:45
Vale 00:45:06
Sí 00:45:27
Esto es true 00:45:33
Oh, esto es true 00:45:35
Oh, esto es true 00:45:38
¿Sí? 00:45:40
Entonces, ¿con qué uno de estos sea true? 00:45:42
Autorizado 00:45:49
¿Sí? 00:45:50
Entonces, dame tu nombre 00:45:54
Paco 00:45:56
No me dice nada 00:45:58
pongo 00:46:00
Estefano 00:46:02
autorizado 00:46:03
pongo 00:46:05
Estefano 00:46:07
depende, si yo quiero exactamente 00:46:08
estos los dejo así 00:46:19
una opción podría ser esta 00:46:20
y antes de comprobarlo 00:46:22
tú me has dado 00:46:30
lo que sea, yo me lo pongo 00:46:43
en minúscula y luego lo comparo 00:46:45
con los números en minúscula 00:46:47
entonces si tú ahora me dices que te llamas 00:46:48
Depende de mi programa que quiera hacer 00:46:51
A lo mejor yo quiero que sea que es sensitive 00:47:01
Para una contraseña quiero que sea que es sensitive 00:47:03
Para un email, por ejemplo, no 00:47:10
Depende de lo que quiera hacer yo 00:47:12
Pero puedo hacer las dos cosas 00:47:16
Vale, la última cosa que quería probar a hacer 00:47:17
Ahí sí está 00:47:24
Leo una palabra, dame tu nombre, y te digo la segunda letra de tu nombre 00:47:32
Quiero imprimir por pantalla la segunda letra de tu nombre 00:47:41
¿Qué hago? Ya lo he leído, está aquí 00:47:53
¿Qué hago? Venga, no escribe en pantalla charla de terror 00:48:08
Ay, señores, venga, ya lo tienes 00:48:19
Segunda letra 00:48:27
¿Me entregáis esto? 00:48:37
¿Cuántos habéis sacado? 00:48:42
Mirad 00:48:46
Me llamo ese 00:48:47
¡Bum! 00:48:49
El problema mío es si me llamo ese 00:48:56
No lo sé, decidme vosotros qué tengo que hacer 00:48:58
Os doy una pista 00:49:08
Son ejercicios sobre if 00:49:12
¿Qué diríais vosotros? 00:49:14
Es lo que decíamos 00:49:16
Ejercicio de if sin if 00:49:17
No puedo 00:49:19
Venga, pues eso puedo 00:49:54
oiga vosotros 00:49:59
¿por qué estáis riendo tanto? 00:50:01
yo no lo entiendo 00:50:03
¡Lanzo! me llamo 00:50:04
Estefano, no puedo 00:50:06
¿así? 00:50:08
venga 00:50:37
entonces me llamo Estefano 00:50:38
me pillate 00:50:42
me llamo 00:50:43
como los americanos, JJ 00:50:45
no puedo 00:50:47
si me llamo JJ, ¿no quieres darme el segundo? 00:50:49
no sé 00:50:57
menor que 100 00:50:58
¿Dónde está el problema, señores? 00:51:06
¿Dónde está el problema? 00:51:24
¿Cuándo surge el problema? 00:51:30
Cuando mi nombre es menor que dos letras. 00:51:36
Si tu nombre de dos letras o más, lo puedo hacer. Y si no te diré, no puedo. Menor que dos mil, distinto de siete. Pero, señores, razonamos un poquito. 00:51:38
Lo que quería hacer también es otra cosa 00:52:00
Te quiero dar la segunda letra de tu nombre 00:52:05
Pero los nombres con la segunda letra T me molestan 00:52:50
Entonces eso no 00:52:54
Un ejercicio claramente interesante y de uso común 00:52:56
¿Funciona esto? 00:53:03
Es esto, ¿no? 00:53:11
Estefano 00:53:12
No puedo, perfecto 00:53:14
Porque yo lo escribo con segunda letra T 00:53:16
Pero Antonio 00:53:18
Sí 00:53:20
¿Están de acuerdo todos así? 00:53:21
Vale, esto explota 00:53:24
¿Qué diferencia hay entre este y este? 00:53:34
Y la pregunta es 00:53:42
¿Funcionan los dos? 00:53:43
Mira, eh 00:53:44
Porque vosotros no me creáis 00:53:45
Estefano, no puedo 00:53:48
Antonio 00:53:50
No lo sé, decídmelo vosotros 00:53:55
¿Qué diferencia hay entre 00:54:02
A mí también me suena que lo dije 00:54:05
Si no, no te lo preguntaba 00:54:07
Vale, diferencia hay entre este y este 00:54:09
Sobre todo son 00:54:11
En este caso de aquí 00:54:12
Si me entregáis esto 00:54:15
O me entregáis esto, vuestra nota cambia 00:54:17
Cuanto más send 00:54:20
Más nota, este es un 10 00:54:34
No, el nivel de vista es mayor o menor 00:54:36
menor o cosa por el estilo que pero son otra cosa mira si mal por qué porque si 00:54:45
os acordáis en la diferencia entre un solo end o dos end es que esto es el 00:55:16
operador perezoso leggi entre este aquí no éste siempre evaluará los dos lados 00:55:22
del end luego hará el end entre los dos y bs es verdadero o falso que pasa que 00:55:30
si le meto solo un S 00:55:36
esto de aquí será falso 00:55:38
pero 00:55:41
aun si esto es falso 00:55:42
él irá a comprobar esta cosa 00:55:44
aquí y al acceder 00:55:46
a la posición 2 00:55:49
a la segunda 00:55:51
letra de una string 00:55:53
que tiene una letra sola 00:55:55
explota 00:55:56
con un string index 00:55:57
out of bound exception 00:56:01
porque el índice 1 es fuera 00:56:02
de los límites 00:56:05
si en vez 00:56:07
pongo dos end 00:56:09
cuando esto 00:56:10
sea falso 00:56:13
él no va a ejecutar esto 00:56:14
se lo salta 00:56:17
porque tanto falso y cualquier cosa 00:56:19
siempre será falso 00:56:21
entonces no 00:56:22
tiene sentido ir a trabajar con esto 00:56:24
esta es la diferencia entre la end 00:56:27
y la end-end 00:56:29
ya que estamos, que el otro día lo decimos pero no lo probamos 00:56:30
pues ahora lo hemos probado 00:56:33
Entonces te viene útil usar uno si tú por alguna razón del multiverso quieres que todas las condiciones que tú pongas allí sean ejecutadas. 00:56:34
Por ejemplo, si este de aquí fuera un método que además de calcular eso hace una cosa lateral, hace otra actividad. 00:56:55
¿Vale? Y tú quieres ejecutarla 00:57:02
Cada vez que se hace este if 00:57:05
Pues entonces lo metes así 00:57:07
Y tú sabes que siempre se ejecuta 00:57:09
¿Dudas? 00:57:11
¿Preguntas? 00:57:16
Vale 00:57:18
Entonces tenéis 00:57:19
Vuestros ejercicios 00:57:21
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
27
Fecha:
3 de octubre de 2024 - 14:17
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
57′ 24″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
165.12 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid