【Ruby】配列メソッドまとめ - sathoshiiiBlog@プログミング学習

配列のメソッドについて知りたい

配列のまとめその3です。以下が、前の記事。

【Ruby】配列基礎まとめ

【Ruby】配列の生成方法まとめ

まとめたり、実際にコード打ちながら書いてたら1週間以上かかりました。。
細かく分けた方がみやすいのかな。。

要素の追加

要素の追加方法まとめ。
特に試験では、値そのものを変更してしまう破壊的メソッドかどうかの判断が必要だったのでその辺を重点的にまとめます。

<<

末尾に値を追加
破壊的メソッド

a = [1,2,3]
a << 5 p a #>= [1, 2, 3, 5]

# 配列を指定すると、末尾に配列そのものが挿入される
a << [1,2,3] p a #>= [1, 2, 3, 5, [1, 2, 3]]

# こういう書き方はエラー
# a << 1,2,3
# a << 1 2 3

push

末尾に追加。+と同様に破壊的メソッド。
末尾にまとめて追加したい場合は、+よりもpushの方が便利

a = [1,2,3]
a.push(5)
p a #>= [1, 2, 3, 5]

# 要素の1つずつを末尾に追加してくれる
a.push(6,7,8)
p a #>= [1, 2, 3, 5, 6, 7, 8]

# 要素に配列を加えた場合
a.push([1,2,3],6)
p a #>= [1, 2, 3, 5, 6, 7, 8, [1, 2, 3], 6]

concat

引数に指定した配列を末尾に連結する。
破壊的メソッド。

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

# ()で囲ってもOK
a.concat([6,7])
p a #>= [1, 2, 3, 4, 5, 6, 7]

#配列を渡してないのでエラー
#a.concat 6
#a.concat(6)
#a.concat(6,7)

+

引数に指定した配列を末尾に連結する。
破壊的メソッドではない！

そのため、変数aの値は書き換わらない。
結果を保持したい場合は、

concatメソッドを使って、変数aを書き換える
別の変数に結果を保持する

結果を出力したいだけであれば、普通にprintメソッドなどで出力すればOK。

a = [1,2,3]
a + [4,5]
# 破壊的メソッドではないので、変数aの値は書き換わらない
p a #>= [1, 2, 3]

# 直接出力
p a + [4,5] #>= [1, 2, 3, 4, 5]
# 別の変数に結果を保持する
b = a + [4,5]
p b #>= [1, 2, 3, 4, 5]

insert

一番目の引数に指定された場所に、一番目以降に指定された値を挿入する。
破壊的メソッド。

一番目の引数に範囲外の値を指定してもエラーにはならない。
その文、nilが設定される。

a = [1,2,3]
a.insert(1,99)
p a #> [1, 99, 2, 3]

# 範囲を超えて指定
a.insert(10,98)
p a #> [1, 99, 2, 3, nil, nil, nil, nil, nil, nil, 98]

# 一番目以降の値を複数指定した場合
b = [1,2,3]
b.insert(1,99,98)
p b #> [1, 99, 98, 2, 3]

一番の引数に、マイナスを指定した場合

気になったので実験。
どうも、元々の配列要素+1した値を超えた値を一番目の引数にマイナス指定するとエラーとなるようです。

変数eの部分です。
追加する値を増やしても同様のエラーでした。

a = [1,2,3]
a.insert(-1,99)
p a #> [1, 2, 3, 99]

b = [1,2,3]
b.insert(-3,99)
p b #> [1, 99, 2, 3]

c = [1,2,3]
c.insert(-4,99)
p c #> [99, 1, 2, 3]

#e = [1,2,3]
#e.insert(-5,99)
#p e #> IndexError

#e = [1,2,3]
#e.insert(-5,99,98)
#p e #> IndexError

unshift

配列の先頭に追加。
破壊的メソッド。

a = [1,2,3]
a.unshift(99)
p a #>= [99, 1, 2, 3]

# 複数指定も可能
# 追加される順番は、引数の順番通り
a.unshift(98,97)
p a #>= [98, 97, 99, 1, 2, 3]

直接配列指定して追加

直接指定する方法です。
主に変更などに使いますが、追加も可能です。

細かい説明は省きますが、色々実験したのが以下です。
特にマイナス指定した場合が注意です！

a = [1,2,3]
a[3] = 99
p a #>= [1, 2, 3, 99]

b = [1,2,3]
b[4] = 99
p b #>= [1, 2, 3, nil, 99]

