Was sind die gängigen Methoden zum Lesen einer Datei in Ruby?

Was sind die gängigen Methoden zum Lesen einer Datei in Ruby?

Hier ist zum Beispiel eine Methode:

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

Ich weiß, dass Ruby extrem flexibel ist. Was sind die Vor- und Nachteile jedes Ansatzes?

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

Es ist auch möglich, die Datei nach wie oben explizit zu schließen (übergeben Sie einen Block, um opensie für Sie zu schließen):

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

Der einfachste Weg, wenn die Datei nicht zu lang ist, ist:

puts File.read(file_name)

In der Tat IO.readoder File.readschließen Sie die Datei automatisch, sodass Sie sie nicht File.openmit einem Block verwenden müssen.

Seien Sie vorsichtig beim "Schlürfen" von Dateien. Dann lesen Sie die gesamte Datei auf einmal in den Speicher.

Das Problem ist, dass es nicht gut skaliert. Möglicherweise entwickeln Sie Code mit einer Datei mit angemessener Größe, stellen ihn dann in Produktion und stellen plötzlich fest, dass Sie versuchen, Dateien mit einer Größe von Gigabyte zu lesen, und Ihr Host friert ein, während er versucht, Speicher zu lesen und zuzuweisen.

Zeile für Zeile ist die E / A sehr schnell und fast immer so effektiv wie das Schlürfen. Es ist eigentlich überraschend schnell.

Ich benutze gerne:

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

oder

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

Die Datei erbt von IO und foreachbefindet sich in IO, sodass Sie beide verwenden können.

Ich habe einige Benchmarks, die zeigen, wie sich der Versuch auswirkt, große Dateien über readzeilenweise E / A zu lesen, unter " Warum ist das" Schlürfen "einer Datei keine gute Vorgehensweise? ".

Sie können die Datei auf einmal lesen:

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

Wenn die Datei groß ist oder groß sein kann, ist es normalerweise besser, sie zeilenweise zu verarbeiten:

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

Manchmal möchten Sie jedoch auf das Dateihandle zugreifen oder die Lesevorgänge selbst steuern:

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

Bei Binärdateien können Sie ein Nulltrennzeichen und eine Blockgröße wie folgt angeben:

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

Schließlich können Sie es ohne Block tun, beispielsweise wenn Sie mehrere Dateien gleichzeitig verarbeiten. In diesem Fall muss die Datei explizit geschlossen werden (verbessert gemäß Kommentar von @antinome):

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

Referenzen: Datei-API und E / A-API .

Eine einfache Methode ist zu verwenden readlines:

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

Jede Zeile in der Eingabedatei ist ein Eintrag im Array. Die Methode behandelt das Öffnen und Schließen der Datei für Sie.

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

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

Normalerweise mache ich das:

open(path_in_string, &:read)

Dadurch erhalten Sie den gesamten Text als Zeichenfolgenobjekt. Es funktioniert nur unter Ruby 1.9.

Geben Sie die letzten n Zeilen aus your_file.log oder .txt zurück

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

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

Eine noch effizientere Methode ist das Streaming, indem der Kernel des Betriebssystems aufgefordert wird, eine Datei zu öffnen und dann nach und nach Bytes daraus zu lesen. Beim Lesen einer Datei pro Zeile in Ruby werden Daten jeweils 512 Byte aus der Datei entnommen und danach in „Zeilen“ aufgeteilt.

Durch Puffern des Dateiinhalts wird die Anzahl der E / A-Aufrufe reduziert, während die Datei in logische Blöcke aufgeteilt wird.

Beispiel:

Fügen Sie diese Klasse Ihrer App als Serviceobjekt hinzu:

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

Rufen Sie es auf und übergeben Sie der :eachMethode einen Block:

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

Lesen Sie hier in diesem ausführlichen Beitrag darüber:

Ruby Magic Slurping & Streaming-Dateien von AppSignal

content = `cat file`

Ich denke, diese Methode ist die "ungewöhnlichste". Vielleicht ist es etwas schwierig, aber es funktioniert, wenn cates installiert ist.