Quali sono tutti i modi comuni per leggere un file in Ruby?

Quali sono tutti i modi comuni per leggere un file in Ruby?

Ad esempio, ecco un metodo:

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

So che Ruby è estremamente flessibile. Quali sono i vantaggi / gli svantaggi di ciascun approccio?

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

È anche possibile chiudere esplicitamente il file dopo come sopra (passare un blocco per chiuderlo openper te):

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

Il modo più semplice se il file non è troppo lungo è:

puts File.read(file_name)

Anzi, IO.reado File.readchiudi automaticamente il file, quindi non è necessario utilizzarlo File.opencon un blocco.

Diffidare di file "slurping". Questo è quando leggi l'intero file in memoria contemporaneamente.

Il problema è che non si adatta bene. Potresti sviluppare codice con un file di dimensioni ragionevoli, quindi metterlo in produzione e improvvisamente scopri che stai provando a leggere i file misurando in gigabyte e il tuo host si blocca mentre tenta di leggere e allocare memoria.

L'I / O riga per riga è molto veloce e quasi sempre efficace come lo slurping. In realtà è sorprendentemente veloce.

Mi piace usare:

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

o

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

Il file eredita da IO ed foreachè in IO, quindi puoi usare entrambi.

Ho alcuni benchmark che mostrano l'impatto del tentativo di leggere file di grandi dimensioni tramite readI / O vs line-by-line in " Perché" slurping "un file non è una buona pratica? ".

Puoi leggere il file tutto in una volta:

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

Quando il file è grande o può essere grande, di solito è meglio elaborarlo riga per riga:

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

A volte vuoi accedere all'handle del file o controllare tu stesso le letture:

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

Nel caso di file binari, è possibile specificare un separatore zero e una dimensione di blocco, in questo modo:

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

Finalmente puoi farlo senza un blocco, ad esempio quando elabori più file contemporaneamente. In tal caso il file deve essere esplicitamente chiuso (migliorato come da commento di @antinome):

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

Riferimenti: File API e IO API .

Un metodo semplice è utilizzare readlines:

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

Ogni riga nel file di input sarà una voce nell'array. Il metodo gestisce l'apertura e la chiusura del file per te.

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

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

Di solito lo faccio:

open(path_in_string, &:read)

Questo ti darà l'intero testo come oggetto stringa. Funziona solo con Ruby 1.9.

restituisce le ultime n righe da your_file.log o .txt

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

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

Un modo ancora più efficiente è lo streaming chiedendo al kernel del sistema operativo di aprire un file, quindi leggere byte da esso bit per bit. Quando si legge un file per riga in Ruby, i dati vengono presi dal file 512 byte alla volta e successivamente suddivisi in "righe".

Bufferando il contenuto del file, il numero di chiamate I / O viene ridotto mentre si divide il file in blocchi logici.

Esempio:

Aggiungi questa classe alla tua app come oggetto di servizio:

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

Chiamalo e passa il :eachmetodo a blocco:

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

Leggi qui in questo post dettagliato:

Ruby Magic: Slurping & Streaming Files di AppSignal

content = `cat file`

Penso che questo metodo sia il più "raro". Forse è un po 'complicato, ma funziona se catè installato.