Introducción

Las instrucciones condicionales son parte de cada lenguaje de programación. Con las instrucciones condicionales, podemos disponer de código que a veces se ejecuta y que en otros momentos no lo hace, según las condiciones del programa en ese momento.

Cuando ejecutamos por completo cada instrucción de un programa, no pedimos a este que evalúe condiciones específicas. Al usar las instrucciones condicionales, los programas pueden determinar si se cumplen ciertas condiciones y luego recibir instrucciones sobre cómo proceder a continuación.

Veamos algunos ejemplos en los que usaríamos instrucciones condicionales:

  • Si el estudiante recibe más del 65 % en su examen, informar que obtuvo una calificación de aprobación; si no, informar que obtuvo una calificación de desaprobación.
  • Si posee dinero en su cuenta, calcular intereses; si no, cobrar una penalización.
  • Si compra 10 o más naranjas, calcular un descuento del 5 %; si compra menos, no hacerlo.

Al evaluar las condiciones y asignar un código para que se ejecute según si se cumplan o no estas condiciones, escribimos código condicional.

Este tutorial le servirá como guía para escribir instrucciones condicionales en el lenguaje de programación Go.

Instrucciones “if”

Comenzaremos con la instrucción if, que evaluará si una instrucción es verdadera o falsa, y ejecutaremos código solo cuando la instrucción sea verdadera.

En un editor de texto simple, abra un archivo y escriba el siguiente código:

grade.go
package main

import "fmt"

func main() {
    grade := 70

    if grade >= 65 {
        fmt.Println("Passing grade")
    }
}

Con este código, disponemos de la variable grade y le asignaremos el valor entero 70. Luego, usaremos la instrucciónifpara evaluar si la variable “grade” es superior o igual (>=) a 65. Si cumple con esta condición, indicaremos al programa que imprima la cadena Passing grade.

Guarde el programa como grade.go y ejecútelo en un entorno de programación local desde una ventana de terminal con el comando go run grade.go.

En este caso, la calificación de 70 cumple la condición de ser superior o igual a 65, por lo que verá el siguiente resultado una vez que ejecute el programa:

Output
Passing grade

A continuación, cambiaremos el resultado de este programa modificando el valor de la variable grade de modo que sea 60:

grade.go
package main

import "fmt"

func main() {
    grade := 60

    if grade >= 65 {
        fmt.Println("Passing grade")
    }
}

Cuando guardemos y ejecutemos este código, no veremos resultados porque no se cumplió la condición y no indicamos al programa que ejecute otra instrucción.

Para dar un ejemplo más, calculemos si el balance de una cuenta bancaria es inferior a 0. Crearemos un archivo llamado account.go y escribiremos el siguiente programa:

account.go
package main

import "fmt"

func main() {
    balance := -5

    if balance < 0 {
        fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
    }
}

Cuando ejecutemos el programa con go run account.go veremos el siguiente resultado:

Output
Balance is below 0, add funds now or you will be charged a penalty.

En el programa, iniciamos la variable balance con el valor -5, que es inferior a 0. Debido a que el balance cumplió la condición de la instrucción if (balance < 0), una vez que guardemos y ejecutemos el código, recibiremos el resultado de la cadena. Una vez más, si cambiamos el balance a 0 o un número positivo, no veremos resultados.

Instrucciones Else

Es probable que le convenga que el programa realice algo aun cuando una instrucción si se evalúe a “false”. En nuestro ejemplo de calificación, nos convendrá obtener resultados independientemente de que la calificación sea o no de aprobación.

Para hacer esto, agregaremos a la condición de calificación anterior una declaración else que se construye así:

grade.go
package main

import "fmt"

func main() {
    grade := 60

    if grade >= 65 {
        fmt.Println("Passing grade")
    } else {
        fmt.Println("Failing grade")
    }
}

Puesto que la variable “grade” tiene el valor 60, la instrucción if se evalúa a “false”, por lo que el programa no imprimirá Passing grade. La instrucción else siguiente indica al programa que realice alguna acción de todos modos.

Al guardar y ejecutar el programa, veremos el siguiente resultado:

Output
Failing grade

Si luego reescribimos el programa para darle a la calificación el valor 65 o uno superior, en su lugar obtendremos Passing grade.

Para agregar una instrucción else al ejemplo de cuenta bancaria, reescribimos el código de esta manera:

account.go
package main

import "fmt"

func main() {
    balance := 522

    if balance < 0 {
        fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
    } else {
        fmt.Println("Your balance is 0 or above.")
    }
}
Output
Your balance is 0 or above.

