Ruby Language
Itération

Chaque

Ruby possède de nombreux types d'énumérateurs, mais le premier et le plus simple type d'énumérateur pour commencer est each . Nous imprimerons even ou odd pour chaque nombre entre 1 et 10 pour montrer comment each fonctionne.

Fondamentalement, il y a deux façons de faire passer les soi-disant blocks . Un block est un morceau de code passé qui sera exécuté par la méthode appelée. each méthode prend un block qu'elle appelle pour chaque élément de la collection d'objets sur laquelle elle a été appelée.

Il existe deux manières de transmettre un bloc à une méthode:

Méthode 1: Inline

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

C'est un moyen très compressé et ruby de résoudre ce problème. Décomposons cela pièce par pièce.

1. (1..10) est une plage de 1 à 10 inclus. Si nous voulions qu'il soit exclusif de 1 à 10 , nous écririons (1...10) .
2. .each est un énumérateur qui énumère each élément de l'objet sur lequel il agit. Dans ce cas, il agit sur each nombre de la plage.
3. { |i| puts i.even? ? 'even' : 'odd' } est le bloc de each instruction, qui peut encore être décomposé.
   1. |i| cela signifie que chaque élément de la plage est représenté dans le bloc par l'identifiant i .
   2. puts est une méthode de sortie dans Ruby qui a un saut de ligne automatique après chaque impression. (Nous pouvons utiliser print si nous ne voulons pas le saut de ligne automatique)
   3. i.even? vérifie si i pair. Nous aurions aussi pu utiliser i % 2 == 0 ; Cependant, il est préférable d'utiliser des méthodes intégrées.
   4. ? "even" : "odd" c'est l'opérateur ternaire de ruby. La manière dont un opérateur ternaire est construit est l' expression ? a : b . C'est court pour

   if expression
     a
   else
     b
   end
   

Pour un code supérieur à une ligne, le block doit être transmis en tant que multiline block .

Méthode 2: multiligne

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

Dans un multiline block le do remplace le support d'ouverture et la end remplace le crochet de fermeture du style en inline .

Ruby prend également en charge reverse_each. Il va parcourir le tableau en arrière.

@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"

Implémentation en classe

Enumerable est le module le plus populaire de Ruby. Son but est de vous fournir des méthodes itérables telles que la map , la select , la reduce , etc. Les classes qui utilisent Enumerable incluent Array , Hash , Range . Pour l'utiliser, vous devez include Enumerable et implémenter each .

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]

Carte

Renvoie l'objet modifié, mais l'objet d'origine reste tel qu'il était. Par exemple:

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

map! change l'objet d'origine:

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

Remarque: vous pouvez également utiliser collect pour faire la même chose.

Itérer sur des objets complexes

Tableaux

Vous pouvez itérer sur les tableaux imbriqués:

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

La syntaxe suivante est également autorisée:

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

Produira:

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

Hash

Vous pouvez parcourir les paires clé-valeur:

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

Produira:

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

Vous pouvez itérer simultanément les clés et les valeurs:

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

Produira:

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

Pour itérateur

Cela itère de 4 à 13 (inclus).

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

Nous pouvons également parcourir les tableaux en utilisant pour

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

for name in names
    puts name
end

Itération avec index

Parfois, vous voulez connaître la position ( index ) de l'élément en cours lors d'une itération sur un énumérateur. À cette fin, Ruby fournit la méthode with_index . Il peut être appliqué à tous les enquêteurs. Fondamentalement, en ajoutant with_index à une énumération, vous pouvez énumérer cette énumération. Index est transmis à un bloc comme deuxième argument.

[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 a un argument optionnel - le premier index qui est 0 par défaut:

[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]

Il existe une méthode spécifique each_with_index . La seule différence entre cela et each.with_index est que vous ne pouvez pas passer un argument à cela, donc le premier index est 0 tout le temps.

[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]