Understanding Boolean Logic in Golang

Comparison Operators

Comparison operators are used in programming to compare values and evaluate to a single true or false Boolean value.

The Boolean comparison operators are listed in the table below.

Let's use a Go code to assign two integers to two variables in order to understand how these operators function:

$x := 5$

$y := 8$

Given that x has a value of 5, it is less than y, which has a value of 8, in this case.

Let's go over the operators from the previous table using those two variables and their corresponding values. You will instruct Go to print whether each comparison operator evaluates to true or false in this program. Go will also produce a string to show you what it's evaluating so you are better able to understand this output:

Output

Go evaluated the following from the expressions using mathematical logic:

Although integers were utilized in this example, float values may have been used instead.

Boolean operators can also be applied to strings. Unless you use an additional string method, they are case-sensitive.

To compare strings in practice, consider the following:

Because they are not exactly the same—one begins with an uppercase S and the other with a lowercase s—the strings Sammy and sammy are not equivalent. However, if you include another variable to which Sammy is assigned a value, they will be equivalent to:

Output

To compare two strings, you can also use the additional comparison operators, such as > and. Go will compare the characters in these strings lexicographically using their ASCII values.

Boolean values can also be assessed using comparison operators:

The code block that came before it determined that true is not equivalent to false.

Keep in mind the difference between the two operators = and ==.

The assignment operator, represented by the first =, sets one value to another. The second comparison operator, ==, determines if two values are equal.

Logical Operators

To compare values, two logical operators are used. Expressions are reduced to boolean condition, yielding either true or false. These operators, defined in the list below, are &&, ||, and !

Commonly, logical operators are used to determine whether or not two or more expressions are true. The student will be given a grade in the system if, for instance, they can be used to confirm that the grade is passing and that the student is enrolled in the course. A different example would be to utilize store credit or recent purchases to evaluate whether a user is a true, active customer of an online store.

Let's analyze three expressions to understand better how logical operators function:

Output

Since the and operator was used in the first instance, $fmt.Println((9 > 7)$ && $(2 4))$, both $9 > 7$ and $2 4$ had to evaluate to true.

Because the or operator was used, it did not matter if $6!= 6$ evaluated to false in the second example, $fmt.Println((8 == 8) || (6!= 6))$, because $8 == 8$ evaluated to true. This would be evaluated as false if the and operator had been used.

When the not operator is used in the third case, $fmt.Println(!(3 = 1))$, the false value that $3 =1$ returns is negated.

Let's aim for false evaluations and replace integers with floats:

In this example:

• and at least one false expression must be evaluated to a false value.
• or must evaluate to false for both expressions. The new expression must be evaluated as false for its inner expression to be true.
• If you need further clarification on these outcomes, look through some truth tables.

Using &&, ||, and !, you may also create compound statements.

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

Look first at the innermost expression: $(0.8 < 3.1) || (0.1 == 0.1)$. Both of the mathematical statements are true, hence this expression evaluates to true.

The following inner expression is added to the returned value true by Go: $(-0.2 > 1.4)$ && $(true)$. This example yields false since (false) and (true) return false and the mathematical statement $-0.2 > 1.4$ is false.

When printing out this statement, the outer expression!(false), which evaluates to true, gives us the following result:

Output

The logical operators &&, ||, and ! evaluate expressions and return Boolean values.

Truth Tables

The logic branch of mathematics has much to learn, but you can pick and choose what you learn to sharpen your algorithmic thinking when programming.

Here are truth tables for the logical operators &&, ||, and ! as well as the comparison operator ==. Although you can reason them out, remembering them can also be useful because it will speed up the decision-making process when programming.

== (equal) Truth Table

&& (and) Truth Table

|| (or) Truth Table

! (not) Truth Table

When creating algorithms (instructions) for computer programming, it is helpful to bear in mind truth tables, which are common mathematical tables used in logic.

Using Boolean Operators for Flow Control

You can use a boolean condition and a clause together to manage the flow and results of a program using flow control statements.

When a boolean condition evaluates to a Boolean value of true or false, the program makes a choice at that time. In other words, a condition would indicate whether an evaluation is true or untrue.

The block of code known as the clause is what comes after the condition and determines how the program will run. This means that it is the "do this" clause in the sentence "If x is true, then do this."

The code block below provides an example of how comparison operators and conditional statements can be used to manage the flow of a Go program:

Each student's grade in this program will be determined as either passing or failing. The print statement "Passing grade" will be activated if a student with a grade of 83 evaluates the first assertion to true. The program will then carry out the print statement linked to the else expression: Failing grade because in the instance of a student with a grade of 59, the first assertion will evaluate to false.

Through flow control statements, boolean operators offer conditions that can be utilized to determine a program's final result.