내가 막 일을 시작했을 때, 한 고급 엔지니어가 나와 함께 일했는데, 그는 진열 방면에서 무당이었다.수조를 처리할 때, 그는 나에게 간단명료한 코드를 작성하는 가장 좋은 기교를 가르쳐 주었다.다음은 제가 발견한 가장 유용한 방법입니다. 저는 처음부터 루비 도구상자에서 사용할 수 있다고 생각합니다.

each

map

flat_map

select

detect

reject

count

partition

with_index

chaining

만약 당신이 코드로 직접 이동하고 설명을 필요로 하지 않는다면, 밑에 있는 cheatsheet 을 검사하십시오.

각각

우리가 상술한 더욱 기이한 방법을 깊이 연구하기 전에 우리는 먼저 가장 기본적인each부터 시작해야 한다. each 는 그룹의 주어진 요소마다 블록을 호출합니다.완성되면 원시 그룹으로 돌아갑니다.마지막 부분은 매우 중요하기 때문에 쉽게 잊어버린다.Ruby와 한동안 함께 일했던 우리들도 때로는 그것을 잊어버릴 때가 있다.다음은 하나의 예다.

result = [1, 2, 3].each do |number|
  puts 'hi'
end

이 코드가 컨트롤러에서 실행될 때 다음과 같은 결과가 발생합니다.참고: 아래와 아래의 예에서 irb는 단지 내가 Ruby 콘솔에 있다는 것을 나타낸다.

irb:> result = [1, 2, 3].each do |number|
>   puts "hi #{number}"
> end
hi 1
hi 2
hi 3
=> [1, 2, 3]

수조의 모든 숫자에 대해 우리는 'hi' 를 인쇄하고 이 숫자를 더한다.그리고 전체 그룹을 훑어본 후에 원시 그룹을 되돌려줍니다.
내가 사용한 것은 위의 do/end 블록 표현법이지만, 당신은 블록에 대해 괄호 문법을 사용할 수 있다는 것을 기억하십시오. 아래와 같습니다.

irb:> result = [1, 2, 3].each{|number| puts "hi #{number}"}
hi 1
hi 2
hi 3
=> [1, 2, 3]

보시다시피 문법이 어떻든지 결과는 똑같습니다.이 안내서에서, 나는 코드와 논리를 더욱 쉽게 이해할 수 있도록 do/end 문법을 계속 사용할 것이다.그럼에도 불구하고 이 모든 방법은 괄호 문법과 함께 사용될 것이다.

지도.

Ruby를 처음 접했을 때 배열을 구성하고 싶을 때마다 다음과 같이 했습니다.

result = []
[1, 2, 3, 4].each do |number|
  result << number + 2
end
# result = [3, 4, 5, 6]

나는 곧 더 좋은 방법이 있다는 것을 알게 되었다. 그것은 바로 사용하는 것이다. map map 원시 그룹의 모든 요소를 블록으로 실행한 결과를 포함하는 새 그룹을 되돌려줍니다.다음 예는 다음과 같습니다.

result = [1, 2, 3, 4].map do |number|
  number + 2
end
# result = [3, 4, 5, 6]

우리는 원시 그룹의 모든 숫자에 2를 더한 다음, 이 결과를 새 그룹에 나누어 되돌려줍니다.이제 우리의 코드는 더욱 간결해졌다.

평면도

map 한 그룹의 결과를 수집하기에 매우 적합하지만, 플러그인 그룹을 비추려면 어떤 일이 일어날까요?이때flat_map가 도움이 되었다.플러그인 그룹이 있는 것을 발견하면 서명해야 할 수도 있습니다. flat_map예를 들어, 두 개의 플러그인 그룹을 포함하는 코드가 있다고 가정하십시오.

result = []
[1, 2, 3].each do |number|
  ['a', 'b', 'c'].each do |letter|
    result << "#{number}:#{letter}"
  end
end
# result = ["1:a", "1:b", "1:c", "2:a", "2:b", "2:c", "3:a", "3:b", "3:c"]

우리는 단급 진열을 얻었다. 이것은 우리가 원하는 것이지만, 우리가 어떻게 그것을 조일 수 있겠는가?사용해 봅시다map.

result = [1, 2, 3].map do |number|
  ['a', 'b', 'c'].map do |letter|
    "#{number}:#{letter}"
  end
end
# result = [["1:a", "1:b", "1:c"], ["2:a", "2:b", "2:c"], ["3:a", "3:b", "3:c"]]

응, 그건 우리가 원하는 게 아니야.네스트된 패턴을 생성하는 동안 평면 단일 레이어 패턴을 원합니다map.플러그인 그룹을 평평하게 하기 위해서 우리는 flat_map를 사용할 수 있다.

result = [1,2,3].flat_map do |number|
  ['a', 'b', 'c'].map do |letter|
    "#{number}:#{letter}"
  end
