Joan Soler-Adillon || Programació: Conceptes
Despatx 52.803 (Campus de la comunicació, UPF) || 93 542 1238
----------------------------------------------------------------
----------------------------------------------------------------
PROGRAMACIÓN: CONCEPTOS || MASTER EN ARTES DIGITALES
Sección 5: Condicionales
1. Condicionales
2. Operadores
3. Operadores lógicos
4. Ejemplos
5. Más ejemplos
Seguro que os suena aquello de "si P, entonces Q". Pues bién, no vamos a empezar a hacer silogismos ni a estudiar Aristóteles (que nunca está de más), sino que lo llevaremos a nuestro campo.
En programación, los condicionales son fundamentales. Sirven al programador para establecer el flujo del programa: darle al programa las pautas para tomar decisiones y obrar en consecuencia.
Lo que hacen los condicionales es comprobar si tal o cual condicion se cumple o no. Si se cumple el programa realizará una acción, y si no, realizará otra o nada. Es decir: si se cumple A, entonces haz B. O en inglés: if a, then b. Y todo esto, obviamente, en la sintaxis correspondiente, con sus paréntesis y sus claves:
if(condicion){
hazTalCosa();
}
Como se puede observar, la condición ha de ir entre paréntesis. Luego, abrimos una clave, y las instrucciones que ponemos desde aquí hasta que cerramos la clave, son las que se ejecutaran si la condición se cumple.
En este caso, hazTalCosa(); solo se ejecutará si se cumple la condición. Si no se cumple, no pasará nada.
¿Que pasa si queremos que, según si se cumple o no una condición, se ejecute o una cosa o se ejecute otra (nunca se quede sin pasar nada)? Pues obviamente podemos hacer dos if, then, uno para la condición positiva y otro para la negativa, pero es más eficiente utilizar un if, else. Es decir: si pasa A, haz B, en caso contrario (else), haz C:
if(condicion){
hazTalCosa();
} else {
hazTalOtra();
}
Respecto a las condiciones, en general, éstas estaran compuestas por comparaciones entre valores. Si "a" es mayor a "b", haz X. Si "c" es menor o igual a "d", haz Y. Si "e" no es igual a "f", haz Z, etc.
if(a > b){
hazTalCosa();
}
Estas comparaciones se realizan utilizando los operadores (como veremos en el punto 2). Lo que el if se pregunta, es si el valor de la condición es verdadero o falso. Pero estas condiciones, como veremos en el punto 3, se pueden combinar unas con otras. Así, podemos preguntarnos algo como: Es "a" menor o igual que "b" y además "c" es no igual a "d"? O, complicándolo más: Es "a" mayor a "b" y o bién "c" menor a "d" o bién "f" igual a "g"?
Ya podéis intuir que la cosa se puede ir complicando, pero nunca se nos escapará de las manos si somos capaces de controlar la sintaxis, en este caso, de paréntesis. Lo veremos con los ejemplos.
Los operadores (relacionales) nos permiten comparar valores numéricos, normalmente contenidos por variables. En Processing, el operador de igualdad y no igualdad nos permiten también comaparar carácteres i cadenas de carácteres, y valores booleanos. Como hablamos en la primera sesión, los ordenadores son muy buenos y rápidos en guardar valores, hacer operaciones, y compararlos. Pues bién, cuando tiene sentido comparar valores es cuando hacemos condicionales.
Los operadores que podemos utilizar son:
== (igualdad)
Compara dos valores para determinar si son iguales. Es muy importante recordar que son necesarios DOS SIGNOS DE IGUALDAD. Uno solo corresponde a la asignación de un valor (lo que hacemos al dar tal o cuál valor a una variable).
if(a == b){
hazTalCosa();
}
!= (no igualdad)
Compara dos valores para determinar si no son iguales. (Si "a" NO es igual a "b"...):
if(a != b){
hazTalCosa();
}
> (mayor a)
Compara dos valores para determinar si el primero es mayor al segundo:
if(a > b){
hazTalCosa();
}
< (menor a)
Compara dos valores para determinar si el primero es menor al segundo:
if(a < b){
hazTalCosa();
}
Compara dos valores para determinar si el primero es mayor o igual al segundo:
if(a >= b){
hazTalCosa();
}
<= (menor o igual a)
Compara dos valores para determinar si el primero es menor o igual al segundo:
if(a <= b){
hazTalCosa();
}
3.- Operadores lógicos
Si los operadores relacionales nos permiten comparar valores, los lógicos nos permiten comparar condiciones tal y como las definimos en el punto 1. De hecho, lo que comparamos son valores booleanos (verdadero/falso), ya que esto es lo que dan como resultado las condiciones que ponemos entre paréntesis detrás de if.
Así, podemos entender que los operadores lógicos operan sobre valores de verdadero/falso (true/false en Processing, que sabéis que habla inglés!).
Los operadores lógicos son:
&& ("y" lógico)
El "y" lógico compara dos valores booleanos y devuelve verdadero sólamente si los dos valores comparados son verdaderos.
true && true = true
true && false = false
false && true = false
false && false = false
Atención con los paréntesis cuando combinamos condiciones:
if((a < b)&&(c==d)){
hazTalCosa();
}
|| ("o" lógico)
El "o" lógico compara dos valores booleanos y devuelve verdadero si uno de los dos valores comparados son verdaderos.
true || true = true
true || false = true
false || true = true
false || false = false
if((a < b) || (c>d)){
hazTalCosa();
}
! ("no" lógico)
El no lógico no compara valores sinó que lo que hace es invertirlos.
!false = true
!true = false
if(!a){
hazTalCosa();
}
Todo esto, así en abstracto, suena mucho más complicado de lo que es. Para empezar con lo último que hemos visto, sigue un ejemplo. Podéis cambiar los valores true/false de los booleanos para entender como funcionan el "y" y el "o" lógicos:
boolean condUno = true;
boolean condDos = false;
//comprobamos el "o" lógico
if(condUno || condDos){
print("se cumple el ||");
}
else{
print("no se cumple el ||");
}
//comprobamos el "i" lógico
if(condUno && condDos){
print("se cumple el &&");
}
else{
print("no se cumple el &&");
}
Con un elemento más gráfico, podemos utilizar un condicional para decidir cuando se para una acción:
Source code: globus
float pos;
void setup(){
size(300,100);
pos = 13;
}
void draw(){
if(pos <= 200){
pos = pos + 4;
}
ellipse(pos,50,20,20);
}
O lo podemos aplicar a la posición:
Source code: bolaStop
float pos;
void setup(){
size(300,100);
pos = 13;
}
void draw(){
if(pos <= 200){
pos = pos + 4;
}
ellipse(pos,50,20,20);
}
O utilizarlos para hacer "rebotar" la pelota en los bordes de la ventana y simular así un espacio cerrado:
Source code: bouncingBallH
int pos, vel;
int sz = 20;
void setup(){
size(300,200);
pos = width/2;
vel = 5;
}
void draw(){
background(0);
//actualitzamos la posición
pos = pos+vel;
//dibujamos
ellipse(pos,height/2,sz,sz);
//comprobamos si está en los límites de la ventana
//si lo está, invertimos el signo de la velocidad:
if((pos<0)||(pos>width)){
vel = -vel;
}
}
Podéis ver como aquí utilizamos un "o" lógico para hacer el condicional con dos condiciones: o bién mayor a WIDTH, o bien menor a ZERO.
Partiendo de lo visto hasta ahora, es fácil añadir el rebote para el eje Y y crear otro ejemplo típico de programación: the bouncing ball.
Source code: bouncingBall
Y finalmente, también podemos utilizar los condicionales para hacer crecer y decrecer la pelota, ya sea para que parezca que respire, o para simular un eje Z.
Source code: breathBall
----------------------------------------------------------------------------------------------------