Ruby each_with_index offset

Kann ich den Offset des Index im Schleifeniterator each_with_index definieren? Mein direkter Versuch schlug fehl:

some_array.each_with_index{|item, index = 1| some_func(item, index) }

Bearbeiten:

Erläuterung: Ich möchte keinen Array-Offset. Ich möchte, dass der Index im each_with_index nicht bei 0 beginnt, sondern bei 1.

Tatsächlich Enumerator#with_indexerhält Offset als optionalen Parameter:

[:foo, :bar, :baz].to_enum.with_index(1).each do |elem, i|
  puts "#{i}: #{elem}"
end

Ausgänge:

1: foo
2: bar
3: baz

Übrigens denke ich, dass es nur in 1.9.2 da ist.

Das Folgende ist kurz und bündig mit Rubys Enumerator-Klasse.

[:foo, :bar, :baz].each.with_index(1) do |elem, i|
    puts "#{i}: #{elem}"
end

Ausgabe

1: foo
2: bar
3: baz

Array # gibt jeweils einen Enumerator zurück, und der Aufruf von Enumerator # with_index gibt einen anderen Enumerator zurück, an den ein Block übergeben wird.

1) Am einfachsten ist es, index+1anstelle indexder Funktion Folgendes zu ersetzen :

some_array.each_with_index{|item, index| some_func(item, index+1)}

aber wahrscheinlich ist das nicht was du willst.

2) Als Nächstes können Sie einen anderen Index jinnerhalb des Blocks definieren und anstelle des ursprünglichen Index verwenden:

some_array.each_with_index{|item, i| j = i + 1; some_func(item, j)}

3) Wenn Sie den Index häufig auf diese Weise verwenden möchten, definieren Sie eine andere Methode:

module Enumerable
  def each_with_index_from_one *args, &pr
    each_with_index(*args){|obj, i| pr.call(obj, i+1)}
  end
end

%w(one two three).each_with_index_from_one{|w, i| puts "#{i}. #{w}"}
# =>
1. one
2. two
3. three

Diese Antwort, die vor einigen Jahren beantwortet wurde, ist jetzt veraltet. Für moderne Rubine funktioniert die Antwort von Zack Xu besser.

Wenn dies some_indexirgendwie sinnvoll ist, sollten Sie einen Hash anstelle eines Arrays verwenden.

Ich bin darauf gestoßen.

Meine nicht notwendige Lösung ist die beste, aber sie hat nur bei mir funktioniert.

In der Ansichtsiteration:

füge einfach hinzu: index + 1

Das ist alles für mich, da ich keinen Verweis auf diese Indexnummern verwende, sondern nur zum Anzeigen in einer Liste.

Ja, du kannst

some_array[offset..-1].each_with_index{|item, index| some_func(item, index) }
some_array[offset..-1].each_with_index{|item, index| some_func(item, index+offset) }
some_array[offset..-1].each_with_index{|item, index| index+=offset; some_func(item, index) }

UPD

Außerdem sollte ich beachten, dass ein Offset, der größer als Ihre Array-Größe ist, einen Fehler verursacht. Weil:

some_array[1000,-1] => nil
nil.each_with_index => Error 'undefined method `each_with_index' for nil:NilClass'

Was können wir hier tun:

 (some_array[offset..-1]||[]).each_with_index{|item, index| some_func(item, index) }

Oder um Offset zu vorherrschen:

 offset = 1000
 some_array[offset..-1].each_with_index{|item, index| some_func(item, index) } if offset <= some_array.size

Das ist ein bisschen hacky

UPD 2

Soweit Sie Ihre Frage aktualisiert haben und jetzt keinen Array-Offset, sondern einen Index-Offset benötigen, funktioniert die @ sawa-Lösung für Sie einwandfrei

Ariel hat recht. Dies ist der beste Weg, um damit umzugehen, und es ist nicht so schlimm

ary.each_with_index do |a, i|
  puts i + 1
  #other code
end

Das ist völlig akzeptabel und besser als die meisten Lösungen, die ich dafür gesehen habe. Ich dachte immer, das ist es, wofür #inject ist ... na ja.

Ein anderer Ansatz ist zu verwenden map

some_array = [:foo, :bar, :baz]
some_array_plus_offset_index = some_array.each_with_index.map {|item, i| [item, i + 1]}
some_array_plus_offset_index.each{|item, offset_index| some_func(item, offset_index) }

Dies funktioniert in jeder Ruby-Version:

%W(one two three).zip(1..3).each do |value, index|
  puts value, index
end

Und für ein generisches Array:

a.zip(1..a.length.each do |value, index|
  puts value, index
end

offset = 2
some_array[offset..-1].each_with_index{|item, index| some_func(item, index+offset) }