CODEWITHSUNDEEP
rubyfile-io
dsg
dsg

Reputation: 13004

What are all the common ways to read a file in Ruby?

What are all the common ways to read a file in Ruby?

For instance, here is one method:

fileObj = File.new($fileName, "r")
while (line = fileObj.gets)
  puts(line)
end
fileObj.close

I know Ruby is extremely flexible. What are the benefits/drawbacks of each approach?

Upvotes: 321

Views: 400511

Answers (11)

the Tin Man
the Tin Man

Reputation: 160551

Be wary of "slurping" files. That's when you read the entire file into memory at once.

The problem is that it doesn't scale well. You could be developing code with a reasonably sized file, then put it into production and suddenly find you're trying to read files measuring in gigabytes, and your host is freezing up as it tries to read and allocate memory.

Line-by-line I/O is very fast, and almost always as effective as slurping. It's surprisingly fast actually.

I like to use:

IO.foreach("testfile") { |x| print "GOT ", x }

or

File.foreach('testfile') { |x| print "GOT", x }

File inherits from IO, and foreach is in IO, so you can use either.

I have some benchmarks showing the impact of trying to read big files via read vs. line-by-line I/O at "https://stackoverflow.com/q/25189262/128421".

Upvotes: 242

Francesco Mari
Francesco Mari

Reputation: 1738

if the file is small (slurping):

puts File.read("filename.txt")

if the file is big (streaming):

File.foreach("filename.txt") { |line| puts line }

Upvotes: 4

helloqiu
helloqiu

Reputation: 133

content = `cat file`

I think this method is the most "uncommon" one. Maybe it is kind of tricky, but it works if cat is installed.

Upvotes: 0

Khalil Gharbaoui
Khalil Gharbaoui

Reputation: 7042

An even more efficient way is streaming by asking the operating system’s kernel to open a file, then read bytes from it bit by bit. When reading a file per line in Ruby, data is taken from the file 512 bytes at a time and split up in “lines” after that.

By buffering the file’s content, the number of I/O calls is reduced while dividing the file in logical chunks.

Example:

Add this class to your app as a service object:

class MyIO
  def initialize(filename)
    fd = IO.sysopen(filename)
    @io = IO.new(fd)
    @buffer = ""
  end

  def each(&block)
    @buffer << @io.sysread(512) until @buffer.include?($/)

    line, @buffer = @buffer.split($/, 2)

    block.call(line)
    each(&block)
  rescue EOFError
    @io.close
 end
end

Call it and pass the :each method a block:

filename = './somewhere/large-file-4gb.txt'
MyIO.new(filename).each{|x| puts x }

Read about it here in this detailed post:

Ruby Magic Slurping & Streaming Files By AppSignal

Upvotes: 3

Kumar KS
Kumar KS

Reputation: 953

file_content = File.read('filename with extension');
puts file_content;

http://www.ruby-doc.org/core-1.9.3/IO.html#method-c-read

Upvotes: 25

Alex Danko
Alex Danko

Reputation: 36

return last n lines from your_file.log or .txt

path = File.join(Rails.root, 'your_folder','your_file.log')

last_100_lines = `tail -n 100 #{path}`

Upvotes: 3

Victor Klos
Victor Klos

Reputation: 438

You can read the file all at once:

content = File.readlines 'file.txt'
content.each_with_index{|line, i| puts "#{i+1}: #{line}"}

When the file is large, or may be large, it is usually better to process it line-by-line:

File.foreach( 'file.txt' ) do |line|
  puts line
end

Sometimes you want access to the file handle though or control the reads yourself:

File.open( 'file.txt' ) do |f|
  loop do
    break if not line = f.gets
    puts "#{f.lineno}: #{line}"
  end
end

In case of binary files, you may specify a nil-separator and a block size, like so:

File.open('file.bin', 'rb') do |f|
  loop do
    break if not buf = f.gets(nil, 80)
    puts buf.unpack('H*')
  end
end

Finally you can do it without a block, for example when processing multiple files simultaneously. In that case the file must be explicitly closed (improved as per comment of @antinome):

begin
  f = File.open 'file.txt'
  while line = f.gets
    puts line
  end
ensure
  f.close
end

References: File API and the IO API.

Upvotes: 76

fl00r
fl00r

Reputation: 83680

File.open("my/file/path", "r") do |f|
  f.each_line do |line|
    puts line
  end
end
# File is closed automatically at end of block

It is also possible to explicitly close file after as above (pass a block to open closes it for you):

f = File.open("my/file/path", "r")
f.each_line do |line|
  puts line
end
f.close

Upvotes: 282

sawa
sawa

Reputation: 168101

I usually do this:

open(path_in_string, &:read)

This will give you the whole text as a string object. It works only under Ruby 1.9.

Upvotes: 9

mckeed
mckeed

Reputation: 9828

The easiest way if the file isn't too long is:

puts File.read(file_name)

Indeed, IO.read or File.read automatically close the file, so there is no need to use File.open with a block.

Upvotes: 384

bta
bta

Reputation: 45057

One simple method is to use readlines:

my_array = IO.readlines('filename.txt')

Each line in the input file will be an entry in the array. The method handles opening and closing the file for you.

Upvotes: 31

Related Questions