Eduzan

Eduzan / Ruby

Ruby Control Statement

Computer Science / Ruby tutorial chapter - Published 2025-12-16 - Ruby

Decision-making in programming is much like making choices in real life. In a program, certain blocks of code are executed based on whether a specific condition is true or false. Programming languages use control statements to manage the flow of execution depending on these conditions. These control structures guide the direction of execution, causing the program to branch or continue based on the current state. In Ruby, the if-else structure helps in testing these conditions.

Types of Decision-Making Statements in Ruby:

1. if statement
2. if-else statement
3. if-elsif ladder
4. Ternary statement

1. if Statement: In Ruby, the if statement determines whether a block of code should be executed based on a condition. If the condition evaluates to true, the associated code is executed.

Syntax:

if (condition)
   # code to be executed
end

Example:

# Ruby program to demonstrate the if statement

temperature = 30

# Check if temperature is above 25 degrees
if temperature > 25
  puts "It's a warm day."
end

Output:

It's a warm day.

2. if-else Statement: The if-else statement is used when one block of code should be executed if the condition is true, and another block should run if the condition is false.

Syntax:

if (condition)
    # code if the condition is true
else
    # code if the condition is false
end

Example:

# Ruby program to demonstrate if-else statement

time = 16

# Check if the time is past noon
if time > 12
  puts "Good afternoon!"
else
  puts "Good morning!"
end

Output:

Good afternoon!

3. if-elsif-else Ladder: This structure allows multiple conditions to be evaluated one after another. Once a true condition is found, the corresponding block of code is executed, and the remaining conditions are skipped.

Syntax:

if (condition1)
    # code if condition1 is true
elsif (condition2)
    # code if condition2 is true
else
    # code if neither condition1 nor condition2 is true
end

Example:

# Ruby program to demonstrate if-elsif-else ladder

score = 85

if score < 50
  puts "You failed."
elsif score >= 50 && score < 65
  puts "You passed with a C grade."
elsif score >= 65 && score < 80
  puts "You passed with a B grade."
elsif score >= 80 && score < 90
  puts "You passed with an A grade."
else
  puts "You passed with an A+ grade."
end

Output:

You passed with an A grade.

4. Ternary Operator: The ternary operator is a shorthand for simple if-else statements. It evaluates a condition and returns one of two values based on whether the condition is true or false.

Syntax:

condition ? true_value : false_value

Example:

# Ruby program to demonstrate the ternary operator

age = 20

# Ternary operator to check if the person is an adult
status = (age >= 18) ? "Adult" : "Minor"
puts status

Output:

Adult

Looping is an essential concept in programming, enabling the repeated execution of a block of code based on a specific condition. Ruby, a dynamic and flexible language, offers various looping constructs to handle iterations effectively. These loops help automate tasks that require repetitive actions within a program.

The primary types of loops in Ruby include:

1. while Loop
2. for Loop
3. do..while Loop
4. until Loop

1. while Loop: In a while loop, the condition is evaluated at the beginning of the loop, and the code block is executed as long as the condition is true. Once the condition becomes false, the loop terminates. This is known as an Entry-Controlled Loop since the condition is checked before executing the loop body. It’s commonly used when the number of iterations is unknown.

Syntax:

while condition [do]
  # code to be executed
end

Example:

# Ruby program demonstrating the 'while' loop

counter = 3

# Using the while loop to print a message 3 times
while counter > 0
  puts "Welcome to Ruby programming!"
  counter -= 1
end

Output:

Welcome to Ruby programming!
Welcome to Ruby programming!
Welcome to Ruby programming!

2. for Loop: The for loop in Ruby functions similarly to the while loop but has a more concise syntax, especially useful when the number of iterations is known in advance. It is often used to iterate over a range, array, or collection. This loop is also an Entry-Controlled Loop since the condition is evaluated before the loop begins.

Syntax:

for variable_name[, variable...] in expression [do]
  # code to be executed
end

Example:

# Ruby program demonstrating the 'for' loop using a range

for num in 1..4 do
  puts "Number: #{num}"
end

Output:

Number: 1
Number: 2
Number: 3
Number: 4

Example 2: Iterating Over an Array

# Ruby program demonstrating the 'for' loop with an array

fruits = ["Apple", "Banana", "Cherry"]

for fruit in fruits do
  puts fruit
end

Output:

Apple
Banana
Cherry

3. do..while Loop: The do..while loop is similar to the while loop, but with one key difference: the condition is evaluated after the code block has been executed, ensuring that the loop runs at least once. This makes it an Exit-Controlled Loop.

Syntax:

loop do
  # code to be executed
  break if condition
end

Example:

# Ruby program demonstrating the 'do..while' loop

counter = 0

# The loop will run at least once
loop do
  puts "Iteration #{counter + 1}"
  counter += 1
  break if counter == 3
end

Output:

Iteration 1
Iteration 2
Iteration 3

4. until Loop: The until loop in Ruby is the opposite of the while loop. It continues executing as long as the given condition remains false, and stops once the condition becomes true. Like while, this is also an Entry-Controlled Loop.

Syntax:

