Ruby ensure Keyword

last modified April 27, 2025

This tutorial explains how to use Ruby's ensure keyword. The ensure clause guarantees code execution regardless of exceptions.

The ensure keyword defines a block that always executes after a begin block, whether an exception occurs or not. It's typically used for cleanup operations.

ensure works with begin, rescue, and else keywords. It runs after normal execution or after any rescue blocks. The code executes even if you return early or raise another exception.

Basic ensure Example

This simple example demonstrates the basic usage of ensure. The ensure block runs regardless of whether an exception occurs.

basic_ensure.rb

begin
  puts "Performing operation"
  raise "Error occurred" if rand < 0.5
rescue => e
  puts "Rescued: #{e.message}"
ensure
  puts "This always runs"
end

The ensure block executes whether the operation succeeds or fails. This makes it ideal for cleanup tasks like closing files or releasing resources.

File Handling with ensure

A common use of ensure is ensuring files are properly closed. This example shows proper file handling even when exceptions occur.

file_handling.rb

begin
  file = File.open("data.txt", "w")
  file.puts "Writing important data"
  raise "Disk error" if rand < 0.3
rescue => e
  puts "Error writing file: #{e}"
ensure
  if file
    file.close
    puts "File closed successfully"
  end
end

The file is guaranteed to close, preventing resource leaks. The if file check ensures we don't try to close a never-opened file.

Database Connection with ensure

Database connections should always be properly closed. This example shows how ensure guarantees connection cleanup.

database.rb

require 'sqlite3'

begin
  db = SQLite3::Database.new("test.db")
  db.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")
  db.execute("INSERT INTO users (name) VALUES ('John')")
rescue SQLite3::Exception => e
  puts "Database error: #{e}"
ensure
  if db
    db.close
    puts "Database connection closed"
  end
end

The database connection closes whether the operations succeed or fail. This prevents connection leaks that could exhaust database resources.

ensure with Return Statements

ensure blocks run even when using return inside a method. This example demonstrates this behavior.

return_ensure.rb

def test_ensure
  begin
    puts "Starting method"
    return "Early return" if rand < 0.5
    puts "Normal execution"
  ensure
    puts "Ensure block executed"
  end
end

puts test_ensure

The ensure block runs before the method returns. This happens regardless of whether the return is early or at the end of normal execution.

Nested ensure Blocks

Ruby allows nested begin blocks with their own ensure clauses. This example shows how they execute in order.

nested_ensure.rb

begin
  puts "Outer begin"
  
  begin
    puts "Inner begin"
    raise "Inner error" if rand < 0.5
  ensure
    puts "Inner ensure"
  end

  raise "Outer error" if rand < 0.5
rescue => e
  puts "Rescued: #{e}"
ensure
  puts "Outer ensure"
end

Each ensure block runs when its corresponding begin block exits. Inner ensures run before outer ones, creating a clean-up stack.

ensure with Threads

ensure blocks in threads execute when the thread terminates, whether normally or due to an exception. This example demonstrates thread cleanup.

thread_ensure.rb

thread = Thread.new do
  begin
    puts "Thread working"
    sleep 1
    raise "Thread error" if rand < 0.5
  ensure
    puts "Thread cleanup"
  end
end

thread.join
puts "Main program continues"

The thread's ensure block runs whether the thread completes successfully or raises an exception. This is crucial for thread-local resource cleanup.

ensure in Method Definitions

Methods can use ensure without explicit begin blocks. This example shows the shorthand syntax for method-level ensure.

method_ensure.rb

def process_data
  puts "Processing data"
  raise "Processing error" if rand < 0.4
rescue => e
  puts "Error: #{e}"
ensure
  puts "Cleanup resources"
end

process_data

The entire method body acts as an implicit begin block. The ensure clause still guarantees execution regardless of how the method exits.

Source

Ruby Exception Handling Documentation

This tutorial covered Ruby's ensure keyword with practical examples showing resource cleanup, thread safety, and method-level guarantees.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Ruby tutorials.

Ebooks