c = [1,2,3]
c[2..4] = 99
p c #>= [1, 2, 99]

d = [1,2,3]
d[4..999] = 99
p d #>= [1, 2, 3, nil, 99]

e = [1,2,3]
e[-1] = 99
p e #>= [1, 2, 99]

# マナス指定して先頭に追加は出来ない
# f = [1,2,3]
# f[-4] = 99
# p f

# 範囲外だとエラー
# f = [1,2,3]
# f[-10] = 99
# p f

要素の変更

[]=

通常の指定方法。破壊的メソッド。
範囲を超えたインデックスを指定すると、伸長された分にはnilで初期化される

-でインデックス指定した場合は注意。
-1は、末尾から数え始める。
-で範囲を超えたインデックスを指定するとエラーになる

a = [1,2,3]
a[0] = 99
p a #>= [99, 2, 3]
# 範囲リテラルでまとめて指定
a = [1,2,3]
a[1..2] = 99
p a #>= [1, 99, 3]

# 配列の範囲を超えて指定
a = [1,2,3]
a[10] = 99
p a #>= [1, 99]

# -指定した場合
a = [1,2,3]
a[-1] = 99
p a #>= [1, 2, 99]

a = [1,2,3]
a[-3] = 99
p a #>= [99, 2, 3]


a = [1,2,3]
a[-4] = 99
p a #>= IndexError

# -0は0と同じ扱い
a = [1,2,3]
a[-0] = 99
p a #>= [1, 2, 99]

fill

配列の全ての要素を指定したオブジェクトに変更する。破壊的メソッド。
引数を 2つ以上指定する方法、ブロックを指定する方法などがある。

a = [1,2,3]
a.fill("a")
p a #>= ["a", "a", "a"]

# 範囲指定した部分のみ変更することも可能
a = [1,2,3]
a.fill("a", 1..2)
p a #>= [1, "a", "a"]

# ブロックを使用した場合
a = [1,2,3]
a.fill(1..2) {|i| i+10}
p a #>= [1, 11, 12]

# 範囲指定はなくてもOK
a = [1,2,3]
a.fill {|i| i+10}
p a #>= [1, 11, 12]

replace

引数で指定された配列で自分自身を置き換える。
=での再代入と異なり、オブジェクトIDが変わらない。

a = [1,2,3]
a.replace([4,5,6])
p a #>= [4, 5, 6]

a = [10,12,33]
p a.object_id #>= 70236204464920
a.replace([14,15,16])
p a #>= [14, 15, 16]
p a.object_id #>= 70236204464920

要素の参照

[]

インデックスを指定。
範囲リテラル、マイナス指定も可能。

# インデックス直接指定
a = [1,2,3]
p a[1] #>= 2
p a[-1] #>= 3
p a[99] #>= nil
p a[-99] #>= nil エラーにはならない

# 範囲を指定して参照
p a[1..2] #>= [2,3]

slice

配列から指定された部分を取り除き、取り除いた値を返却する。
非破壊メソッドなので取得だけにも使える。

本当に取り除いてしまいたい場合は、!をつけて破壊メソッドに変更して使用する

a = [1,2,3]
p a.slice(0) #>= 1
p a.slice(-1) #>= 3
p a.slice(99) #>= nil
p a.slice(-99) #>= nil
p a.slice(1..2) #>= [2,3]
#　上は非破壊メソッド扱いなので変数aの値は書き換わらない
p a #>= [1,2,3]
# !をつけることで破壊メソッドになる
p a.slice!(0) #>= 1
# 破壊メソッドなので、変数aの値から[0]の値が取り除かれている
p a #>= [2,3]

values_at

[]と同様の指定が可能。
[]との違いは、返却された値が配列という点。

a = [1,2,3]
p a.values_at(0) #>= [1]
p a.values_at(-1) #>= [3]
p a.values_at(99) #>= [nil]
p a.values_at(-99) #>= [nil]

# 範囲リテラルの指定も可能
p a.values_at(1..2) #>= [2,3]

at

インデックスが整数の場合に使用可能。
範囲リテラルは指定できない。

-の指定はOK。
範囲外の値を指定すると、nilで返却。

a = [1,2,3]
p a.at(1) #>= 2
p a.at(-1) #>= 3
p a.at(99) #>= nil
p a.at(-99) #>= nil
# p a.at(1..2) #TypeError

整数の値のみかと思いきや、実は小数点ありの値も指定可能？
ただし、小数点以下は切り捨てっぽい