until condition [do]
  # code to be executed
end

Example:

# Ruby program demonstrating the 'until' loop

counter = 5

# Using the until loop to print values until counter reaches 10
until counter == 10 do
  puts counter
  counter += 1
end

Output:

5. Class Variables: Class variables start with @@ and are shared across all instances of a class. They belong to the class itself rather than any individual instance. Class variables must be initialized before they are used. An uninitialized class variable will raise an error.

Example:

# Ruby program to illustrate Class Variables

class Library
  # Class variable
  @@book_count = 0

  def initialize(title)
    # Instance variable
    @title = title
  end

  def display_title
    puts "Book Title: #{@title}"
  end

  def add_book
    # Increment the class variable
    @@book_count += 1
    puts "Total books: #@@book_count"
  end
end

# Creating objects
book1 = Library.new("The Art of Ruby")
book2 = Library.new("Ruby on Rails Guide")

# Calling methods
book1.display_title
book1.add_book

book2.display_title
book2.add_book

Output:

Book Title: The Art of Ruby
Total books: 1
Book Title: Ruby on Rails Guide
Total books: 2

6. Global Variables: Global variables start with a $ sign and are accessible from anywhere in the Ruby program. They are not limited to a specific class or scope. By default, an uninitialized global variable has a nil value. However, excessive use of global variables can make code difficult to debug and maintain.

Example:

# Ruby program to illustrate Global Variables

# Global variable
$global_count = 5

class FirstClass
  def display_count
    puts "Global count in FirstClass: #$global_count"
  end
end

class SecondClass
  def display_count
    puts "Global count in SecondClass: #$global_count"
  end
end

# Creating objects
obj1 = FirstClass.new
obj2 = SecondClass.new

# Calling methods
obj1.display_count
obj2.display_count

Output:

Global count in FirstClass: 5
Global count in SecondClass: 5

In Ruby, you can use a case statement without specifying a value. Instead, you can use the when clauses to evaluate different conditions directly.

Example: Case Statement Without a Value

# Ruby program demonstrating case statement without a value

str = "HelloWorld123"

# Case statement evaluating different conditions
case
when str.match(/\d/)
  puts "The string contains numbers."
when str.match(/[a-zA-Z]/)
  puts "The string contains letters."
else
  puts "The string contains neither letters nor numbers."
end

Example:

The string contains numbers.

Output:

Global variable in FirstClass is 20
Global variable in SecondClass is 20

Case Statement in Method Call

You can use a case statement directly in a method call, where it will return a value just like any other method.

Example: Case Statement in a Method Call

# Ruby program demonstrating case statement in a method call

str = "4567"

# Case statement inside a method call to return a value
puts case
when str.match(/\d/)
  "The string contains numbers."
when str.match(/[a-zA-Z]/)
  "The string contains letters."
else
  "The string contains neither numbers nor letters."
end

Output:

The string contains numbers.

Ruby provides several control flow statements in addition to loops, conditionals, and iterators. These statements allow altering the normal execution flow in a program, controlling how the code is executed based on conditions or specific cases.

Here’s a breakdown of some important Ruby control flow statements:

1. break Statement: The break statement is used to exit a loop prematurely when a certain condition is met. Typically used in loops such as while, for, and case statements, it stops the execution of the loop as soon as the condition becomes true.

Syntax:

break

Example:

# Ruby program demonstrating the break statement

i = 1

# Using a while loop
while true
  if i * 6 >= 30
    break  # Exit the loop if condition is met
  end

  puts i * 6
  i += 1
end

Output:

2.next Statement: The next statement is used to skip the current iteration and move to the next one in a loop. It’s similar to the continue statement in languages like C and Java.

Syntax:

next

Example:

# Ruby program demonstrating the next statement

# Using a for loop
for t in 0...10
  if t == 5
    next  # Skip the iteration when t is 5
  end

  puts t
end

Output:

3. redo Statement: The redo statement restarts the current iteration of the loop without testing the loop’s condition again. Unlike next, which skips to the next iteration, redo causes the loop to restart the current one.

Syntax:

redo

Example:

# Ruby program demonstrating the redo statement

val = 0

while val < 4
  puts val
  val += 1

  redo if val == 4  # Restart the loop when val equals 4
end

Output:

4.retry Statement (Deprecated): The retry statement was used in earlier versions of Ruby (before 1.9) to restart a loop or an iterator from the beginning. It has been removed in later versions, as it was considered a deprecated feature.

5.return Statement: The return statement is used to exit a method and optionally pass a value back to the caller. If no value is provided, it returns nil.

Example:

# Ruby program demonstrating the return statement

def my_method
  val1 = 100
  val2 = 200

  return val1, val2  # Returning multiple values

  puts "This won't be executed"
end

result = my_method
puts result

Output:

100
200

6. throw/catch Statement: The throw and catch statements are used to create an advanced control flow structure. It’s like a multi-level break that allows you to exit out of deeply nested loops or methods. throw is used to break out, while catch defines a label where control can be transferred.

Example:

# Ruby program demonstrating throw/catch control flow

