【Ruby】配列を結合する方法を徹底解説！コード例付き
はじめに：Rubyにおける配列結合の重要性
プログラミングにおいて、データの集合を扱うことは非常に頻繁にあります。特に、Rubyでは「配列（Array）」は非常に柔軟で強力なデータ構造であり、様々な要素を格納し、操作することができます。多くのプログラミングタスク、例えばデータの集計、リストの作成、複数のソースから得た情報を統合する場合などに、複数の配列を一つにまとめる必要が出てきます。
この「配列を結合する」操作は、一見単純に見えますが、Rubyにはいくつかの異なる方法があり、それぞれに特徴があります。単に要素を付け加えるだけでなく、重複を排除したり、元の配列を変更するかしないか（破壊的か非破壊的か）、ネストされた配列を平坦化したりと、様々なニーズに対応するための手段が用意されています。
本記事では、Rubyで配列を結合する主要な方法を網羅的に解説します。それぞれの方法について、基本的な使い方、コード例、特徴（破壊的かどうか、重複の扱い、パフォーマンスなど）、そしてどのような場面で利用するのが適切か、といった点を詳しく掘り下げていきます。この記事を読むことで、あなたはRubyにおける配列結合の様々なテクニックを習得し、あなたのプログラムの要件に合わせて最適な方法を選択できるようになるでしょう。
さあ、Rubyの配列結合の世界へ踏み込んでいきましょう。
配列結合の基本的な考え方：連結と和集合
Rubyにおける配列結合は、主に以下の2つの基本的な考え方に分類できます。
-
連結 (Concatenation): これは、単に一方の配列の要素を、もう一方の配列の末尾に追加して、新しい一つの配列を作成する操作です。元の配列の要素の順番は基本的に維持され、重複する要素もそのまま含まれます。これは、複数のリストを単に結合したい場合によく使われます。
-
和集合 (Union): これは、数学的な集合の概念に基づいています。二つの配列の要素をすべて集め、重複する要素を一つにまとめて、新しい配列を作成する操作です。結果として得られる配列には、元の二つの配列のいずれかに含まれていたユニークな要素のみが含まれます。これは、重複を排除しつつ、すべての要素をリストアップしたい場合に有効です。
これらの基本的な考え方を理解した上で、Rubyで提供されている具体的なメソッドや演算子を見ていきましょう。
1. + 演算子：最もシンプルで非破壊的な連結
Rubyで配列を連結する最も直感的で簡単な方法は、+ 演算子を使用することです。この演算子は、二つの配列を連結し、新しい配列を返します。元の配列は変更されません（非破壊的な操作）。
基本的な使い方
+ 演算子は、二つの配列の間に記述して使用します。
“`ruby
array1 = [1, 2, 3]
array2 = [4, 5, 6]
+ 演算子で連結
combined_array = array1 + array2
puts “元の配列1: #{array1}”
puts “元の配列2: #{array2}”
puts “結合された配列: #{combined_array}”
“`
実行結果:
元の配列1: [1, 2, 3]
元の配列2: [4, 5, 6]
結合された配列: [1, 2, 3, 4, 5, 6]
この例からわかるように、array1とarray2の内容は変化せず、それらを連結した新しい配列combined_arrayが生成されています。
重複する要素を含む場合の動作
+ 演算子は単に要素を連結するだけなので、重複する要素もそのまま保持します。
“`ruby
array_a = [1, 2, 3, 2]
array_b = [3, 4, 5, 1]
combined_with_duplicates = array_a + array_b
puts “元の配列a: #{array_a}”
puts “元の配列b: #{array_b}”
puts “重複を含む結合配列: #{combined_with_duplicates}”
“`
実行結果:
元の配列a: [1, 2, 3, 2]
元の配列b: [3, 4, 5, 1]
重複を含む結合配列: [1, 2, 3, 2, 3, 4, 5, 1]
1, 2, 3といった要素が重複して含まれていることが確認できます。
異なる型の要素を含む配列の結合
Rubyの配列は異なる型の要素を混在させることができます。+ 演算子も、異なる型の要素を持つ配列同士を問題なく結合できます。
“`ruby
array_mixed1 = [1, “apple”, 3.14]
array_mixed2 = [:symbol, true, nil]
combined_mixed = array_mixed1 + array_mixed2
puts “元の配列mixed1: #{array_mixed1}”
puts “元の配列mixed2: #{array_mixed2}”
puts “異なる型を含む結合配列: #{combined_mixed}”
“`
実行結果:
元の配列mixed1: [1, "apple", 3.14]
元の配列mixed2: [:symbol, true, nil]
異なる型を含む結合配列: [1, "apple", 3.14, :symbol, true, nil]
空の配列との結合
空の配列と+ 演算子で結合しても、期待通りの結果が得られます。空の配列を加えても、元の配列は変わりません。
“`ruby
array_non_empty = [10, 20]
array_empty = []
combined_with_empty = array_non_empty + array_empty
combined_empty_first = array_empty + array_non_empty
puts “非空配列と空配列の結合: #{combined_with_empty}”
puts “空配列と非空配列の結合: #{combined_empty_first}”
puts “空配列と空配列の結合: #{array_empty + []}”
“`
実行結果:
非空配列と空配列の結合: [10, 20]
空配列と非空配列の結合: [10, 20]
空配列と空配列の結合: []
複数の配列を一度に結合
+ 演算子は連鎖させることができます。これにより、複数の配列を一度に結合することが可能です。
“`ruby
arr1 = [1, 2]
arr2 = [3, 4]
arr3 = [5, 6]
combined_all = arr1 + arr2 + arr3
puts “複数の配列の結合: #{combined_all}”
“`
実行結果:
複数の配列の結合: [1, 2, 3, 4, 5, 6]
+ 演算子の特徴と注意点
- 非破壊的: 元の配列は変更されず、常に新しい配列を生成して返します。
- 単純な連結: 要素の重複は排除されず、出現順に連結されます。
- 可読性が高い: 演算子として直感的で、コードが読みやすいです。
- パフォーマンス: 大量の要素を持つ配列を繰り返し
+で結合すると、中間的な新しい配列が何度も生成されるため、パフォーマンスが低下する可能性があります。特にループ内で配列に要素を追加していくような場合は、他のメソッド（後述のconcatやpushなど）の方が効率的です。
+ 演算子は、手軽に二つの配列を連結したい場合や、元の配列を保持しておきたい場合に非常に便利な方法です。
2. concat メソッド：破壊的な連結
Array#concatメソッドは、引数として与えられた配列の要素を、レシーバ（メソッドが呼び出された元の配列）の末尾に追加します。これは破壊的な操作であり、元の配列自身が変更されます。
基本的な使い方
concatメソッドは、配列オブジェクトに対して呼び出し、引数に連結したい別の配列を渡します。
“`ruby
array1 = [1, 2, 3]
array2 = [4, 5, 6]
puts “結合前の配列1: #{array1}”
puts “結合前の配列2: #{array2}”
concat メソッドで連結（破壊的）
array1.concat(array2)
puts “結合後の配列1: #{array1}”
puts “結合後の配列2: #{array2}” # array2 は変更されない
“`
実行結果:
結合前の配列1: [1, 2, 3]
結合前の配列2: [4, 5, 6]
結合後の配列1: [1, 2, 3, 4, 5, 6]
結合後の配列2: [4, 5, 6]
この例からわかるように、concatを呼び出したarray1自身が変更され、array2の要素がその末尾に追加されています。array2は変更されません。
重複する要素を含む場合の動作
concatも+と同様に、単に要素を連結するだけなので、重複する要素もそのまま保持します。
“`ruby
array_a = [1, 2, 3, 2]
array_b = [3, 4, 5, 1]
puts “結合前の配列a: #{array_a}”
array_a.concat(array_b)
puts “重複を含む結合後の配列a: #{array_a}”
“`
実行結果:
結合前の配列a: [1, 2, 3, 2]
重複を含む結合後の配列a: [1, 2, 3, 2, 3, 4, 5, 1]
異なる型の要素を含む配列の結合
concatも異なる型の要素を含む配列を問題なく結合できます。
“`ruby
array_mixed1 = [1, “apple”, 3.14]
array_mixed2 = [:symbol, true, nil]
puts “結合前の配列mixed1: #{array_mixed1}”
array_mixed1.concat(array_mixed2)
puts “異なる型を含む結合後の配列mixed1: #{array_mixed1}”
“`
実行結果:
結合前の配列mixed1: [1, "apple", 3.14]
異なる型を含む結合後の配列mixed1: [1, "apple", 3.14, :symbol, true, nil]
空の配列との結合
空の配列をconcatで結合しても、期待通りの結果が得られます。空の配列をconcatしても、元の配列は変わりません。
“`ruby
array_non_empty = [10, 20]
array_empty = []
puts “非空配列結合前: #{array_non_empty}”
array_non_empty.concat(array_empty)
puts “非空配列結合後 (空配列をconcat): #{array_non_empty}” # 変更なし
array_empty.concat([30, 40])
puts “空配列結合後 (非空配列をconcat): #{array_empty}” # 空配列が変更される
“`
実行結果:
非空配列結合前: [10, 20]
非空配列結合後 (空配列をconcat): [10, 20]
空配列結合後 (非空配列をconcat): [30, 40]
複数の配列を一度にconcat
concatメソッドは複数の配列を引数として受け取ることができます。
“`ruby
arr1 = [1, 2]
arr2 = [3, 4]
arr3 = [5, 6]
puts “結合前のarr1: #{arr1}”
arr1.concat(arr2, arr3) # arr1にarr2の要素とarr3の要素をまとめて追加
puts “複数の配列をconcatしたarr1: #{arr1}”
“`
実行結果:
結合前のarr1: [1, 2]
複数の配列をconcatしたarr1: [1, 2, 3, 4, 5, 6]
これは、arr1.concat(arr2).concat(arr3) と連鎖させるのと同じ結果になりますが、複数の引数を渡す方がシンプルです。
concat メソッドの特徴と注意点
- 破壊的: レシーバである元の配列自身が変更されます。
- 返り値: 変更されたレシーバ自身（元の配列オブジェクト）を返します。これにより、
concatの呼び出しをメソッドチェーンの一部として使用できます。 - パフォーマンス: 新しい配列を生成する
+演算子とは異なり、既存の配列のメモリ領域を拡張して要素を追加することが多いため、特に大量の要素を持つ配列に対しては、+演算子よりも効率的である傾向があります。 - 使用シーン: 元の配列を直接変更したい場合や、パフォーマンスが重要な場面（特に大きな配列の結合やループ内での追加）で適しています。
concatを使用する際は、元の配列が変更されるという点を十分に理解しておく必要があります。もし元の配列のコピーを保持しておきたい場合は、dupメソッドなどで複製を作成してからconcatを使用するか、+演算子を使用することを検討してください。
“`ruby
original_array = [1, 2]
copied_array = original_array.dup # コピーを作成
another_array = [3, 4]
copied_array.concat(another_array)
puts “元の配列: #{original_array}” # 変更されない
puts “コピーして結合した配列: #{copied_array}” # 変更される
“`
3. | 演算子：配列の和集合（Union）
| 演算子は、二つの配列の和集合を計算し、新しい配列を返します。これは、一方または両方の配列に含まれるすべてのユニークな要素を収集する操作です。結果の配列には、重複する要素は含まれません。元の配列は変更されません（非破壊的な操作）。
基本的な使い方
| 演算子は、二つの配列の間に記述して使用します。
“`ruby
array1 = [1, 2, 3]
array2 = [3, 4, 5]
| 演算子で和集合
union_array = array1 | array2
puts “元の配列1: #{array1}”
puts “元の配列2: #{array2}”
puts “和集合の配列: #{union_array}”
“`
実行結果:
元の配列1: [1, 2, 3]
元の配列2: [3, 4, 5]
和集合の配列: [1, 2, 3, 4, 5]
3は両方の配列に含まれていますが、結果の配列には一つだけ含まれています。
重複する要素を含む配列での動作
元の配列に重複が含まれていても、結果の配列にはユニークな要素のみが含まれます。
“`ruby
array_a = [1, 2, 3, 2]
array_b = [3, 4, 5, 1]
union_with_duplicates = array_a | array_b
puts “元の配列a: #{array_a}”
puts “元の配列b: #{array_b}”
puts “重複を含む和集合配列: #{union_with_duplicates}”
“`
実行結果:
元の配列a: [1, 2, 3, 2]
元の配列b: [3, 4, 5, 1]
重複を含む和集合配列: [1, 2, 3, 4, 5]
元の配列array_aに含まれる2の重複や、array_bに含まれる1の重複、そして両方に含まれる3の重複がすべて排除され、ユニークな要素のみがリストアップされています。要素の順序は、最初の配列に出現した順序を優先し、次に2番目の配列にのみ出現した要素が追加される傾向がありますが、Rubyのバージョンや内部実装によって完全に保証されるわけではありません。基本的には「ユニークな要素の集まり」と考えるのが安全です。
異なる型の要素を含む配列の和集合
| 演算子も異なる型の要素を持つ配列を問題なく扱えます。型が異なれば、当然重複とは見なされません。
“`ruby
array_mixed1 = [1, “apple”, 3.14, 1]
array_mixed2 = [“apple”, :symbol, true, nil]
union_mixed = array_mixed1 | array_mixed2
puts “元の配列mixed1: #{array_mixed1}”
puts “元の配列mixed2: #{array_mixed2}”
puts “異なる型を含む和集合配列: #{union_mixed}”
“`
実行結果:
元の配列mixed1: [1, "apple", 3.14, 1]
元の配列mixed2: ["apple", :symbol, true, nil]
異なる型を含む和集合配列: [1, "apple", 3.14, :symbol, true, nil]
数値の1と文字列の"apple"は元の配列で重複していましたが、結果では一つずつになっています。数値の1と文字列の"apple"は型が異なるため重複とは見なされません。
空の配列との和集合
空の配列と| 演算子で和集合を取ると、非空の配列がそのまま結果となります。
“`ruby
array_non_empty = [10, 20]
array_empty = []
union_with_empty = array_non_empty | array_empty
union_empty_first = array_empty | array_non_empty
puts “非空配列と空配列の和集合: #{union_with_empty}”
puts “空配列と非空配列の和集合: #{union_empty_first}”
puts “空配列と空配列の和集合: #{array_empty | []}”
“`
実行結果:
非空配列と空配列の和集合: [10, 20]
空配列と非空配列の和集合: [10, 20]
空配列と空配列の和集合: []
複数の配列を一度に和集合
| 演算子も連鎖させることができます。
“`ruby
arr1 = [1, 2, 3]
arr2 = [3, 4, 5]
arr3 = [5, 6, 1]
union_all = arr1 | arr2 | arr3
puts “複数の配列の和集合: #{union_all}”
“`
実行結果:
複数の配列の和集合: [1, 2, 3, 4, 5, 6]
全ての配列に含まれるユニークな要素が集められています。
| 演算子の特徴と注意点
- 非破壊的: 元の配列は変更されず、常に新しい配列を生成して返します。
- 和集合: 重複する要素を排除し、ユニークな要素のみを収集します。
- 使用シーン: 複数のリストから重複を排除しつつ、すべての要素をリストアップしたい場合に最適です。例えば、複数のタグリストをまとめてユニークなタグのリストを作成する場合などに便利です。
- パフォーマンス: 重複チェックが必要なため、単純な連結(
+やconcat)に比べて要素数が多い場合の処理に時間がかかる可能性があります。
| 演算子は、集合論的な操作を行いたい場合に非常に強力なツールです。
4. push メソッドと << 演算子：要素を個別に追加（連結の一種）
pushメソッドと<<演算子（shovel演算子）は、配列の末尾に一つまたは複数の要素を追加するために使用されます。これらは厳密には「配列と配列を結合する」ためのものではありませんが、他の配列の要素を、ある配列に一つずつ追加していくことで、結果的に連結のような操作を実現できます。これらは破壊的な操作です。
基本的な使い方
push: 一つまたは複数の要素を引数に取り、それらを配列の末尾に追加します。<<: 一つの要素を引数に取り、それを配列の末尾に追加します。
“`ruby
array = [1, 2, 3]
puts “追加前: #{array}”
push で要素を追加
array.push(4)
puts “push(4)後: #{array}”
array.push(5, 6)
puts “push(5, 6)後: #{array}”
<< で要素を追加
array << 7
puts “<< 7 後: #{array}”
array << 8 << 9 # 連鎖も可能
puts “<< 8 << 9 後: #{array}”
“`
実行結果:
追加前: [1, 2, 3]
push(4)後: [1, 2, 3, 4]
push(5, 6)後: [1, 2, 3, 4, 5, 6]
<< 7 後: [1, 2, 3, 4, 5, 6, 7]
<< 8 << 9 後: [1, 2, 3, 4, 5, 6, 7, 8, 9]
どちらも元の配列を変更しています。
他の配列の要素を一つずつ追加する
他の配列の要素を現在の配列に追加したい場合、これらのメソッドとイテレータ（eachなど）を組み合わせて使用できます。
“`ruby
array1 = [1, 2]
array2 = [3, 4, 5]
puts “結合前 array1: #{array1}”
puts “結合前 array2: #{array2}”
array2 の各要素を array1 に push
array2.each do |element|
array1.push(element)
end
puts “each + push 結合後 array1: #{array1}”
別のアプローチ: each + <<
array3 = [6, 7]
array4 = [8, 9]
puts “結合前 array3: #{array3}”
puts “結合前 array4: #{array4}”
array4.each do |element|
array3 << element
end
puts “each + << 結合後 array3: #{array3}”
“`
実行結果:
結合前 array1: [1, 2]
結合前 array2: [3, 4, 5]
each + push 結合後 array1: [1, 2, 3, 4, 5]
結合前 array3: [6, 7]
結合前 array4: [8, 9]
each + << 結合後 array3: [6, 7, 8, 9]
このように、他の配列の要素をループで取り出し、pushや<<で追加することで、結果として配列の連結と同じ効果を得ることができます。
push / << の特徴と注意点
- 破壊的: レシーバである元の配列自身が変更されます。
- 要素の追加: 基本的には個別の要素を追加するためのメソッドです。配列を引数として渡すと、その配列オブジェクト自体が要素として追加されます（後述）。
- 返り値: 変更されたレシーバ自身（元の配列オブジェクト）を返します。
- パフォーマンス: 一度に多くの要素を追加するよりも、少数の要素を繰り返し追加する場合に適しています。特に、ループ内で要素を収集していくようなシナリオで頻繁に使用されます。
pushvs<<:pushは複数の要素を一度に追加できますが、<<は一度に一つの要素しか追加できません。しかし、<<はメソッドチェーンとして記述できるため、連続して要素を追加したい場合に簡潔に書けます。
配列オブジェクト自体を追加する場合
注意点として、pushや<<に配列オブジェクトそのものを引数として渡すと、その配列が要素として追加されます。配列の中身が展開されて追加されるわけではありません。
“`ruby
array = [1, 2]
other_array = [3, 4]
puts “追加前: #{array}”
array.push(other_array)
puts “push(other_array)後: #{array}” # 配列が要素として追加される
array2 = [5, 6]
other_array2 = [7, 8]
puts “追加前2: #{array2}”
array2 << other_array2
puts “<< other_array2 後: #{array2}” # 配列が要素として追加される
“`
実行結果:
追加前: [1, 2]
push(other_array)後: [1, 2, [3, 4]]
追加前2: [5, 6]
<< other_array2 後: [5, 6, [7, 8]]
この結果からわかるように、配列がそのままネストされた形で追加されています。もし配列の要素をフラットに追加したい場合は、concatメソッドを使うか、前述のようにeachと組み合わせて要素を一つずつ追加する必要があります。
5. unshift メソッド：要素を先頭に追加（連結の一種）
unshiftメソッドは、pushや<<とは逆に、配列の先頭に一つまたは複数の要素を追加します。これも破壊的な操作です。
基本的な使い方
unshiftメソッドは、一つまたは複数の要素を引数に取り、それらを配列の先頭に追加します。
“`ruby
array = [4, 5, 6]
puts “追加前: #{array}”
unshift で要素を先頭に追加
array.unshift(3)
puts “unshift(3)後: #{array}”
array.unshift(1, 2) # 複数の要素を引数に渡すと、引数の順序で先頭に追加される
puts “unshift(1, 2)後: #{array}”
“`
実行結果:
追加前: [4, 5, 6]
unshift(3)後: [3, 4, 5, 6]
unshift(1, 2)後: [1, 2, 3, 4, 5, 6]
複数の要素を渡した場合、引数の順序（この例では1, 2）で先頭に追加されることに注意してください。つまり、[4, 5, 6].unshift(1, 2) は [4, 5, 6].unshift(1).unshift(2) と同じ結果にはなりません。後者の場合は [1, 4, 5, 6].unshift(2) となり、結果は [2, 1, 4, 5, 6] となります。
他の配列の要素を先頭に一つずつ追加する
他の配列の要素を先頭に追加したい場合も、イテレータと組み合わせることができます。ただし、元の配列の要素の順序を維持したい場合は、追加する配列を逆順にしてからunshiftする必要があります。
“`ruby
array1 = [3, 4]
array2 = [1, 2]
puts “結合前 array1: #{array1}”
puts “結合前 array2: #{array2}”
array2 の各要素を array1 の先頭に unshift
array2 を逆順にしてから unshift することで、array2 の元の順序を array1 の先頭で再現できる
array2.reverse.each do |element|
array1.unshift(element)
end
puts “each + unshift 結合後 array1: #{array1}”
“`
実行結果:
結合前 array1: [3, 4]
結合前 array2: [1, 2]
each + unshift 結合後 array1: [1, 2, 3, 4]
unshift の特徴と注意点
- 破壊的: レシーバである元の配列自身が変更されます。
- 先頭への追加: 要素を配列の先頭に追加します。
- 返り値: 変更されたレシーバ自身（元の配列オブジェクト）を返します。
- パフォーマンス: 配列の先頭に要素を追加する操作は、末尾に追加する操作（
push,<<,concat）に比べて一般的にパフォーマンスコストが高くなります。これは、先頭に新しい要素のためのスペースを確保するために、既存の全ての要素をメモリ上でずらす必要があるためです。大量の要素を持つ配列に対して頻繁に行う操作としては推奨されません。 - 使用シーン: 配列の先頭に少数の要素を追加したい場合や、スタックのようなLIFO（Last-In, First-Out）構造を配列で模倣する際に使用できます（ただし、LIFOには
pushとpopを使うのが一般的です）。
unshiftもpush/<<と同様に、配列オブジェクト自体を引数に渡すと、配列がネストされた形で要素として追加されます。
“`ruby
array = [3, 4]
other_array = [1, 2]
puts “追加前: #{array}”
array.unshift(other_array)
puts “unshift(other_array)後: #{array}” # 配列が要素として追加される
“`
実行結果:
追加前: [3, 4]
unshift(other_array)後: [[1, 2], 3, 4]
6. ネストされた配列の結合：flatten メソッド
これまでの方法は、二つの配列を並べて連結したり、ユニークな要素を集めたりするものでした。しかし、配列の要素として別の配列が含まれている、いわゆる「ネストされた配列」を、一つの平坦な（フラットな）配列にしたい場合があります。このような場合に役立つのがflattenメソッドです。
flattenメソッドは、ネストされた配列を再帰的に平坦化し、新しい一次元配列を返します。元の配列は変更されません（非破壊的な操作）。破壊的なバージョンとしてflatten!メソッドもあります。
基本的な使い方
flattenメソッドを配列オブジェクトに対して呼び出します。
“`ruby
nested_array = [1, [2, 3], [4, [5, 6], 7], 8]
puts “ネストされた配列: #{nested_array}”
flatten で平坦化
flattened_array = nested_array.flatten
puts “平坦化された配列: #{flattened_array}”
puts “元の配列: #{nested_array}” # 元の配列は変更されない
“`
実行結果:
ネストされた配列: [1, [2, 3], [4, [5, 6], 7], 8]
平坦化された配列: [1, 2, 3, 4, 5, 6, 7, 8]
元の配列: [1, [2, 3], [4, [5, 6], 7], 8]
すべてのネストが解除され、一次元の配列になっています。
破壊的な flatten!
元の配列を直接変更したい場合は、破壊的なflatten!メソッドを使用します。
“`ruby
nested_array = [1, [2, 3], [4, [5, 6], 7], 8]
puts “flatten!前の配列: #{nested_array}”
nested_array.flatten!
puts “flatten!後の配列: #{nested_array}”
“`
実行結果:
flatten!前の配列: [1, [2, 3], [4, [5, 6], 7], 8]
flatten!後の配列: [1, 2, 3, 4, 5, 6, 7, 8]
深さの指定
flattenメソッドには引数として整数を渡すことができ、これは平坦化する深さを指定します。例えば、flatten(1)とすると、最も外側のネストだけを解除します。
“`ruby
nested_array = [1, [2, 3], [4, [5, [6, 7]], 8], 9]
puts “元の配列: #{nested_array}”
深さ1まで平坦化
flattened_level1 = nested_array.flatten(1)
puts “深さ1で平坦化: #{flattened_level1}”
深さ2まで平坦化
flattened_level2 = nested_array.flatten(2)
puts “深さ2で平坦化: #{flattened_level2}”
深さ3まで平坦化 (完全に平坦化される)
flattened_level3 = nested_array.flatten(3)
puts “深さ3で平坦化: #{flattened_level3}”
深さ0または負の値 => 完全に平坦化される
flattened_level0 = nested_array.flatten(0)
puts “深さ0で平坦化: #{flattened_level0}”
flattened_level_neg = nested_array.flatten(-1) # -1も完全に平坦化
puts “深さ-1で平坦化: #{flattened_level_neg}”
“`
実行結果:
元の配列: [1, [2, 3], [4, [5, [6, 7]], 8], 9]
深さ1で平坦化: [1, 2, 3, 4, [5, [6, 7]], 8, 9]
深さ2で平坦化: [1, 2, 3, 4, 5, [6, 7], 8, 9]
深さ3で平坦化: [1, 2, 3, 4, 5, 6, 7, 8, 9]
深さ0で平坦化: [1, 2, 3, 4, 5, 6, 7, 8, 9]
深さ-1で平坦化: [1, 2, 3, 4, 5, 6, 7, 8, 9]
深さを指定することで、どのレベルまでネストを解除するかを制御できます。引数を省略した場合や、0または負の値を指定した場合は、完全に平坦化されます。
flatten の特徴と注意点
- 非破壊的/破壊的:
flattenは非破壊的、flatten!は破壊的です。 - ネストの解消: 配列の要素に含まれる配列を展開します。
- 引数: 深さを指定する整数を引数に取ることができます。
- 使用シーン: 要素として他の配列を含む配列を、単一のリストとして扱いたい場合に非常に便利です。例えば、データベースから関連データをまとめて取得した結果がネストされた配列になった場合などに、後続の処理のために平坦化したいといったシナリオが考えられます。
- パフォーマンス: ネストの深さや配列のサイズによっては、それなりの処理時間を要する場合があります。
7. その他の関連する方法
上記の主要な方法以外にも、配列結合に関連する様々なアプローチやメソッドが存在します。
* 演算子（Array Splat / 要素の展開）
* 演算子は、配列の要素を「展開」するために使用できます。これは直接的な配列結合の演算子ではありませんが、メソッドの引数リストなどで配列の要素を個別に渡したい場合によく使われ、間接的に結合に関連する状況で使用されることがあります。
例えば、pushメソッドに複数の要素を追加したい場合、要素をまとめた配列を*で展開して渡すことができます。
“`ruby
array = [1, 2]
elements_to_add = [3, 4, 5]
puts “追加前: #{array}”
elements_to_add の要素を * で展開して push に渡す
array.push(*elements_to_add)
puts “push(*elements_to_add)後: #{array}”
“`
実行結果:
追加前: [1, 2]
push(*elements_to_add)後: [1, 2, 3, 4, 5]
これは array.push(3, 4, 5) と同じ効果を持ちます。concatの場合は引数が配列であることを期待するのでconcat(*elements_to_add)とは通常使いません（concat(elements_to_add)とします）。* splatは主にメソッドの引数や、他の配列や集合的なオブジェクトから要素を取り出して新しい配列を作る場合などに利用されます。
例えば、複数の配列リテラルを簡単に結合したい場合にも使えます。
“`ruby
arr1 = [1, 2]
arr2 = [3, 4]
arr3 = [5, 6]
[] を使って新しい配列を作り、その中に * で展開した要素を入れる
combined_array = [arr1, arr2, *arr3]
puts “[] と * で結合: #{combined_array}”
“`
実行結果:
[] と * で結合: [1, 2, 3, 4, 5, 6]
これは arr1 + arr2 + arr3 と同じ結果になります。* 演算子を使うと、配列だけでなく、Rangeやその他のEnumerableオブジェクトの要素も展開して配列に含めることができます。
“`ruby
numbers = [1, 2]
range = (5..8)
string_chars = “abc”.chars # [“a”, “b”, “c”]
combined_from_various = [numbers, 3, 4, range, *string_chars]
puts “様々なオブジェクトからの結合: #{combined_from_various}”
“`
実行結果:
様々なオブジェクトからの結合: [1, 2, 3, 4, 5, 6, 7, 8, "a", "b", "c"]
この* splatを使った方法は、新しい配列を作成しつつ、複数の配列や他の列挙可能なオブジェクトから要素を取り込んで初期化する際に非常に便利です。
product メソッド：デカルト積
これは厳密には「結合」とは少し異なりますが、二つの配列から要素を組み合わせて新しい配列の配列（タプル）を作成する操作として関連性が高いです。productメソッドは、二つの配列のデカルト積を計算します。
“`ruby
colors = [“Red”, “Blue”]
sizes = [“S”, “M”, “L”]
デカルト積を計算
combinations = colors.product(sizes)
puts “デカルト積: #{combinations}”
“`
実行結果:
デカルト積: [["Red", "S"], ["Red", "M"], ["Red", "L"], ["Blue", "S"], ["Blue", "M"], ["Blue", "L"]]
これは配列の要素をペアにして、考えられる全ての組み合わせを新しい配列（要素は二要素の配列）として返します。これは、異なるリストの要素を組み合わせて、すべての可能な組み合わせを生成したい場合に役立ちます。
zip メソッド：要素ごとの結合
zipメソッドは、複数の配列から同じインデックス位置にある要素を取り出し、それらをまとめて新しい配列（タプル）を作成します。これは「縦方向に」配列を結合するイメージです。
“`ruby
names = [“Alice”, “Bob”, “Charlie”]
ages = [25, 30, 35]
cities = [“Tokyo”, “Osaka”, “Fukuoka”]
zip メソッドで要素ごとに結合
combined_info = names.zip(ages, cities)
puts “Zip結合: #{combined_info}”
“`
実行結果:
Zip結合: [["Alice", 25, "Tokyo"], ["Bob", 30, "Osaka"], ["Charlie", 35, "Fukuoka"]]
これは配列の要素をペアやタプルとしてまとめたい場合に非常に便利です。例えば、関連する情報を異なる配列で保持している場合に、それをまとめて処理しやすくするのに使われます。要素数が異なる配列をzipした場合、短い方の配列の長さに合わせて結合が行われます。長い方の配列の余分な要素は無視されます。
“`ruby
short_list = [1, 2]
long_list = [:a, :b, :c, :d]
zipped = short_list.zip(long_list)
puts “要素数が異なるZip結合: #{zipped}”
zipped_reversed = long_list.zip(short_list)
puts “要素数が異なるZip結合 (逆): #{zipped_reversed}”
“`
実行結果:
要素数が異なるZip結合: [[1, :a], [2, :b]]
要素数が異なるZip結合 (逆): [[:a, 1], [:b, 2]]
各結合方法の比較と選択
これまで見てきたように、Rubyには様々な配列結合の方法があります。それぞれの方法には利点と欠点があり、解決したい問題に応じて最適な方法を選択することが重要です。
主要な方法について、その特徴を比較表にまとめます。
| 方法 | 操作のタイプ | 破壊的/非破壊的 | 重複の扱い | 主な使用シーン | パフォーマンスに関する考慮事項 |
|---|---|---|---|---|---|
+ |
連結 | 非破壊的 | 保持 | 手軽な連結、元の配列を保持したい | 大規模配列の繰り返し結合は非効率 |
concat |
連結 | 破壊的 | 保持 | 元の配列を変更したい、大規模配列の結合、ループ内追加 | 一般的に+より効率的 (特に大規模配列) |
| |
和集合 | 非破壊的 | 排除 (ユニーク) | 重複を排除しつつ要素を収集したい | 重複チェックのコストがかかる |
push / << |
要素追加 | 破壊的 | 保持 | 個別の要素追加、ループ内での要素収集 | 少量要素の追加に適している。配列オブジェクト自体を渡すとネストされる。 |
unshift |
要素追加 | 破壊的 | 保持 | 配列の先頭に要素を追加したい | 配列の先頭に要素を追加する操作はパフォーマンスコストが高い傾向がある |
flatten |
平坦化 | 非破壊的 | 保持 | ネストされた配列を一次元にしたい | ネストの深さや配列のサイズによる。オプションで深さ指定可能。 |
flatten! |
平坦化 | 破壊的 | 保持 | ネストされた配列を一次元にしたい (元の配列を変更) | flattenと同様 |
* (splat) |
要素展開 | (新しい配列生成) | 保持 | 新しい配列初期化時、メソッド引数への配列要素展開 | 要素展開のコストは発生する |
product |
デカルト積 | 非破壊的 | なし | 要素の組み合わせをすべて列挙したい | 生成される配列の要素数が急増しうる (array1.size * array2.size) |
zip |
要素結合 | 非破壊的 | なし | 関連する要素をまとめてタプルにしたい | 短い方の配列の長さに制限される |
どの方法を選ぶか？
-
最もシンプルに二つの配列を連結したい（元の配列を変更しない）:
+演算子。最も直感的で読みやすい方法です。
-
二つの配列を連結し、最初の配列を変更したい:
concatメソッド。破壊的な操作が必要な場合や、パフォーマンスを重視する場合に適しています。
-
二つの配列の要素をすべて集めたいが、重複は排除したい:
|演算子。和集合が必要な場合に迷わずこれを選びましょう。
-
繰り返し処理の中で、配列に要素を一つずつ追加していきたい:
pushまたは<<演算子。ループ内での要素収集によく使われます。
-
配列の先頭に要素を追加したい:
unshiftメソッド。ただし、パフォーマンスに注意が必要です。
-
配列の要素が配列になっており、それらを平坦な一つの配列にしたい:
flattenまたはflatten!メソッド。ネストの深さを指定することも可能です。
-
複数の配列や他のコレクションの要素を使って新しい配列を効率的に作りたい:
*splat 演算子を使った配列リテラルの記法 ([*arr1, *arr2]) が便利です。
-
二つの配列からすべての可能な要素の組み合わせリストを作りたい:
productメソッド。
-
複数の配列の同じインデックスの要素を組にしてリストを作りたい:
zipメソッド。
最終的には、コードの可読性、パフォーマンス要件、そして「元の配列を変更するかしないか」「重複を許容するかしないか」「ネストをどう扱うか」といった具体的な要件に基づいて、最適な方法を選択することになります。
パフォーマンスに関する詳細な考察
配列の結合方法を選択する際に、特に大規模なデータを扱う場合はパフォーマンスが重要な要素となります。
-
+演算子: 新しい配列オブジェクトを生成するため、元の配列が大きい場合や、ループの中で繰り返し+を使用して要素を追加していくようなシナリオでは、頻繁なメモリ割り当てとコピーが発生し、パフォーマンスのボトルネックになりやすいです。例えば、result = []から始めて(1..100000).each {|i| result = result + [i]}のように書くと非常に遅くなります。 -
concatメソッド: 既存の配列のメモリ領域を拡張して要素を追加するため、新しい配列の生成と比較して効率が良いです。特に、前述の例のようにループの中で配列を成長させていく場合は、result = []から始めて(1..100000).each {|i| result.concat([i])}（またはresult << iやresult.push(i)) の方が遥かに高速です。複数の配列を一度にconcat(arr1, arr2, ...)で渡すのも効率的です。 -
|演算子: 和集合を計算するためには、要素の重複チェックが必要です。Rubyの内部では、おそらくハッシュテーブルのような構造を使って効率的に重複を管理していますが、それでも要素が増えれば増えるほど、チェックにかかる時間は増加します。単純な連結に比べると、一般的にコストが高くなります。 -
push/<<: 末尾への要素追加は、配列の構造上、通常非常に効率的です（償却定数時間）。これは、配列の末尾に十分な空き領域がある場合が多いためです。ループ内での要素追加に最適です。 -
unshift: 配列の先頭への要素追加は、既存の要素を全てずらす必要があるため、配列のサイズに比例したコスト（線形時間）がかかります。大規模な配列に対して頻繁にunshiftを行うと、パフォーマンスに大きな影響を与えます。 -
flatten/flatten!: ネストされた配列の構造を解析し、新しい配列を構築（または既存の配列を変更）するため、配列全体の要素数やネストの深さに応じたコストがかかります。 -
*(splat): 要素の展開自体にコストはかかりますが、新しい配列を初期化する際に複数のソースから要素を取り込むのは効率的な方法の一つです。
結論として、パフォーマンスが懸念される大規模データや繰り返し処理においては、以下の点を考慮してください。
- 配列を成長させる場合は、
concatまたはpush/<<を使う。 - 新しい配列を生成する場合でも、
+よりはconcatを使用して一度に結合するか、または*splat を利用する方が良い場合がある。 - 先頭への追加（
unshift）はパフォーマンス的に不利であることを理解する。 - 和集合 (
|) は重複チェックのコストがかかることを理解する。
ただし、小規模な配列を扱う場合や、処理回数が少ない場合は、パフォーマンスの差はほとんど無視できるレベルであり、コードの可読性や簡潔さを優先して+演算子などを選択するのが良いでしょう。常に「まず読みやすさ、必要ならパフォーマンス」という考え方が重要です。
まとめ：最適な結合方法を選択するために
Rubyで配列を結合する方法は多岐にわたります。それぞれが異なる目的と特徴を持っています。
- 連結 (
+,concat,push/<<,unshift): 要素を単に並べる操作。+は非破壊的、他は破壊的。push/<</unshiftは要素単位の追加だが、イテレータと組み合わせることで他の配列の要素を追加できる。 - 和集合 (
|): 重複を排除し、ユニークな要素を集める操作。非破壊的。 - 平坦化 (
flatten,flatten!): ネストされた配列を一次元にする操作。flattenは非破壊的、flatten!は破壊的。 - その他の関連 (
*splat,product,zip): 新しい配列の構築、要素の組み合わせ、要素ごとのタプル化など、特定のニーズに対応する。
どの方法を選択するかは、以下の点を考慮して判断します。
- 破壊的か非破壊的か: 元の配列を保持したいか、それとも変更しても構わないか。
- 重複をどう扱うか: 重複を保持したいか、それとも排除したいか。
- 結合の方向/構造: 末尾に追加したいか、先頭に追加したいか、ネストを解消したいか、要素を組み合わせたいか。
- パフォーマンス: 大規模データや繰り返し処理があるか。
- 可読性: コードの意図が明確に伝わるか。
これらの観点から、あなたのプログラムの要件に最も合った方法を選択してください。多くの場合は+やconcat、|が主要な選択肢となるでしょう。ループ処理での要素収集にはpush/<<が適しています。ネストの解消にはflattenが不可欠です。
Rubyの配列操作は非常に柔軟で強力です。様々なメソッドや演算子を理解し、適切に使い分けることで、より効率的で読みやすいコードを書くことができるようになります。
この記事が、あなたがRubyでの配列結合をマスターするための一助となれば幸いです。実際に様々なコードを書いてみて、それぞれの方法の挙動や特徴を体感してみてください。練習あるのみです！
これで、Rubyでの配列結合に関する徹底解説を終わります。