Quais são as formas mais comuns de ler um arquivo no Ruby?

Quais são as formas mais comuns de ler um arquivo no Ruby?

Por exemplo, aqui está um método:

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

Eu sei que Ruby é extremamente flexível. Quais são os benefícios / desvantagens de cada abordagem?

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

Também é possível fechar explicitamente o arquivo depois como acima (passe um bloco para fechá- openlo para você):

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

A maneira mais fácil se o arquivo não for muito longo é:

puts File.read(file_name)

De fato, IO.readou File.readfeche o arquivo automaticamente, para que não haja necessidade de usar File.opencom um bloco.

Desconfie de arquivos "slurping". É quando você lê o arquivo inteiro na memória de uma só vez.

O problema é que ele não escala bem. Você pode desenvolver código com um arquivo de tamanho razoável, colocá-lo em produção e de repente descobrir que está tentando ler arquivos medidos em gigabytes, e seu host está congelando ao tentar ler e alocar memória.

A E / S linha a linha é muito rápida e quase sempre tão eficaz quanto o slurping. É surpreendentemente rápido, na verdade.

Eu gosto de usar:

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

ou

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

O arquivo é herdado do IO e foreachestá no IO, para que você possa usá-lo.

Eu tenho alguns benchmarks mostrando o impacto de tentar ler arquivos grandes por meio de readE / S linha a linha em " Por que" compactar "um arquivo não é uma boa prática? ".

Você pode ler o arquivo de uma só vez:

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

Quando o arquivo é grande, ou pode ser grande, geralmente é melhor processá-lo linha por linha:

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

Às vezes, você deseja acessar o identificador de arquivo ou controlar as leituras:

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

No caso de arquivos binários, você pode especificar um separador nulo e um tamanho de bloco, assim:

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

Finalmente, você pode fazer isso sem um bloco, por exemplo, ao processar vários arquivos simultaneamente. Nesse caso, o arquivo deve ser explicitamente fechado (aprimorado conforme o comentário de @antinome):

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

Referências: API do arquivo e a API do IO .

Um método simples é usar readlines:

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

Cada linha no arquivo de entrada será uma entrada na matriz. O método controla a abertura e o fechamento do arquivo para você.

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

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

Eu costumo fazer isso:

open(path_in_string, &:read)

Isso fornecerá o texto inteiro como um objeto de string. Funciona apenas no Ruby 1.9.

retorna as últimas n linhas de your_file.log ou .txt

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

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

Uma maneira ainda mais eficiente é fazer o streaming solicitando ao kernel do sistema operacional que abra um arquivo e, em seguida, leia os bytes bit a bit. Ao ler um arquivo por linha no Ruby, os dados são retirados do arquivo 512 bytes por vez e divididos em "linhas" depois disso.

Ao armazenar em buffer o conteúdo do arquivo, o número de chamadas de E / S é reduzido ao dividir o arquivo em blocos lógicos.

Exemplo:

Adicione esta classe ao seu aplicativo como um objeto de serviço:

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

Chame-o e passe ao :eachmétodo um bloco:

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

Leia sobre isso aqui neste post detalhado:

Arquivos Ruby Magic Slurping & Streaming por AppSignal

content = `cat file`

Eu acho que esse método é o mais "incomum". Talvez seja meio complicado, mas funciona se catestiver instalado.