end
# result = ["1:a", "1:b", "1:c", "2:a", "2:b", "2:c", "3:a", "3:b", "3:c"]

flat_map 의 작업 원리는 map와 유사하며 블록의 결과를 하나의 그룹에 수집하지만 보상으로 평평하게 펼친다.엔진 덮개 아래flat_map는 concatenating의 모든 내부 어레이를 하나의 어레이로 결합합니다.flat_map를 사용하여 우리가 원하는 단일 그룹을 되돌려줍니다.

선택 항목

map 예와 유사하게 처음에 배열에서 요소를 조건부로 선택하려면, 예를 들어 모든 짝수를 선택하면 다음과 같이 합니다.

result = []
[1, 2, 3, 4].each do |number|
  result << number if number.even?
end
# result = [2, 4]

그것은 효과적이지만, 더욱 간결한 방법이 하나 더 있다. 그것은 바로 사용이다. select select 블록이 실제 값을 되돌려 주는 모든 요소를 포함하는 그룹을 되돌려줍니다.이것은 우리가 이렇게 위의 코드 블록을 다시 쓸 수 있다는 것을 의미한다.

result = [1, 2, 3, 4].select do |number|
  number.even?
end
# result = [2,4]

들키다

지금 우리는 그것을 한 단계 높여야 한다.만약 당신이 한 수조에서 모든 짝수를 얻고 싶지 않고, 단지 당신이 찾은 첫 번째 짝수만 얻고 싶다면?이를 위해 detect를 사용할 수 있습니다. detect 블록을true의 첫 번째 항목으로 되돌려줍니다.따라서 위와 유사한 코드 블록을 실행하지만 select 을 detect 로 바꾸면 첫 번째 짝수만 되돌려줍니다.

result = [1, 2, 3, 4].detect do |number|
  number.even?
end
# result = 2

여기서 주의해야 할 점은 우리가 지금 되돌아오는 것은 하나의 수조가 아니라 하나의 숫자이다.
그러나 만약 우리의 블록이 영원히 진실로 평가되지 않는다면 무슨 일이 일어날까요?만약 우리의 수조에 짝수가 없다면?이 경우 detect는 0으로 돌아갑니다.

result = [1, 3, 5, 7].detect do |number|
  number.even?
end
# result = nil

한 마디로 하면 detect 블록을true의 첫 번째 항목으로 되돌려주거나 블록에 아무런 항목이true로 계산되지 않으면nil로 되돌려줍니다.

거부

이제 select의 꼴찌, 즉 reject를 봅시다. reject 블록이 FALSE로 계산된 모든 항목을 반환합니다.그래서 이렇게 하는 것보다

result = []
[1, 2, 3, 4].each do |number|
  result << number if !number.even?
end
# result = [1, 3]

이러한 코드를 단순화하여 다음을 수행할 수 있습니다.

result = [1, 2, 3, 4].reject do |number|
  number.even?
end
# result = [1, 3]

이번에 우리는 모든 짝수가 아닌 숫자를 되돌려 줄 것이기 때문에 number.even?false를 되돌려 줄 것이다.

갈라놓다

우리는 방금 select와 reject를 사용하여 루비에서 그룹을 필터하는 두 가지 방법을 보았다.그러나 만약 당신이 직접 한 개의 수조를 두 개의 수조로 나누고 싶다면, 하나는 짝수에 쓰고, 하나는 홀수에 쓰려면 어떻게 해야 합니까?이를 실현하는 한 가지 방법은 다음과 같습니다.

even = [1, 2, 3, 4].select do |number|
  number.even?
end
# even = [2, 4]
odd = [1, 2, 3, 4].reject do |number|
  number.even?
end
# odd = [1, 3]

하지만 더 좋은 방법이 하나 더 있어요. 사용할 수 있어요partition!이번에는 자리를 뜨지 마세요. partition 는 두 개의 수조를 되돌려줍니다. 첫 번째는 블록이true로 계산된 원시 수조의 원소를 포함하고 두 번째는 나머지 원소를 포함합니다.즉, 위에서 설명한 내용을 다음과 같이 단순화할 수 있습니다.

result = [1, 2, 3, 4].partition do |number|
  number.even?
end
# result = [[2, 4], [1, 3]]

보시다시피 partition 는 두 개의 그룹을 되돌려줍니다. 하나는 짝수, 하나는 홀수.만약 우리가 even와 odd 변수를 분배하고 싶다면, 우리가 해야 할 일은

even = result.first
odd = result.last

그러나 네가 짐작할 수 있는 바와 같이 더 좋은 방법이 하나 더 있다!우리는 단일result 변수를 완전히 제거하고 다음과 같은 코드를 작성할 수 있다

even, odd = [1, 2, 3, 4].partition do |number|
  number.even?
