CLOSE

Recommanded Free YOUTUBE Lecture: <% selectedImage %>

## Array

Array은 integer형 숫자를 색인으로 객체를 저장하고 접근하기 위해서 사용하는 클래스다. Array는 C나 Java의 배열과 마찬가지로 0부터 시작한다. C언어와 달리 음의 정수를 색인으로 할 수 있는데, 이 경우 배열의 끝에서 부터 색인을 시작한다. 예를 들어 -1은 배열의 마지막 원소, -2는 마지막에서 두번째 원소다.

### Public Class Methods

#### [] (*args)

args를 원소로하는 새 배열을 만든다.
```Array.[](1, 'a', /^A/)
Array[1, 'a', /^A/]
[1, 'a', /^A/]```

#### new

1. new (size=0, obj=mil)
2. new (array)
3. new (size) {|index| block}
새로운 배열을 반환한다. 첫번째 식은 크기가 0인 배열을 반환한다. 2번째 배열은 객체를 size 크기 만큼 가진 배열을 만든다. 세번째 형식은 size 만큼 괄호에 있는 식을 수행하고 그 결과를 배열에 저장한다.
```a = Array.new(2, Hash.new)
a['cat'] = 'feline'
a['cat'] = 'Felix'

# Hash 객체를 원소 2개를 가지는 배열을 만든다.
a = Array.new(2) { Hash.new }
a['cat] = 'feline'

# 1 부터 5까지 제곱한 결과를 가지는 배열을 만든다.
squares = Array.new(5) {|i| i*i}
squares

copy = Array.new(squares)```

#### try_convert(obj) -> array or nil

to_ary메서드를 이용해서 obj를 배열로 변환을 한다. 변환에 성공하면 배열을 반환하고 실패하면 nil을 반환한다. 이 메서드는 주로 매개변수가 배열인지 확인하기 위해서 사용한다.
```Array.try_convert()   #=> 
Array.try_convert("1")   #=> nil

if tmp = Array.try_convert(arg)
# arg는 배열이다.
elsif tmp = String.try_convert(arg)
# arg는 string이다.
end```

### Public Instance Method

#### ary & other_ary -> new_ary

교집합 연산을 한다. 두 배열에서 중복된 원소만을 골라서 새로운 배열을 만든다.
`[ 1, 1, 3, 5] & [ 1, 2, 3 ]`

#### ary * str -> new_string

반복 연산을 한다. 정수일 경우 정수 크기만큼 원소를 복사한다. 문자열일 경우 join 연산을 한다.
```[1, 2, 3] * 3    # [1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3] * ":"  # "1:2:3"```

#### ary + other_ary -> new_ary

두 배열을 연결해서 새 배열을 만든다.
`[ 1, 2, 3 ] + [ 4, 5 ] = [ 1, 2, 3, 4, 5 ]`

#### ary - other_ary -> new_ary

차집합 연산을 한다. 두개의 배열에서 중복된 원소를 제외한 값을 원소로 하는 새로운 배열을 만든다.
`[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]`

#### ary << obj -> ary

배열의 끝에 객체를 추가한다.
`[ 1, 2 ] << "c" << "d" << [ 3, 4 ] #=>  [ 1, 2, "c", "d", [ 3, 4 ] ]`

#### ary <=> other_ary -> -1, 0, +1 or nil

배열을 비교한다. 왼쪽과 오른쪽 배열이 같으면 0, 작으면 -1, 크면 +1을 반환한다.
```[ "a", "a", "c" ]    <=> [ "a", "b", "c" ]   #=> -1
[ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ]            #=> +1```

#### ary == other_ary -> bool

배열을 비교해서 같으면 true, 다르면 false를 반환한다.

#### slice(range) -> new_ary or nil

