Entendendo a lógica booleana em Go

O tipo de dados Booleano (bool) pode ser um de dois valores, verdadeiro ou falso. Os Booleanos são usados na programação para fazer comparações e controlar o fluxo do programa.

Os Booleanos representam os valores de verdade que estão associados ao ramo lógico da matemática, que informa algoritmos na ciência da computação. Nomeado em homenagem ao matemático George Boole, a palavra Booleano sempre começa com um B maiúsculo.

O tipo de dados em Go para Booleanos é bool, escrito em letras minúsculas. Os valores true [verdadeiro] e false [falso] sempre estarão com as letras t e f, respectivamente em minúsculas, já que eles são valores especiais em Go.

Este tutorial irá abordar os fundamentos básicos necessários para entender como o tipo de dados bool funciona, incluindo a comparação Booleana, operadores lógicos e tabelas de verdade.

Operadores de comparação

Em programação, os operadores de comparação são usados para comparar valores e avaliá-los em um único valor Booleano de verdadeiro ou falso.

A tabela abaixo mostra operadores de comparação Booleanos.

Para entender como esses operadores funcionam, vamos atribuir dois números inteiros a duas variáveis em um programa em Go:

x := 5
y := 8

Neste exemplo, já que x tem o valor de 5, ele é menor que y que tem o valor de 8.

Usando essas duas variáveis e seus valores associados, vamos examinar cuidadosamente os operadores da tabela anterior. Neste programa, você pedirá ao Go para imprimir se cada operador de comparação avalia como verdadeiro ou falso. Para ajudar a entender melhor esse resultado, você também fará o Go imprimir uma string para mostrar o que está avaliando:

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)
}

Output
x == y: false
x != y: true
x < y: true
x > y: false
x <= y: true
x >= y: false

De acordo com a lógica matemática, o Go avaliou o seguinte das expressões:

• 5 (x) é igual a 8 (y)? falso
• 5 não é igual a 8? verdadeiro
• 5 é menor que 8? verdadeiro
• 5 é maior que 8? falso
• 5 é menor ou igual a 8? verdadeiro
• 5 não é menor ou igual a 8? falso

Embora os inteiros foram usados aqui, você poderia substituí-los por valores float.

As strings também podem ser usadas com operadores Booleanos. Elas diferenciam maiúsculas de minúsculas, a menos que você utilize um método string adicional.

Você pode examinar como as strings são comparados na prática:

Sammy := "Sammy"
sammy := "sammy"

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

Output
Sammy == sammy:  false

A string Sammy não é igual à string sammy, porque elas não são exatamente as mesmas; uma começa com uma maiúscula S e a outra com uma minúscula s. Mas, se você adicionar outra variável à qual for atribuído o valor de Sammy, então, elas avaliarão para iguais:

Sammy := "Sammy"
sammy := "sammy"
alsoSammy := "Sammy"

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

Output
Sammy == sammy:  false
Sammy == alsoSammy true

Você também pode usar outros operadores de comparação incluindo > e < para comparar duas strings. O Go irá comparar essas strings lexicograficamente, usando os valores ASCII dos caracteres.

Você também pode avaliar valores Booleanos com operadores de comparação:

t := true
f := false

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

Output
t != f:  true

O bloco de código anterior avaliou que true não é igual a false.

Note a diferença entre os dois operadores = e ==.

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

O primeiro = é o operador de atribuição, que definirá um valor como sendo igual a outro. O segundo, ==, é um operador de comparação e irá avaliar se dois valores são iguais.

Operadores lógicos

Há dois operadores lógicos que são usados para comparar valores. Eles avaliam expressões em valores Booleanos, retornando true ou false. Esses operadores são &&, || e ! e são definidos na lista abaixo:

• && (x && y) é o operador and. Será verdade se ambas as declarações forem verdadeiras.
• || (x || y) é o operador or. Será verdade se pelo menos uma declaração for verdadeira.
• ! (! x) é o operador not. Será verdade apenas se a instrução for falsa.

Os operadores lógicos são normalmente usados para avaliar se duas ou mais expressões são verdadeiras ou não verdadeiras. Por exemplo, eles podem ser usados para determinar se a nota é de aprovação e se o estudante está inscrito no curso; além disso, se ambos os casos forem verdadeiros, então o estudante receberá uma nota no sistema. Outro exemplo seria determinar se um usuário é um cliente ativo válido de uma loja online, com base em se eles têm o crédito da loja, ou fizeram uma compra nos últimos 6 meses.

