Ruby Language
배열

통사론

• a = [] # 배열 리터럴 사용
• a = Array.new # 리터럴을 사용하는 것과 같습니다.
• a = Array.new (5) # 값이 nil 인 5 개의 요소가있는 배열을 만듭니다.
• a = Array.new (5, 0) # 5 개의 원소를 갖는 배열을 디폴트 값 0으로 생성합니다.

#지도

Enumerable에서 제공하는 #map 은 각 요소에서 블록을 호출하고 결과를 수집하여 배열을 만듭니다.

[1, 2, 3].map { |i| i * 3 }
# => [3, 6, 9]

['1', '2', '3', '4', '5'].map { |i| i.to_i }
# => [1, 2, 3, 4, 5]

원래 배열은 수정되지 않습니다. 소스 값과 같은 순서로 변환 된 값을 포함하는 새 배열이 리턴됩니다. map! 원래 배열을 수정하려는 경우 사용할 수 있습니다.

map 메소드에서 메소드를 호출하거나 proc을 array의 모든 요소에 사용할 수 있습니다.

# call to_i method on all elements
%w(1 2 3 4 5 6 7 8 9 10).map(&:to_i)
# => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# using proc (lambda) on all elements
%w(1 2 3 4 5 6 7 8 9 10).map(&->(i){ i.to_i * 2})
# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

map 은 collect 와 동의어입니다.

리터럴 생성자 []로 배열 만들기

배열은 대괄호 ( [ 및 ] )로 요소 목록을 묶어서 만들 수 있습니다. 이 표기법의 배열 요소는 쉼표로 구분됩니다.

array = [1, 2, 3, 4]

배열에는 유형에 제한이없는 모든 종류의 객체가 포함될 수 있습니다.

array = [1, 'b', nil, [3, 4]]

문자열 배열 만들기

문자열 배열은 루비의 백분율 문자열 구문을 사용하여 만들 수 있습니다.

array = %w(one two three four)

이것은 배열을 다음과 같이 정의하는 것과 기능면에서 동일합니다.

array = ['one', 'two', 'three', 'four']

%w() 대신 %w{...} , %w[...] 또는 %w<...> 와 같은 다른 구분자 쌍을 사용할 수 있습니다.

다음과 같이 임의의 영숫자가 아닌 구분 기호를 사용할 수도 있습니다. %w!...! , %w#...# 또는 %w@...@ .

%W 대신 사용될 수 %w 문자열 보간을 통합. 다음을 고려하세요:

var = 'hello'