배열의 원소에 접근하기 위한 다양한 방법. index위치에 있는 배열 원소를 가져온다. start를 명시할 경우 start에서 length 범위까지의 원소를 배열로 반환한다. 범위는 ".."을 이용한다. 음의 정수를 사용하면 배열의 뒤에서 접근한다.
```a = [ "a", "b", "c", "d", "e" ]
a +  a + a    #=> "cab"
a                   #=> nil
a[1, 2]                #=> [ "b", "c" ]
a[1..3]                #=> [ "b", "c", "d" ]
a[4..7]                #=> [ "e" ]
a[6..10]               #=> nil
a[-3, 3]               #=> [ "c", "d", "e" ]
# special cases
a                   #=> nil
a[5, 1]                #=> []
a[5..10]               #=> []```

#### ary[start, length] = obj or other_ary or nil -> obj or other_ary or nil

==== ary[range] = obj or other_ary or nil -> obj or other_ary or nil
```a = Array.new
a = "4";                 #=> [nil, nil, nil, nil, "4"]
a[0, 3] = [ 'a', 'b', 'c' ] #=> ["a", "b", "c", nil, "4"]
a[1..2] = [ 1, 2 ]          #=> ["a", 1, 2, nil, "4"]
a[0, 2] = "?"               #=> ["?", 2, nil, "4"]
a[0..2] = "A"               #=> ["A", "4"]
a[-1]   = "Z"               #=> ["A", "Z"]
a[1..-1] = nil              #=> ["A", nil]
a[1..-1] = []               #=> ["A"]```

#### assoc(obj) -> new_ary or nil

배열이 여러 객체로 이루어졌을 때, obj로 시작하는 객체를 찾아서 반환한다. 찾지 못했다면 nil을 반환한다.
```s1 = [ "colors", "red", "blue", "green" ]
s2 = [ "letters", "a", "b", "c" ]
s3 = "foo"
a = [ s1, s2, s3 ]   #  [ "letters", "a", "b", "c" ]
a.assoc("foo")       # nil```

#### at(index) -> obj or nil

배열에서 index 위치에 있는 객체를 반환한다. 음의 정소일 경우 뒤에서 탐색한다.
```a = [ "a", "b", "c", "d", "e" ]

a.at(0)   # "a"
a.at(-1)  # "e"```

#### clear -> any

배열에서 원소를 제거한다.
```a = [ "a", "b", "c", "d", "e" ]
a.clear   # nil```

#### compact -> new_ary

배열에서 nil을 제거한 새로운 배열을 반환한다. 원래 배열은 그대로다.
```a = [ "a", nil, "b", nil, "c", nil, "d", nil, "e" ]
a.compact   # [ "a", "b", "c", "d", "e" ]```

#### compact! -> ary or nil

원래 배열에서 nil을 제거한다.
```[ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ]
[ "a", "b", "c" ].compact!           #=> nil```

#### concat(other_ary) -> ary

배열에 otehr_ary 배열을 추가한다.
`[ "a", "b" ].concat( ["c", "d"] ) #=> [ "a", "b", "c", "d" ]`

#### count{ |item| block } -> int

배열 원소의 갯수를 반환한다. obj을 매개 변수로 사용할 경우, obj과 같은 원소의 갯수를 반환한다. block을 이용할 경우 block의 식을 만족하는 원소의 갯수를 반환한다.
```ary = [1, 2, 4, 2]
ary.count             #=> 4
ary.count(2)          #=> 2
ary.count{|x|x%2==0}  #=> 3```

#### cycle(n=nill) an_enumerator

block을 n 번만큼 반복한다. 만약 n이 nil이라면 무한 반복한다. 반복이 끝나면 nil을 반환한다.
```a = ["a", "b", "c"]
a.cycle {|x| puts x }  # print, a, b, c, a, b, c,.. forever.
a.cycle(2) {|x| puts x }  # print, a, b, c, a, b, c.```

#### delete (obj) { block } -> obj or nil

