【Ruby】配列（Array）とは？初心者でもわかりやすい使い方と活用例を解説

プログラミング言語•2025/2/15

はじめに

Rubyでプログラミングを始めると、データを効率的に扱うために配列を使う機会が多いのではないでしょうか。
配列は複数のデータを1つにまとめ、並べて管理できる便利な機能です。
たとえば、ユーザー情報や商品の一覧を管理するときに配列が活躍します。
そうはいっても、具体的にどのように使えばよいか迷うこともあるかもしれません。
この記事では、Rubyにおける配列の基本的な使い方から実務での活用シーンまで、初心者の方でもわかりやすいように段階的に解説します。

この記事を読むとわかること

配列 (Array) の基本的な考え方
要素の追加・削除・参照・置き換え方法
繰り返しや検索を行うための主なメソッド
実務で想定される配列の活用例
トラブルを回避するためのヒント

これらのポイントを理解することで、配列を使ったデータ処理をよりスムーズに進められるようになります。
身近な例も交えて紹介しますので、初心者の方でも安心して読み進めてみてください。

Rubyの配列とは何か

配列は、複数の要素を順番に並べて管理するための仕組みです。
たとえば「りんご」「バナナ」「みかん」といった文字列を一つのまとまりとして扱うことができます。
Rubyでは Array クラスを使って実装されており、[] を利用して要素を並べるのが基本です。

Rubyの場合、配列は文字列・数値・真偽値などさまざまな型のデータを混在させることができる特徴があります。
これは他の言語と比べるととても柔軟です。
ただし、柔軟すぎて混乱してしまうケースもあるため、後ほどのセクションで実務における注意点も解説していきます。

配列を使うメリット

配列を使うと、複数のデータをまとめて処理できるため、次のような利点があります。

データを一括で管理しやすい
繰り返し処理がしやすい
検索や並び替えを簡単に実装できる

実務ではユーザーのメールアドレスの一覧や、Webアプリの投稿一覧の管理などで頻繁に用いられます。
配列を使いこなせるようになると、複数のデータをまとめて操作するときに大変便利です。

配列の基本的な操作

配列の代表的な操作は次のとおりです。

要素の追加
要素の削除
要素の取得（参照）
要素の置き換え

ここでは基本的なメソッドについて、実務シーンと関連づけながら解説します。

要素の追加

Rubyの配列に要素を追加する方法は、主に push, <<, unshift, insert などがあります。
これらを使うことで、配列の末尾や先頭、特定の位置に新しい要素を挿入することができます。


# 配列の末尾に要素を追加する例
fruits = ["apple", "banana"]
fruits.push("orange")  # => ["apple", "banana", "orange"]
fruits << "melon"      # => ["apple", "banana", "orange", "melon"]

# 配列の先頭に要素を追加する例
vegetables = ["carrot", "onion"]
vegetables.unshift("tomato")  # => ["tomato", "carrot", "onion"]

# 指定した位置に要素を挿入する例
numbers = [10, 20, 40]
numbers.insert(2, 30)         # => [10, 20, 30, 40]

実務のシーンで考えると、たとえばSNSのタイムラインを配列で管理しているとき、新しい投稿は末尾や先頭に追加していくケースが多いです。
表示順によって、最初に表示したい場合は unshift、逆に最後に追加していくなら push や << を使えばOKです。

要素の削除

要素を削除する場合は、末尾を削除する pop、先頭を削除する shift、指定した要素を削除する delete、インデックス指定の削除なら delete_at などを使います。


# 末尾を削除する例
fruits = ["apple", "banana", "orange"]
last_fruit = fruits.pop      # last_fruit => "orange", fruits => ["apple", "banana"]

# 先頭を削除する例
vegetables = ["tomato", "carrot", "onion"]
first_vegetable = vegetables.shift  # first_vegetable => "tomato", vegetables => ["carrot", "onion"]

# 配列内の特定要素を削除する例
numbers = [10, 20, 30, 40, 50]
numbers.delete(30)           # => [10, 20, 40, 50]

# インデックスを指定して削除する例
numbers.delete_at(2)         # => [10, 20, 50]