%w(#{var}) # => ["\#{var}"]
%W(#{var}) # => ["hello"]

여러 단어는 \를 사용하여 이스케이프 처리하여 해석 할 수 있습니다.

%w(Colorado California New\ York) # => ["Colorado", "California", "New York"]

심볼 배열 만들기

array = %i(one two three four)

배열 [:one, :two, :three, :four] 만듭니다.

%i(...) 대신 %i{...} 또는 %i[...] 또는 %i!...!

또한 보간법을 사용하려면 %I 이것을 수행 할 수 있습니다.

a = 'hello'
b = 'goodbye'
array_one = %I(#{a} #{b} world)
array_two = %i(#{a} #{b} world)

array_one = [:hello, :goodbye, :world] 및 array_two = [:"\#{a}", :"\#{b}", :world]

Array :: new로 배열 만들기

빈 Array ( [] )는 Array 클래스 메서드 인 Array::new 하여 만들 수 있습니다.

Array.new    

배열의 길이를 설정하려면 숫자 인수를 전달하십시오.

Array.new 3 #=> [nil, nil, nil]

배열에 기본값을 채우는 방법에는 두 가지가 있습니다.

• 두 번째 인수로 변경할 수없는 값을 전달하십시오.
• 현재 색인을 가져 와서 변경 가능한 값을 생성하는 블록을 전달하십시오.

Array.new 3, :x #=> [:x, :x, :x]

Array.new(3) { |i| i.to_s } #=> ["0", "1", "2"]

a = Array.new 3, "X"            # Not recommended.
a[1].replace "C"                # a => ["C", "C", "C"]

b = Array.new(3) { "X" }        # The recommended way.
b[1].replace "C"                # b => ["X", "C", "X"]

배열 요소 조작

요소 추가 :

[1, 2, 3] << 4
# => [1, 2, 3, 4]

[1, 2, 3].push(4)
# => [1, 2, 3, 4]

[1, 2, 3].unshift(4)
# => [4, 1, 2, 3]

[1, 2, 3] << [4, 5]
# => [1, 2, 3, [4, 5]]

요소 제거 :

array = [1, 2, 3, 4]
array.pop
# => 4
array
# => [1, 2, 3]

array = [1, 2, 3, 4]
array.shift
# => 1
array
# => [2, 3, 4]

array = [1, 2, 3, 4]
array.delete(1)
# => 1
array
# => [2, 3, 4]

array = [1,2,3,4,5,6]
array.delete_at(2) // delete from index 2
# => 3  
array 
# => [1,2,4,5,6] 


array = [1, 2, 2, 2, 3]
array - [2]
# => [1, 3]    # removed all the 2s
array - [2, 3, 4]
# => [1]       # the 4 did nothing

배열 결합 :

[1, 2, 3] + [4, 5, 6]
# => [1, 2, 3, 4, 5, 6]

[1, 2, 3].concat([4, 5, 6])
# => [1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6] - [2, 3]
# => [1, 4, 5, 6]

[1, 2, 3] | [2, 3, 4]
# => [1, 2, 3, 4]

[1, 2, 3] & [3, 4]
# => [3]

배열을 곱할 수도 있습니다.

[1, 2, 3] * 2
# => [1, 2, 3, 1, 2, 3]

배열 조합, 교차점 및 차이점

x = [5, 5, 1, 3]
y = [5, 2, 4, 3]

Union ( | )에는 중복 제거 된 두 배열의 요소가 포함되어 있습니다.

x | y
=> [5, 1, 3, 2, 4]

교차 ( & )는 첫 번째 배열과 두 번째 배열에 모두 존재하는 요소를 포함합니다.

x & y
=> [5, 3]

차이점 ( - )은 첫 번째 배열에 있고 두 번째 배열에는없는 요소를 포함합니다.

x - y
=> [1]

배열 필터링

종종 특정 조건을 충족하는 배열 요소에서만 작동하기를 원합니다.

고르다

특정 조건과 일치하는 요소를 반환합니다.

array = [1, 2, 3, 4, 5, 6]
array.select { |number| number > 3 } # => [4, 5, 6]

받지 않다

특정 조건과 일치하지 않는 요소를 반환합니다.

array = [1, 2, 3, 4, 5, 6]
array.reject { |number| number > 3 } # => [1, 2, 3]

#select 와 #reject 모두 배열을 반환하므로 연결될 수 있습니다.

array = [1, 2, 3, 4, 5, 6]
array.select { |number| number > 3 }.reject { |number| number < 5 }
  # => [5, 6]

주입, 감소

주입과 줄이기는 똑같은 이름입니다. 다른 언어에서는 이러한 함수를 foldl (foldl 또는 foldr와 같은)이라고도합니다. 이러한 메서드는 모든 Enumerable 개체에서 사용할 수 있습니다.

Inject는 두 개의 인수 함수를 취해 배열의 모든 요소 쌍에 적용합니다.

배열 [1, 2, 3] 대해 시작 값과 블록을 지정하여 이러한 모든 값을 0의 시작 값과 함께 추가 할 수 있습니다.

[1,2,3].reduce(0) {|a,b| a + b} # => 6

여기서는 함수에 시작 값과 모든 값을 함께 추가하는 블록을 전달합니다. 블록은 함께 제 실행 0 으로서 과 a 1 로 b 는 그 결과를 얻어, 다음과 같은 있으므로 후 추가 a 1 번째 값 2 . 그리고 우리는 그 결과를 가지고 ( 3 ) 및 목록 (도에서 최종 요소에 그에 추가 3 우리에게 우리의 결과 (부여) 6 ).

첫 번째 인수를 생략하면 a 가 목록의 첫 번째 요소가되도록 설정하므로 위의 예는 다음과 같습니다.

[1,2,3].reduce {|a,b| a + b} # => 6

또한 함수가있는 블록을 전달하는 대신 명명 된 함수를 시작 값 또는 기호없이 기호로 전달할 수 있습니다. 이것으로 위의 예제는 다음과 같이 작성할 수 있습니다.

[1,2,3].reduce(0, :+) # => 6

또는 시작 값을 생략하십시오.

[1,2,3].reduce(:+) # => 6

요소에 액세스하기

인덱스의 배열을 사용하여 배열의 요소에 액세스 할 수 있습니다. 배열 색인 번호 매기기는 0 에서 시작합니다.

%w(a b c)[0] # => 'a'
%w(a b c)[1] # => 'b'

범위를 사용하여 배열을자를 수 있습니다.

%w(a b c d)[1..2] # => ['b', 'c'] (indices from 1 to 2, including the 2)
%w(a b c d)[1...2] # => ['b'] (indices from 1 to 2, excluding the 2)

이렇게하면 새 배열이 반환되지만 원본에는 영향을주지 않습니다. 루비는 또한 부정적인 인덱스의 사용을 지원합니다.

%w(a b c)[-1] # => 'c'
%w(a b c)[-2] # => 'b'

음수 및 양수 색인도 결합 할 수 있습니다.

%w(a b c d e)[1...-1] # => ['b', 'c', 'd']

기타 유용한 방법

first 번째 요소를 사용하여 배열의 첫 번째 요소에 액세스합니다.

[1, 2, 3, 4].first # => 1

또는 배열에서 반환 된 첫 번째 n 요소에 액세스하려면 first(n) 을 입력합니다.

[1, 2, 3, 4].first(2) # => [1, 2]

마찬가지로 last 와 last(n) 대해서 :

[1, 2, 3, 4].last    # => 4
[1, 2, 3, 4].last(2) # => [3, 4]

sample 을 사용하여 배열의 임의의 요소에 액세스하십시오.

[1, 2, 3, 4].sample  # => 3
[1, 2, 3, 4].sample  # => 1

또는 sample(n) :

[1, 2, 3, 4].sample(2) # => [2, 1]
[1, 2, 3, 4].sample(2) # => [3, 4]

2 차원 배열

Array::new 생성자를 사용하면 주어진 크기와 각 슬롯에 새로운 배열로 배열을 초기화 할 수 있습니다. 내부 배열에는 크기와 초기 값을 지정할 수 있습니다.

예를 들어, 3x4 배열을 만들려면 다음과 같이하십시오.

array = Array.new(3) { Array.new(4) { 0 } }

위에 생성 된 배열은 p 인쇄 할 때 다음과 같이 보입니다.

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

다음과 같이 요소를 읽거나 쓸 수 있습니다.

x = array[0][1]
array[2][3] = 2

배열 및 표시 연산자 (*)

* 연산자는 변수와 배열을 언팩하여 개별 인수로 메소드에 전달할 수 있습니다.

이것은 배열에 하나의 객체를 래핑하는 데 사용할 수 있습니다 (아직없는 경우).

def wrap_in_array(value)
  [*value]
end

wrap_in_array(1)
#> [1]

wrap_in_array([1, 2, 3])
#> [1, 2, 3]

wrap_in_array(nil)
#> []

위의 예제에서 wrap_in_array 메서드는 하나의 인수 value 허용 value .

value 가 Array 경우 해당 요소가 압축 해제되고 해당 요소가 포함 된 새 배열이 만들어집니다.

value 가 단일 객체이면 해당 단일 객체를 포함하는 새 배열이 만들어집니다.

value 이 nil 이면 빈 배열이 반환됩니다.

splat 연산자는 경우에 따라 메서드에서 인수로 사용하면 특히 편리합니다. 예를 들어, nil , 단일 값 및 배열을 일관된 방식으로 처리 할 수 ​​있습니다.

def list(*values)
  values.each do |value|
    # do something with value
    puts value
  end
end

list(100)
#> 100

list([100, 200])
#> 100
#> 200

list(nil)
# nothing is outputted

분해

모든 요소는 요소를 여러 변수에 할당하여 신속하게 분해 할 수 있습니다. 간단한 예 :

arr = [1, 2, 3]
# ---
a = arr[0]
b = arr[1]
c = arr[2]
# --- or, the same
a, b, c = arr

splat 연산자 ( * )로 변수를 선행하면 다른 변수에 포착되지 않은 모든 요소의 배열이 입력됩니다. 아무 것도 남지 않으면 빈 배열이 할당됩니다. 하나의 스 플랫 만 단일 할당에 사용할 수 있습니다.

a, *b = arr       # a = 1; b = [2, 3]
a, *b, c = arr    # a = 1; b = [2]; c = 3
a, b, c, *d = arr # a = 1; b = 2; c = 3; d = []
a, *b, *c = arr   # SyntaxError: unexpected *

분해는 안전 하며 오류를 발생시키지 않습니다. nil 은 충분한 원소가없는 곳에서 할당되고, 범위를 벗어난 인덱스에 액세스 할 때 [] 연산자의 동작과 일치합니다.

arr[9000] # => nil
a, b, c, d = arr # a = 1; b = 2; c = 3; d = nil

분해는 할당 된 객체에 대해 to_ary 암묵적으로 호출하려고 시도합니다. 당신의 타입에이 메소드를 구현하면 그것을 분해 할 수 있습니다 :

class Foo
  def to_ary
    [1, 2]
  end
end
a, b = Foo.new # a = 1; b = 2

분해되는 객체가 respond_to? 가 아닌 경우 respond_to? to_ary 는 단일 요소 배열로 처리됩니다.

1.respond_to?(:to_ary) # => false
a, b = 1 # a = 1; b = nil

분해 () decomposition () 는 다른 원소 대신에 () delimited decomposition expression을 사용하여 중첩 될 수 있습니다 :

arr = [1, [2, 3, 4], 5, 6]
a, (b, *c), *d = arr # a = 1; b = 2; c = [3, 4]; d = [5, 6]
#   ^^^^^

이것은 실제로 표시 의 반대입니다.

실제로, 분해 표현은 () 로 구분할 수 있습니다. 그러나 첫 번째 레벨의 분해는 선택 사항입니다.

a, b = [1, 2]
(a, b) = [1, 2] # the same thing

엣지 경우 : 하나의 식별자 는 외부 또는 중첩 된 패턴 일 수있는 구조 패턴으로 사용할 수 없습니다.

(a) = [1] # SyntaxError
a, (b) = [1, [2]] # SyntaxError

destructuring 표현식에 배열 리터럴 을 할당 할 때 outer [] 를 생략 할 수 있습니다.

a, b = [1, 2]
a, b =  1, 2  # exactly the same

이것은 병렬 할당 이라고 알려져 있지만, 후드에서 동일한 분해를 사용합니다. 이는 임시 변수를 추가하지 않고 변수의 값을 교환 할 때 특히 유용합니다.

t = a; a = b; b = t # an obvious way
a, b = b, a         # an idiomatic way
(a, b) = [b, a]     # ...and how it works

할당의 오른쪽을 작성할 때 값이 캡처되므로 소스 및 대상과 동일한 변수를 사용하는 것이 상대적으로 안전합니다.

다차원 배열을 1 차원 배열로 바꾸기

[1, 2, [[3, 4], [5]], 6].flatten  # => [1, 2, 3, 4, 5, 6]

다차원 배열이 있고 간단한 (즉 1 차원) 배열로 만들 필요가있는 경우 #flatten 메서드를 사용할 수 있습니다.

고유 한 배열 요소 가져 오기

반복 을 피하기 위해 배열 요소를 읽을 필요가있는 경우에는 #uniq 메서드를 사용하십시오.

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq
#=> [1, 2, 3, 4, 5]

대신 배열에서 모든 복제 된 요소를 제거하려면 #uniq! 사용할 수 있습니다 #uniq! 방법:

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq!
#=> [1, 2, 3, 4, 5]

출력은 동일하지만 #uniq! 또한 새 배열을 저장합니다.

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq
#=> [1, 2, 3, 4, 5]
a
#=> [1, 1, 2, 3, 4, 4, 5]

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq!
#=> [1, 2, 3, 4, 5]
a
#=> [1, 2, 3, 4, 5]

배열의 모든 조합 / 순열 가져 오기

블록과 함께 호출 될 때 permutation 법은 숫자 집합의 순서화 된 모든 시퀀스로 구성된 2 차원 배열을 생성합니다.

이 메서드가 블록없이 호출되면 enumerator 반환합니다. 배열로 변환하려면 to_a 메소드를 호출하십시오.

반면에 combination 방법은 블록과 함께 호출 될 때 숫자 컬렉션의 모든 시퀀스로 구성된 2 차원 배열을 생성합니다. 순열과 달리, 순서는 조합에서 무시됩니다. 예를 들어, [1,2,3] 은 [3,2,1] 과 같습니다 [3,2,1]

조합 메서드를 단독으로 호출하면 열거자가 생성됩니다. 배열을 얻으려면 to_a 메서드를 호출하십시오.

repeated_combination 및 repeated_permutation 메서드는 동일하지만 동일한 요소를 여러 번 반복 할 수 있다는 점만 다릅니다.

예를 들어, 시퀀스 [1,1] , [1,3,3,1] , [3,3,3] 은 규칙적인 조합과 순열에서 유효하지 않습니다.

연속 된 숫자 또는 문자 배열 만들기

이는 Range 객체에서 Enumerable#to_a 를 호출하여 쉽게 수행 할 수 있습니다.

(1..10).to_a    #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

(a..b) 는 a와 b 사이의 모든 숫자를 포함한다는 것을 의미합니다. 마지막 번호를 제외하려면 a...b 사용 a...b

a_range = 1...5
a_range.to_a       #=> [1, 2, 3, 4]

또는

('a'..'f').to_a    #=> ["a", "b", "c", "d", "e", "f"]
('a'...'f').to_a   #=> ["a", "b", "c", "d", "e"]

배열을 만드는 편리한 단축키는 [*a..b]

[*1..10]           #=> [1,2,3,4,5,6,7,8,9,10]
[*'a'..'f']        #=> ["a", "b", "c", "d", "e", "f"]

#compact를 사용하여 배열에서 모든 nil 요소 제거

배열에 하나 이상의 nil 요소가 nil 요소를 제거해야하는 경우 Array#compact 또는 Array#compact! 다음과 같이 메소드를 사용할 수 있습니다.

array = [ 1, nil, 'hello', nil, '5', 33]

array.compact # => [ 1, 'hello', '5', 33]

#notice that the method returns a new copy of the array with nil removed,
#without affecting the original

array = [ 1, nil, 'hello', nil, '5', 33]

#If you need the original array modified, you can either reassign it

array = array.compact # => [ 1, 'hello', '5', 33]

array = [ 1, 'hello', '5', 33]

#Or you can use the much more elegant 'bang' version of the method

array = [ 1, nil, 'hello', nil, '5', 33]

array.compact # => [ 1, 'hello', '5', 33]

array = [ 1, 'hello', '5', 33]

마지막으로 #compact 또는 #compact! nil 요소가없는 배열에서 호출되면 nil을 반환합니다.

array = [ 'foo', 4, 'life']

array.compact # => nil

array.compact! # => nil

숫자 배열 만들기

숫자 배열을 만드는 일반적인 방법은 다음과 같습니다.

numbers = [1, 2, 3, 4, 5]

Range 객체는 숫자 배열을 생성하는 데 광범위하게 사용할 수 있습니다.

numbers = Array(1..10) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

numbers = (1..10).to_a # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#step 및 #map 메소드를 사용하면 숫자 범위에 조건을 부과 할 수 있습니다.

odd_numbers = (1..10).step(2).to_a # => [1, 3, 5, 7, 9]

even_numbers = 2.step(10, 2).to_a # => [2, 4, 6, 8, 10]

squared_numbers = (1..10).map { |number| number * number } # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

위의 모든 메소드는 숫자를 열심히로드합니다. 느슨하게로드해야하는 경우 :

number_generator = (1..100).lazy # => #<Enumerator::Lazy: 1..100>

number_generator.first(10) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

모든 객체에서 배열에 캐스트

모든 객체에서 Array를 얻으려면 Kernel#Array .

다음은 그 예입니다 :

Array('something') #=> ["something"]
Array([2, 1, 5])   #=> [2, 1, 5]
Array(1)           #=> [1]
Array(2..4)        #=> [2, 3, 4]
Array([])          #=> []
Array(nil)         #=> []

예를 들어 다음 코드에서 join_as_string 메서드를 바꿀 수 있습니다.

def join_as_string(arg)
  if arg.instance_of?(Array)
    arg.join(',')
  elsif arg.instance_of?(Range)
    arg.to_a.join(',')
  else
    arg.to_s
  end
end

join_as_string('something') #=> "something"
join_as_string([2, 1, 5])   #=> "2,1,5"
join_as_string(1)           #=> "1"
join_as_string(2..4)        #=> "2,3,4"
join_as_string([])          #=> ""
join_as_string(nil)         #=> ""

다음 코드를 참조하십시오.

def join_as_string(arg)
  Array(arg).join(',')
end