Información sobre la lógica de booleanos en Go

El tipo de datos “Boolean” (​​​​​​bool​​​​​​) puede ser uno de dos valores, ya sea true (verdadero) o false (falso). Los booleanos se utilizan en programación para realizar comparaciones y controlar el flujo de los programas.

Los booleanos representan los valores de verdad que se asocian con la rama lógica de la matemática, que informa algoritmos en la Informática. La palabra “Boolean”, en honor al matemático George Boole, siempre comienza con B mayúscula.

El tipo de datos en Go para “Boolean” es bool, que se escribe por completo en minúsculas. Los valores true y false siempre aparecerán con t y f minúsculas respectivamente, ya que son valores especiales en Go.

En este tutorial, se abordarán los aspectos básicos que necesitará para comprender el funcionamiento del tipo de datos bool, que incluye la comparación booleana, los operadores lógicos y las tablas de verdad.

Operadores de comparación

En el ámbito de la programación, los operadores de comparación se utilizan para comparar valores y realizar evaluaciones hasta un único valor “Boolean” verdadero o falso.

En la siguiente tabla se muestran operadores de comparación “Boolean”.

Operador Que significa
== Igual a
! = No es igual a
< Menor que
> Mayor que
<= Menor o igual que
>= Mayor o igual que

Para entender el funcionamiento de estos operadores, asignaremos dos números enteros a dos variables en un programa de Go:

x := 5 y := 8 

En este ejemplo, dado que x tiene el valor 5, es inferior a y, que tiene el valor 8.

Usando estas dos variables y sus valores asociados, repasemos los operadores de la tabla anterior. A través de este programa, solicitará a Go que realice impresiones si cada operador de comparación hace evaluaciones con verdadero o falso. Para ayudar a entender mejor este resultado, también solicitará a Go imprimir una cadena que muestre lo que evalúa:

package main  import "fmt"  func main() {     x := 5     y := 8      fmt.Println("x == y:", x == y)     fmt.Println("x != y:", x != y)     fmt.Println("x < y:", x < y)     fmt.Println("x > y:", x > y)     fmt.Println("x <= y:", x <= y)     fmt.Println("x >= y:", x >= y) } 
Outputx == y: false x != y: true x < y: true x > y: false x <= y: true x >= y: false 

Siguiendo la lógica matemática, Go evaluó lo siguiente de las expresiones:

  • ¿Es 5 (x) igual a 8 (y)? false
  • ¿5 no es igual a 8? true
  • ¿5 es menor que 8? true
  • ¿5 es mayor que 8? false
  • ¿5 es menor o igual que 8? true
  • ¿5 no es menor o igual que 8? false

Si bien en este caso se utilizaron enteros, podría sustituirlos por valores flotantes.

Las cadenas también pueden utilizarse con operadores “Boolean”. Se distinguen mayúsculas y minúsculas, a menos que utilice un método de cadena adicional.

Podrá ver cómo se comparan las cadenas en la práctica:

Sammy := "Sammy" sammy := "sammy"  fmt.Println("Sammy == sammy: ", Sammy == sammy) 
OutputSammy == sammy:  false 

La cadena Sammy no es igual a la cadena sammy, ya que su similitud no es absoluta; una comienza con S mayúscula y la otra con s minúscula. Sin embargo, si añade otra variable que tenga asignado el valor Sammy, entonces se evaluarán como iguales:

Sammy := "Sammy" sammy := "sammy" alsoSammy := "Sammy"  fmt.Println("Sammy == sammy: ", Sammy == sammy) fmt.Println("Sammy == alsoSammy", Sammy == alsoSammy) 
OutputSammy == sammy:  false Sammy == alsoSammy true 

También puede usar los otros operadores de comparación, incluidos > y < para comparar dos cadenas. Go comparará estas cadenas de forma lexicográfica usando los valores ASCII de los caracteres.

También puede evaluar valores “Boolean” con operadores de comparación:

t := true f := false  fmt.Println("t != f: ", t != f) 
Outputt != f:  true 

El bloque de código anterior evaluó que true no es igual a false.

Observe la diferencia entre los dos operadores = y ==.

x = y   // Sets x equal to y x == y  // Evaluates whether x is equal to y 

El primero = es el operador de asignación, que establecerá un valor igual a otro. El segundo, ==, es un operador de comparación y evaluará si dos valores son iguales.

Operadores lógicos

Existen dos operadores lógicos que se utilizan para comparar valores. Evalúan las expresiones hasta los valores “Boolean” y muestran true o false. Estos operadores son &&, || y !, y se definen en la siguiente lista:

  • && (x && y) es el operador and. Es verdadero si ambas instrucciones lo son.
  • || (x || y) es el operador or. Es verdadero si al menos una instrucción lo es.
  • ! (! x) es el operador not. Sólo es verdadero si la instrucción es falsa.

Los operadores lógicos suelen utilizarse para evaluar si dos o más expresiones son verdaderas o no. Por ejemplo, pueden utilizarse para determinar si una calificación es aprobatoria y que el estudiante está registrado en el curso, y si ambos son verdaderos entonces se le asignará al alumno una calificación en el sistema. Otro ejemplo implicaría determinar si un usuario es un cliente activo válido de una tienda en línea,basándose en la posibilidad de que tenga crédito con la tienda o haya realizado una compra en los últimos 6 meses.

