Facebook Joinc 그룹
Joinc QA 사이트
Tweet
joinc는 Firefox와 chrome에서 테스트 했습니다. IE에서는 테이블이 깨지거나 이미지가 보이지 않을 수 있습니다. 특히 구글 Docs이미지의 경우 엑박처리될 수 있습니다.
Tweet
joinc는 Firefox와 chrome에서 테스트 했습니다. IE에서는 테이블이 깨지거나 이미지가 보이지 않을 수 있습니다. 특히 구글 Docs이미지의 경우 엑박처리될 수 있습니다.
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
- new (size=0, obj=mil)
- new (array)
- new (size) {|index| block}
a = Array.new(2, Hash.new)
a[0]['cat'] = 'feline'
a[1]['cat'] = 'Felix'
# Hash 객체를 원소 2개를 가지는 배열을 만든다.
a = Array.new(2) { Hash.new }
a[0]['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([1]) #=> [1]
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 * int -> new_ary
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를 반환한다.
aryindex -> obj or nil
ary[start, length] -> new_ary or nil
aryrange -> new_ary or nil
slice(index) -> obj
slice(start, length) -> new_ary or nil
slice(range) -> new_ary or nil
배열의 원소에 접근하기 위한 다양한 방법. index위치에 있는 배열 원소를 가져온다. start를 명시할 경우 start에서 length 범위까지의 원소를 배열로 반환한다. 범위는 ".."을 이용한다. 음의 정수를 사용하면 배열의 뒤에서 접근한다.
a = [ "a", "b", "c", "d", "e" ] a[2] + a[0] + a[1] #=> "cab" a[6] #=> 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[5] #=> nil a[5, 1] #=> [] a[5..10] #=> []
aryindex = obj -> obj
ary[start, length] = obj or other_ary or nil -> obj or other_ary or nil
==== aryrange = obj or other_ary or nil -> obj or other_ary or nil
a = Array.new a[4] = "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 -> int
count(obj) -> int
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) {|obj| block} -> nil
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) -> obj or nil
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
a.delete("z") { "not found" } #=> "not found"
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 {|item| block} -> ary
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 {|item| block} -> ary
each -> an_enumerator
배열의 원소를 가져와서 블럭에서 연산한다.
a = [ "a", "b", "c" ]
a.each {|x| print x, " -- " }
each_index {|index| blok} -> ary
==== each_index -> an_enumerator====
배열 값 (원소)대신 index 값을 가져온다는 것을 제외하고는 array.each와 같다.
배열 값 (원소)대신 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) -> obj
fetch (index, default) -> obj
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 (obj) -> ary
fill (obj, start [, length]) -> ary
fill (obj, range) -> ary
fill {|index| block} -> ary
fill (start [,length]) {|index| block} -> ary
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 (obj) -> int or nil
index {|item| block} -> int or nil
index -> an_enumerator
배열에서 obj와 같은 원소의 index를 반환한다.
a = [ "a", "b", "c" ]
a.index("b") #=> 1
a.index("z") #=> nil
a.index{|x|x=="b"} #=> 1
first -> obj or nil
first(n) -> new_ary