CONDICIONALES

Vamos a empezar ahora con otra de las bases: los bloques condicionales.

Estos bloques los vamos a usar para dividir el flujo de ejecución del programa por un camino u otro, dependiendo de una condición. Esto es útil para hacer que el programa tome caminos diferentes, según se vaya dando el desarrollo del mismo. Por ejemplo: Si el usuario ganó mostrarle el puntaje final, sino hacer que juegue el siguiente player.

Un ejemplo acorde a lo que estábamos viendo podría ser:

 

Pedirle al usuario que ingrese dos números, y luego dividirlos entre sí y mostrar el resultado.

Pedirle al usuario que ingrese dos números, y luego dividirlos entre sí y mostrar el resultado.

 

Si desarrollan este programa van a encontrar un problema al momento de ingresar el valor 0 en segunda instancia, puesto que… NO PODEMOS DIVIDIR POR CERO.

Este es un problema a tener en cuenta, puesto que muchas aplicaciones podrían cerrarse al intentar dividir por cero. Así que, antes de realizar la división, deberíamos realizar un chequeo para asegurarnos de que el valor sea correcto. Para esto, vamos a usar un bloque de código llamado “if“. Este bloque nos permite realizar una comprobación, y si esta se cumple, ejecutar un bloque de código determinado. Para decirlo en español, lo que deberíamos plantear es:

  • Pedir el primer número.
  • Pedir el segundo número.
  • Si el segundo número es distinto de cero, hacer la división.

Vamos a ver un ejemplo:

 

using System;
          
public class Program
{
  public static void Main()
  {
    int num1;
    int num2;
    int result;
    
    Console.WriteLine("Ingrese un número: ");
    num1 = int.Parse(Console.ReadLine());
    
    Console.WriteLine("Ingrese otro número: ");
    num2 = int.Parse(Console.ReadLine());
    
    if(num2 != 0)
    {
      result = num1 / num2;
      Console.WriteLine("El resultado es: " + result);
    }
  }
}

 

Noten que este bloque nuevo que acaban de ver es similar a los otros bloques que están más arriba:

  • El bloque “public class…”
  • El bloque “public static void Main()”

¿Qué es lo similar? Que es un bloque de código que contiene llaves. Las llaves representan un bloque de código que contiene más cosas (una definición muuuuuuy sencilla). El bloque de código “if” contiene otro bloque de código entre “SUS” llaves. Esto significa, en este caso, que el bloque de código se va a ejecutar sólo si se cumple determinada condición, especificada en el comienzo del bloque.

Y… ¿Qué significa “que se cumple” la condición?

¿Recuerdan que hay un tipo de dato “bool“? Este tipo de dato sólo podía almacenar un valor true o false. Bien… En esta instancia vamos a empezar a usarlo bastante. ¿Recuerdan también que este tipo de dato también se usaba para responder a preguntas como si el usuario ganó, perdió, o si pasó algo? Podemos usar ese tipo de dato para que el programa decida qué camino tomar o si ejecutar o no un bloque de código.

Así como teníamos operadores matemáticos, también tenemos algo llamado “operadores lógicos“. Estos operadores también utilizan un valor a la izquierda y uno a la derecha, pero en lugar de darnos un resultado numérico, nos dan un resultado “bool“. Este es el tipo de dato del cual estábamos hablando, y que nos va a servir para trabajar con condicionales, es decir, para hacer una cosa u otra, según se cumpla o no una determinada condición.

Vamos a ver una tabla comparativa respecto de ambos tipos de operadores. Noten que algunos operadores pueden usarse de manera unaria (o sea, sólo requieren el operador y un valor), y otros pueden usarse de manera binaria (o sea, requieren un valor a la izquierda, el operador y otro valor a la derecha):

 

OPERADORES BOOLEANOS:

El tipo de dato que se obtiene como resultado SIEMPRE es bool, sin importar el tipo de dato a la izquierda y a la derecha.