Aquí, cambiamos el valor de la variable balance a un número positivo para que realice una impresión la instrucción else. A fin de lograr que la primera instrucción if realice una impresión, podemos reescribir el valor a un número negativo.

Al combinar una instrucción if con una instrucción else, construye una instrucción condicional de dos partes que indicará a la computadora que ejecute un código determinado independientemente de que se cumpla o no la condición if.

Instrucciones else if

Hasta ahora, presentamos una opción de booleano para declaraciones condicionales y cada declaración if realizando una evaluación a “true” o “false”. En muchos casos, nos convendrá un programa que evalúe más de dos posibles resultados. Para esto, usaremos una instrucción else if, la cual se redacta en Go como else if. else if o la “instrucción else if” se parece a la instrucción if y evaluará otra condición.

En el programa de cuentas bancarias, posiblemente nos convenga disponer de tres resultados discretos para tres situaciones diferentes:

  • El balance es inferior a 0.
  • El balance es igual a 0.
  • El balance es superior a 0.

La instrucción else if se dispondrá entre las instrucciones if y else de la siguiente manera:

account.go
package main

import "fmt"

func main() {
    balance := 522

    if balance < 0 {
        fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
    } else if balance == 0 {
        fmt.Println("Balance is equal to 0, add funds soon.")
    } else {
        fmt.Println("Your balance is 0 or above.")
    }
}

Ahora, hay tres posibles resultados que pueden producirse una vez que ejecutemos el programa:

  • Si la variable balance es igual a 0, veremos el resultado de la instrucción else if (Balance is equal to 0, add funds soon).
  • Si la variable balance se fija en un número positivo, veremos el resultado de la instrucción else (Your balance is 0 or above).
  • Si la variable balance se fija a un número negativo, el resultado será la cadena de la instrucción if (Balance is below 0, add funds now or you will be charged a penalty).

¿Qué sucede si, no obstante, deseamos disponer de más de tres posibilidades? Podemos hacer esto escribiendo más de una instrucción else if en nuestro código.

En el programa grade.go, reescribiremos el código para que haya algunas calificaciones de letras correspondientes a rangos de calificaciones numéricas:

  • 90, o más, equivale a una calificación “A”.
  • Entre 80 y 89, equivale a una calificación “B”.
  • Entre 70 y 79 equivale a una calificación “C”.
  • Entre 65 y 69 equivale a una calificación “D”.
  • 64, o menos, equivale a una calificación “F”.

Para ejecutar este código, necesitaremos una instrucción if, tres instrucciones else ify una instrucción else que manejarán todos los casos fallidos.

Reescribiremos el código del ejemplo anterior para disponer de cadenas que impriman cada una de las calificaciones de letras. Podemos hacer que nuestra instrucción else sea igual.

grade.go
package main

import "fmt"

func main() {
    grade := 60

    if grade >= 90 {
        fmt.Println("A grade")
    } else if grade >= 80 {
        fmt.Println("B grade")
    } else if grade >= 70 {
        fmt.Println("C grade")
    } else if grade >= 65 {
        fmt.Println("D grade")
    } else {
        fmt.Println("Failing grade")
    }
}

Debido a que las instrucciones else if se evalúan en orden, podemos mantener un perfil bastante básico para nuestras instrucciones. Este programa completa los siguientes pasos:

  1. Si la calificación es superior a 90, el programa imprimirá A grade; si es inferior a 90, el programa continuará con la declaración siguiente…

  2. Si la calificación es superior o igual a 80, el programa imprimirá B grade; si es 79 o inferior, el programa continuará con la declaración siguiente…

  3. Si la calificación es superior o igual a 70, el programa imprimirá C grade; si la calificación es 69 o inferior, el programa continuará con la declaración siguiente…

  4. Si la calificación es superior o igual a 65, el programa imprimirá D grade; si es 64 o inferior, el programa continuará con la declaración siguiente…

  5. El programa imprimirá Failing grade porque no se cumplieron todas las condiciones anteriores.

Instrucciones If anidadas

Una vez que se sienta cómodo con las instrucciones if, else if y else, puede proseguir con las instrucciones condicionales anidadas. Podemos usar instrucciones if anidadas para situaciones en las que deseemos verificar una condición secundaria si la primera condición se ejecuta como verdadera. Para esto, podemos tener una instrucción if-else dentro de otra instrucción if-else. Veamos la sintaxis de una instrucción if anidada:

if statement1 { // outer if statement
    fmt.Println("true")

    if nested_statement { // nested if statement
        fmt.Println("yes")
    } else { // nested else statement
        fmt.Println("no")
    }

} else { // outer else statement
    fmt.Println("false")
}

