Ruby Logical Operators Tutorial

In this section we will learn what the Logical Operators are and how to use them in Ruby.

Note: in this section we’re assuming you’re familiar with the Ruby operators in general and Ruby Comparison operators.

What is Logical Operators in Ruby?

The Logical Operators are those type of operators that allow us to combine the result of more than one expression and get a final result based on the output of those expressions.

For example, let’s say your program is designed to decide whether a person can enter to a bar. There are two conditions in your program to be checked:

– If the age of the person is over 21 AND if the person has enough money!

Here we have two conditions that both should result true otherwise the target user shouldn’t be able to enter to the building.

This is an example where we can use one of the logical operators called and. Basically, using the and operator we can combine the result of two expressions (for example age >21 and money >100) and only if both expressions resulted true then the final result will be true as well.

Alright, the and operator is just one example of logical operators. But we have more operators in this category and so let’s go and see these operators now.

List of Logical operators in Ruby

In the table below you can see the list of logical operators supported in the Ruby.

Ruby AND `&&` Operator:

The and or && operator is used to combine the result of two expressions and if and only if the result of both expressions were true then the final result will be true as well. Otherwise even if one of the expressions resulted false, then the final result will be false as well.

Notes:

• There’s no difference between the `and` and `&&`
  operator. We can use any one of them.

• The expressions this operator takes could be from a simple value
  like an integer, float, string etc. which Ruby can try to convert into
  true or false (based on the value of the expression) or a comparison
  operation using relational operators that result a boolean value (true
  or false).

• This operator short-circuits! This means if the result of the
  first expression was false, it won’t check the result of the second
  expression anymore! This is because based on the rules of the operator,
  even if one expression results false, the entire result will be false!
  So there’s no point on checking the other expression when the first one
  already resulted false.

Example: using AND && operator in Ruby

age = 23
money = 150
if age >= 21 && money >= 100
puts "This person can enter to the bar"
end
Output:
This person can enter to the bar

Here in the condition of the if statement we have two expressions for the && operator. If both of these expressions resulted true, then the final result will be true as well and so the body of the if statement will run as a result.

Now we can see that the age variable is higher than 21 and so the result of the first expression (the left expression) is true and now the right side expression will be checked which is to see if the value of the money variable is higher than 100. So because the second expression is also true, then the final result will be true as well and for this reason the body of the if statement ran.

Note that we could replace the && operator with the and operator and the result would be the same.

Example: using the `and` operator in Ruby:

age = 23
money = 150
if age >= 21 and money >= 100
puts "This person can enter to the bar"
end
Output:
This person can enter to the bar

Ruby OR || Operator:

Just like the and operator, the or operator is used to check the result of two expressions that result either a truthy or falsy value and based on those results, return a final boolean value.

But here’s the main difference:

While the AND operator returns the value true only if both involved expressions result true, the OR operator only looks for one expression to result true! Basically if the first expression resulted false, this operator will check the second expression to see if that results true or not. Now if the second expression resulted true, then the final result of this operator will be true as well. But if both expressions resulted false, then the final result of this operator will be false as well.

Example: using OR || operator in Ruby

full_name = "John Doe"
language = "Ruby"
if language == "Java" or language == "Ruby"
puts "Hello #{full_name}, you can apply for a job position in our company"
end
Output:
Hello John Doe, you can apply for a job position in our company

In this example, if the value of the language variable was either equal to Ruby or Java then the result of the if statement’s condition will be true and so its body will run as a result.

Note that we could replace the or operator in the example above and still get the same result.

Example: using the `||` operator in Ruby

full_name = "John Doe"
language = "Ruby"
if language == "Java" || language == "Ruby"
puts "Hello #{full_name}, you can apply for a job position in our company"
end
Output:
Hello John Doe, you can apply for a job position in our company

Ruby Not `!` Operator (AKA Reverse the Result Operator):

The not operator is used to reverse the result of a boolean expression. For example, if we use this operator behind an expression that is true, then the result will be false. Or if we use this operator behind a false value then the final result will be true.

Example: using the not operator in Ruby

if !false
puts "The body of the if statement ran..."
end
Output:
The body of the if statement ran…

Note that the condition of the if statement was false at first but because we’ve used the not operator behind this result, then the final result reversed and we got the value true as a result.

Also note that we could replace the ! operator with the not operator and still get the same result:

if not false

puts “The body of the if statement ran…”

end

Output:

The body of the if statement ran…