Para entender el funcionamiento de los operadores lógicos, evaluaremos tres expresiones:

fmt.Println((9 > 7) && (2 < 4))   // Both original expressions are true fmt.Println((8 == 8) || (6 != 6)) // One original expression is true fmt.Println(!(3 <= 1))            // The original expression is false 
Outputtrue true true 

En el primer caso, fmt.Println((9 > 7) && (2 < 4)), tanto 9 > 7 como 2 < 4 debieron evaluarse como verdaderas, ya que se utilizó el operador and.

En el segundo caso, fmt.Println((8 == 8) || (6 ! = 6)), ya que 8 == 8 se evaluó como verdadero; no marcó una diferencia que 6 != 6 se evalúe como falso porque se utilizó el operador or. Si hubiera utilizado el operador and​​​ , esto se evaluaría como falso.

En el tercer caso, fmt.Println(!(3 <= 1)), el operador not niega el valor falso que 3 <=1 muestra.

Sustituiremos los flotantes por enteros y buscaremos evaluaciones falsas:

fmt.Println((-0.2 > 1.4) && (0.8 < 3.1))  // One original expression is false fmt.Println((7.5 == 8.9) || (9.2 != 9.2)) // Both original expressions are false fmt.Println(!(-5.7 <= 0.3))               // The original expression is true 

En este ejemplo:

  • Para and debe haber al menos una expresión falsa evaluada como falsa.
  • Para or, ambas expresiones deben evaluarse como falsas.
  • La expresión interna de ! debe ser verdadera para que la nueva expresión se evalúe como falsa.

Si estos resultados le parecen confusos, revise algunas tablas de verdad para aclarar conceptos.

También puede escribir instrucciones compuestas usando &&, || y !:

!((-0.2 > 1.4) && ((0.8 < 3.1) || (0.1 == 0.1))) 

Primero, observe la expresión más interna: (0.8 < 3.1) || (0.1 == 0.1). Esta expresión se evalúa como true porque ambas instrucciones matemáticas son true.

A continuación, Go utiliza el valor mostrado true y lo combina con la siguiente expresión interior: (-0.2 > 1.4) && (true). En este ejemplo se muestra false, ya que la instrucción matemática -0.2 > 1.4 es falsa, y (false) y (true) muestran false.

Por último, se encuentra la expresión externa: !( false), que se evalúa como true, por lo que el valor mostrado al final, si imprimimos esta instrucción, es el siguiente:

Outputtrue 

Los operadores lógicos &&, || y ! evalúan las expresiones y muestran los valores “Boolean”.

Tablas de verdad

Hay mucho que aprender sobre la rama lógica de la matemática, pero puede aprender de forma selectiva algo de esto para mejorar su pensamiento algorítmico a la hora de crear programas.

Las siguientes son tablas de verdad para el operador de comparación == y cada uno de los operadores lógicos &&, || y !. Aunque pueda ser capaz de encontrar una explicación para ellos, también puede resultar útil memorizarlos, ya que esto puede agilizar su proceso de toma de decisiones para la programación.

Tabla de verdad de == (equal)

x == y Resultado
true == true true
true == false false
false == true false
false == false true

Tabla de verdad de && (and)

x and y Resultado
true and true true
true and false false
false and true false
false and false false

Tabla de verdad de || (or)

x or y Resultado
true or true true
true or false true
false or true true
false or false false

Tabla de verdad de ! (not)

not x Resultado
not true false
not false true

Las tablas de verdad son tablas matemáticas comunes que se emplean en la lógica y resulta útil tomarlas en cuenta al crear algoritmos (instrucciones) en el campo de la programación informática.

Uso de operadores “Boolean” para el control de flujo

Para controlar el flujo y los resultados de un programa en la forma de instrucciones de control de flujo, puede usar una condición seguida de una* cláusula*.

Una condición evalúa hasta un valor “Boolean” verdadero o falso y se presenta un punto en el que se toma una decisión en el programa. Es decir, una condición le mostraría si algo se evalúa a verdadero o falso.

La cláusula es el bloque de código que sigue la condición y dicta el resultado del programa. Es decir, es la parte “hacer esto” de la construcción “Si x es true, hacer esto”.

En el bloque de código que se muestra a continuación se muestra un ejemplo de operadores de comparación trabajando en equipo con instrucciones condicionales para controlar el flujo de un programa de Go:

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

Este programa evaluará si la calificación de cada estudiante es aprobatoria o reprobatoria. En el caso de un estudiante con una calificación de 83, la primera instrucción se evaluará a true y se activará la instrucción de impresión de Passing grade. En el caso de un estudiante con una calificación de 59, la primera instrucción se evaluará a false, por lo que el programa proseguirá con la ejecución de la instrucción de impresión vinculada a la expresión “else”: Failing grade.

Los operadores “Boolean” presentan condiciones que pueden utilizarse para decidir el resultado final de un programa a través de instrucciones de control de flujo.

Conclusión

En este tutorial, repasamos la comparación y los operadores lógicos pertenecientes al tipo “Boolean”, así como las tablas de verdad y el uso de booleanos para el control de flujo de un programa.