¿Cuáles son todas las formas comunes de leer un archivo en Ruby?

¿Cuáles son todas las formas comunes de leer un archivo en Ruby?

Por ejemplo, aquí hay un método:

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

Sé que Ruby es extremadamente flexible. ¿Cuáles son los beneficios / inconvenientes de cada enfoque?

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

También es posible cerrar explícitamente el archivo después de lo anterior (pase un bloque para cerrarlo openpor usted):

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

La forma más fácil si el archivo no es demasiado largo es:

puts File.read(file_name)

De hecho, IO.reado File.readcierre automáticamente el archivo, por lo que no es necesario usarlo File.opencon un bloque.

Tenga cuidado con los archivos "sorber". Ahí es cuando lees todo el archivo a la memoria a la vez.

El problema es que no escala bien. Podría estar desarrollando código con un archivo de tamaño razonable, luego ponerlo en producción y de repente descubrir que está tratando de leer archivos que miden en gigabytes, y su host se está congelando mientras intenta leer y asignar memoria.

La E / S línea por línea es muy rápida y casi siempre tan efectiva como el sorber. Es sorprendentemente rápido en realidad.

Me gusta usar:

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

o

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

El archivo hereda de IO y foreachestá en IO, por lo que puede usar cualquiera.

Tengo algunos puntos de referencia que muestran el impacto de tratar de leer archivos grandes a través readde E / S línea por línea en " ¿Por qué no es una buena práctica" sorber "un archivo? ".

Puede leer el archivo de una vez:

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

Cuando el archivo es grande, o puede ser grande, generalmente es mejor procesarlo línea por línea:

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

Sin embargo, a veces desea acceder al identificador de archivo o controlar las lecturas usted mismo:

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

En el caso de archivos binarios, puede especificar un separador nulo y un tamaño de bloque, así:

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

Finalmente, puede hacerlo sin bloqueo, por ejemplo, al procesar múltiples archivos simultáneamente. En ese caso, el archivo debe cerrarse explícitamente (mejorado según el comentario de @antinome):

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

Referencias: API de archivo y la API de IO .

Un método simple es usar readlines:

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

Cada línea en el archivo de entrada será una entrada en la matriz. El método se encarga de abrir y cerrar el archivo por usted.

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

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

Usualmente hago esto:

open(path_in_string, &:read)

Esto le dará todo el texto como un objeto de cadena. Funciona solo bajo Ruby 1.9.

devuelve las últimas n líneas de your_file.log o .txt

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

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

Una forma aún más eficiente es la transmisión pidiendo al núcleo del sistema operativo que abra un archivo y luego lea los bytes poco a poco. Al leer un archivo por línea en Ruby, los datos se toman del archivo 512 bytes a la vez y luego se dividen en "líneas".

Al almacenar en búfer el contenido del archivo, el número de llamadas de E / S se reduce al dividir el archivo en fragmentos lógicos.

Ejemplo:

Agregue esta clase a su aplicación como un objeto de servicio:

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

Llámalo y pasa el :eachmétodo un bloque:

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

Lea sobre esto aquí en esta publicación detallada:

Ruby Magic Slurping & Streaming Files por AppSignal

content = `cat file`

Creo que este método es el más "poco común". Tal vez sea un poco complicado, pero funciona si catestá instalado.