Conditional Statements in Ruby
Crucial control flow techniques in Ruby, conditional statements let your program to decide what to do and run different code blocks depending on predetermined criteria. Conditionals are technically expressions that evaluate to a value, as are almost all other control structures in Ruby.
The Foundation of Conditionals: Truthiness and Falsiness
A Ruby condition is satisfied if the expression being tested is “truthy.” In contrast to languages like JavaScript or C Language, Ruby has a very rigid notion of what is not true:
Falsy Values: Two values in particular are deemed “false” (will yield false when evaluated as a condition):
false.nil.
Truthy Values: Each other value is regarded as “truthy” (will, when tested as a condition, return true). In other languages, these values are frequently regarded as incorrect:
- The numeric zero (
0). - The empty string (
""). - Empty arrays (
[]). - Empty hashes (
{}).
You can use the double negation syntax (!!) to explicitly examine a value’s boolean status.
Code Example (Testing Truthiness):
def check_truthy(var_name, var)
is_truthy = var ? "truthy" : "falsy"
puts "#{var_name} is #{is_truthy}"
end
check_truthy("false", false) # => false is falsy
check_truthy("nil", nil) # => nil is falsy
check_truthy("0", 0) # => 0 is truthy
check_truthy("empty string", "") # => empty string is truthyOutput
false is falsy
nil is falsy
0 is truthy
empty string is truthyif statement
For conditional branching, the most common form is the if statement.
Structure and Syntax
The if keyword is used to begin the if expression, which needs to be ended. Either a newline, a semicolon (;), or the keyword then must be used to separate the condition from the code block. The term “condition” is usually not included in parenthesis.
elsif: Allows for additional condition checks. Note the spelling with only one ‘e’.else: Contains the code that runs if all precedingifandelsifconditions evaluate tofalseornil.
Code Example (Standard Branching):
x = 2
if x == 1
puts "one"
elsif x == 2
puts "two"
else
puts "many"
endOutput
twoif as an Expression
An expression that returns the value of the last statement run in the corresponding block, or nil if no block was run, is what Ruby’s if structure is all about. This enables a variable to be immediately assigned to the result.
Code Example (Assignment using if expression):
age = 25
status = if age < 18
:minor
else
:adult
end
# This line explicitly prints the value of the `status` variable.
puts "The person's status is: #{status}"Output
The person's status is: adultunless statement
The except statement is a negated version of if that only runs code in the event that the condition is nil or false. When employing a negative expression, it is advised because it makes the code easier to read.
The else clause, which runs if the condition is true, is supported by the except statement, but the elsif clause is not.
Code Example (Using unless):
document_read_only = false
unless document_read_only
puts "Document is editable."
else
puts "Document is read-only."
end
# => Document is editable.
Output
Document is editable.Conditional Modifiers (Inline)
When used as modifiers for straightforward, one-line assertions, if, except, while, and until should be placed right after the expression they change. This format highlights the code that is being run.
For if/while, the changed phrase is evaluated only if the condition is met; for unless/until, it is assessed for unmet conditions.
Constraint: You can’t use an else clause in modifier form.
Precedence: Since they bind weakly, modifiers have relatively little precedence.
Code Example (Conditional Modifiers):
radiation = 4000
# Prints a warning if the condition is true
puts "Danger, Will Robinson" if radiation > 3000Output
Danger, Will RobinsonThe Ternary Operator ()
Ruby has only one ternary (three-operand) operator, the conditional operator (?:). It offers a condensed substitute for an if/else statement.
Syntax
The format is conditional ? value_if_truthy : value_if_falsy.
Code Example (Ternary Operator):
# Assign a value to the 'age' variable.
age = 25
# Use a ternary operator to assign a status based on age.
# If age is less than 18, 'status' will be :minor.
# Otherwise, 'status' will be :adult.
status = age < 18 ? :minor : :adult
# Print the final value of the 'status' variable to the console.
puts statusOutput
adultcase statement
One multiway conditional structure that is useful is the case statement. After the case keyword, an optional phrase can be entered, and it will be compared to several when clauses.
Matching Mechanism ()
Instead of the ordinary == operator, the case equality operator (===) is the central component of the case statement. If the left operand (the value of the when expression) subsumes the right operand (the value of the case expression), then the === operator checks.
To offer semantic matching, classes frequently override this operator:
Ranges: uses Range#include? to determine whether a value is part of the range.
Regular Expressions: determines if a string fits the regexp#=~ pattern.
Classes/Modules: Verifies whether the value belongs to the class (Module#is_a?).
The first matching when block’s statements are performed if the case condition is true. Clauses such as “never allows fall-through” or “no break is required” are verified only after a match has been found.
Code Example (Case with Type and Range Matching):
x = 17
case x
when 13..19 # Matches against Range
puts "teenager"
when Integer # Matches against Class
puts "It's an integer"
when /foo/ # This branch is skipped
puts "Contains 'foo'"
else
puts "Other"
endOutput
teenagerCode Example (Case without an explicit subject):
You can use a case statement without a subject (the phrase that comes after the case). This version tests each when clause independently as a boolean condition until one of them evaluates to true.
case
when ENV['A'] == 'Y'
puts 'A'
when ENV['B'] == 'Y'
puts 'B'
else
puts 'Neither A nor B'
end Output
Neither A nor BRelated Control Flow Structures
Loops
A section of code can be continually run using while loops.
while: carries out the block while the condition is true.until: carries out the block until the condition is met (i.e., while it is false).
Code Example (Looping):
i = 0
until i == 5
puts "Iteration ##{i}"
i +=1
end
# Executes 5 times Output
Iteration #0
Iteration #1
Iteration #2
Iteration #3
Iteration #4The Flip-Flop Operator
The flip-flop operator is employed in a conditional or loop statement between two conditions. It evaluates to false until the left operand, the first condition, turns true, at which time it “flips” to true. It remains true until the right operand, the second condition, becomes true, after which it “flops” back to false.
Code Example (Flip-Flop):
result = (1..5).select do |e|
e >= 2 && e <= 4
end
puts resultOutput
2
3
4Exception Handling Conditionals
To regulate flow based on success or failure, the keywords else and assure are also utilised in exception handling (begin/rescue blocks).
rescue: If an exception is raised in the begin block, control is transferred.
else (in exception handling): The otherwise clause’s code is only executed if the begin block’s function is completed without raising an exception.
ensure: Includes code that is always run when the block ends, whether a return was sent, an exception was raised, or the block ended normally.
Code Example (Exception else and ensure):
def example_division(x, y)
begin
z = x/y
rescue ZeroDivisionError
puts "Don't divide by zero!"
return nil
else
puts "This code runs on success."
return z
ensure
puts "This code ALWAYS runs."
end
end
example_division(10, 2)
# => This code runs on success.
# => This code ALWAYS runs.
# => 5 [119, 127]
example_division(10, 0)
# => Don't divide by zero!
# => This code ALWAYS runs.
# => nil Output
This code runs on success.
This code ALWAYS runs.
Don't divide by zero!
This code ALWAYS runs.You can also read What Is Mean By Operators In Ruby, It’s Types With Examples