De este código pueden surgir algunos resultados:

  • Si statement1 se evalúa a “true”, el programa evaluará si nested_statement también se evalúa a “true”. Si ambos casos son verdaderos, se obtendrá el siguiente resultado:
Output
true yes
  • Sin embargo, si statement1 se evalúa a “true”, pero nested_statement se evalúa a “false”, el resultado será el siguiente:
Output
true no
  • Si statement1 se evalúa a “false”, no se ejecutará la instrucción “if-else” anidada, por lo que la instrucción else se ejecutará sola y el resultado será el siguiente:
Output
false

También podemos disponer de varias instrucciones if anidadas en nuestro código:

if statement1 { // outer if
    fmt.Println("hello world")

    if nested_statement1 { // first nested if
        fmt.Println("yes")

    } else if nested_statement2 { // first nested else if
        fmt.Println("maybe")

    } else { // first nested else
        fmt.Println("no")
    }

} else if statement2 { // outer else if
    fmt.Println("hello galaxy")

    if nested_statement3 { // second nested if
        fmt.Println("yes")
    } else if nested_statement4 { // second nested else if
        fmt.Println("maybe")
    } else { // second nested else
        fmt.Println("no")
    }

} else { // outer else
    statement("hello universe")
}

En este código, hay una instrucción if anidada dentro de cada instrucción if además de la instrucción if else. Esto hará posibles más opciones dentro de cada condición.

Veamos un ejemplo de instrucciones if anidadas con nuestro programa de grade.go. Podemos verificar primero si una calificación es de aprobación (superior o igual al 65 %) y luego evaluar la letra de la calificación a la que debería equivaler la calificación numérica. Sin embargo, si la calificación no es de aprobación no es necesario que revisemos las calificaciones con letras y, como alternativa, podemos hacer que el programa informe que la calificación equivale a una desaprobación. Nuestro código modificado con la instrucción if anidada tendrá el siguiente aspecto:

grade.go

package main

import "fmt"

func main() {
    grade := 92
    if grade >= 65 {
        fmt.Print("Passing grade of: ")

        if grade >= 90 {
            fmt.Println("A")

        } else if grade >= 80 {
            fmt.Println("B")

        } else if grade >= 70 {
            fmt.Println("C")

        } else if grade >= 65 {
            fmt.Println("D")
        }

    } else {
        fmt.Println("Failing grade")
    }
}

Si ejecutamos el código con la variable grade fijada en el valor entero 92, se cumplirá la primera condición y el programa imprimirá Passing grade of: A continuación, verificará si la calificación es mayor o igual a 90, y dado que esta condición también se cumple, imprimirá A.

Si ejecutamos el código con la variable grade fijada en 60, la primera condición no se cumplirá, por lo que el programa omitirá las instrucciones anidadas if, pasará a la instrucción else e imprimirá Failing grade.

Podemos, por supuesto,agregar aún más opciones a esto y usar una segunda capa de instrucciones if anidadas. Posiblemente nos convenga evaluar las notas de A+, A y A- por separado. Podemos hacerlo revisando primero si la calificación es de aprobación, luego si la calificación es 90 o superior y finalmente si es superior a 96 para equivaler a A+:

grade.go
...
if grade >= 65 {
    fmt.Print("Passing grade of: ")

    if grade >= 90 {
        if grade > 96 {
            fmt.Println("A+")

        } else if grade > 93 && grade <= 96 {
            fmt.Println("A")

        } else {
            fmt.Println("A-")
        }
...

En este código, para una variable grade fijada en 96 el programa realizará lo siguiente:

  1. Verificar si la calificación es superior o igual a 65 (true)
  2. Imprimir Passing grade of:
  3. Verificar si la calificación es superior o igual a 90 (true)
  4. Verificar si la calificación es superior a 96 (false)
  5. Verificar si la calificación es superior a 93 e inferior o igual a 96 (true)
  6. Imprimir A
  7. Dejar estas instrucciones condicionales anidadas y continuar con el código restante

Por lo tanto, el resultado del programa para una calificación de 96 tiene el siguiente aspecto:

Output
Passing grade of: A

Las instrucciones if anidadas pueden permitir añadir varios niveles específicos de condiciones a su código.

Conclusión

Al usar instrucciones condicionales como if, tendrá mayor control sobre las ejecuciones que realice su programa. Las instrucciones condicionales indican al programa que evalúe si se cumple una condición determinada. Si la condición se cumple, este ejecutará código específico, pero si no se cumple continuará con otros códigos.

Para continuar practicando con las instrucciones condicionales, intente usar diferentes operadores para familiarizarse más con ellas.

0 Comments

Creative Commons License