Para entender como os operadores lógicos funcionam, vamos avaliar três expressões:

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

Output
true
true
true

No primeiro caso, fmt.Println((9 > 7) && (2 < 4)), ambos 9 > 7 e 2 < 4 precisavam avaliar como verdadeiros, já que o operador and foi usado.

No segundo caso, fmt.Println((8 == 8)) || 6 ! = 6)), como 8 = = 8 avaliou como verdadeiro, não fez diferença que 6 ! = 6 avaliou como falso, pois o operador or foi usado. Se você tivesse usado o operador and, isso avaliaria como falso.

No terceiro caso, fmt.Println(!( 3 <= 1)), o operador not nega o valor falso retornado de 3 <=1.

Vamos substituir os números floats por inteiros e almejar avaliações de falso:

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

Neste exemplo:

• and deve ter pelo menos uma expressão falsa avaliar como falso.
• em relação a or, ambas as expressões devem avaliar como falso.
• ! deve ter sua expressão interna como verdade, a fim de que a nova expressão avalie como falso.

Se esses resultados não ficaram claros para você, consulte algumas tabelas de verdade para obter mais esclarecimentos.

Você também pode escrever instruções compostas usando &&, || e !:

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

Primeiramente, examine a expressão mais próxima ao centro: (0.8 < 3.1) || (0.1 == 0.1). Essa expressão avalia como true porque ambas as declarações matemáticas são true.

Em seguida, o Go pega o valor retornado true e o combina à próxima expressão interna: (-0.2 > 1.4) && (true). Esse exemplo retorna false porque a declaração matemática -0.2 > 1.4 é falsa e (false) e (true) retornam false.

Por fim, temos a expressão exterior: !( false), que é avaliada como true, então o valor final retornado se imprimirmos essa declaração será:

Output
true

Os operadores lógicos &&, || e ! avaliam expressões e retornam valores Booleanos.

Tabelas de verdade

Há muito a se aprender sobre o ramo da lógica na matemática, mas você pode aprender um pouco a respeito de modo seletivo, a fim de aprimorar o seu pensamento algorítmico ao programar.

A seguir, apresentamos tabelas verdade para o operador de comparação == e cada um dos operadores lógicos &&, || e !. Embora você possa ser capaz de entendê-los, também pode ser útil memorizá-los, já que isso pode tornar seu processo de decisão na programação mais rápido.

== (equal) Tabela verdade

&& (and) Tabela verdade

|| (ou) Tabela verdade

! (não) Tabela verdade

| não | x | Retorna | | — | — | — | — | | não | verdadeiro | falso | | não | falso | verdadeiro |

As tabelas verdade são tabelas matemáticas comuns usadas em lógica. Elas são úteis de se ter em mente durante a criação de algoritmos (instruções) em programação de computadores.

Usando os operadores Booleanos para o controle de fluxo

Para controlar o fluxo e os resultados de um programa na forma de instruções de controle de fluxo, você pode usar uma condição seguida de uma cláusula.

Uma condição avalia em relação a um valor Booleano de verdadeiro ou falso, apresentando um ponto em que uma decisão será tomada no programa. Ou seja, uma condição diria a você se algo avalia em relação a verdadeiro ou falso.

A cláusula é o bloco de código que vem após a condição e determina o resultado do programa. Ou seja, trata-se da parte “faça isso” da construção “Se x é true, então, faça isso”.

O bloco de código abaixo mostra um exemplo de operadores de comparação que funcionam um depois do outro, com instruções condicionais para controlar o fluxo de um programa em Go:

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

Esse programa irá avaliar se cada nota do estudante é de aprovação ou reprovação. No caso de um estudante com uma nota de 83, a primeira instrução avaliará como true e a instrução de impressão da Passing grade (nota de aprovação) será acionada. No caso de um estudante com uma nota de 59, a primeira instrução avaliará como false, então o programa seguirá em frente para executar a instrução de impressão vinculada à expressão else: Failing grade (nota de reprovação).

Os operadores Booleanos apresentam condições que podem ser usadas para decidir o resultado eventual de um programa através de instruções de controle de fluxo.

Conclusão

Este tutorial trouxe explicações sobre os operadores de comparação e de lógica que pertencem ao tipo Booleano, além de tabelas verdade e o uso dos Booleanos para o controle de fluxo de programa.