Check Whether a File Exists in Ruby with File.exist?

You will learn how Ruby checks filesystem paths with File.exist?, how to verify that a path is specifically a regular file with File.file?, and how to handle common path-related issues such as ~, relative paths, and directories.

Ruby provides predicate methods—methods whose names end in ?—for asking questions about files and directories.

For a general existence check, use:

File.exist?(path)

It returns:

• true when something exists at path
• false when the path does not exist

“Something” can be a regular file, directory, symbolic link, or another filesystem entry. If you specifically need a normal file rather than a directory, use:

File.file?(path)

This distinction matters because a path can exist without being a file. For example, /home/me/Documents may exist, but it is a directory and cannot be read like a normal text file.

Checking a path before reading, writing, deleting, or processing it can produce clearer messages and prevent predictable errors. However, existence checks are not a substitute for error handling: a file can be deleted or have its permissions changed immediately after the check.

Think of a filesystem as a building map.

• File.exist? asks: “Is there anything at this address?”
• File.file? asks: “Is there a regular document cabinet at this address?”
• File.directory? asks: “Is there a room at this address?”

An address may be real but point to a room rather than a document cabinet. That is why File.exist? and File.file? answer slightly different questions.

Use a full or relative path as the argument.

path = "/home/me/a_file.txt"

if File.exist?(path)
  puts "The path exists."
else
  puts "Nothing exists at that path."
end

If the program requires a regular file, prefer File.file?:

path = "/home/me/a_file.txt"

if File.file?(path)
  puts "This is an existing file."
else
  puts "The path is missing or is not a regular file."
end

To identify a directory instead:

path = "/home/me/Documents"
puts File.directory?(path)

Relative paths are resolved from the program's current working directory:

puts Dir.pwd
puts File.exist?("settings.yml")

If a path begins with ~, expand it first. Ruby does not automatically treat ~ as your home directory in every file operation.

path = File.expand_path("~/a_file.txt")
puts File.file?(path)

Consider this example:

path = "notes.txt"

if File.file?(path)
  contents = File.read(path)
  puts contents
else
  puts "notes.txt is not an existing file."
end

Step by step:

1. path = "notes.txt" stores a relative path in the path variable.
2. File.file?(path) checks the current working directory for notes.txt.
3. If notes.txt exists and is a regular file, the condition is true.
4. Ruby runs File.read(path), which reads the file's contents into contents.
5. puts contents prints those contents.
6. If the file is missing, or if notes.txt is a directory, File.file? returns false and Ruby prints the fallback message instead.

You can inspect the current working directory when debugging relative paths:

puts "Working directory: #{Dir.pwd}"

• Configuration loading: Check whether an optional local configuration file exists before trying to load it.
• File uploads: Confirm that a temporary uploaded file is still present before processing it.
• Report generation: Avoid overwriting an existing report unless the user has chosen to replace it.
• Import scripts: Verify that a CSV or JSON input path points to a file before parsing it.
• Log management: Check whether a log directory exists before creating files inside it.
• Command-line tools: Validate a file path supplied by a user and provide an understandable error message.

In production Ruby code, checks are usually paired with validation and error handling.

Validate command-line input early

input_path = ARGV[0]

unless input_path && File.file?(input_path)
  warn "Provide the path to an existing file."
  exit 1
end

puts File.read(input_path)

This is a guard clause: it handles invalid input immediately, keeping the main code path simpler.

Create a directory when it is missing

require "fileutils"

output_dir = "tmp/reports"
FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)

Still rescue filesystem errors

A successful File.file? result does not guarantee that File.read will succeed. The file could disappear, or the process may lack permission.

path = "private.txt"

begin
  puts File.read(path)
rescue Errno::ENOENT
  warn "The file no longer exists."
rescue Errno::EACCES
  warn "Permission was denied."
end

For code that must read a file, attempt the operation and handle expected errors rather than relying only on a prior check.

Treating an existing directory as a file

This code accepts directories because File.exist? only checks existence:

path = "/home/me/Documents"
puts File.exist?(path) # true

If you plan to read a normal file, use File.file?:

puts File.file?(path) # false for a directory

Forgetting the leading slash in an intended absolute path

path = "home/me/a_file.txt"

This is a relative path. Ruby searches relative to Dir.pwd. An absolute Unix-style path starts with /:

path = "/home/me/a_file.txt"

Assuming ~ is expanded automatically

File.file?("~/a_file.txt")

Expand the home-directory shortcut yourself:

File.file?(File.expand_path("~/a_file.txt"))

Checking first but not handling failures

This can still fail after the condition succeeds:

if File.file?(path)
  File.read(path)
end

Another process could remove the file between the check and the read. Rescue expected errors when the operation is important.

Using a path check as permission validation

A path can exist even though your program cannot read it. Use File.readable?(path) when you specifically want to check readability, but still handle permission errors when reading.

File.exist? is broad. File.file? is more precise when the code expects a file.

For creating files, an existence check alone is often not enough. Decide whether overwriting is allowed, and use the appropriate file-opening mode or an atomic creation strategy when correctness matters.

# Does any filesystem entry exist here?
File.exist?(path)

# Is it an existing regular file?
File.file?(path)

# Is it an existing directory?
File.directory?(path)

# Is the path a symbolic link?
File.symlink?(path)

# Expand ~ and make an absolute path
File.expand_path("~/a_file.txt")

# Current directory used by relative paths
Dir.pwd

• Use File.exist? for “does this path exist?”
• Use File.file? before reading a normal file.
• Use File.directory? before treating a path as a folder.
• A relative path such as "data.json" is resolved from Dir.pwd.
• Expand ~ with File.expand_path.
• Handle Errno::ENOENT and Errno::EACCES around important file operations.

How do I check whether a file exists in Ruby?

Use File.exist?(path) for any existing filesystem entry, or File.file?(path) when the path must be a regular file.

What is the difference between File.exist? and File.file??

File.exist? returns true for files and directories. File.file? returns true only for regular files.

Does File.exist? work with relative paths?

Yes. Ruby resolves relative paths from the current working directory, available through Dir.pwd.

How do I check whether a directory exists in Ruby?

Use File.directory?(path).

Why does File.file?("~/file.txt") return false?

The ~ shortcut may not be expanded as expected. Use File.expand_path("~/file.txt") first.

Can a file disappear after File.file? returns true?

Yes. Filesystems can change between checks and later operations. Rescue errors such as Errno::ENOENT when reading or writing is critical.

Does file existence mean the file is readable?

No. A file can exist while the program lacks permission to read it. Handle Errno::EACCES when performing the read.

• File.read and File.write — Read from and write to filesystem files after validating a path.
• File.directory? — Check whether a path is an existing directory.
• File.expand_path — Convert relative paths and ~ paths into absolute paths.
• Dir.pwd — Understand where Ruby resolves relative paths.
• Exception handling with begin and rescue — Handle missing files and permission failures safely.
• FileUtils — Create, copy, move, and remove directories and files in Ruby scripts.