Webサービスなどで登録済みのデータを消す場面を想像すると、削除メソッドはよく利用されます。
ユーザーが投稿を取り消したい場合や、カートから商品を取り除きたい場合にもこれらのメソッドを利用することが多いでしょう。

要素の取得

特定の要素にアクセスするときは、インデックスを利用します。
インデックスは0から始まるため、1番目の要素は array[0] となります。
Rubyでは、マイナスのインデックスを使って後ろから要素を取得することも可能です。


fruits = ["apple", "banana", "orange"]
p fruits[0]   # => "apple"
p fruits[-1]  # => "orange" (最後の要素)

また、配列の範囲を指定して複数の要素を取得することもできます。


numbers = [1, 2, 3, 4, 5]
p numbers[1..3]    # => [2, 3, 4]
p numbers[2, 2]    # => [3, 4]  (2番目から2個)

このように、実務ではユーザー情報の中から特定の要素だけ取得するケースや、ページネーションで一部のデータを切り出すケースが考えられます。
範囲指定を上手く使うと、画面に表示するデータを効率的に取り出すことができます。

要素の置き換え

要素の内容を変更する場合も、インデックスを使って直接代入するだけでOKです。


fruits = ["apple", "banana", "orange"]
fruits[1] = "grape"    # => ["apple", "grape", "orange"]

大量のデータに対して一部だけ変更する需要は、実務ではよくあります。
投稿のタイトル部分だけ修正したいとか、在庫数の数字だけ更新したいときにも同じ考え方が適用できます。

繰り返し処理と検索のための主なメソッド

配列の要素に対して繰り返し処理を行うには、Rubyの each や map を使うのが一般的です。
また、検索や抽出をするときには select, find, include? などが便利です。

each

each は配列の要素を順番に取り出して処理を行うメソッドです。
実務で最もよく見かけるパターンの一つと言えます。


users = ["Alice", "Bob", "Carol"]
users.each do |user|
  puts "Hello, #{user}!"
end

ここでは単純に文字列を出力する例を紹介していますが、実際にはデータベースへの登録処理や、ファイルへの書き込みなど幅広く応用されます。

map

map は各要素に対して指定した処理を行い、その結果を新しい配列にして返してくれるメソッドです。
たとえば、文字列をすべて大文字に変換するときや、数値を2倍にするようなケースで使われます。


numbers = [1, 2, 3, 4, 5]
doubles = numbers.map { |num| num * 2 }
p doubles  # => [2, 4, 6, 8, 10]

何らかの変換処理をまとめて行いたいときに大活躍します。
実務でも、ユーザー入力のフォーマットを統一する場合などにとても便利です。

select

select は配列の要素の中から、条件を満たすものだけを取り出して新しい配列を作ります。
たとえば、ある条件に合う商品だけを抽出するときなどに使います。


numbers = [10, 25, 30, 45, 60]
filtered = numbers.select { |num| num > 30 }
p filtered  # => [45, 60]

実務の例としては、在庫が一定数以上の商品を絞り込む、売上が特定金額以上のユーザーのみ集計する、といった場面に応用できます。

find

find は配列の中から、条件を満たす最初の要素を取得します。
複数要素ではなく、最初のヒットを取る場合に向いています。


users = [
  { name: "Alice", age: 25 },
  { name: "Bob",   age: 30 },
  { name: "Carol", age: 19 }
]

adult = users.find { |u| u[:age] >= 20 }
p adult  # => {:name=>"Alice", :age=>25}

実務では「指定したIDを持つユーザー情報を探す」といったケースによく使われるでしょう。
大量のデータを扱うアプリケーションでは、複数レコードをまとめて取得した後、該当する1件だけ見つけたいときに便利です。

include?

配列に特定の要素が含まれているかどうかを判定するときは include? を使います。


fruits = ["apple", "banana", "orange"]
p fruits.include?("banana")  # => true
p fruits.include?("grape")   # => false

ユーザーが入力したデータが既に存在するかどうかをチェックしたり、アクセス権の判定に使ったりすることが考えられます。

配列のブロックやイテレータを活用する

