Jakie są typowe sposoby odczytu pliku w Rubim?

Jakie są typowe sposoby odczytu pliku w Rubim?

Na przykład, oto jedna metoda:

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

Wiem, że Ruby jest niezwykle elastyczna. Jakie są zalety / wady każdego podejścia?

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

Możliwe jest również jawne zamknięcie pliku po jak wyżej (przekaż blok, aby opengo zamknąć):

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

Najłatwiejszym sposobem, jeśli plik nie jest zbyt długi, jest:

puts File.read(file_name)

Rzeczywiście IO.readlub File.readautomatycznie zamknij plik, więc nie ma potrzeby używania File.openz blokiem.

Uważaj na pliki „slurping”. Wtedy od razu odczytujesz cały plik do pamięci.

Problem polega na tym, że nie skaluje się dobrze. Możesz opracowywać kod z plikiem o rozsądnych rozmiarach, a następnie wprowadzić go do produkcji i nagle odkryć, że próbujesz odczytać pliki mierzone w gigabajtach, a Twój host zawiesza się, gdy próbuje odczytać i przydzielić pamięć.

Line-by-I / O jest bardzo szybki i prawie zawsze tak samo skuteczny jak slurping. W rzeczywistości jest zaskakująco szybki.

Lubię używać:

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

lub

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

Plik dziedziczy z IO i foreachjest w IO, więc możesz użyć jednego z nich.

Mam pewne testy porównawcze pokazujące wpływ próby odczytu dużych plików za pomocą operacji readwe / wy wiersz po wierszu w sekcji „ Dlaczego„ zamazywanie ”pliku nie jest dobrą praktyką? ”.

Możesz odczytać plik naraz:

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

Gdy plik jest duży lub może być duży, zwykle lepiej jest go przetwarzać wiersz po wierszu:

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

Czasami chcesz uzyskać dostęp do uchwytu pliku lub samodzielnie kontrolować odczyty:

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

W przypadku plików binarnych możesz podać separator zerowy i rozmiar bloku, na przykład:

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

Wreszcie możesz to zrobić bez bloku, na przykład podczas przetwarzania wielu plików jednocześnie. W takim przypadku plik musi zostać jawnie zamknięty (poprawiony zgodnie z komentarzem @antinome):

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

Odnośniki: File API i IO API .

Jedną z prostych metod jest użycie readlines:

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

Każda linia w pliku wejściowym będzie wpisem w tablicy. Ta metoda obsługuje otwieranie i zamykanie pliku.

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

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

Zazwyczaj robię to:

open(path_in_string, &:read)

To da ci cały tekst jako ciąg znaków. Działa tylko pod Ruby 1.9.

zwraca ostatnie n wierszy z twojego_pliku.log lub .txt

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

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

Jeszcze bardziej wydajnym sposobem jest przesyłanie strumieniowe, prosząc jądro systemu operacyjnego o otwarcie pliku, a następnie odczytanie z niego bajtów po kawałku. Podczas odczytywania pliku w wierszu w języku Ruby dane są pobierane z pliku 512 bajtów naraz i dzielone na „linie”.

Dzięki buforowaniu zawartości pliku zmniejsza się liczba wywołań We / Wy, dzieląc plik na logiczne części.

Przykład:

Dodaj tę klasę do swojej aplikacji jako obiekt usługi:

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

Zadzwoń i przekaż :eachmetodzie blok:

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

Przeczytaj o tym tutaj w tym szczegółowym poście:

Ruby Magic Slurping & Streaming Files By AppSignal

content = `cat file`

Myślę, że ta metoda jest najbardziej „rzadka”. Może to trochę trudne, ale działa, jeśli catjest zainstalowane.