Apa saja cara umum untuk membaca file di Ruby?

Apa saja cara umum untuk membaca file di Ruby?

Sebagai contoh, berikut adalah satu metode:

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

Saya tahu Ruby sangat fleksibel. Apa manfaat / kelemahan dari setiap pendekatan?

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

Dimungkinkan juga untuk secara eksplisit menutup file setelah seperti di atas (lulus blok untuk openmenutupnya untuk Anda):

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

Cara termudah jika file tidak terlalu panjang adalah:

puts File.read(file_name)

Memang, IO.readatau File.readsecara otomatis menutup file, sehingga tidak perlu menggunakan File.openblok.

Berhati-hatilah dengan file "slurping". Saat itulah Anda membaca seluruh file ke memori sekaligus.

Masalahnya adalah itu tidak skala dengan baik. Anda bisa mengembangkan kode dengan file berukuran wajar, lalu memproduksinya dan tiba-tiba menemukan Anda mencoba membaca file berukuran dalam gigabytes, dan host Anda membeku ketika mencoba membaca dan mengalokasikan memori.

Baris-demi-baris I / O sangat cepat, dan hampir selalu seefektif slurping. Ini ternyata sangat cepat.

Saya suka menggunakan:

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

atau

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

File mewarisi dari IO, dan foreachada di IO, jadi Anda bisa menggunakan keduanya.

Saya memiliki beberapa tolok ukur yang menunjukkan dampak dari mencoba membaca file besar melalui readvs. I-O baris demi baris di " Mengapa" menyeruput "file bukan praktik yang baik? ".

Anda dapat membaca file sekaligus:

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

Ketika file besar, atau mungkin besar, biasanya lebih baik untuk memprosesnya baris demi baris:

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

Kadang-kadang Anda ingin akses ke penanganan file atau mengontrol bacaan sendiri:

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

Dalam hal file biner, Anda dapat menentukan nil-separator dan ukuran blok, seperti:

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

Akhirnya Anda bisa melakukannya tanpa blok, misalnya saat memproses beberapa file secara bersamaan. Dalam hal ini file tersebut harus ditutup secara eksplisit (ditingkatkan sesuai komentar @antinome):

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

Referensi: File API dan IO API .

Salah satu metode sederhana adalah dengan menggunakan readlines:

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

Setiap baris dalam file input akan menjadi entri dalam array. Metode ini menangani membuka dan menutup file untuk Anda.

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

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

Saya biasanya melakukan ini:

open(path_in_string, &:read)

Ini akan memberi Anda seluruh teks sebagai objek string. Ini hanya berfungsi di bawah Ruby 1.9.

kembalikan n baris terakhir dari your_file.log atau .txt

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

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

Cara yang lebih efisien adalah streaming dengan meminta kernel sistem operasi untuk membuka file, kemudian membaca byte dari file itu sedikit demi sedikit. Saat membaca file per baris di Ruby, data diambil dari file 512 byte sekaligus dan dibagi menjadi "baris" setelah itu.

Dengan buffering konten file, jumlah panggilan I / O berkurang saat membagi file dalam potongan logis.

Contoh:

Tambahkan kelas ini ke aplikasi Anda sebagai objek layanan:

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

Sebut saja dan berikan :eachmetode ini blok:

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

Baca di sini di pos terperinci ini:

Ruby Magic Slurping & Streaming File Menurut AppSignal

content = `cat file`

Saya pikir metode ini adalah yang paling "tidak umum". Mungkin agak sulit, tetapi berfungsi jika catdiinstal.