Ruby Language
되풀이

마다

루비에는 여러 유형의 열거 자 (enumerator)가 있지만 처음부터 가장 간단한 열거 자 유형이 each 있습니다. 우리는 인쇄 할 even 또는 odd 사이에 각 번호에 대해 1 과 10 방법을 보여 each 작품.

기본적으로 소위 blocks 을 전달하는 두 가지 방법이 있습니다. block 은 호출되는 메소드에 의해 실행될 코드 조각입니다. each 메소드는 호출 된 객체 컬렉션의 모든 요소를 ​​호출하는 block 을 사용합니다.

메서드에 블록을 전달하는 방법에는 두 가지가 있습니다.

방법 1 : 인라인

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

이것은 이것을 압축하기위한 매우 압축 된 루비 방법이다. 이것을 한 장씩 나누어 봅시다.

1. (1..10) 은 1 에서 10 까지의 범위입니다. 1 에서 10 배타적으로 사용하기를 원한다면 (1...10) 쓸 것입니다.
2. .each 는 .each 개체의 each 요소를 열거하는 열거 자입니다. 이 경우 범위 내의 each 숫자에 each 작동합니다.
3. { |i| puts i.even? ? 'even' : 'odd' } 는 each 문장에 대한 블록이며, 그 자체가 더 세분화 될 수 있습니다.
   1. |i| 이는 범위 내의 각 요소가 식별자 i 블록 내에서 표현된다는 것을 의미합니다.
   2. puts 는 출력 할 때마다 자동 줄 바꿈이있는 Ruby의 출력 메소드입니다. (자동 줄 바꿈을 원하지 않으면 print 을 사용할 수 있습니다)
   3. i.even? i 짝수인지 확인합니다. i % 2 == 0 사용할 수도있었습니다. 그러나 내장 된 방법을 사용하는 것이 바람직합니다.
   4. ? "even" : "odd" 이것은 루비의 삼항 연산자입니다. 삼항 연산자가 생성되는 방식은 expression ? a : b . 이것은

   if expression
     a
   else
     b
   end
   

한 줄 이상 코드에 대한 block A와 전달되어야 multiline block .

방법 2 : 다중 행

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

multiline block 에서 do 는 여는 괄호를 대체하고 end 는 inline 스타일의 닫는 괄호를 대체합니다.

Ruby는 reverse_each도 지원합니다. 배열을 거꾸로 반복합니다.

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

수업에서의 구현

Enumerable 은 Ruby에서 가장 인기있는 모듈입니다. 이 클래스의 목적은 map , select , reduce 등의 반복 가능한 메소드를 제공하는 것입니다. Enumerable 을 사용하는 클래스에는 Array , Hash , Range 됩니다. 그것을 사용하려면 include Enumerable 을 include Enumerable 하고 each 구현해야 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]

지도

변경된 객체를 반환하지만 원래 객체는 그대로 유지됩니다. 예 :

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

map! 원래 객체를 변경합니다.

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

참고 : collect 를 사용하여 동일한 작업을 수행 할 수도 있습니다.

복잡한 객체 반복

배열

중첩 된 배열을 반복 할 수 있습니다.

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

다음 구문도 허용됩니다.

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

생산할 것입니다 :

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

해시

키 - 값 쌍을 반복 할 수 있습니다.

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

생산할 것입니다 :

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

키와 값을 동시에 반복 할 수 있습니다.

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

생산할 것입니다 :

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

반복자의 경우

이 과정은 4에서 13까지 반복됩니다.

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

또한 다음을 사용하여 배열을 반복 할 수 있습니다.

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

for name in names
    puts name
end

인덱스 반복

때로는 열거자를 반복하면서 현재 요소의 위치 ( 인덱스 )를 알고 싶을 수도 있습니다. 이러한 목적을 위해 Ruby는 with_index 메소드를 제공합니다. 모든 열거 자에게 적용 할 수 있습니다. 기본적으로 열거 형에 with_index 를 추가하여 해당 열거 형을 열거 할 수 있습니다. 인덱스는 두 번째 인수로 블록에 전달됩니다.

[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 에는 선택적 인수가 있습니다. 첫 번째 색인은 기본적으로 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 있습니다. 그것과 each.with_index 의 유일한 차이점은 인수를 넘길 수 없다는 것입니다. 따라서 첫 번째 인덱스는 항상 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]