배열에서 object와 같은 원소를 삭제한다. 삭제할 원소를 찾았다면 obj를 반환한다. 만약 obj를 찾지 못했다면 nil을 반환한다. 원소를 찾지 못할 경우 실행할 코드를 블럭에 담을 수 있다.
```#!/usr/bin/ruby

a = [ "a", "b", "b", "b", "c" ]
a.delete("b")                   #=> "b"
a                               #=> ["a", "c"]
a.delete("z")                   #=> nil

#### delete_at (index) -> obj or nil

배열에서 index 위치의 원소를 삭제한다. 성공적으로 삭제했다면 삭제한 원소를 반환 하고 그렇지 않다면 nil을 반환한다.
```a = %w( ant bat cat dog )
a.delete_at(2)    #=> "cat"
a                 #=> ["ant", "bat", "dog"]
a.delete_at(99)   #=> nil```

#### delete_if -> en_enumerator

삭제할 때 조건을 코드로 줄 수 있다.
```a = [ "a", "b", "c" ]
a.delete_if {|x| x >= "b" }   #=> ["a"]```

#### droip (n) -> new_ary

0번째 원소부터 n번째 원소까지 삭제한다.
```a = [1, 2, 3, 4, 5, 0]
a.drop(3)             #=> [4, 5, 0]```

#### each -> an_enumerator

배열의 원소를 가져와서 블럭에서 연산한다.
```a = [ "a", "b", "c" ]
a.each {|x| print x, " -- " }```

#### each_index {|index| blok} -> ary

==== each_index -> an_enumerator==== 배열 값 (원소)대신 index 값을 가져온다는 것을 제외하고는 array.each와 같다.
```a = [ "a", "b", "c" ]
a.each_index {|x| print x, " -- " }  # 0 -- 1 -- 2 --```

#### enpty? -> true or false

만약 배열에 원소가 있다면, treu 없다면 false를 반환한다.
`[].empty?    #=> true`

#### eql? (other) -> true or false

배열 other과 같은지 검사한다. 같다면 true 다르다면, false를 반환한다.
```a = [ "a", "b", "c" ]
b = [ "a", "b", "c" ]
a.eql?(b)              # true```

#### fetch (index) {|index| block} -> obj

배열에서 index이 값을 반환 시도를 한다. 만약 index가 배열 크기를 벗어나는 곳을 가리키면, IndexError 예외를 발생한다. 만약 default를 명시했다면, IndexError대신 default를 반환한다. 블럭이 있다면, 블럭의 코드를 실행한다.
```a = [ 11, 22, 33, 44 ]
a.fetch(1)               #=> 22
a.fetch(-1)              #=> 44
a.fetch(4, 'cat')        #=> "cat"
a.fetch(4) { |i| i*i }   #=> 16```

#### fill (range {|index| block} -> ary

배열의 원소를 특정 객체로 채우기 위해서 사용한다. start와 length로 채울 범위를 지정할 수 있고, 블럭을 이용해서 채울 값을 코드화 할 수도 있다.
```a = [ "a", "b", "c", "d" ]
a.fill("x")              #=> ["x", "x", "x", "x"]
a.fill("z", 2, 2)        #=> ["x", "x", "z", "z"]
a.fill("y", 0..1)        #=> ["y", "y", "z", "z"]
a.fill {|i| i*i}         #=> [0, 1, 4, 9]
a.fill(-2) {|i| i*i*i}   #=> [0, 1, 8, 27]```

#### index -> an_enumerator

배열에서 obj와 같은 원소의 index를 반환한다.
```a = [ "a", "b", "c" ]
a.index("b")        #=> 1
a.index("z")        #=> nil
a.index{|x|x=="b"}  #=> 1```

#### first(n) -> new_ary

배열의 첫번째 원소를 반환한다. 혹은 처음 부터 n 번째까지의 원소를 포함한 배열을 반환한다.
```a = [ "q", "r", "s", "t" ]
a.first     #=> "q"
a.first(2)  #=> ["q", "r"]```