Ruby Language
Iteration

Jeder

Ruby hat viele Arten von Enumeratoren, aber die erste und einfachste Art von Enumerator ist each . Wir werden even oder odd für jede Zahl zwischen 1 und 10 ausdrucken, um zu zeigen, wie die each funktionieren.

Grundsätzlich gibt es zwei Wege, um sogenannte blocks . Ein block ist ein Code, der übergeben wird und von der aufgerufenen Methode ausgeführt wird. each Methode nimmt einen block den sie für jedes Element der Objektauflistung aufruft, für das sie aufgerufen wurde.

Es gibt zwei Möglichkeiten, einen Block an eine Methode zu übergeben:

Methode 1: Inline

(1..10).each { |i| puts i.even? ? 'even' : 'odd' }

Dies ist ein sehr komprimierter und rubinrischer Weg, um dies zu lösen. Lassen Sie uns das Stück für Stück abbauen.

1. (1..10) ist ein Bereich von 1 bis einschließlich 10 . Wenn wir wollten, dass es 1 bis 10 , schreiben wir (1...10) .
2. .each ist ein Enumerator, der each Element in dem Objekt .each dem er arbeitet. In diesem Fall wirkt es auf each Nummer im Bereich.
3. { |i| puts i.even? ? 'even' : 'odd' } ist der Block für each Anweisung, der selbst weiter zerlegt werden kann.
   1. |i| Dies bedeutet, dass jedes Element im Bereich durch den Bezeichner i innerhalb des Blocks dargestellt wird.
   2. puts ist eine Ausgabemethode in Ruby, die nach jedem Ausdruck einen automatischen Zeilenumbruch hat. (Wir können print wenn wir den automatischen Zeilenumbruch nicht möchten.)
   3. i.even? prüft, ob i gerade bin Wir hätten auch i % 2 == 0 ; Es ist jedoch vorzuziehen, integrierte Methoden zu verwenden.
   4. ? "even" : "odd" Dies ist Rubys ternärer Operator. Die Art und Weise, wie ein ternärer Operator aufgebaut ist, ist expression ? a : b . Das ist kurz für

   if expression
     a
   else
     b
   end
   

Bei Code, der länger als eine Zeile ist block sollte der block als multiline block .

Methode 2: Mehrzeilig

(1..10).each do |i|
  if i.even?
    puts 'even'
  else
    puts 'odd'
  end
end

In einem multiline block das do die öffnende Klammer und das end ersetzt die schließende Klammer vom inline Stil.

Ruby unterstützt auch reverse_each. Es wird das Array rückwärts iterieren.

@arr = [1,2,3,4]
puts @arr.inspect # output is [1,2,3,4]

print "Reversed array elements["
@arr.reverse_each do |val|
        print " #{val} " # output is 4 3 2 1
end
print "]\n"

Implementierung in einer Klasse

Enumerable ist das beliebteste Modul in Ruby. Ihr Zweck ist es, Sie mit iterierbaren Methoden wie map , select , reduce usw. Enumerable . Klassen, die Enumerable umfassen Array , Hash , Range . Um es zu verwenden, müssen Sie include Enumerable und each implementieren.

class NaturalNumbers
  include Enumerable

  def initialize(upper_limit)
    @upper_limit = upper_limit
  end

  def each(&block)
    0.upto(@upper_limit).each(&block)
  end
end

n = NaturalNumbers.new(6)

n.reduce(:+)                   # => 21
n.select(&:even?)              # => [0, 2, 4, 6]
n.map { |number| number ** 2 } # => [0, 1, 4, 9, 16, 25, 36]

Karte

Gibt das geänderte Objekt zurück, das ursprüngliche Objekt bleibt jedoch unverändert. Zum Beispiel:

arr = [1, 2, 3]
arr.map { |i| i + 1 } # => [2, 3, 4]
arr # => [1, 2, 3]

map! ändert das ursprüngliche Objekt:

arr = [1, 2, 3]
arr.map! { |i| i + 1 } # => [2, 3, 4]
arr # => [2, 3, 4]

Hinweis: Sie können auch mit collect dasselbe tun.

Iteration über komplexe Objekte

Arrays

Sie können verschachtelte Arrays durchlaufen:

[[1, 2], [3, 4]].each { |(a, b)| p "a: #{ a }", "b: #{ b }" }

Die folgende Syntax ist ebenfalls erlaubt:

[[1, 2], [3, 4]].each { |a, b| "a: #{ a }", "b: #{ b }" }

Wird herstellen:

"a: 1"
"b: 2"
"a: 3"
"b: 4"

Hashes

Sie können Schlüssel-Wert-Paare durchlaufen:

{a: 1, b: 2, c: 3}.each { |pair| p "pair: #{ pair }" }

Wird herstellen:

"pair: [:a, 1]"
"pair: [:b, 2]"
"pair: [:c, 3]"

Sie können Schlüssel und Werte gleichzeitig durchlaufen:

{a: 1, b: 2, c: 3}.each { |(k, v)| p "k: #{ k }", "v: #{ k }" }

Wird herstellen:

"k: a"
"v: a"
"k: b"
"v: b"
"k: c"
"v: c"

Für Iterator

Dies wiederholt sich von 4 bis einschließlich 13.

for i in 4..13
    puts "this is #{i}.th number"
end

Wir können auch Arrays mit for durchlaufen

names = ['Siva', 'Charan', 'Naresh', 'Manish']

for name in names
    puts name
end

Iteration mit Index

Manchmal möchten Sie die Position ( Index ) des aktuellen Elements beim Durchlaufen eines Enumerators erfahren. Zu diesem Zweck stellt Ruby die with_index Methode with_index . Es kann auf alle Enumeratoren angewendet werden. Durch Hinzufügen von with_index zu einer Enumeration können Sie diese Enumeration grundsätzlich with_index . Der Index wird als zweites Argument an einen Block übergeben.

[2,3,4].map.with_index { |e, i| puts "Element of array number #{i} => #{e}" }
#Element of array number 0 => 2
#Element of array number 1 => 3
#Element of array number 2 => 4
#=> [nil, nil, nil]

with_index hat ein optionales Argument - der erste Index ist standardmäßig 0 :

[2,3,4].map.with_index(1) { |e, i| puts "Element of array number #{i} => #{e}" }
#Element of array number 1 => 2
#Element of array number 2 => 3
#Element of array number 3 => 4
#=> [nil, nil, nil]

each_with_index gibt es eine bestimmte Methode. Der einzige Unterschied zwischen ihm und each.with_index besteht darin, dass Sie kein Argument an dieses übergeben können. each.with_index ist der erste Index immer 0 .

[2,3,4].each_with_index { |e, i| puts "Element of array number #{i} => #{e}" }
#Element of array number 0 => 2
#Element of array number 1 => 3
#Element of array number 2 => 4
#=> [2, 3, 4]