Rubyでは、配列に対してさらに高度な操作を行うためにブロックやイテレータを活用します。
たとえば each_with_index を使うと、要素とインデックスを同時に扱うことができます。


fruits = ["apple", "banana", "orange"]
fruits.each_with_index do |fruit, i|
  puts "#{i}番目の要素は#{fruit}です"
end

こういったイテレータを知っておくと、複雑な処理をコンパクトに書けるようになります。
実務でも、画面表示で「何番目の商品なのか」を示したいときに、インデックス付きで処理すると便利です。

配列の結合や分割

配列の要素を結合して1つの文字列にしたり、文字列から配列を作り直したいケースもあります。


fruits = ["apple", "banana", "orange"]
joined_string = fruits.join(", ")
p joined_string  # => "apple, banana, orange"

split_result = joined_string.split(", ")
p split_result   # => ["apple", "banana", "orange"]

join : 配列を文字列に結合する
split : 文字列を区切り文字で分割して配列に変換する

実務だと、CSV形式のデータやユーザーからの入力を扱うときに使うことが多いです。
ファイル出力時に要素をカンマ区切りで書き出したい場合などが典型的な例です。

配列のソート

ソートが必要になるケースも多々あります。
Rubyでは sort メソッドを使うことで、簡単に配列を並び替えることができます。


numbers = [50, 20, 30, 10, 40]
p numbers.sort      # => [10, 20, 30, 40, 50]
p numbers.sort.reverse  # => [50, 40, 30, 20, 10]

実務の例では、売上金額の大きい順に並び替えたり、登録日順にリストを作ったりする用途があります。
Rubyは強力な並び替え機能を備えているため、さまざまなカスタマイズが可能です。

配列のユニーク化

配列から重複を取り除くこともよく行われます。
Rubyでは uniq を使うことで、重複要素をまとめて排除して新たな配列を取得できます。


numbers = [10, 20, 10, 30, 20, 40]
unique_numbers = numbers.uniq
p unique_numbers  # => [10, 20, 30, 40]

ユーザーからの重複データが混在している場合や、カテゴリーを一覧表示するときなどに便利です。
重複した値があると困る場面では、事前に uniq を適用しておくと安心できます。

多次元配列について

配列の中にさらに配列を入れることで、多次元の配列を扱うことができます。
たとえば、行列のデータを表現したり、ユーザーごとの購入履歴などをリストのリストとして持つイメージです。


matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]
p matrix[0][2]  # => 3  (1行目の3番目)

実務の例としては、ページごとに情報を階層的に持ちたいケースや、2次元的な座標データを扱いたいケースがあります。
多次元配列は少々複雑になるため、扱いやすい構造に整えておくと後からメンテナンスしやすいでしょう。

配列とハッシュの組み合わせ

Rubyの配列は、ハッシュ（Hash）と組み合わせて使うことも多いです。
たとえば、ユーザーの情報をハッシュで保持して、それを複数まとめて配列にするなどの使い方です。


users = [
  { name: "Alice", age: 25 },
  { name: "Bob",   age: 30 },
  { name: "Carol", age: 19 }
]

users.each do |user|
  puts "名前: #{user[:name]}, 年齢: #{user[:age]}"
end

実務的には、ユーザー情報・商品情報・注文情報などをまとめるときにごく一般的な構造です。
配列とハッシュが自在に扱えるようになると、データ管理が格段に楽になります。

よくある落とし穴と注意点

配列はとても便利ですが、扱い方を誤るとトラブルの原因になることもあります。
ここではいくつか注意点を紹介しておきます。

インデックスの範囲外アクセス

Rubyの配列は範囲外をアクセスしてもエラーにはならず、nil を返す特徴があります。
誤って範囲外を参照しているときでも例外が発生しないため、バグに気づきにくいことがあります。


fruits = ["apple", "banana", "orange"]
p fruits[10]  # => nil

実務では、この nil が原因で処理が予期しない動きをする可能性があります。
意図しない範囲外アクセスをしないように、処理を細かくチェックしたり、要素数を事前に確認する習慣をつけましょう。

破壊的メソッドの使用

