How to Write to a File in Ruby

By the end of this page, you will understand how Ruby writes data to files, which file modes to use, how to save text safely, and how this applies to exporting database data into a text file.

Ruby has built-in file handling through the File class and related IO methods. You do not need a separate file management system just to create, read, or write files.

When you export data from a database into a text file, the process usually looks like this:

1. Fetch rows from the database
2. Convert each row into text
3. Open a file in the correct mode
4. Write the text
5. Close the file

Ruby makes this simple with methods like:

• File.open
• File.write
• puts
• print
• write

The most common beginner-friendly pattern is a block with File.open, because Ruby automatically closes the file when the block ends.

File.open("output.txt", "w") do |file|
  file.puts "Hello, world!"
end

This matters in real programming because many applications need to:

• export reports
• generate logs
• save backups
• create CSV or text files
• write API results to disk

Using the correct file mode is important:

• "w" creates or overwrites a file
• "a" appends to the end of a file
• "r" reads from a file

For database exports, you will often loop through query results and write one line per record.

Think of a file as a notebook on your desk.

• Opening a file is like opening the notebook.
• Writing to it is like adding lines with a pen.
• Closing it is like shutting the notebook so nothing is left unfinished.

Ruby's block form of File.open is like asking someone to open the notebook, let you write in it, and then automatically close it when you are done. That is why it is safer and more convenient than opening and closing manually.

Basic file writing

File.open("notes.txt", "w") do |file|
  file.puts "First line"
  file.puts "Second line"
end

What this does

• Opens notes.txt in write mode
• Creates the file if it does not exist
• Overwrites the file if it already exists
• Writes two lines
• Closes the file automatically

Quick one-line write

File.write("notes.txt", "Hello from Ruby\n")

This is useful when you already have all content in one string.

Append instead of overwrite

File.open("notes.txt", "a") do |file|
  file.puts "Another line"
end

This adds content to the end of the file instead of replacing it.

Example: save database-style records

users = [
  {  ,  ,   },
  {  ,  ,   }
]

.open(, )  ||
  users.each  ||
    file.puts 
  

products = ["Book", "Pen", "Laptop"]

File.open("products.txt", "w") do |file|
  products.each do |product|
    file.puts product
  end
end

Step by step

1. Ruby creates an array named products.
2. File.open("products.txt", "w") opens the file in write mode.
   • If the file does not exist, Ruby creates it.
   • If it exists, Ruby clears the old contents.
3. The opened file object is passed into the block as file.
4. products.each starts looping through the array.
5. First iteration:
   • product is "Book"
   • file.puts product writes Book and a newline
6. Second iteration:
   • product is "Pen"

Ruby file writing is commonly used for:

• Database exports: save query results into .txt, .csv, or log files
• Report generation: create daily summaries or audit reports
• Logging: store errors, warnings, or job output
• Backups: save data snapshots before updates
• Data exchange: write files to be consumed by another system
• Scripts and automation: store processed results from scraping, APIs, or batch jobs

Example: exporting customer names from a database query result

customers = ["Anna", "David", "Maria"]

File.open("customers.txt", "w") do |file|
  customers.each do |name|
    file.puts name
  end
end

In a Rails app, this same idea is often used when generating exports in background jobs or admin tools.

In real projects, developers rarely just write raw text without structure. They usually combine file writing with patterns like validation, formatting, and error handling.

Common patterns

Guard clause before writing

records = []
return if records.empty?

This avoids creating an empty export unnecessarily.

Build lines before saving

lines = ["Header"]
lines << "Row 1"
lines << "Row 2"
File.write("report.txt", lines.join("\n") + "\n")

This is useful when the full content is easy to build in memory first.

Write inside an iteration for large datasets

File.open("report.txt", "w") do |file|
  records.each do |record|
    file.puts record.to_s
  end
end

This is often better when many rows are involved, because you do not need to keep the entire file content in one string.

Error handling

  .open(, )  ||
    file.puts 
  
 
  puts 
 
  puts 

1. Using write mode when you meant append mode

Broken example:

File.open("log.txt", "w") do |file|
  file.puts "New log entry"
end

Problem:

• "w" deletes existing content before writing.

Fix:

File.open("log.txt", "a") do |file|
  file.puts "New log entry"
end

2. Forgetting that write does not add a newline

Broken example:

File.open("names.txt", "w") do |file|
  file.write "Alice"
  file.write "Bob"
end

Result:

AliceBob

Fix:

File writing basics in Ruby

File.open("file.txt", "w") do |file|
  file.puts "Hello"
end

Common file modes

• "r" = read
• "w" = write and overwrite
• "a" = append

Common methods

• File.open(path, mode) — open a file
• File.write(path, content) — write a whole string at once
• file.puts(text) — write text with newline
• file.write(text) — write text exactly as given

Safe pattern

File.open("data.txt", "w") do |file|
  file.puts "line 1"
end

Append example

How do I create a text file in Ruby?

Use File.open with write mode:

File.open("example.txt", "w") { |file| file.puts "Hello" }

If the file does not exist, Ruby creates it.

How do I append text to an existing file in Ruby?

Use append mode:

File.open("example.txt", "a") { |file| file.puts "More text" }

Does Ruby have built-in file handling?

Yes. Ruby includes built-in classes such as File and IO for reading, writing, and managing files.

What is the difference between puts and write in Ruby files?

puts adds a newline automatically. write writes the exact string as-is.

Can I export database records to a text file in Ruby?

Yes. Query the records, loop through them, format each row as text, and write each line to a file.

• Reading files in Ruby — the natural next step after learning to write files.
• Ruby IO — file handling is part of Ruby's broader input/output system.
• Loops in Ruby — useful for writing many database rows into a file.
• Arrays and hashes in Ruby — database results are often stored in these structures.
• String interpolation in Ruby — helpful for formatting records before writing them.
• Exception handling in Ruby — useful when file operations fail due to permissions or paths.
• CSV generation in Ruby — a common alternative to plain text exports.
• Working with databases in Ruby — the source of the data you want to export.