Si el operador de la izquierda es menor que el de la derecha, nos da true como resultado. Caso contrario false.

EJEMPLOS:

using System;
          
public class Program
{
  public static void Main()
    {
        Console.WriteLine(1 < 1.1f);
        Console.WriteLine(1.1f < 1.1f);
    }
}
/*
Output:
True
False
*/

 

Si el operador de la izquierda es mayor que el de la derecha, nos da true como resultado. Caso contrario false.

EJEMPLOS:

using System;
          
public class Program
{
  public static void Main()
    {
        Console.WriteLine(1.1f > 1);
        Console.WriteLine(1.1f > 1.1f);
    }
}
/*
Output:
True
False
*/

 

Se usa para comprobar desigualdad entre dos elementos. Estos dos elementos pueden ser de distinto tipo de dato, y no necesariamente tienen que ser números. Mientras se puedan comparar, está bien. 

EJEMPLO:

using System;
          
public class Program
{
  public static void Main()
  {
       //Desigualdad numérica:
       Console.WriteLine((2 + 2) != 4);
       Console.WriteLine(5 != 0);
       Console.WriteLine(5 != 5.0f); //Atención al resultado!!

       //Desigualdad de texto.
       string a = "hello";
       string b = "hello";
       string c = "bye";

       //Comparación de cadenas de caracteres.
       Console.WriteLine(a != b);
       Console.WriteLine(a != c);
    }
}
/*
Output:
False
True
False
False
True
*/

 

Comprueba igualdad entre dos objetos. No hace falta que los dos sean números o que sean del mismo tipo de dato.

 

using System;
          
public class Program
{
  public static void Main()
    {
        // Igualdad: true
        Console.WriteLine((2 + 2) == 4);

        // Cadenas de texto:
        string a = "hello";
        string b = String.Copy(a);

        // Compara dos valores de texto.
        Console.WriteLine(a == b);
    Console.WriteLine(a == "bye");
    }
}
/*
Output:
True
True
False
*/

 

AND (y). Este operador es un tanto diferente al resto. Se usa para operar entre dos valores booleanos. El resultado que devuelve es true si ambos valores (a la izquierda y a la derecha), son true. Si alguno de los dos no lo es, devuelve false.

 

using System;
          
public class Program
{
  public static void Main()
    {
    bool isMale;
    bool isFemale;
        if (isMale == true && isFemale == false)
    {
      Console.WriteLine("Is Male");
    }
        else if(isMale == false && isFemale == true)
    {
      Console.WriteLine("Is Female.");
    }else
    {
      Console.WriteLine("It's a Xenomorph.");
    }
    }
}

 

OPERADORES MATEMÁTICOS:

El tipo de dato resultante de estas operaciones puede variar dependiendo de cuáles sean sus tipos de datos a la izquierda y a la derecha. Pero siempre va a elegir uno de los dos tipos y siempre el más abarcativo.

Operador de suma. Puede sumar dos número o concatenar dos textos. También se lo puede combinar con dos tipos de números diferentes o entre números y textos. En cualquiera de los casos, siempre nos da como resultado uno de los dos tipos de datos implicados en la suma, y siempre es el más abarcativo.

EJEMPLOS:

 

using System;
          
public class Program
{
  public static void Main()
  {
    Console.WriteLine(+5);        // unario
        Console.WriteLine(5 + 5);     // adición
        Console.WriteLine(5 + .5);    // adición
        Console.WriteLine("5" + "5"); // concatenación de strings
        Console.WriteLine(5.0 + "5"); // conversión y concatenación.
        
    //Noten cómo la conversión entre los distintos tipos se
    //hace automáticamente.
  }
}

/*
Output:
5
10
5.5
55
55
*/

 

Operador de resta. Se usa para una resta entre dos valores. El uso unario hace que el valor cambie de signo, o sea, es el equivalente a multiplicarlo por -1.