end
# even = [2, 4] and odd = [1, 3]

이 문법은 자동으로 첫 번째 그룹을 even에 분배하고 두 번째 그룹을 odd에 분배한다.플러그인 그룹을 처리할 때, 이 그룹 분배 문법을 언제든지 사용할 수 있습니다.다음은 세 개의 수조를 어떻게 분해하는지의 예이다.

irb:> a, b, c = [[1], [2], [3]]
=> [[1], [2], [3]]
irb:> a
=> [1]
irb:> b
=> [2]
irb:> c
=> [3]

헤아리다

count는 어느 정도 자명한 것으로 기본적으로 수조의 원소수를 계산한다.

irb:> [1, 1, 2, 2, 3, 3].count
=> 6

하지만 더 많이 할 수 있다는 거 알아요?우선, 당신은 count 매개 변수를 전달할 수 있습니다.만약 count 매개 변수를 전달한다면, 이 매개 변수가 수조에 나타나는 횟수를 계산할 것이다.

irb:> [1, 1, 2, 2, 3, 3].count(1)
=> 2
irb:> ['a', 'a', 'b', 'c'].count('c')
=> 1

너도 count 한 구역을 통과할 수 있어!😲블록을 전달할 때 count 블록을true의 항목수로 계산하는 계수로 되돌려줍니다.

irb:> [1, 1, 2, 2, 3, 3].count do |number|
  number.odd?
end
=> 4

우리는 수조 중의 매 홀수를 모두 계수하였는데, 되돌아온 결과는 4였다.

인덱스

마지막으로 가장 중요하지 않은 것은 색인을 사용하여 그룹을 옮겨다니는 것에 대해 토론하고 싶다는 것이다.보통, 우리가 일련의 요소 중의 위치를 추적하려고 할 때, 우리는 이렇게 한다.

irb:> index = 0
irb:> ['a', 'b', 'c'].each do |letter|
  puts index
  index += 1
end
0
1
2

하지만 더 좋은 방법이 있다! with_index 을 each 와 함께 사용하거나, 제가 열거한 모든 방법을 사용해서 그룹의 위치를 추적할 수 있습니다.다음은 그것을 어떻게 사용하는지의 예들이다.(기억하십시오: 그룹 인덱스는 0부터 시작합니다.)😃)

irb:> ['a', 'b', 'c'].each.with_index do |letter, index|
  puts index
end
0
1
2

이 예에서, 우리는 단지 수조에서 교체되고, 모든 요소의 인덱스를 출력할 뿐이다.

result = ['a', 'b', 'c'].map.with_index do |letter, index|
  "#{letter}:#{index}"
end
# result = ["a:0", "b:1", "c:2"]

이 예에서, 우리는 map 방법을 사용하여 색인과 수조의 알파벳을 조합하여 새로운 수조를 형성한다.

result = ['a', 'b', 'c'].select.with_index do |letter, index|
  index == 2
end
# result = ["c"]

이 예는 좀 까다롭다.여기에서 우리는 색인을 사용하여 수조에서 색인이 2인 요소를 선택하는 것을 돕는다.이 예에서 이 요소는 "c"이다.

쇠사슬

제가 여러분께 남기고 싶은 마지막 지식은 위에 있는 모든 수조로 돌아가는 방법count과 detect을 제외하고는 모두 연결할 수 있다는 것입니다.이러한 예시에 대해 나는 괄호 표시법을 사용할 것이다. 왜냐하면 나는 왼쪽에서 오른쪽으로 링크를 읽는 방법이 위에서 아래로 읽는 것보다 더 쉽다고 생각하기 때문이다.
예를 들어, 다음과 같이 할 수 있습니다.

result = [1, 2, 3, 4].map{|n| n + 2}.select{|n| n.even?}.reject{|n| n == 6}.map{|n| "hi #{n}"} 
# result = ["hi 4"]

위에서 배운 바와 같이 우리는 이곳에서 발생한 일을 분석해 봅시다.
1)map 각 배열 요소에 2를 추가하고 반환[3, 4, 5, 6]2)select는 이 그룹에서 짝수만 선택하여 반환[4, 6]3)reject는 6과 같은 숫자를 모두 삭제하여 우리에게 남게 할 것이다[4]4) 기말고사map는 4까지'헤이'를 붙이고 돌아온다["hi 4"]

성공했어!!!!

축하해, 네가 종점에 도착했어!Ruby 코드를 작성할 때 이러한 배열 방법이 유용하다는 것을 알게 되기를 바랍니다.혹시 모르는 게 있으면 댓글로 알려주세요.이것은 내가 처음으로 교정을 쓴 것이기 때문에 나는 모든 피드백을 환영한다🤗

If you would like all of these code examples without the lengthy explanations checkout
우아하게 모으자!