Ruby: c'è qualcosa come Enumerable # drop che restituisce un enumeratore invece di un array?

Question

Ho alcuni grandi file a larghezza fissa e ho bisogno di rilasciare la riga dell'intestazione.

Tenere traccia di un iteratore non sembra molto idiomatico.

# This is what I do now. 
File.open(filename).each_line.with_index do |line, idx| 
    if idx > 0 
    ... 
    end 
end 

# This is what I want to do but I don't need drop(1) to slurp 
# the file into an array. 
File.open(filename).drop(1).each_line do { |line| ... } 

Qual è l'idioma Ruby per questo?

Answer 1

Se è necessario più di una volta, è possibile scrivere un'estensione su Enumerator.

class Enumerator 
    def enum_drop(n) 
    with_index do |val, idx| 
     next if n == idx 
     yield val 
    end 
    end 
end 

File.open(testfile).each_line.enum_drop(1) do |line| 
    print line 
end 

# prints lines #1, #3, #4, … 

Answer 2

Fuori della parte superiore della mia testa, ma sono sicuro che con un po 'di ricerca c'è un modo più elegante

File.open(filename).each_line.to_a[1..-1].each{ |line|... } 

Va bene graffio che ... ha fatto un po' di ricerca, e questo potrebbe essere migliore

File.open(filename).each_line.with_index.drop_while{ |line,index| index == 0 }.each{ |line, index| ... } 

Answer 3

Questo è un po ' più ordinato:

File.open(fname).each_line.with_index do |line, lineno| 
    next if lineno == 0 
    # ... 
end 

o

io = File.open(fname) 
# discard the first line 
io.gets 
# process the rest of the file 
io.each_line {|line| ...} 
io.close 

Answer 4

Dubito che questo sia idiomatico, ma è semplice.

Answer 5

Ora che hai ottenuto risposte ragionevoli, ecco un modo completamente diverso di gestirlo.

class ProcStack 
    def initialize(&default) 
    @block = default 
    end 
    def push(&action) 
    prev = @block 
    @block = lambda do |*args| 
     @block = prev 
     action[*args] 
    end 
    self 
    end 
    def to_proc 
    lambda { |*args| @block[*args] } 
    end 
end 
#... 
process_lines = ProcStack.new do |line, index| 
    puts "processing line #{index} => #{line}" 
end.push do |line, index| 
    puts "skipping line #{index} => #{line}" 
end 
File.foreach(filename).each_with_index(&process_lines) 

Non è né idiomatico né terribilmente intuitivo la prima volta, ma è divertente!

Answer 6

Penso che tu sia sulla buona strada con l'Enumeratore e rilascia (1). Per qualche strana ragione, mentre Enumerable definisce #drop, Enumerator no. Ecco un lavoro Enumerator # goccia:

class Enumerator 
    def drop(n_arg) 
     n = n_arg.to_i # nil becomes zero 
     raise ArgumentError, "n must be positive" unless n > 0 
     Enumerator.new do |yielder| 
     self.each do |val| 
      if n > 0 
      n -= 1 
      else 
      yielder << val 
      end 
     end 
     end 
    end 
    end