Wie verhalte ich mich bei der ersten Iteration in einer Ruby-Schleife anders?

Ich benutze immer einen Zähler, um nach dem ersten item ( i==0) in einer Schleife zu suchen:

i = 0
my_array.each do |item|
  if i==0
    # do something with the first item
  end
  # common stuff
  i += 1
end

Gibt es eine elegantere Möglichkeit, dies zu tun (vielleicht eine Methode)?

Du kannst das:

my_array.each_with_index do |item, index|
    if index == 0
        # do something with the first item
    end
    # common stuff
end

Probieren Sie es auf ideone .

Die Verwendung each_with_index, wie andere beschrieben haben, würde gut funktionieren, aber aus Gründen der Abwechslung ist hier ein anderer Ansatz.

Wenn Sie etwas Spezifisches nur für das erste Element und etwas Allgemeines für alle Elemente einschließlich des ersten tun möchten, können Sie Folgendes tun:

# do something with my_array[0] or my_array.first
my_array.each do |e| 
  # do the same general thing to all elements 
end

Aber wenn Sie das Allgemeine mit dem ersten Element nicht tun möchten, können Sie Folgendes tun:

# do something with my_array[0] or my_array.first
my_array.drop(1).each do |e| 
  # do the same general thing to all elements except the first 
end

Arrays haben eine "each_with_index" -Methode, die für diese Situation praktisch ist:

my_array.each_with_index do |item, i|
  item.do_something if i==0
  #common stuff
end

Was am besten passt, hängt von der jeweiligen Situation ab.

Eine weitere Option (wenn Sie wissen, dass Ihr Array nicht leer ist):

# treat the first element (my_array.first)
my_array.each do | item |
   # do the common_stuff
end

each_with_indexvon Enumerable (Enumerable ist bereits mit Array gemischt, sodass Sie es problemlos auf einem Array aufrufen können):

irb(main):001:0> nums = (1..10).to_a
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):003:0> nums.each_with_index do |num, idx|
irb(main):004:1* if idx == 0
irb(main):005:2> puts "At index #{idx}, the number is #{num}."
irb(main):006:2> end
irb(main):007:1> end
At index 0, the number is 1.
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Wenn Sie das Array danach nicht benötigen:

ar = %w(reversed hello world)

puts ar.shift.upcase
ar.each{|item| puts item.reverse}

#=>REVERSED
#=>olleh
#=>dlrow

Ruby's Enumerable#injectbietet ein Argument, mit dem Sie bei der ersten Iteration einer Schleife etwas anderes tun können:

> l=[1,2,3,4]
=> [1, 2, 3, 4]
> l.inject(0) {|sum, elem| sum+elem}
=> 10

Das Argument ist für gängige Dinge wie Summen und Produkte nicht unbedingt erforderlich:

> l.inject {|sum, elem| sum+elem}
=> 10

Wenn Sie jedoch bei der ersten Iteration etwas anderes tun möchten , kann dieses Argument für Sie hilfreich sein:

> puts fruits.inject("I like to eat: ") {|acc, elem| acc << elem << " "}
I like to eat: apples pears peaches plums oranges 
=> nil

Hier ist eine Lösung, die sich nicht in einer sofort einschließenden Schleife befinden muss und die Redundanz vermeidet, einen Statusplatzhalter mehrmals anzugeben, es sei denn, Sie müssen dies wirklich tun.

do_this if ($first_time_only ||= [true]).shift

Sein Umfang entspricht dem Inhaber: $first_time_onlywird global einmal sein; @first_time_onlywird einmal für die Instanz und first_time_onlyeinmal für den aktuellen Bereich sein.

Wenn Sie die ersten mehrmals möchten, können Sie leicht sagen, [1,2,3]ob Sie unterscheiden müssen, in welcher der ersten Iterationen Sie sich befinden, oder sogar etwas Besonderes, [1, false, 3, 4]wenn Sie etwas Seltsames benötigen.