a = [1,2,3]
p a.at(0.2) #>= 1
p a.at(1.2) #>= 2
p a.at(2.2) #>= 3
p a.at(3.2) #>= nil

p a.at(0.9) #>= 1
p a.at(1.9) #>= 2
p a.at(2.9) #>= 3
p a.at(3.9) #>= nil

fetch

atメソッドと基本同じ。
範囲外の値をインデックスを指定した場合にエラーとなる。

第2引数を指定すると、エラー時の値を指定できる。

a = [1,2,3]
p a.fetch(0) #>= 1
p a.fetch(-1) #>= 3
#p a.fetch(99) #>= IndexError
#p a.fetch(-99) #>= IndexError

p a.fetch(0, "Err") #>= 1
# 範囲外のインデックスを指定した場合に第2引数で指定した値が表示される
p a.fetch(99, "Err") #>= "Err"

#　こういった書き方も出来る
p a.fetch 99, "Err" #>= "Err"
p a.fetch(99) {|i| "Err #{i}"}  #>= "Err 99"

first

配列の要素の先頭を返す。
第1引数を指定すると、先頭から指定した要素分を配列で返す。

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

last

配列の要素末尾を返す。
第1引数を指定すると、先頭から指定した要素分を配列で返す。

a = [1,2,3]
p a.last #> 3
p a.last(1) #> [3]
p a.last(2) #> [2,3]
# オーバー分は返却されない
p a.last(99) #> [1, 2, 3]
#p a.last(-1) #> ArgumentError

assoc

配列の配列を検索し、その配列の最初の要素が指定された値と==で等しければその値を返却する。

一致しない場合は、nilを返す。
文字列、シンボルでも対応可能。

a = [[1,2,3],[4,5,6],[7,8,9]]
p a.assoc(0) #> nil
p a.assoc(1) #> [1, 2, 3]
p a.assoc(4) #> [4, 5, 6]

a = [1,2,3]
p a.assoc(1) #> nil

a = [["a","b","c"],[:e,:f,:g]]
p a.assoc("a") #> ["a", "b", "c"]
p a.assoc("b") #> nil
p a.assoc(:e) #> [:e, :f, :g]

rassoc

配列の配列を検索し、その配列のインデックスの1の要素が指定された値と==で一致した要素を返す。
かなり限定的。。。使うときあるのかなー。。

a = [[1,2,3],[4,5,6],[7,8,9]]
p a.rassoc(1) #> nil
p a.rassoc(2) #> [1,2,3]
p a.rassoc(3) #> nil
p a.rassoc(4) #> nil
p a.rassoc(5) #> [4, 5, 6]
p a.rassoc(6) #> nil
p a.rassoc(7) #> nil
p a.rassoc(8) #> [7, 8, 9]
p a.rassoc(9) #> nil

要素の調査

include?

指定された値が要素の中に存在する場合にtrueを返す。

a = [1,-1,"a",:a,true]
p a.include?(1) #>= true
p a.include?(-1) #>= true
p a.include?("a") #>= true
p a.include?(:a) #>= true
p a.include?(true) #>= true
p a.include?(false) #>= false
p a.include?(999) #>= false

index

配列の先頭から指定された値と==で等しい要素の位置を返す。

a = [1,2,3]
p a.index(0) #> nil
p a.index(1) #> 0
p a.index(2) #> 1
p a.index(3) #> 3

rindex

配列の末尾から指定された値と==で等しい要素の位置を返す。
結果は、indexから同じなので先頭から位置を数えるポイ。

a = [1,2,3]
p a.rindex(0) #> nil
p a.rindex(1) #> 0
p a.rindex(2) #> 1
p a.rindex(3) #> 3

要素の削除

delete_at

指定されたインデックスに対応する要素を取り除き、その要素を返す。
対応するインデックスがない場合は、nilを返す。
破壊的メソッド。

マイナスの指定も可能。

a = [1,2,3]
p a.delete_at(0) #> 1
p a #> [2,3]
p a.delete_at(999) #> nil

a = [1,2,3]
p a.delete_at(-1) #> 3
p a #> [1,2]
p a.delete_at(-999) #> nil

delete_if

ブロックに要素を渡す。
ブロック内の評価結果がtrueになった要素を全て取り除いた自分自身を返却する。
破壊的メソッド。

reject!と同様。

a = [1,2,3,4,5,6]
p a.delete_if {|i| i %2 == 0} #>= [1, 3, 5]
p a #>= [1, 3, 5]

reject!

delete_ifと同じ。
!をつけないと破壊的メソッドにならない。

