jueves, 8 de noviembre de 2012

Operadores y expresiones en Objective-C

  • En los capítulos anteriores se observó el uso de variables y constantes en Objective-C y también se describen los diferentes tipos de datos. 
  • Crear variables es sólo parte de la historia. 
  • El siguiente paso es aprender cómo utilizar estas variables y constantes en el código de Objective-C
  • El método principal para trabajar con datos es en forma de expresiones. 
  • En este capítulo vamos a analizar en detalle las expresiones de Objective-C y los operadores.

¿Qué diablos es una expresión?

La expresión más básica consiste en que un operador, operando dos y una asignación. El siguiente es un ejemplo de una expresión:

int resultado = 1 + 2;
En el ejemplo anterior, el operador (+) se utiliza para añadir dos operandos (1 y 2) juntos. 
El operador de asignación (=) posteriormente "mete" el resultado de la suma a una variable entera llamada resultado. 
Los operandos pueden ser variables, constantes, literales o expresiones (o una mezcla de constantes y variables).

Veamos los distintos tipos de operadores disponibles en Objective-C.


El operador de asignación


Ya hemos visto en el más básico de los operadores de asignación, el operador =. 
 El operador de asignación simplemente asigna (o "mete") el resultado de una expresión a una variable. 
En esencia, el operador de asignación = toma dos operandos. 
El operando de la izquierda es la variable a un valor que se va a asignar y el operando de la derecha es el valor que se asignará.  
El operando de la derecha es, más a menudo, una expresión que realiza algún tipo de operación aritmética o de evaluación lógica , el resultado de que se asigna a la variable.  
Los siguientes ejemplos son válidos todos los usos del operador de asignación:
int x; // declaramos la variables

x = 10;  // Asignamos el valor de 10

x = y + z; //Asignamos la suma de z y y a la variable
x = y;   // Asignamos el valor de y a la variable
Los operadores de asignación también puede ser" encadenados" a asignar el mismo valor a múltiples variables.  
Por ejemplo, el ejemplo de código siguiente asigna a las variables el valor 20 a la x, y y z:

int x, y, z;

x = y = z = 20;

Operadores aritméticos en Objective-C

Objective-C ofrece una amplia gama de operadores con el fin de crear expresiones matemáticas.  
Estos operadores principalmente caen en la categoría de operadores binarios en los que se toman dos operandos. 

La excepción es el operador unario negativo (-) que sirve para indicar que un valor es negativo o positivo.
Este operador es diferente al operador de resta (-) que toma dos operandos (es decir, un valor que se resta de otro).  
Por ejemplo:

int x = -10; // Operador unario

x = y - z; // Resta de dos variables
Los operadores matemáticos son los siguientes:

OperadorDescripción
-(unario)Cambia a valor negativo una variable o expresión
*Multiplicación
/División
+Suma o adición
-Resta o sustracción
%Módulo

En una expresión, podemos utilizar muchos operadores matemáticos, por ejemplo:

x = y * 10 + z - 5 / 4;

Mientras que el código anterior es perfectamente válido, es importante tener en cuenta que Objective-C NO evalúa la expresión de izquierda a derecha o de derecha a izquierda, sino más bien en un orden especificado por la precedencia de los distintos operadores. 


Operadores abreviados


En una sección anterior vimos que el operador básico de asignación (=).  
Objective-C proporciona un número de operadores diseñadas para combinar un trabajo con una operación matemática o lógica. 
 Estos son principalmente de uso al realizar una evaluación donde el resultado es que se almacena en uno de los operandos.  
Por ejemplo, se podría escribir una expresión como sigue:
x = x + y;

La expresión anterior se suma el valor contenido en la variable x para el valor contenido en la variable y y almacena el resultado en la variable x
Esto lo podemos simplificar de la siguiente forma:
x += y



La expresión anterior realiza exactamente la misma tarea que x = x + y, pero evita al programador algo de tecleo.

Los operadores abreviados que se encuentran disponibles en Objective-C se resumen en la siguiente tabla:

OperadorEquivale a:
x += y
x = x + y;
x -= y
x = x - y;
x *= y
x = x * y;
x /= y
x = x / y;
x %= y
x = x % y;

Operadores para incrementar y decrementar


Otro atajo útil se puede lograr utilizando el incremento Objective-C y los operadores de decremento (también referido como operadores unarios porque operan en un único operando).  
Al igual que con los operadores de asignación abreviados descritos en la sección anterior, considere lo siguiente  fragmento de código:
x = x + 1; // Incrementa el valor de x en uno

