PARTE 3 - Sentencias Condicionales (Condiciones)
Lo Basico:
Las condiciones son sentencias que sirven para decidir si se va a continuar con el codigo establecido dentro de dicha condicion. Son como guias, que determinan el camino del plugin, dependiendo de las condiciones que se usen y dependiendo si se cumplen o no.
Realmente son muy faciles de usar, asi que dificilmente se puede tener complicacion al entenderlas y aplicarlas en un codigo. Aparte de ser una de las cosas que mas se usa, en la creacion de plugins.
Las condiciones pueden ser combinadas entre si... y pueden ser mediante
and (
y) o mediante
or (
o).
&& Es el simbolo usado para "y".
|| Es el simbolo usado para "o".
Ejemplo:
Code:
// x es mayor a 0 o menor o igual a 255
x > 0 || x <= 255
// x es mayor a 15 y g es menor a 10
x > 15 && g < 10
// x es menor a 15
// o g es menor a 0 y g es mayor a -10
x < 15 || g < 0 && g > -10
// x es mayor a 16
// y g es mayor a 10 o g es menor a 0
x > 16 && (g > 10 || g < 0)
// a es mayor a b y c es menor a d y e es menor a f
a > b && c < d && e < f
Los desiguales tienen un caso especial y pueden usarse de diferente forma:
Code:
// x es mayor a 0 y menor o igual a 5
x > 0 && x <= 5
// Pero tambien se puede hacer de la siguiente forma
0 < x <= 5
Esa forma, solo funciona en ciertos rangos de valores especificos.
Y solo funciona con &&, no con ||
Code:
// x es mayor a 5 o menor a 0
x > 5 || x < 0
Las condiciones tambien se pueden usar para chequear que algo no sea verdadero.
! Se usa para lo contrario a verdadero, o sea... False. Es decir, lo opuesto
!= Se usa cuando algo no es igual
Code:
// x no es menor a 0
!(x < 0)
// x no es igual a 0
x != 0
Code:
// x es mayor a 0 y g es menor a 2
x > 0 && g < 2
// Lo mismo que arriba, pero con el operador opuesto:
!(x <= 0 || g >= 2)
// Esta condicion se lee de la siguiente forma:
// Si x <= 0, devuelve false (falso)
// Si g >= 2, devuelve false (falso)
// Sino, devuelve true (verdadero), es decir... si es: x > 0 y g < 2
Sentencia "IF":
La sentencia de condicion "if" es lo principal para usar las condiciones anteriormente explicadas. Es decir, que es el metodo por el cual se usan. La estructura de las condiciones son de la siguiente forma:
Code:
if( [condicion] )
{
// Codigo que se ejecutara si la condicion se cumple
}
// Ahora, un ejemplo de tal estructura:
if( x > 1 )
{
// Este codigo se ejecutara si x es mayor a 1
}
Al mismo tiempo tambien esta el "else if" y el "else" que son otras sentencias de condicion, pero que van de la mano. No puede haber un "else if" o un "else" si no hay un "if" previo.
Code:
if( [condicion 1] )
{
// condicion #1 es verdadera
}
else if( [condicion 2] )
{
// condicion #1 es falsa
// y la condicion #2 es verdadera
}
else
{
// condicion #1 es falsa
// y la condicion #2 es falsa
}
// Aunque no necesariamente tiene que haber un "else if"
// Puede ir un if y luego un else, entonces si la condicion del if no se cumple
// Se ejecuta lo que esta dentro del else
Aca un ejemplo mas para que lo entiendan mejor:
Code:
new x = 5
if( x > 3 )
{
// 1
}
else if( x < 4 )
{
// 2
}
else
{
// 3
}
// En este caso mostraria lo que esta en el "1". Sin embargo...
// Si cambiamos el 5 de la variable "x" por un 4. Mostraria lo que esta en el "3".
// Otro dato a dar, es que el "else if" puede ser usado mas de una vez.
// No necesariamente tiene que ser 1, esto son solo ejemplos.
Loops (Bucle):
Hay 3 tipos de loops que se pueden usar, y son los siguientes:
La lista esta ordenada en cuestion a la dificultad. Igualmente, no son muy dificiles, sin embargo al principio cuesta un poco entender su funcionamiento, pero principalmente... usarlas/aplicarlas dentro de un plugin.
Los loops, sirven para ejecutar un bloque de codigo, en forma repetitiva. De acuerdo a distintas condiciones y/o parametros que le asignamos.
El loop
while continua ejecutando mientras que la condicion se siga cumpliendo, es decir... que de true (verdadero/positivo). La estructura de este loop, es la siguiente:
Code:
while( [condicion] )
{
// Bloque de codigo
}
La forma en la que trabaja el while es la siguiente:
- Chequea la condicion establecida
- Si la condicion se cumple, ejecuta el codigo; de lo contrario, finaliza el loop
- Vuelve al primer paso
Como veran, el while es muy similar al "if", a diferencia de que este se repite constantemente.
El loop
do, while es practicamente lo mismo al while.
La unica diferencia es el orden en el que trabaja y se usa:
Code:
do
{
// Bloque de codigo
}
while( [condicion] );
// El punto y coma no es necesario, solo si el punto y coma esta forzado en el plugin
La forma en la que trabaja el do, while es la siguiente:
- Ejecuta el codigo dentro
- Chequea la condicion establecida
- Si la condicion se cumple, ejecuta el codigo; de lo contrario, finaliza el loop
- Vuelve al segundo paso
El loop
for es mas complicado que los otros loops, sin embargo no es algo realmente dificil. Cuestion de ver, entender y practicar.
Generalmente es usado para contar de un numero a otro (Recuerden que todo representa numeros en la programacion).
El "for" consta de 3 partes (parametros): inicial, condicion, incremento.
Inicial - Creacion de variables para usar en el loop.
Condicion - Sentencia de condicion para chequear si el loop debe continuar.
Incremento - Incrementar el valor de la variable que fue creada.
La estructura del loop "for" es la siguiente:
Code:
for( [inicial]; [condicion]; [incremento] ) // Los punto y coma en este caso son obligatorios!
{
// Bloque de codigo
}
La forma en la que trabaja el for es la siguiente:
- Se ejecuta el incial
- Si la condicion es cumple, ejecuta el codigo; de lo contrario, finaliza el loop
- Ejecuta el bloque de codigo
- Ejecuta el incremento
- Vuelve al segundo paso
Algunos ejemplos:
Code:
// Contando de 1 a 5:
for( new i = 1; i <= 5; i++ ) // i++ incrementa la variable i de a 1
{
// Bloque de codigo
}
// Contando de 10 a 1:
for( new i = 10; i >= 1; i-- ) // i-- decrece la variable i de a 1
{
// Bloque de codigo
}
Dentro de los loops, se puede forzar para que una parte del codigo sea salteada y se vuelva a la condicion del loop. Esto se hace con el operador "continue":
Code:
for( new i = 0; i < 4; i++ )
{
if( i == 2 )
{
continue;
}
// Bloque de codigo que se ejecutara excepto cuando i sea igual a 2
// Es decir que se va a ejecutar cuando i sea igual a 0, 1, 3 y 4
}
Dentro de los loops, tambien se puede forzar a que finalice dicho loops, si se cumple cierta condicion, con el operador "break":
Code:
for( new i = 0; i < 4; i++ )
{
if( i == 2 )
{
break;
}
// Este codigo solo se ejecutara cuando la variable i es igual a 0 y 1
// Cuando la variable i es igual a 2, el loop finaliza
}
Sentencia "Switch":
Los switch son para determinar ciertos bloques de codigos dependiendo el resultado que de una funcion, una variable, etc... Son practicamente iguales al if. En muchos casos es mas comodo, prolijo, facil, etc... usar switch que conficiones con IF:
Code:
switch( variable ) // No necesariamente tiene que ser una variable, puede ser una funcion directamente
{
case VALOR1:
{
// variable es igual a VALOR1
}
case VALOR2:
{
// variable es igual a VALOR2
}
case VALOR3:
{
// variable es igual a VALOR3
}
}
// En el caso del switch, en vez de else, aca se usa "default":
switch( variable ) // No necesariamente tiene que ser una variable, puede ser una funcion directamente
{
case VALOR1:
{
// variable es igual a VALOR1
}
case VALOR2:
{
// variable es igual a VALOR2
}
default:
{
// variable no es igual a ninguno de los otros case's
// Es decir que no es ni VALOR1 ni VALOR2
}
}
__________________
Linear Mode
