- explain falsy vs truthy in Ruby
- apply the key logic operators AND, OR, and NOT
- combine operations into a logic expression
- utilize a truth table to illustrate a logical expression
- trace multiple paths through a code snippet
- apply compound logic to flatten nested
- Truth Table
- Flow Control
First, start by doing some research. You may choose independent or paired.
Truthy and falsey values
- How many falsey values are there in Ruby?
- What is truthy in Ruby?
When you’ve answered the questions above, which of these are truthy and which are falsey?
#pry if value_to_check puts "I'm truthy!" end
Values to Check:
Why is it helpful to have a working understanding of boolean logic? It can help us flatten
if statements and reduce the number of lines in our code. We are also going to encounter this frequently in our jobs. A lack in understanding can introduce bugs into our code bases.
AND/OR/NOT and Truth Tables
A truth table is a mathematical table used in logic. In the truth table below the first two columns (
b) are our input variables. Our table should cover all of the different possible combinations of input variables. There are four different combinations for our two input variables (
b). These are represented as rows. The remaining columns show all of the possible results of three Ruby operators for a given row. So the first row says if
a && b is
a || b is
pry session to clarify how these three Ruby operators work. For each row, set
b to their values and experiment with the Ruby operators.
 pry(main)> a = true => true  pry(main)> b = true => true  pry(main)> a && b => true
Expressions and Precedence with Parentheses
Let’s pop a few scenarios into pry, pause before hitting ‘enter’:
What do you expect it to return?
false && false || true
It depends on the order Ruby executes. Precedence refers to the order of opperations which Ruby follows. Here are a few you probably use regularly. The list is read top down in order of precedence.
! >, >=, <, <= <=>, ==, ===, !=, =~, !~ && || =, +=, -=, etc.
Ruby will run comparisions in order or precedence, if there are multiple of the same operator they will be evaluated starting with the left most operator.
If we take this Boolean Expression,
false || true && false || false, we can diagram the order Ruby will evaluate it in.
false || true && false || false \ / false || false || false false
What if you want the order Ruby executes this in to be different from its default? Enter, parens ().
Let’s revisit that last expressions in
pry, but let’s add some parentheses.
false && false || true false && (false || true)
Turn & Talk Turn to your neighbor and discuss what order you believe Ruby is evaluating each boolean expression in. What will the result be?
Complex Truth Tables
Evaluate the following by creating a truth table for three boolean values (
C) and using it to solve the following expressions:
(A || B) && (A || C)
(A || !B) || (!A || C)
((A && B) && C) || (B && !A)
((A && B) && !C) || ((A && C) && !B)
By yourself or with a partner:
- Clone the Boolean Logic Practice Repo onto your local machine
- cd vehicle_boolean
- rspec spec/vehicle_analysis_spec.rb (make sure all tests start out passing)
- You may need to
gem install stringioand/or
gem install o_stream_catcher
- You may need to
- Complete Activity 1 and Activity 2 (see below)
Activity 1: Vehicle
# vehicle.rb class Vehicle attr_reader :model, :four_wheel, :big_back_wheels def initialize(model, four_wheel, big_back_wheels) @model = model @four_wheel = four_wheel @big_back_wheels = big_back_wheels end def car? model == "car" end def tractor? model == "tractor" end def pickup? model == "pickup" end def four_wheel_drive? four_wheel end def big_back_wheels? big_back_wheels end end
# vehicle_analysis.rb class VehicleAnalysis def analyze(vehicle) if vehicle.car? if vehicle.four_wheel_drive? || !vehicle.four_wheel_drive? puts "Vehicle has four wheels " if vehicle.four_wheel_drive? puts "with four wheel drive" else puts "with two wheel drive" end end elsif vehicle.tractor? puts "Vehicle has four wheels " if vehicle.big_back_wheels? puts "with big wheels in the back" end elsif vehicle.pickup? puts "Vehicle has four wheels " if vehicle.four_wheel_drive? puts "with four wheel drive" else puts "with two wheel drive" end if vehicle.big_back_wheels? puts "with big wheels in the back" end end end end
# analysis_runner.rb require "vehicle" require "vehicle_analysis" vehicle = Vehicle.new("pickup", true, true) VehicleAnalysis.new.analyze(vehicle)
- How many unique execution paths are there through the block of code starting with
- Chart out the conditions which would lead to these paths consider using a truth table.
Activity 2: Flattening
Take the code from the previous exercise. Let’s try to refactor it. Start by flattening it down. Can you simplify the logic to reduce the number of paths? How few can you get it down to? Compare your results with a peer.
Convert the nested if/else statements to flatter boolean expressions.
- What objects are truthy? What objects are falsey?
- What are the rules of precedence in Boolean expressions?
- Why might you use complex Boolean expressions?