a = [1,2,3,4,5,6]
p a.reject! {|i| i %2 == 0} #>= [1, 3, 5]
p a #>= [1, 3, 5]

a = [1,2,3,4,5,6]
p a.reject {|i| i %2 == 0} #>= [1, 3, 5]
p a #>= [1, 2, 3, 4, 5, 6]

delete

指定された値と==メソッドで等しい要素があれば取り除いてその値を返す。
なければnilを返す。
破壊的メソッド。

a = [1,2,3]
p a.delete(0) #>= nil
p a.delete(1) #>= 1
p a.delete(2) #>= 2
p a.delete(3) #>= 3
p a.delete(99) #>= nil
p a #>= []

clear

全ての要素を削除する。
自分自身を返却する。
破壊的メソッド。

a = [1,2,3]
p a.clear #>= []
p a #>= []

slice!

指定されたインデックスに対応する要素を取り除く。
取り除いた要素を返却する。
!付きで破壊メソッド。

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

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

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

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

# !なしだと値が変わらない
a = [1,2,3,4,5]
p a.slice(1,3) #>= [2, 3, 4]
p a #>= [1, 2, 3, 4, 5]

shift

先頭から指定された数の要素を取り除く。
取り除いた値を返却する。
破壊的メソッド。

引数指定がない場合、1が指定されたとして先頭の要素を返す。
1が直接指定された場合は、配列で返すが、指定されない場合は、値そのものを返すポイ。

マイナス指定するとエラー。

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

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

a = [1,2,3]
p a.shift(0) #>= []
p a #>= [1, 2, 3]

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

# a = [1,2,3]
# p a.shift(-1) #>= ArgumentError

pop

shiftと逆で末尾から指定された数だけ削除する。
他は、shiftと同じ。
破壊的メソッド。

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

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

a = [1,2,3]
p a.pop(99) #>= [1,2,3]
p a #>= []

–

「-」メソッドは、指定された配列にある要素を取り除く。
取り除いた値を返却する。

破壊的メソッドではない！

重複している値は一律削除される点に注意。

a = [1,2,3,4,5]
p a - [1] #>= [2, 3, 4, 5]
p a #>= [1, 2, 3, 4, 5]

p a - [1,5] #>= [2, 3, 4]
p a - [10,15] #>= [1, 2, 3, 4, 5]
p a - [1,15] #>= [2, 3, 4, 5]

# 重複した値は全て取り除かれる
b = [1,2,3,1,2,4,5]
p b - [1] #>= [2, 3, 2, 4, 5]

演算

|

和集合。
両方のいずれかに含まれる要素を含む配列を返す。

a = [1,2,3]
b = [2,3,4]

p a | b #>= [1, 2, 3, 4]

&

積集合。
両方に含まれる要素を含む配列を返す。

a = [1,2,3]
b = [2,3,4]
p a & b #>= [2, 3]

比較

==

先頭から要素を==メソッドで比較する。
全ての値が等しければ、true/falseで結果を返す。

p [1,2,3] == [1,2,3] #> true
p [1,2,3] == [1,4,5] #> false

# 色々比較してみた結果
p ["a"] == ["a"] #> true
p ["a"] == ["b"] #> false

p [:a] == [:a] #> true
p [:a] == [:b] #> false

p [true] == [true] #> true
p [true] == [false] #> true

# 型違いも比較してくれる
p ["a"] == [:a] #> false
p ["true"] == [true] #> false
p ["1"] == [1] #> false

<=>

先頭から要素を比較する。

同じであれば、0。
左辺が大きければ、1。
右辺が大きければ、-1。

booleanでの比較はnil。型が異なる値との比較もnilを返すポイ。

p [1,2,3] <=> [1,2,3] #> 0
p [1,2,3] <=> [1,4,5] #> -1
p [1,2,3] <=> [1,1,5] #> 1

# 文字での比較
p ["a"] <=> ["b"] #> -1
p ["b"] <=> ["a"] #> 1

# シンボルでの比較
p [:a] <=> [:b] #> -1
p [:b] <=> [:a] #> 1

# booleanでの比較
p [true] <=> [false] #> nil
p [false] <=> [true] #> nil

# 型違いの比較
p ["a"] <=> [:a] #> nil
p ["1"] <=> [1] #> nil

繰り返し

each

ブロックに各要素が渡され、繰り返す。

[1,2,3,4,5].each {|n| p n * 2}
=begin
  複数行のコメントです。
  結果は以下。
