Ruby: Czy istnieje coś takiego jak drop # #, który zwraca moduł wyliczający zamiast tablicy?

Question

Mam kilka dużych plików o stałej szerokości i muszę upuścić wiersz nagłówka.

Śledzenie iteratora nie wydaje się bardzo idiomatyczne.

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

Co to jest idiom Ruby?

Answer 1

Jeśli potrzebujesz go więcej niż raz, możesz napisać rozszerzenie do 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

Off górze mojej głowie, ale jestem pewien, że z jakiegoś dalszych badań jest bardziej elegancki sposób

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

... Ok zarysowania że zrobił trochę badań i to może być lepiej

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

Answer 3

to nieznacznie neater:

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

lub

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

Answer 4

Wątpię, czy to jest idiomatyczne, ale to proste.

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

Answer 5

Teraz, gdy uzyskałeś rozsądne odpowiedzi, oto zupełnie inny sposób radzenia sobie z tym.

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) 

Po raz pierwszy nie jest to idiomatyczne, ani strasznie intuicyjne, ale jest zabawne!

Answer 6

Myślę, że masz rację z Enumerator i upuść (1). Z jakiegoś dziwnego powodu, podczas gdy Enumerable definiuje #drop, Enumerator tego nie robi. Oto praca Enumerator # drop:

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