Rubyには破壊的メソッド（呼び出した配列を直接変更するメソッド）があります。
map!, select!, uniq! など、末尾に ! がついているものが代表例です。
これらを無意識に使うと、元の配列が意図せず変更されてしまうことがあります。


numbers = [1, 2, 3, 4, 5]
modified_numbers = numbers.map! { |n| n * 2 }
p modified_numbers  # => [2, 4, 6, 8, 10]
p numbers           # => [2, 4, 6, 8, 10] (元の配列も変更されてしまう)

実務では、元データが変わってしまうと、後続の処理が誤作動するリスクがあるため要注意です。
コピーを作成してから変更するなど、データの扱いを明確に分けると安心できます。

想定外の型混在

Rubyの配列はどんな型でも混在できるため、文字列と数値を同じ配列で扱うことができます。
しかし、実務的には「数値だけ」「文字列だけ」といった制約を設けた方がトラブルが減ります。


mixed_array = [1, "hello", true, 3.14]

型が混在すると、特定のメソッドを使ったときにエラーが発生する可能性があります。
開発メンバーが増えたときも、データの型がまちまちだと意図が伝わりにくいです。
できるだけ用途に応じて配列の型は揃えるようにしましょう。

実務での配列の活用シーン

Webアプリケーションにおける一覧表示

たとえば、ECサイトなどでは商品一覧を配列で取得し、画面に表示する機能があります。
登録順や在庫数、価格の安い順などで並び替えをして、その上で一部の要素だけ抽出するケースが典型的です。
この場合は sort, select, each などのメソッドを組み合わせて使うことが多いでしょう。

ユーザー管理と配列

ユーザー情報をハッシュで持ちつつ、それを配列でまとめるといった例です。
たとえば、Webサービスに登録しているユーザー全員を一括で処理したいときには、配列の繰り返し処理が便利です。
必要に応じて、特定のIDだけを find で取り出すケースも考えられます。

ログや履歴データ

アプリケーションの動作履歴やアクセスログを配列で保存しておき、後から解析するという使い方もあります。
この場合はデータ件数が多くなるため、効率よく抽出（ select や find ）することがポイントです。
配列のままで管理しにくくなった場合は、データベースの利用も検討する必要があります。

フォーム入力の一括処理

複数行入力があるフォームの送信データを配列として受け取り、一括でDBに登録するような仕組みも考えられます。
この場合は、配列の各要素を一つずつ処理する必要があるため、繰り返し処理（ each や map ）を使うことが多いです。
入力チェックの過程で include? などを使用し、不正な値が含まれていないかを調べることもできます。

配列のパフォーマンス上の注意点

Rubyの配列操作は非常に柔軟ですが、大量データを扱う場合はパフォーマンスに気を配る必要があります。
例えば、配列の先頭に大量の要素を追加・削除する（unshift や shift）操作を頻繁に行うと、要素の並び替えに時間がかかります。
また、要素の検索を行うときに配列をまるごと走査すると、要素数が増えるほど処理が遅くなる場合があります。

大量のデータを扱う場合は、検索用にハッシュやセットを使う、またはデータベースで管理するなど方法を見直すほうが良い場合があります。

実務での開発では、配列の使いやすさと性能を総合的に考えて設計することが大事です。
極端にデータ量が多くなる場合は、配列だけでなくハッシュ、セット、または専用のデータベースを活用するとよいでしょう。

テストとデバッグのコツ

配列を使ったコードをテストするときは、まず期待する出力と実際の出力が正しく一致するかを確認するのが基本です。
たとえば次のようなパターンをテストケースに加えると、バグの早期発見につながります。

空の配列を操作した場合 : 要素追加や削除でエラーにならないか
範囲外アクセス : インデックスが誤った場合の挙動
特殊な文字列や型の混在 : 数値と文字列が混在している場合
破壊的メソッドの意図しない使用 : 元の配列の状態が変化していないか

実務ではバグが起きた場合に、配列の中身をデバッグ出力してトラブルシュートすることが多いです。
p array などで中身を見やすい形に出力すると、問題の原因を特定しやすくなります。

実務におけるデータ構造の選択

配列が便利である一方、実務では他のデータ構造を検討すべきケースもあります。
たとえば以下のような状況です。