　2
　4
　6
　8
　10
=end

[1,2,3,4,5].each do |n| 
  p n * 2 
end
=begin
　2
　4
　6
　8
　10
=end

each_index

ブロックの各要素に配列のインデックスが渡される。

[1,2,3,4,5].each_index {|n| p n}
=begin
0
1
2
3
4
=end

[1,2,3,4,5].each_index do |n| 
  p n 
end
=begin
0
1
2
3
4
=end

cycle

配列の要素を延々と繰り返す。
末尾まで来ると、先頭に戻って繰り返す。。。

処理は割愛。

reverse_each

eachの逆。

[1,2,3,4,5].reverse_each {|n| p n}
=begin
5
4
3
2
1
=end

[1,2,3,4,5].reverse_each do |n| 
  p n 
end
=begin
5
4
3
2
1
=end

連結

join

配列の要素を指定された区切り文字で連結した文字列で返す。

p ["a","b","c"].join("_") #>= "a_b_c"
p ["a","b","c"].join() #>= "abc"
p ["a","b","c"].join("A") #>= "aAbAc"

*メソッド

joinと同じ。
数値を渡すと違うメソッドになるので注意。

リファレンス

p ["a","b","c"] *("_") #>= "a_b_c"
p ["a","b","c"] *("A") #>= "aAbAc"

# こういう書き方もOK
p ["a","b","c"] * "_"  #>= "a_b_c"
p ["a","b","c"] * "A"  #>= "aAbAc"

# 数値を渡すと違うメソッド扱いになってしまうので注意
p ["a","b","c"] * 3  #>= ["a", "b", "c", "a", "b", "c", "a", "b", "c"]

配列の長さ

length

配列の長さを調べる。
配列がからの場合は0を返す。

p [1,2,3].length #>= 3
p [].length #>= 0

size

lengthと同じ。

p [1,2,3].size #>= 3
p [].size #>= 0

empty?

配列が空の場合にtrueを返す

p [1,2,3].empty? #>= false
p [].empty? #>= true
p [""].empty? #>= false

ソート

sort

配列をソートする。
！をつけると破壊的メソッドになる。

a = [1,25,6,3,8,1,0]
p a.sort #>= [0, 1, 1, 3, 6, 8, 25]

# 変わらない
p a #>= [1, 25, 6, 3, 8, 1, 0]

# !をつけて破壊的メソッドにすることで値が書き換わる
p a.sort!
p a #>= [0, 1, 1, 3, 6, 8, 25]

b = [1,25,6,3,8,1,0]
# ブロックを使って書き方
p b.sort{|a,b| a <=> b} #>= [0, 1, 1, 3, 6, 8, 25]
# ソート順を逆にする
p b.sort{|a,b| b <=> a} #>= [25, 8, 6, 3, 1, 1, 0]

sort_by

ソートを自由にカスタマイズしたい場合に使う

a = ["aaaaa","b","cc"]
p a.sort_by {|a| a.size} #=> ["b", "cc", "aaaaa"]

# 1の値を先頭に移動
a = [1,3,5,1,6,1,1]
p a.sort_by {|a| a == 1 ? -1 : 1} #=> [1, 1, 1, 1, 3, 5, 6]

変換

uniq

重複した要素を取り除く配列を返す。

！付きで破壊的メソッド。
！付きで取り除く値がない場合、nilを返す

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

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

b = ["a", :a, 'a']
p b.uniq #>= ["a", :a]

compact

要素のnilを取り除いた配列を返す。

！付きで破壊的メソッド。
！付きの場合、取り除く値がない時はnilを返す。

a = [1,2,nil,3,nil,nil,4,5]
p a.compact #>= [1, 2, 3, 4, 5]
p a #>= [1, 2, nil, 3, nil, nil, 4, 5]

p a.compact! #>= [1, 2, 3, 4, 5]
p a #>= [1, 2, 3, 4, 5]
p a.compact! #>= nil

reverse

配列の要素を逆順に並び替えた配列で返す。
逆順にするだけで、ソートしてくれるわけではない。

!付きで破壊的メソッド。

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

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

b = [1,3,5,4,2,9]
p b.reverse #=> [9, 2, 4, 5, 3, 1]

flatten

配列を再起的に平滑化した配列を返す。
引数で、平滑化する深さを指定できる。
深さ以上、またはマイナス値を指定すると引数なしと同じ結果になった。

！付きで破壊的メソッド。
平滑化されない場合、nilを返す。