def check_number(num)
  throw :error if num < 10  # Exit the block if number is less than 10
  puts "Number is greater than or equal to 10!"
end

catch :error do
  check_number(15)
  check_number(25)
  check_number(5)  # This will cause the throw statement to exit the block
end

puts "Code after catch block"

Output:

Number is greater than or equal to 10!
Number is greater than or equal to 10!
Code after catch block

`Break` statement:

In Ruby, the break statement is used to stop the execution of a loop prematurely. It is often applied in loops like while and for, where it helps to exit the loop when a specific condition is met. Once the condition triggers the break statement, the loop terminates, and the code continues after the loop.

Syntax:

break

Example:

# Ruby program demonstrating the break statement
i = 1

# Using a while loop
while true
  puts i * 3  # Print multiples of 3
  i += 1
  if i * 3 >= 21
    break  # Exit the loop if the condition is met
  end
end

Output:

Explanation: In this example, the loop prints multiples of 3. Once the value i * 3 becomes 21 or greater, the break statement stops the loop.

Example:

# Another example demonstrating break statement
x = 0

# Using a while loop
while true
  puts x  # Print current value of x
  x += 1
  break if x > 3  # Stop the loop when x becomes greater than 3
end

Output:

`next` Statement in Ruby

The next statement is used to skip the rest of the current loop iteration and immediately proceed to the next iteration. It’s similar to the continue statement in other programming languages like C or Python. This is useful when certain conditions inside a loop should cause the loop to skip to the next step without executing further code for that iteration.

Syntax:

next

Example:

# Ruby program demonstrating the next statement
for x in 0..6
  if x + 1 < 4
    next  # Skip the current iteration if the condition is met
  end

  puts "Value of x is: #{x}"  # Print the value of x for other cases
end

Output:

Value of x is: 3
Value of x is: 4
Value of x is: 5
Value of x is: 6

A directory is a location where files can be stored. In Ruby, the Dir class and the FileUtils module provide various methods for managing directories, while the File class handles file operations. Double dot (..) refers to the parent directory, and single dot (.) refers to the current directory itself.

The Dir Class

The Dir class allows access to and manipulation of directory structures in Ruby. It includes methods for listing directory contents, creating directories, changing directories, and more.

Features of the Dir Class

1. Creating Directories: The mkdir method is used to create a new directory. It returns 0 if the directory is successfully created.

Syntax:

next

Examples:

# Ruby program demonstrating the next statement
for x in 0..6
  if x + 1 < 4
    next  # Skip the current iteration if the condition is met
  end

  puts "Value of x is: #{x}"  # Print the value of x for other cases
end

Output:

Value of x is: 3
Value of x is: 4
Value of x is: 5
Value of x is: 6

`redo` statement:

The redo statement in Ruby is used to repeat the current iteration of a loop without re-evaluating the loop condition. It is useful when you want to retry the current iteration based on a specific condition. This statement can only be used inside loops.

Syntax:

redo

Example:

# Ruby program demonstrating redo statement
restart = false

# Using a for loop
for x in 2..20
  if x == 15
    if restart == false
      # Print message when x is 15 for the first time
      puts "Re-doing when x = #{x}"
      restart = true

      # Using redo statement to repeat the current iteration
      redo
    end
  end
  puts x
end

Output:

2
3
4
5
6
7
8
9
10
11
12
13
14
Re-doing when x = 15
15
16
17
18
19
20

`retry` Statement in Ruby

The retry statement is used to restart the entire loop from the beginning. It is typically used within a block that includes begin-rescue error handling. The control jumps back to the start of the block or the loop, retrying the entire process. As of Ruby 1.9, the retry statement is considered deprecated for regular loops but is still available in begin-rescue blocks for exception handling.

Example :

# Ruby program demonstrating retry statement

# Using a do loop
10.times do |i|
  begin
    puts "Iteration #{i}"
    raise if i > 2  # Raise an exception if i is greater than 2
  rescue
    # Retry the iteration if an exception is raised
    retry
  end
end

Output:

Iteration 0
Iteration 1
Iteration 2
Iteration 3
Iteration 3
Iteration 3
...

End of lesson.

Back to Ruby

Ruby Control Statement

Ruby Decision Making (if, if-else, if-else-if, ternary)

Ruby Loops (for, while, do..while, until)

Case Statement Without a Value

Case Statement in Method Call

Control Flow Statements in Ruby

Break and Next Statement

`Break` statement:

`next` Statement in Ruby

Working with Directories in Ruby

The Dir Class

Features of the Dir Class

Ruby redo and retry Statement

`redo` statement:

`retry` Statement in Ruby

Ruby Control Statement

Ruby Decision Making (if, if-else, if-else-if, ternary)

Ruby Loops (for, while, do..while, until)

Case Statement Without a Value

Case Statement in Method Call

Control Flow Statements in Ruby

Break and Next Statement

Break statement:

next Statement in Ruby

Working with Directories in Ruby

The Dir Class

Features of the Dir Class

Ruby redo and retry Statement

redo statement:

retry Statement in Ruby

`Break` statement:

`next` Statement in Ruby

`redo` statement:

`retry` Statement in Ruby