Lire les n dernières lignes d'un fichier en Ruby?

J'ai besoin de lire les 25 dernières lignes d'un fichier (pour l'affichage de la plus récente des entrées de journal). Est-il de toute façon en Ruby pour démarrer à la fin d'un fichier et de le lire à l'envers?

InformationsquelleAutor Josh Moore | 2009-04-16

file-io ruby

36

Si sur un *nix système avec tail, vous pouvez tricher, comme ceci:
```
last_25_lines = `tail -n 25 whatever.txt`
```
- Je pense qu'une bibliothèque serait plus suffisante pour traverser les capacités de la plateforme, mais vous obtenez l'idée.
- Probablement vrai. Je n'ai pas l'exécuter du code Ruby sur quoi que ce soit mais les *nix-systèmes et je pense que vous aurez un moment difficile de trouver l'un de ceux sans "queue" ... Aussi, parfois, vous n'avez pas le luxe d'installer une bibliothèque. Voulais juste montrer le "one liner' 🙂
- Je n'ai pas encore déployé sur un environnement qui n'a pas de queue. Cette réponse devrait être acceptée à mon avis.
InformationsquelleAutor rfunduk
25

Le fichier est-il assez grand que vous avez besoin pour éviter la lecture de toute la chose? Si non, vous pourriez faire
```
IO.readlines("file.log")[-25..-1]
```
Si elle est grande, vous pouvez avoir besoin d'utiliser IO#rechercher à lire de près de la fin du fichier, et de continuer à chercher vers le début jusqu'à ce que vous avez vu 25 lignes.
- Si vous ne voulez pas passer par la peine de le renverser, vous pouvez utiliser [-25..-1] à la place.
- Beaty. Pas besoin de supposer quoi que ce soit sur le système de commandes disponibles de cette façon. Merci. 🙂
- problème avec [-25..-1], si le fichier a moins de 25 lignes, alors le résultat est nul, je vous conseille d'utiliser IO.readlines("file.log").last(25) qui renvoie tableau vide dans ce cas.
InformationsquelleAutor Brian Campbell
13

Il y a une bibliothèque pour Ruby appelé Fichier::Queue. Cette pouvez-vous obtenir les N dernières lignes d'un fichier comme le UNIX queue utilitaire.

Je supposer qu'il y a une certaine recherche de l'optimisation en place dans la version UNIX de la queue avec des indicateurs comme ceux-ci (testé sur un fichier texte un peu plus de 11 M):
```
[john@awesome]$du -sh 11M.txt
11M     11M.txt
[john@awesome]$time tail -n 25 11M.txt
/sbin/ypbind
/sbin/arptables
/sbin/arptables-save
/sbin/change_console
/sbin/mount.vmhgfs
/misc
/csait
/csait/course
/.autofsck
/~
/usb
/cdrom
/homebk
/staff
/staff/faculty
/staff/faculty/darlinr
/staff/csadm
/staff/csadm/service_monitor.sh
/staff/csadm/.bash_history
/staff/csadm/mysql5
/staff/csadm/mysql5/MySQL-server-community-5.0.45-0.rhel5.i386.rpm
/staff/csadm/glibc-common-2.3.4-2.39.i386.rpm
/staff/csadm/glibc-2.3.4-2.39.i386.rpm
/staff/csadm/csunixdb.tgz
/staff/csadm/glibc-headers-2.3.4-2.39.i386.rpm

real    0m0.012s
user    0m0.000s
sys     0m0.010s
```
Je peux seulement imaginer le Rubis de la bibliothèque utilise une méthode similaire.

Edit:

pour les Pax de la curiosité:
```
[john@awesome]$time cat 11M.txt | tail -n 25
/sbin/ypbind
/sbin/arptables
/sbin/arptables-save
/sbin/change_console
/sbin/mount.vmhgfs
/misc
/csait
/csait/course
/.autofsck
/~
/usb
/cdrom
/homebk
/staff
/staff/faculty
/staff/faculty/darlinr
/staff/csadm
/staff/csadm/service_monitor.sh
/staff/csadm/.bash_history
/staff/csadm/mysql5
/staff/csadm/mysql5/MySQL-server-community-5.0.45-0.rhel5.i386.rpm
/staff/csadm/glibc-common-2.3.4-2.39.i386.rpm
/staff/csadm/glibc-2.3.4-2.39.i386.rpm
/staff/csadm/csunixdb.tgz
/staff/csadm/glibc-headers-2.3.4-2.39.i386.rpm

real    0m0.350s
user    0m0.000s
sys     0m0.130s
```
encore moins d'une seconde, mais si il y a beaucoup d'opérations sur les fichiers de ce fait une grande différence.
- Que signifie "chat 11M.txt | tail-n 25" donnez-vous? Qui va les obliger à queue de traiter l'ensemble du flux.
- Ou tout simplement de chat 11M.txt >/dev/null pour cette question - qui va vous donner le temps de traiter le flux, ce qui pourrait être de l'ordre de 1/100e de seconde.
- Bugbear de la mine, @JohnT: "29 fois plus lent" de 100secs est -2800secs. La phrase correcte est "à peu près 1/29 de la vitesse". Mais je prends votre point clairement queue est à l'aide d'une méthode de recherche quand il a le fichier plutôt que d'un ruisseau. On pourrait l'espérer, Ruby est que smart.
- Ouais c'est ce que je voulais dire... les examens demain, je suis trop fatigué pour se concentrer =(
- Mentionné lien est mort. Vérifier github.com/flori/file-tail
InformationsquelleAutor John T
8

Version améliorée de manveru excellent cherchent à base de solution. Celle-ci rentre exactement n lignes.
```
class File

  def tail(n)
    buffer = 1024
    idx = [size - buffer, 0].min
    chunks = []
    lines = 0

    begin
      seek(idx)
      chunk = read(buffer)
      lines += chunk.count("\n")
      chunks.unshift chunk
      idx -= buffer
    end while lines < ( n + 1 ) && pos != 0

    tail_of_file = chunks.join('')
    ary = tail_of_file.split(/\n/)
    lines_to_return = ary[ ary.size - n, ary.size - 1 ]

  end
end
```
- Ce code fonctionne sur un Mac, mais échoue sur linux avec un message d'erreur "tail': undefined local variable or method "taille". Toutes les idées sur la façon de résoudre ce problème?
- Il n'est pas tenu de vérifier, ce qui signifie que vous pouvez lire finissez par la recherche d'un négatif idx. Aussi, ce n'est pas très bien optimisé pour un fichier avec des lignes très longues (c'est à dire, sauver les morceaux dans un prédestiné tampon). Posté une version qui prend en charge à la fois.
InformationsquelleAutor Donald Scott Wilde

