配列のメソッドまとめ

覚えてないので自分用のカンペ。

配列に要素を加えるメソッド

a.unshift(item)

• 配列aの先頭に新しい要素をつけ加えるメソッド

a = [1,2,3,4,5]
a.unshift(0)
p a 
=> [0,1,2,3,4,5]  # 出力結果

a << item もしくは a.push(item)

• << とpushは同じ働きのメソッドで、配列aの末尾に新しい要素itemを付け加える。

a = [1,2,3,4,5]
a << 6  # もしくはa.push(6)
p a
=> [1,2,3,4,5,6]

a.concat(b) もしくは a + b

• 配列(a)に別の配列(b)を連結する。
• concatは破壊的メソッド。(レシーバにあたるオブジェクトの値そのものを変える。もしb=aとして別の変数にオブジェクトを入れてても、aとbは同一オブジェクトを示すため、aに破壊的メソッドを使えばbの値も変更される)
• ＋は元の配列をそのままにして新しい配列を作る。

a = [1,2,3,4,5]
a.concat([8,9])
p a
=> [1,2,3,4,5,8,9]

a[n] = item もしくは a[n..m] = item もしくは a[n, len] = item

• 配列aの指定された部分の要素をitemに置き換える。

a = [1,2,3,4,5,6,7,8]
a[2..4] = 0
p a
=> [1,2,0,6,7,8]
a[1,3] = 9
p a
=> [1,9,7,8]

配列から要素を取り除くメソッド

a.compact もしくは a.compact!

• 配列aの中から要素がnilのものを取り除く。
• compactは新しい配列を作る。compact！メソッドはnilを取り除いたあとのaを返すが、何も取り除けなければnilを返す。

a = [1,nil,3,nil,nil]
a.compact!
p a
=> [1,3]

a.delete(x)

• 配列aから要素xを取り除く。

a = [1,2,3,2,1]
a.delete(2)
p a
=> [1,3,1]

a.delete_at(n)

• 配列a[n]の要素を取り除く。

a = [1,2,3,4,5]
a.delete_at(2)
p a
=> [1,2,4,5]

a.delete_if{|item| ・・・} もしくは a.reject{|item| ・・・} もしくは a.reject!{|item| } ・・・}

• 配列aの各要素itemについて、ブロックを実行した結果が真だった場合、aからitemを取り除く。
• delete_ifとreject!は破壊的なメソッド。

a = [1,2,3,4,5]
a.delete_if(|i| i>3)
p a
=> [1,2,3]

a.slice!(n) もしくは a.slice!(n..m) もしくは a.slice!(n,len)

• 配列aから指定され部分を取り除き、取り除いた値を返す。
• slice！は破壊的なメソッド

a = [1,2,3,4,5]
p a.slice!(1,2)
=> [2,3]
p a
=> [1,4,5]

a.uniq もしくは a.uniq!

• 配列のaの重複する要素を削除。uniq！は破壊的なメソッド。

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

a.shift

• 配列aの先頭要素を取り除き、取り除いた値を返す。

a = [1,2,3,4,5]
a.shift
=> 1
p a
=> [2,3,4,5]

a.pop

• 配列aの末尾要素を取り除き、取り除いた値を返す。

a= [1,2,3,4,5]
a.pop
=> 5
p a
=> [1,2,3,4]

配列の要素を置き換えるメソッド

これも！がつくものは破壊的なメソッド、！がつかないものは別の配列を作って返すメソッド。

a.collect{|item| ・・・} もしくは a.collect!{|item| } ・・・} もしくは a.map{|item|} ・・・} もしくは a.map!{|item| ・・・}

• 配列aの各要素itemにブロックを適用し、その結果を集めて新しい配列を作る。
• 要素数は変わらないが、配列の各要素はブロック中の処理によって前と異なるものになる。

a = [1,2,3,4,5]
a.collect! {|item| item * 2}
p a
=> [2,4,6,8,10]

a.fill(value) もしくは a.fill(value,begin) もしくは a.fill(value,begin,len) もしくは a.fill(value,n..m)

• 配列aの要素をvalueに置き換える。引数が１つの場合は、aの要素すべてをvalueにする。
• 引数が２つの場合はbeginから配列の末尾まで、引数が３つの場合はbeginからlen個までをvalueにする。
• また２つ目の引数に「n..m」と範囲を指定している場合はその範囲をvalueにする。

p [1,2,3,4,5].fill(0)
=> [0,0,0,0,0]
p [1,2,3,4,5].fill(0,2)
=> [1,2,0,0,0]
p [1,2,3,4,5].fill(0,2,2)
=> [1,2,0,0,5]
p [1,2,3,4,5].fill(0,2..3)
=> [1,2,0,0,5]

a.flatten もしくは a.flatten!

• 配列を平坦化する。(「平坦化」というのは、配列の中に配列が入れ子になっているような場合に、その入れ子を展開して、１つの大きな配列にする操作のこと。)

a = [1,2,3,4,5]
a.reverse!
p a
=> [5,4,3,2,1]

a.reverse もしくは a.reverse!

• 配列aの要素を逆順に並べ替える。

a = [1,2,3,4,5]
a.reverse!
p a
=> [5,4,3,2,1]

a.sort もしくは a.sort! もしくは a.sort{|i,j| ・・・} もしくは a.sort!{|i,j| ・・・}

• 配列aの各要素を並べ替える。並べ替え方は、ブロックで指定。
• ブロックを指定しない場合は<=>演算子を使って比較する。

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

# 文字列同士を<=>演算子で比較した場合は文字コードの値で大小が決まる。（アルファベットの場合は大文字の次に小文字）
array = ["Ruby", "Perl", "PHP", "Python"]
sorted = array.sort
p sorted
=> ["PHP", "Perl", "Python", "Ruby"]

# 文字列長い順にソート
array = ["Ruby", "Perl", "PHP", "Python"]
sorted = array.sort{ |a,b| b.length <=> a.length }
p sorted
=> ["Python", "Perl", "Ruby", "PHP"]

a.sort_by{|i| ・・・}

• 配列aの要素を並べ替える。
• 並べ替え方はすべての要素についてブロックを評価した結果をソートした順に行われる。

a = [2,4,3,5,1]
p a.sort_by{|i| -i}
=> [5,4,3,2,1]