Quelles sont toutes les façons courantes de lire un fichier dans Ruby?

Quelles sont toutes les façons courantes de lire un fichier dans Ruby?

Par exemple, voici une méthode:

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

Je sais que Ruby est extrêmement flexible. Quels sont les avantages / inconvénients de chaque approche?

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

Il est également possible de fermer explicitement le fichier après comme ci-dessus (passez un bloc pour le openfermer pour vous):

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

Le moyen le plus simple si le fichier n'est pas trop long est:

puts File.read(file_name)

En effet, IO.readou File.readfermez automatiquement le fichier, il n'est donc pas nécessaire de l'utiliser File.openavec un bloc.

Méfiez-vous des fichiers "slurping". C'est alors que vous lisez le fichier entier en mémoire à la fois.

Le problème est qu'il ne se modifie pas bien. Vous pourriez développer du code avec un fichier de taille raisonnable, puis le mettre en production et découvrir soudain que vous essayez de lire des fichiers mesurant en gigaoctets, et votre hôte se bloque alors qu'il essaie de lire et d'allouer de la mémoire.

Les E / S ligne par ligne sont très rapides et presque toujours aussi efficaces que le slurping. C'est étonnamment rapide en fait.

J'aime utiliser:

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

ou

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

Le fichier hérite d'IO et se foreachtrouve dans IO, vous pouvez donc utiliser l'un ou l'autre.

J'ai quelques points de repère montrant l'impact d'essayer de lire de gros fichiers via des readE / S ligne par ligne sur " Pourquoi" slurping "un fichier n'est-il pas une bonne pratique? ".

Vous pouvez lire le fichier en une seule fois:

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

Lorsque le fichier est volumineux ou peut être volumineux, il est généralement préférable de le traiter ligne par ligne:

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

Parfois, vous souhaitez accéder au descripteur de fichier ou contrôler vous-même les lectures:

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

Dans le cas de fichiers binaires, vous pouvez spécifier un séparateur nul et une taille de bloc, comme ceci:

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

Enfin, vous pouvez le faire sans bloc, par exemple lors du traitement de plusieurs fichiers simultanément. Dans ce cas, le fichier doit être explicitement fermé (amélioré selon le commentaire de @antinome):

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

Références: File API et IO API .

Une méthode simple consiste à utiliser readlines:

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

Chaque ligne du fichier d'entrée sera une entrée dans le tableau. La méthode gère l'ouverture et la fermeture du fichier pour vous.

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

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

Je fais habituellement ceci:

open(path_in_string, &:read)

Cela vous donnera le texte entier sous forme d'objet chaîne. Cela ne fonctionne que sous Ruby 1.9.

retourne les n dernières lignes de your_file.log ou .txt

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

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

Une manière encore plus efficace est la diffusion en continu en demandant au noyau du système d'exploitation d'ouvrir un fichier, puis de lire les octets peu à peu. Lors de la lecture d'un fichier par ligne dans Ruby, les données sont extraites du fichier 512 octets à la fois et divisées en «lignes» après cela.

En mettant en mémoire tampon le contenu du fichier, le nombre d'appels d'E / S est réduit tout en divisant le fichier en segments logiques.

Exemple:

Ajoutez cette classe à votre application en tant qu'objet de service:

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

Appelez-le et passez la :eachméthode un bloc:

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

Lisez à ce sujet ici dans cet article détaillé:

Ruby Magic Slurping & Streaming Files par AppSignal

content = `cat file`

Je pense que cette méthode est la plus "rare". C'est peut-être un peu délicat, mais cela fonctionne si catest installé.