配列Arrayクラス

配列の生成

Array [1,2,3]
Array.new(3, "str")  #["str","str","str"]
Array.new(3) {|i| i * 3}  #[0, 3, 6]

要素の追加

以下のメソッドでは＋以外は破壊的メソッド

破壊的メソッド
<< , push : 最後に１要素を追加
concat  : 最後に配列を追加
insert : 引数１に指定した場所に追加
unshift : 先頭に要素を追加

破壊的メソッドではない
+ : 最後に配列を追加

例

a = [1,2,3]
a << [4,5]   # =>[1,2,3,[4,5]] object_idが変わらない
a.concat [6,7]  # =>[1,2,3,[4,5],6,7] object_idが変わらない
a.insert(3, 3.5)  #=>[1,2,3,3.5,[4,5],6,7] object_idが変わらない
a.unshift(10)   #=>[10,1,2,3] object_idが変わらない
a += [5]          # object_idが変わる

配列の要素を変更

[]=  : 指定要素や範囲を入れ替える
fill : 指定範囲の要素を入れ替える
replace : 配列全体を入れ替える（object_idは変化しない）

例

a = [1,2,3]
a.fill("s")  #["s","s","s"]
a.fill("t", 1..2)  #["s","t","t"]
a.fill(1..2) { |i| i}  #["s",1,2]

a.replace([4,5,6])   #a=[4,5,6]

配列の要素を参照する

[]
slice : 指定範囲を返す
values_at
at : 引数のインデックス値を返す
fetch  : atと同様だが、index overの場合エラーとなる
first : 引数が有る場合、先頭から引数分を返す
last : 引数がある場合、末尾から引数分を返す
assoc  : 配列の配列を検索しindex 0の値が一致する配列を返す
rassoc : 配列の配列を検索しindex１の要素と一致する配列を返す

例

a = [1,2,3]
a[1]  #2
a.at(1)  #2
a[1..2]  #[2,3]
a.values_at(1)  #[2]

a.at(4)  #nil
a.fetch(4)  # IndexError
a.fetch 4, "ERROR"  #"ERROR"
a.fetch(4) {|i| "Error#{i}"}  #"Error4"

a.first  #1
a.first(2)  #[1,2]

b = [[1,2],[2,3],[4,5],[6,7,5]]
b.assoc(2)  #[2,3]
b.rassic(5)  #[4,5]
b.rassic(7)  #[6,7,5]

配列の要素を調べる

include?
index : 配列の先頭から引数と一致するインデックス番号を返す
rindex : 配列の後ろから引数と一致するインデックス番号を返す

例

a = [1,2,3,4,5,4,3,2,1]
a.include?(4)  #true
a.index(2) #2
a.rindex(2) #7

配列の要素を削除する

delete_at  (破壊的メソッド)
delete_if , reject! : ブロックに要素を渡し評価がTrueの場合のみ削除する  (破壊的メソッド)
delete : 引数と一致する要素を全て削除する  (破壊的メソッド)
clear : 要素を削除する (破壊的メソッド)
slice!  : 指定範囲を除く
shift : 先頭から指定された要素数を削除する (破壊的メソッド)
pop : 末尾から指定された要素数を削除する (破壊的メソッド)
-  : 指定された要素を削除, deleteと同じ動きをするが新しい配列を返す

例

a = [1,2,3,4,5]
a.delete_if{|n| n % 2 == 0}  #[1,3,5]

a=[1,2,3,4,5,4,3,2,1]
a.delete(3)  #a=[1,2,4,5,4,2,1]
a - [2]  #[1,4,5,4,1]
a  #[1,2,4,5,4,2,1]

配列の演算

|  : 要素を全て返す
& : 一致する要素を返す

配列の比較

==  : 一致する場合true
<=> 

配列の繰り返し

each : 要素を繰り返す
each_index : 配列のインデックス番号が渡される
cycle : 配列を順に繰り返す（終了処理がないと無限）
reverse_each : 要素を逆順に繰り返す

例

a = [1,2,3,4,5]
a.each{|n| print n + " "}
1 2 3 4 5
a.each_index||n| print n + " "}
0 1 2 3 4 
a.cycle{|n| print n + " "}
1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 ........(省略)

配列の要素を連結する

join

例

[1,2,3].join(",")  #"1,2,3"

配列の長さを求める

length : アイテム数を返す
empty?  : 配列がない場合True
nitems : nil以外のアイテム数を返す

配列をソートする

sort : ソートした結果を返す
sort! : ソートした結果を元の値に保存する

例

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

a.sort{|a,b| a <=> b}  #[1,2,3,4,5]
a.sort{|a,b| b <=> b}  #{5,4,3,2,1]

配列を変換する

uniq : 重複を除いた配列を返す
compact : nilを除いた配列を返す
reverse : 逆順に並び替える
flatten : 配列を引数の次元に平坦化する
collect ,map  : 要素にブロックの結果を新しい配列で返す
shuffle : 要素をシャッフルして返す

例

a = [[[[1,2],3],[[4,5],6]]
a.flatten #[1,2,3,4,5,6]
a.flatten(1) #[[1,2],3,[4,5],6]

a = [1,2,3,4,5]
a.map{|n| m * 2} #[2,4,6,8,10]

配列を組み合わせて生成する

product : 要素を組み合わせて返す
zip : 同じインデックス番号の要素と組み合わされる
* : 要素を引数の数分切り替えし追加する

例

[1,2].product(["a", "b", "c"]) #[[1,"a"], [1,"b"], [1,"c"],[2,"a"],[2,"b"],[2."c"]]

[1,2].zip(["a","b"])  #[[1,"a"], [2."b"]]
[1,2,3].zip(["a","b"])  #[[1,"a"], [2."b"], [3, nil]]

[1.2]*4  #[1,2,1,2,1,2,1,2]

配列をパックする

pack : パックする。引数が'm'の場合MIMEエンコードする

例

["abc"].pack('m')
=> "YWJj\n"

1. "YWJj\n".unpack('m') でデコード出来る

+,-演算子

配列に+演算子は連結した配列を返す

a = [1,2,3,4]
b = [2,4,5,6]
a + b
 => [1, 2, 3, 4, 2, 4, 5, 6] 
a - b
 => [1, 3] 

&&, || 演算子の結果

a = [1,2,3,4]
b = [2,4,5,6]
a & b
 => [2, 4] 
a | b
 => [1, 2, 3, 4, 5, 6] 
a && b
 => [2, 4, 5, 6] 
a || b
 => [1, 2, 3, 4] 

%w()

中の要素をスペースで区分すると配列を返す

%w(a b c)  #=> ["a", "b", "c"]
%w(a,b,c d) #=> ["a,b,c". "d"]
%w("a" b c)  #=> ["\"a\"", "b", "c"]