Ruby Language
Iteration

Varje

Ruby har många typer av teller men den första och enklaste typen av teller till att börja med är each . Vi kommer att skriva ut even eller odd för varje nummer mellan 1 och 10 att visa hur each fungerar.

I princip finns det två sätt att passera så kallade blocks . Ett block är ett kodstycke som skickas som kommer att köras med den metod som kallas. each metod tar ett block som det kräver för varje element i insamlingen av objekt som den kallades på.

Det finns två sätt att överföra ett block till en metod:

Metod 1: Inline

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

Detta är ett mycket komprimerat och rubinrikt sätt att lösa detta. Låt oss bryta ned detta bit för bit.

1. (1..10) är ett intervall från 1 till 10 inklusive. Om vi ville att det skulle vara 1 till 10 exklusivt skulle vi skriva (1...10) .
2. .each är en uppräknare som räknar upp each element i objektet det agerar på. I det här fallet verkar det på each nummer i intervallet.
3. { |i| puts i.even? ? 'even' : 'odd' } är blocket för each uttalande, som själv kan delas ytterligare ned.
   1. |i| detta betyder att varje element i intervallet representeras i blocket av identifieraren i .
   2. puts är en utgångsmetod i Ruby som har ett automatiskt linjestopp efter varje gång det skrivs ut. (Vi kan använda print om vi inte vill ha det automatiska linjeavbrottet)
   3. i.even? kontrollerar om i är jämn. Vi kunde också ha använt i % 2 == 0 ; emellertid är det att föredra att använda inbyggda metoder.
   4. ? "even" : "odd" här är rubins ternära operatör. Hur en ternär operatör är konstruerad är expression ? a : b . Detta är förkortat

   if expression
     a
   else
     b
   end
   

För kod längre än en rad ska block ges som ett multiline block .

Metod 2: Multiline

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

I ett multiline block ersätter do öppningsfästet och end ersätter stängningsfästet från inline stilen.

Ruby stöder även reverse_each. Det kommer att upprepa matrisen bakåt.

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

Implementering i en klass

Enumerable är den mest populära modulen i Ruby. Syftet är att ge dig iterable metoder som map , select , reduce , etc. Klasser som använder Enumerable inkluderar Array , Hash , Range . För att använda det måste du include Enumerable och implementera 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]

Karta

Returnerar det ändrade objektet, men det ursprungliga objektet förblir som det var. Till exempel:

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

map! ändrar det ursprungliga objektet:

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

Obs! Du kan också använda collect att göra samma sak.

Iterera över komplexa föremål

arrayer

Du kan iterera över kapslade matriser:

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

Följande syntax är också tillåtet:

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

Kommer att producera:

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

hashes

Du kan iterera över nyckelvärdespar:

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

Kommer att producera:

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

Du kan iterera över nycklar och värden samtidigt:

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

Kommer att producera:

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

För iterator

Detta upprepas från 4 till 13 (inklusive).

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

Vi kan också iterera över arrayer som används för

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

for name in names
    puts name
end

Iteration med index

Ibland vill du veta positionen ( indexet ) för det aktuella elementet medan du itererar över en teller. För sådana ändamål tillhandahåller Ruby with_index metoden. Det kan tillämpas på alla uppräknare. I grund och botten, genom att lägga till with_index till en uppräkning, kan du räkna upp den uppräkningen. Index skickas till ett block som det andra argumentet.

[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 har ett valfritt argument - det första indexet som är 0 standard:

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

Det finns en specifik metod each_with_index . Den enda skillnaden mellan den och each.with_index är att du inte kan skicka ett argument till det, så det första indexet är 0 hela tiden.

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