Arrayで使えるメソッド
------------------------------------------------------------
# push n
配列の末尾に n を追加する(破壊的)
a=[1,2,3]
a.push(4,5)
a
=> [1, 2, 3, 4, 5]
------------------------------------------------------------
# pop
# pop(n)
配列から１つ取り除いて返す
または nで指定した数だけ配列から取り除き、その要素を配列で返す
返り値と残った値を使って、配列を分割するのにも使える
a = [1, 2, 3, 4, 5]
a.pop(3)
=> [3, 4, 5]
a
=> [1, 2]
------------------------------------------------------------
# shift
配列の先頭から要素を捨てて、配列を返す。
a=[1,2,3,4,5]
a.shift(3)
=> [1, 2, 3]
a
=> [4, 5]
------------------------------------------------------------
# unshift
配列の先頭に要素を追加する
a=[1,2,3,4,5]
a.unshift 6
=> [6, 1, 2, 3, 4, 5]
------------------------------------------------------------
# drop(n)
先頭のn要素を捨てた配列を返す
配列は書き換えない
a = [1,2,3,4,5]
a.drop(2) #=> [3,4,5]
------------------------------------------------------------
# drop_while{|e| ....}
最初に偽になった要素までを捨てる
(最初に偽になった要素以降を取り出す)
a = [1,2,3,4,5]
a.drop_while{|i|i%3!=0}
=> [3, 4, 5]
see also take_while
------------------------------------------------------------
# each {|i| ... }
配列の要素に対し繰り返す
------------------------------------------------------------
# each_index {|i| ... }
配列のindexに対して繰り返す
for(i=0; i<N; i++) a[i]... 的な使い方ができる。
a=[3,1,4,1,5,9]
a.each_index.map{|i| "#{i}:#{a[i]},"}
=> ["0:3,", "1:1,", "2:4,", "3:1,", "4:5,", "5:9,"]
メモ:
a.map.with_index{|v,i| "#{i}:#{v},"}
=> ["0:3,", "1:1,", "2:4,", "3:1,", "4:5,", "5:9,"]
------------------------------------------------------------
# count(n)
nに一致する要素の数を返す
# count{|e| ... }
ブロックが真になった要素の数を返す
a = [3, 1, 4, 1, 5, 9]
a.count{|i| i%3 == 0}
=> 2
------------------------------------------------------------
# delete
配列から一致する要素を削除する
a = [3, 1, 4, 1, 5, 9]
a.delete(1)
a
=> [3, 4, 5, 9]
------------------------------------------------------------
# delete_at(n)
位置 n の要素を削除する
a=[3,1,4,1,5,9]
a.delete_at(-1)
a
=> [3, 1, 4, 1, 5]
------------------------------------------------------------
# delete_if{|i| ...}
条件に一致する要素を削除する
------------------------------------------------------------
# fill(val)
すべての要素を val にする
# fill(val, start, length)
# fill(val, range)
指定した範囲を val にする
a=[3,1,4,1,5,9]
a.fill(-1, 3..nil)
=> [3, 1, 4, -1, -1, -1]
------------------------------------------------------------
# filter{i| ... }
# select{|i|... }
各要素に対しブロックを評価し、真だった要素の配列を返す
------------------------------------------------------------
# index(n)
# find_index(n)
# index{|i| ... }
# find_index{|i| ... }
n に一致するまたは、ブロックが真を返す最初の位置を返す
a=[3,1,4,1,5,9]
a.index(1)
=> 1
a.index{|v|v>3}
=> 2
# rindex(n)
# rindex{|i) ...}
nに一致する最後の要素の位置を返す
a=[3,1,4,1,5,9]
a.rindex(1)
=> 3
------------------------------------------------------------
# first
配列の先頭の要素を返す。
Lisp でいえば car
(cdr は drop(1))
first(n) として複数要素を返すことができる
------------------------------------------------------------
# flatten
配列を平たん化する
a="this is a pen".split.map(&:chars)
=> [["t", "h", "i", "s"], ["i", "s"], ["a"], ["p", "e", "n"]]
a.flatten
=> ["t", "h", "i", "s", "i", "s", "a", "p", "e", "n"]
------------------------------------------------------------
# include?(n)
配列が要素nを含むとき true, そうでないとき false を返す
------------------------------------------------------------
# insert(n, *val)
位置n の直前に val を追加する
a=[3,1,4,1,5,9]
a.insert(2, 11,12,13)
=> [3, 1, 11, 12, 13, 4, 1, 5, 9]
------------------------------------------------------------
# last
# last(n)
配列の最後の要素を返す
------------------------------------------------------------
# all? {|e| ... }
すべての要素が真のとき、真を返す
# any? {|e| ... }
1個以上の要素が真のとき、真を返す
# one? {|e| ... }
1個の要素が真のとき、真を返す
"XXXXOXXXX".chars.one?{|v|v=="O"}
=> true
"XXXXOXXXO".chars.one?{|v|v=="O"}
=> false
------------------------------------------------------------
# permutation(n)
順列を返す
a=[?a, ?b, ?c]
=> ["a", "b", "c"]
a.permutation(2).to_a
=> [["a", "b"], ["a", "c"], ["b", "a"], ["b", "c"], ["c", "a"], ["c", "b"]]
------------------------------------------------------------
# combination(n)
組み合わせを返す
a=[?a, ?b, ?c]
=> ["a", "b", "c"]
a.combination(2).to_a
=> [["a", "b"], ["a", "c"], ["b", "c"]]
------------------------------------------------------------
# rotate
指定した位置(省略時は1)の要素が先頭になる配列を生成し返す。
a
=> [3, 1, 4, 1, 5, 9]
a.rotate
=> [1, 4, 1, 5, 9, 3]
a
=> [3, 1, 4, 1, 5, 9]
a.rotate(-1)
=> [9, 3, 1, 4, 1, 5]
------------------------------------------------------------
# sample
配列からランダムに１つ(引数を指定すれば複数）選んで返す
a=(1..6).to_a
a.sample
=> 4
a.sample
=> 2
------------------------------------------------------------
# slice(n)
# slice(n, length)
# slice(range)
Array#[] と同じ。
配列から指定した範囲の部分配列を返す
------------------------------------------------------------
# sort
ソートする。要素は <=> で比較する。
# sort_by
要素をそのまま <=> で比較するのではなくブロックの出力で比較する
"pencil".chars.sort_by{|c|c.ord}
=> ["c", "e", "i", "l", "n", "p"]
------------------------------------------------------------
# sum
# sum{|e| ... }
"abc".chars.sum{|c|c.ord}
=> 294
97+98+99
=> 294
------------------------------------------------------------
# take(n)
配列の先頭n要素を返す
n は省略できない。
n が2以上なら firstと同じ
------------------------------------------------------------
# take_while{|e| ... }
要素が偽になるまでの要素を配列で返す。
（先頭から数えて要素が真である範囲を返す）
a=[1,2,3,4,5,6]
a.take_while{|n|n<4}
=> [1, 2, 3]
a.take_while{|n|n>3}
=> []
------------------------------------------------------------
# to_h
配列をハッシュにする
[[:foo, :bar], [1, 2]].to_h
=> {:foo=>:bar, 1=>2}
> %w(uma shika inu neko).each_with_index.to_h
=> {"uma"=>0, "shika"=>1, "inu"=>2, "neko"=>3}
ブロックを指定するとそのブロックが返した [key, value]でハッシュを作る
%w(uma shika inu neko).to_h{|w| [w, w.size]}
=> {"uma"=>3, "shika"=>5, "inu"=>3, "neko"=>4}
------------------------------------------------------------
# zip
> [1,2,3].zip(["a", "b", "c"])
=> [[1, "a"], [2, "b"], [3, "c"]]
w=%w(uma shika inu kaba)
=> ["uma", "shika", "inu", "kaba"]
(0...w.size).zip(w)
=> [[0, "uma"], [1, "shika"], [2, "inu"], [3, "kaba"]]
------------------------------------------------------------
# join
# *
%w(uma shika inu kaba).join("//")
=> "uma//shika//inu//kaba"
%w(uma shika inu kaba)*"//"
=> "uma//shika//inu//kaba"
------------------------------------------------------------
# |
和演算
[1, 1, 4, 2, 3] | [5, 4, 5]
#=> [1, 4, 2, 3, 5]
------------------------------------------------------------
# &
積演算
[3,1,4,1,5,9] & [1,7,3,2,0,5.0,8]
=> [3, 1]
------------------------------------------------------------
# +
連結
[1,2,3] + [2,3,4,5]
=> [1, 2, 3, 2, 3, 4, 5]
------------------------------------------------------------
# -
減算。
減算される側の配列中の、減算する配列に含まれる要素はすべて削除される。
[1,2,3]-[2,3,4,5]
=> [1]
[1,2,2,3,3]-[2,3,4,5]
=> [1]
