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:
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.
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:
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ónif
para 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:
OutputPassing grade
A continuación, cambiaremos el resultado de este programa modificando el valor de la variable grade
de modo que sea 60
:
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:
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:
OutputBalance 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.
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í:
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:
OutputFailing 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:
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.")
}
}
OutputYour 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
.
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:
La instrucción else if
se dispondrá entre las instrucciones if
y else
de la siguiente manera:
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:
balance
es igual a 0
, veremos el resultado de la instrucción else if
(Balance is equal to 0, add funds soon
).balance
se fija en un número positivo, veremos el resultado de la instrucción else
(Your balance is 0 or above
).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:
Para ejecutar este código, necesitaremos una instrucción
if, tres instrucciones else if`` y 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.
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:
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…
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…
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…
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…
El programa imprimirá Failing grade
porque no se cumplieron todas las condiciones anteriores.
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:
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:
Outputtrue yes
statement1
se evalúa a “true”, pero nested_statement
se evalúa a “false”, el resultado será el siguiente:
Outputtrue no
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:
Outputfalse
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:
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+:
...
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:
Passing grade of:
A
Por lo tanto, el resultado del programa para una calificación de 96 tiene el siguiente aspecto:
OutputPassing grade of: A
Las instrucciones if
anidadas pueden permitir añadir varios niveles específicos de condiciones a su código.
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.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
This textbox defaults to using Markdown to format your answer.
You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!
Sign up for Infrastructure as a Newsletter.
Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.
Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.