a = [[1,2,3],["a","b","c"],[:A,:B]]
p a.flatten #>= [1, 2, 3, "a", "b", "c", :A, :B]
p a #>= [[1, 2, 3], ["a", "b", "c"], [:A, :B]]

p a.flatten! #>= [1, 2, 3, "a", "b", "c", :A, :B]
p a #>= [1, 2, 3, "a", "b", "c", :A, :B]

b = []
p b.flatten #>= []
p b.flatten! #>= nil

c = [[[1,2],[3,4]],["a","b"],[:A,:B]]
p c.flatten #>= [1, 2, 3, 4, "a", "b", :A, :B]
p c.flatten(1) #>= [[1, 2], [3, 4], "a", "b", :A, :B]
p c.flatten(99) #>= [1, 2, 3, 4, "a", "b", :A, :B]
p c.flatten(-1) #>= [1, 2, 3, 4, "a", "b", :A, :B]

collect

要素ごとにブロックを評価し、その結果で要素を書き換えた配列を返す。
！付きで破壊的メソッド。

ブロックの書き方で、do~endと{}の書き方があるがdo~endの時だけ書き方注意！

a = [1,2,3]
p a.collect{|i| i * 2} #> [2, 4, 6]
p a #> [1, 2, 3]

# 書き方注意！
# 以下書き方だと、pメソッドに引きずられるためブロック呼び出しまで処理がいかない
p a.collect! do |i|
  i * 2
end #>= 
p a #>= [1, 2, 3]

# ()で囲んむか、do~endではなく{}を使う
p (a.collect! do |i|
  i * 2
end) #>= [2, 4, 6]
p a #>= [2, 4, 6]

map

collectと同じ。

a = [1,2,3]
p a.map{|i| i * 2} #> [2, 4, 6]
p a #> [1, 2, 3]

# 書き方注意！
# 以下書き方だと、pメソッドに引きずられるためブロック呼び出しまで処理がいかない
p a.map! do |i|
  i * 2
end #>= 
p a #>= [1, 2, 3]

# ()で囲んむか、do~endではなく{}を使う
p (a.map! do |i|
  i * 2
end) #>= [2, 4, 6]
p a #>= [2, 4, 6]

shuffle

配列の要素をシャッフルして返す。

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

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

組み合わせ

product

自身と与えられた配列から1つずつ要素を取って組み合わせた配列を作り、その全ての組み合わせを要素とする配列を返す。

非破壊的メソッド。

!付きメソッドはなし。

a = [1,2]
b = ["a","b"]

p a.product(b) #>= [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
# これでもOK
p a.product b #>= [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
p a #>= [1,2]

# 引数なしの場合でもエラーにはならない
p a.product #=> [[1], [2]]

# 破壊的メソッドはなし
#p a.product!(b) #> NoMethodError

c = [1,2]
d = ["a","b","c"]
p c.product d #> [[1, "a"], [1, "b"], [1, "c"], [2, "a"], [2, "b"], [2, "c"]]
p d.product c #> [["a", 1], ["a", 2], ["b", 1], ["b", 2], ["c", 1], ["c", 2]]

zip

自身と与えられた配列から1つずつ要素を取って配列を作り、それを要素とする配列を返す。

productメソッドとの違いは、組み合わせは前から順に同じインデックスのモノ飲みとなる。
足らない要素には、nilが入る。

非破壊的メソッド。
！付きは無し。

a = [1,2]
b = ["a","b"]

p a.zip(b) #>= [[1, "a"], [2, "b"]]
# これでもOK
p a.zip b #>= [[1, "a"], [2, "b"]]
p a #>= [1,2]

# 引数なしの場合でもエラーにはならない
p a.zip #=> [[1], [2]]

# 破壊的メソッドはなし
#p a.zip!(b) #> NoMethodError

c = [1,2]
d = ["a","b","c"]
p c.zip d #> [[1, "a"], [2, "b"]]
p d.zip c #> [["a", 1], ["b", 2], ["c", nil]]

#引数を2つ以上渡した場合
p c.zip(d,e) #>= [[1, "a", :a], [2, "b", :b]]

*

与えられた数値分繰り返した配列を返す。

非破壊メソッド。

a = [1,2,3]
p a * 2 #>= [1, 2, 3, 1, 2, 3]
p a #>= [1, 2, 3]

まとめ

要素の追加
要素の変更
要素の参照
要素の調査
要素の削除
演算
比較
繰り返し
連結
配列の長さ
ソート
変換
配列の組み合わせ

配列のメソッド多い！