J'ai juste écrit une rapide mise en oeuvre avec #seek:

class File
  def tail(n)
    buffer = 1024
    idx = (size - buffer).abs
    chunks = []
    lines = 0

    begin
      seek(idx)
      chunk = read(buffer)
      lines += chunk.count("\n")
      chunks.unshift chunk
      idx -= buffer
    end while lines < n && pos != 0

    chunks.join.lines.reverse_each.take(n).reverse.join
  end
end

File.open('rpn-calculator.rb') do |f|
  p f.tail(10)
end

En fait tout à votre recherche à base de code est proche, ce n'est pas tout à fait exact, car il n'a pas de bande de la part de la partie avant de la première \n. Voir la Réponse ci-dessous. 🙂
:11:dans tail': undefined method compter " pour nil:NilClass (NoMethodError)

InformationsquelleAutor manveru

Voici une version de la queue qui ne stocke aucune tampons en mémoire pendant que vous allez, mais utilise à la place de "pointeurs". Aussi n'est lié à la vérification de sorte que vous ne finissent pas la recherche à un décalage négatif (par exemple si vous avez plus à lire, mais moins que votre taille de bloc de gauche).

def tail(path, n)
  file = File.open(path, "r")
  buffer_s = 512
  line_count = 0
  file.seek(0, IO::SEEK_END)

  offset = file.pos # we start at the end

  while line_count <= n && offset > 0
    to_read = if (offset - buffer_s) < 0
                offset
              else
                buffer_s
              end

    file.seek(offset-to_read)
    data = file.read(to_read)

    data.reverse.each_char do |c|
      if line_count > n
        offset += 1
        break
      end
      offset -= 1
      if c == "\n"
        line_count += 1
      end
    end
  end

  file.seek(offset)
  data = file.read
end

des cas de test à https://gist.github.com/shaiguitar/6d926587e98fc8a5e301

Ce n'est pas de fermer le fichier.

InformationsquelleAutor Shai

4

Je ne peux pas se porter garant pour Ruby, mais la plupart de ces langues, suivez la C idiome de fichier I/o, Qui signifie il n'y a aucun moyen de faire ce que vous demandez à d'autres que la recherche. Cela prend généralement l'une des deux approches.
- De départ au début du fichier et de la numérisation de tout cela, le souvenir de la plus récente à 25 lignes. Puis, quand vous frappez la fin du fichier, imprimer.
- Une approche similaire, mais de tenter de rechercher une meilleure deviner l'emplacement de la première. Que signifie chercher à (par exemple) à la fin du fichier de moins de 4000 caractères, puis de faire exactement ce que vous avez fait dans la première approche, avec la condition que, si vous n'obtenez pas de 25 lignes, vous devez sauvegarder et essayez à nouveau (par exemple, à la fin du fichier de moins de 5000 caractères).
La deuxième voie est celle que je préfère car, si vous choisissez votre premier décalage avec sagesse, vous aurez presque certainement besoin d'un seul coup à elle. Les fichiers journaux ont toujours tendance à avoir résolu maximum les longueurs de ligne (je pense que les programmeurs ont toujours une propension à 80 colonnes des fichiers de temps après leur utilité s'est dégradée). J'ai tendance à choisir le nombre de lignes souhaité multiplié par 132 comme mon décalage.

Et à partir d'un rapide coup d'œil de Rubis docs en ligne, on dirait qu'il ne suivez la C idiome. Vous utilisez "ios.seek(25*-132,IO::SEEK_END)" si vous suivez mon conseil, puis de le lire en avant à partir de là.
- Tous mes terminaux et emacs tampons sont toujours de 80 colonnes de large; qui me permet de s'adapter à différentes côte à côte sur mon écran, ce qui est très utile.
- Je suis sûr que le IO#cherchent va être la solution optimale en terme de performance.
InformationsquelleAutor paxdiablo
0

Comment sur:
```
file = []
File.open("file.txt").each_line do |line|
  file << line
end

file.reverse.each_with_index do |line, index|
  puts line if index < 25
end
```
La performance serait terrible d'un gros fichier tel qu'il parcourt deux fois, la meilleure approche serait déjà mentionné lire le fichier et le stocker des 25 dernières lignes dans la mémoire et l'affichage de ceux-ci. Mais ce n'était qu'une alternative à la pensée.

InformationsquelleAutor nitecoder

Vous devez vous connecter pour publier un commentaire.