EJEMPLOS:

using System;
          
public class Program
{
  public static void Main()
    {
        int a = 5;
    int b = -10;
        Console.WriteLine(-a); //Cambia el signo por el opuesto.
    Console.WriteLine(-b); //Cambia el signo por el opuesto.
        Console.WriteLine(a - 1); //Resta 1 a la variable "a".
        Console.WriteLine(a - .5); //Resta 0.5 a la variable "a".
    }
}
/*
Output:
-5
10
4
4.5
*/

 

Multiplica dos valores numéricos. No tiene uso unario predeterminado.

EJEMPLOS:

using System;
          
public class Program
{
  public static void Main() 
    {
        Console.WriteLine(5 * 2);
        Console.WriteLine(-.5 * .2);
        Console.WriteLine(-.5m * .2m);
    }
}
    /*
Output
    10
    -0.1
    -0.10
*/

 

Este operador tiene otro uso relacionado con algo llamado “Pointer” (puntero). Este concepto es un tanto más complejo, pero se usa mucho en lenguajes como C y C++. Si quieren investigar algo de esto al respecto, les dejo un link:

https://docs.microsoft.com/es-ES/dotnet/csharp/programming-guide/unsafe-code-pointers/pointer-types

Ambos operadores dividen valores entre sí, lo que cambia es el valor que devuelve. El operador “/” devuelve el cociente (resultado), mientras que el operador “%” devuelve el resto de esa división.

EJEMPLOS:

using System;
          
public class Program
{
  public static void Main()
    {        
        Console.WriteLine("\nDividiendo 7 por 3.");
        //El cociente entero es 2, el resto es 1.
        Console.WriteLine("Cociente entero:           {0}", 7 / 3);
        Console.WriteLine("Cociente entero negativo:  {0}", -7 / 3);
        Console.WriteLine("Resto:                  {0}", 7 % 3);
        // Forzar un cociente float.
        float dividend = 7;
        Console.WriteLine("Cociente float:    {0}", dividend / 3);

        Console.WriteLine("\nDividiendo 8 por 5.");
        //El cociente entero es 1, el resto es 3.
        Console.WriteLine("Cociente entero:           {0}", 8 / 5);
        Console.WriteLine("Cociente entero negativo:  {0}", 8 / -5);
        Console.WriteLine("Resto:                  {0}", 8 % 5);
        //Forzar cociente float.
        Console.WriteLine("Cociente float:    {0}", 8 / 5.0);
    }
}
// Output:
//Dividiendo 7 por 3.
//Cociente entero:           2
//Cociente entero negativo:  -2
//Resto:                  1
//Cociente float:    2.33333333333333

//Dividiendo 8 por 5.
//Cociente entero:           1
//Cociente entero negativo:  -1
//Resto:                  3
//Cociente float:    1.6

 

Los operadores <= y >= funcionan casi de manera idéntica a < y > con la diferencia de que también comprueban igualdad.

Este tipo de operadores los van a utilizar siempre a lo largo de cada proyecto que emprendan, así que sería ideal que se aprendan su funcionamiento e incluso empiecen a pensar de la misma manera que el compilador interpreta esto. Siempre es como cuando aprenden un idioma nuevo: No es sólo saber hablarlo sino aprender a pensar en ese idioma. Acá pasa lo mismo. Sería ideal que aprendan a pensar de la manera en la que el lenguaje o “un” lenguaje interpreta las órdenes, para ya ir escribiendo y traduciendo las ideas que se les van ocurriendo casi de manera instantánea. No se queden sólo con las cosas que muestro acá, siempre investiguen y pidan otras opiniones. La mayoría de las cosas que escribo son a la manera que las fuí aprendiendo y las voy usando, pero la realidad es que siempre voy cambiando la forma de programar. Traten de no programar igual que otra persona! Busquen la suya propia, y tomense sus tiempos para ir moldeándose. Es sólo un consejo. ;).