x = x - 1; // Decrementa el valor de x en uno

Estas expresiones aumentar y disminuir el valor de x en 1.  
En lugar de utilizar este método es más rápido usar los operadores + + y --. L
os siguientes ejemplos realizar exactamente las mismas tareas que los ejemplos anteriores:

x++; Incrementa el valor de x en uno


x--; Decrementa el valor de x en uno
Estos operadores se pueden colocar antes o después del nombre de variable.  
Si el operador se coloca antes del nombre de la variable de incremento o decremento se realiza antes que cualquier otras operaciones se realizan en la variable.  
Por ejemplo, en el siguiente ejemplo, x se incrementa antes de que se asigna a y, dejando a y con un valor de 10:

int x = 9;
int y;

y = ++x;

En el ejemplo siguiente, sin embargo, el valor de x (9) está asignado a la variable y el valor de reducción antes de que se realiza.  
Después de la expresión se evalúa el valor de y será 9 y el valor de x será 8.
int x = 9;
int y;

y = x--;

Operadores de comparación

Además de los operadores matemáticos y asignación, Objective-C también incluye un juego de operadores lógicos útiles para realizar comparaciones.  
Estos operadores devuelven un booleano (BOOL) true (1) o falso (0) en función del resultado de la comparación.

Los operadores de comparación son los más usados ​​en la construcción de flujo del programa de control lógico

 Por ejemplo, una sentencia if se puede construir en base a si un valor coincide con otro:

if (x == y)
      
El resultado de la comparación también puede ser almacenado en una variable BOOL. Por ejemplo, el siguiente código se traducirá en un verdadero (1) valor que se almacena en la variable de resultado:
BOOL result;
int x = 10;
int y = 20;

result = x < y;

Es evidente que 10 es menor que 20, lo que resulta en una verdadera evaluación de laexpresión  x < y . 
La siguiente tabla muestra el conjunto completo de operadores de comparación de Objective-C:

OperadorDescripción
x == yRegresa verdadero si x es igual a y
x > yRegresa verdadero si x es mayor que y
x >= yRegresa verdadero si x es mayor o igual que y
x < yRegresa verdadero si x es menor que y
x <= yRegresa verdadero si x es menor o igual que y
x != yRegresa verdadero si x es diferente que y

Operadores lógicos


Objective-C también proporciona un conjunto de operadores conocidos como los operadores lógicos diseñados para devolver true (YES) y false (NO).  
En la práctica equivale a un verdadero (1) y  falso es igual a 0. Estos operadores tanto devuelven resultados booleanos y toman valores booleanos como operandos
Los operadores principales no son, AND (&&), OR (!) (| |) Y XOR (^).

El
Operador  NOT (!) simplemente invierte el valor actual de una variable booleana, o el resultado de una expresión.  

Por ejemplo, si un indicador variable llamada actual 1 (verdadero), anteponiendo la variable con un operador '!'  invierte el valor a 0 (falso):

bool bandera= YES; //variable verdadera
bool bandera2;
bandera2 = !bandera; // La segunda variable es falsa
El OR (| |) devuelve 1 si uno de sus dos operandos se evalúa como verdadera, de lo contrario, devuelve 0. Por ejemplo, el ejemplo siguiente se considera verdadero, porque al menos una de las expresiones de cada lado del operador OR es verdadera:
 if ((10 < 20) || (20 < 10))
        NSLog (@"Es verdadeo!!!!");

El operador AND (&&) regresa un valor 1 o verdadero, sólo si ambas expresiones son verdaderas.
La siguiente expresión regresa un valor falso pore una de las expresiones es falsa:

if ((10 < 20) && (20 < 10))
      NSLog (@"mmmmm...");

El operador ternario

Objective-C utiliza algo llamado un operador ternario para proporcionar una forma de acceso directo de la toma de decisiones.  
La sintaxis del operador ternario (también conocido como el operador condicional) es como sigue:

[condición] ? [expresión si el resultado es verdadero] : [expresión si el resultado es falsa]

La forma en que esto funciona es que [condición] se reemplaza con una expresión que se va a devolver. Verdadero (1) o falso (0) Si el resultado es verdadero, entonces la expresión que sustituye a la [verdadera expresión] se evalúa. Por el contrario, si el resultado es falso entonces el [expresión falsa] se evalúa.  
Vamos a ver esto en acción:
int x = 10;
int y = 20;

NSLog(@"El número mayor es %i", x > y ? x : y );

No hay comentarios:

Publicar un comentario