検索が頻繁に行われる：ハッシュやセットのほうが高速な場合が多い
キーと値のペアを管理したい：ハッシュのほうがわかりやすい
データの追加・削除が先頭で頻繁に行われる：リンクリスト的な構造が向いている可能性がある

とはいえ、Rubyで最初に学ぶのは配列とハッシュが定番です。
基本的には配列で事足りる場面が多いですが、要件に応じて最適なデータ構造を選ぶことが大切です。

実務でのエラーハンドリング

配列操作を行うときに、万が一データが存在しなかったり空だったりする場合を想定しておきましょう。
たとえば、ユーザーからの入力で配列が空の場合、エラーにはならずとも想定外の動きになることがあります。
そういったときは事前に条件分岐を入れておくと安心です。


def process_list(items)
  if items.empty?
    puts "処理対象のデータがありません"
    return
  end

  items.each do |item|
    # 何らかの処理
  end
end

現実的には、フォームが空の状態でもサーバーにリクエストが送られてくる場合や、外部APIから空の配列が返ってくる場合もあります。
そうしたケースを想定してコードを書くことが、品質の高いプログラムを作るポイントです。

実装例：簡易Todoリスト

ここでは、配列を使ったシンプルなTodoリストの実装例を紹介します。
ターミナルからタスクを追加したり、一覧を表示したり、完了済みにしたりするイメージです。


tasks = []

loop do
  puts "1: タスク追加, 2: タスク一覧, 3: タスク完了, 4: 終了"
  input = gets.chomp

  case input
  when "1"
    puts "追加するタスクを入力してください"
    task = gets.chomp
    tasks << { title: task, done: false }
    puts "タスク「#{task}」が追加されました"
  when "2"
    puts "=== タスク一覧 ==="
    tasks.each_with_index do |t, i|
      status = t[:done] ? "[完]" : "[未]"
      puts "#{i}: #{t[:title]} #{status}"
    end
  when "3"
    puts "完了するタスクの番号を入力してください"
    num = gets.chomp.to_i
    if tasks[num]
      tasks[num][:done] = true
      puts "タスク「#{tasks[num][:title]}」を完了にしました"
    else
      puts "該当するタスクがありません"
    end
  when "4"
    break
  else
    puts "無効な入力です"
  end
end

このように、配列（ここでは tasks）を使うことで、複数のタスクをまとめて管理しています。
各タスクはハッシュ形式でタイトルと完了フラグを持っており、それを配列に格納しているという仕組みです。
実務のプロトタイプでも似たようなアイデアで管理画面やタスク管理機能を作ることがあります。

配列の可変長引数とメソッド定義

Rubyではメソッドを定義するときに可変長引数を使うことで、呼び出し側が複数の値を一度に渡せる仕組みが存在します。
受け取った引数は配列として管理されるため、配列を操作する知識が役立ちます。


def greet_all(*names)
  names.each do |name|
    puts "Hello, #{name}!"
  end
end

greet_all("Alice", "Bob", "Carol")
# Hello, Alice!
# Hello, Bob!
# Hello, Carol!

実務でも、未知の数の引数を受け取る必要があるメソッドを定義するときに、この可変長引数が役に立ちます。
メソッド内部では、引数が配列としてまとめられているので、配列の知識がそのまま応用できます。

まとめ

Rubyにおける配列 (Array)は、データをまとめて管理するうえで欠かせない存在です。
要素の追加・削除・取得・置き換えといった基本操作は、Webアプリやスクリプトなどあらゆる場面で活用されます。
さらに、繰り返し処理（each や map）や検索メソッド（select, find など）を使いこなすと、複雑な処理でも短いコードで書けるようになります。

実務で配列を使うときは、柔軟性が高い反面、「意図しない破壊的変更」や「範囲外アクセス」といったトラブルが起こりやすい点にも注意が必要です。
大量データを扱う際のパフォーマンスや、データ構造の選択も頭に入れておくと安心です。

とはいえ、Rubyの配列は簡単に書けて読みやすいコードを実現できる大切なツールです。
今後もコードを書いていく中で、配列の基礎をしっかり身につけて、効率的にデータを扱ってみてください。