Ruby: ¿Hay algo así como Enumerable # drop que devuelve un enumerador en lugar de una matriz?

Question

Tengo algunos archivos grandes de ancho fijo y necesito soltar la línea del encabezado.

Seguir la pista de un iterador no parece muy idiomático.

# 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| ... } 

¿Qué es el modismo de Ruby para esto?

Answer 1

Si lo necesita más de una vez, puede escribir una extensión en 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

De la parte superior de mi cabeza, pero estoy seguro de que con un poco más investigación que hay una manera más elegante

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

cero Está bien que ... hizo un poco de investigación y esto podría ser mejor

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

Answer 3

Ésta es ligeramente más ordenado:

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

Dudo que esto sea idiomático, pero es simple.

f = File.open(filename) 
f.readline 
f.each_line do |x| 
    #... 
end 

Answer 5

Ahora que ha obtenido respuestas razonables, esta es una forma completamente diferente de manejarlo.

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) 

No es ni idiomático, ni terriblemente intuitivo la primera vez, pero es divertido!

Answer 6

Creo que va por buen camino con el Enumerador y soltar (1). Por alguna extraña razón, mientras que Enumerable define #drop, el Enumerator no. Aquí es un enumerador # caída de trabajo:

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