【Ruby】injectとは？配列やハッシュをスマートに操作する方法を初心者にもわかりやすく解説

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

はじめに

Rubyのプログラムを書くときに、inject（またはreduce）というメソッドに出会うことがあるかもしれません。
このメソッドは、配列やハッシュなどの要素を一つずつ順に取り出して処理を行い、最終的に一つの値にまとめるときに使います。
単純な合計だけでなく、変数を追加で使わなくてもデータをまとめたり変換したりできるので、慣れると便利に感じるでしょう。

ただし、最初は少し抽象的な使い方に見えてしまうかもしれません。
本記事では、Ruby初心者の方でもわかりやすいように、injectの仕組みや具体的な活用例を段階的に説明していきます。

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

injectメソッドの基本的な動作や書き方
配列やハッシュなどを使った具体的なコード例
実際の業務や学習で出てくる応用的な使い方のポイント
injectを使うときの注意点やよくあるトラブル例

これらを理解すれば、Rubyのコードをよりコンパクトに書きやすくなります。

injectメソッドとは

RubyのEnumerableモジュールに含まれているメソッドの一つで、コレクション要素（配列、ハッシュ、範囲など）を順に取り出しながら、ある処理を積み重ねて最終的な値に集約することができます。

仕組み

injectは二つの引数を受け取るブロックが典型的です。
一つは蓄積用の変数、もう一つは配列やハッシュなどの各要素になります。
この二つを使って処理を行い、ブロックの戻り値が次のループでの蓄積用変数へと渡され、最終的な結果が返却される仕組みです。


# イメージコード
collection.inject(初期値) do |蓄積用の値, コレクションの要素|
  # 処理
  次に渡したい値
end

初期値は必須ではありません。
省略すると、最初の繰り返しのときには配列の先頭要素が「蓄積用の値」として使われます。
慣れないうちは初期値を明示的に書く方がわかりやすいこともあります。

reduceとの違い

Rubyでは、injectとほとんど同じ機能を持つreduceというメソッドもあります。
実は名前が違うだけで中身は同じです。
いずれを使っても同じ結果が得られるため、好みに応じて選べます。
コードレビューなどでは一貫して同じ方を使うことが多いかもしれません。

injectの基本的な書き方


array = [1, 2, 3, 4]

result = array.inject(0) do |sum, element|
  sum + element
end

puts result  # => 10

上の例では、初期値0を与えて、ブロック内でsum + elementを計算することで、最終的に配列内の全要素を合計した10が返されています。
このように**injectは「蓄積用の値 + コレクションの要素 => 次のステップに渡す」イメージ」で考えると理解しやすいです。

injectを使った配列の操作

数値の合計

配列に含まれる数字を合計する場合は、よくあるパターンです。
ループを書かずに集計をシンプルに表現できます。
下記のコード例を見てみましょう。


numbers = [5, 10, 15]

total = numbers.inject(0) do |sum, num|
  sum + num
end

puts total  # => 30

numbers.inject(0)によって、初期値0をsumにセットし、配列の要素を一つずつ取り出して合計を更新していきます。
最終的に、30が結果として得られます。

もし初期値を省略したらどうなる？

初期値を書かずにnumbers.injectのようにすると、最初の要素（この場合は5）が最初のsumに割り当てられます。


numbers = [5, 10, 15]

total_without_initial = numbers.inject do |sum, num|
  sum + num
end

puts total_without_initial  # => 30

結果は同じですが、配列が空の場合などに挙動が変わるので、最初は初期値を入れておく方が安全なケースもあります。

配列の要素を組み合わせて文字列を作る

数値に限らず、文字列をまとめる用途にも使えます。
たとえば配列の要素を結合して一つの文字列にするなどです。


words = ["Ruby", "on", "Rails"]

sentence = words.inject("") do |result, word|
  if result == ""
    word
  else
    result + " " + word
  end
end

puts sentence  # => "Ruby on Rails"

この例では、配列の各要素をスペース区切りで一つの文字列にまとめています。
inject("")によって初期値を空文字列に設定し、ブロック内で結合処理を行っている流れです。

配列から複雑なデータ構造を生成する

たとえば、配列の要素に応じてキーと値を変換してハッシュを作りたいときにもinjectが使えます。
配列の要素が連想配列の形になる場合など、injectでまとめると行数が少なくなることがあります。


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

user_hash = users.inject({}) do |memo, user|
  memo[user[:name]] = user[:age]
  memo
end

puts user_hash
# => {"Alice"=>20, "Bob"=>25, "Carol"=>30}

このようにinjectを使うことで、**「要素を読み取り→必要な処理→結果をまとめる」**という一連の流れを一箇所で実現できます。

injectを使ったハッシュの操作

ハッシュの値の合計

配列だけでなく、ハッシュでもinjectを活用できます。
たとえばキーが商品名、値が在庫数のようなハッシュがあった場合、合計の在庫を出すときには次のように書けます。


stocks = {
  "apple" => 100,
  "banana" => 50,
  "orange" => 75
}

total_stocks = stocks.inject(0) do |sum, (_, quantity)|
  sum + quantity
end

puts total_stocks  # => 225

ハッシュのブロックには、|(キー, 値)|のように要素を受け取ります。
この例ではキーは使わないため、_（アンダースコア）にしてわかりやすくしています。
合計値を求める場合に限らず、値を積み上げていくロジックに利用できます。

データをまとめる

たとえば、ハッシュの値を別の構造に変換しながら処理することも可能です。
キーと値を別々の配列に入れたいときにもinjectは有用です。


fruits = {
  "apple" => 100,
  "banana" => 50,
  "orange" => 75
}

separated = fruits.inject({ names: [], quantities: [] }) do |memo, (fruit, qty)|
  memo[:names] << fruit
  memo[:quantities] << qty
  memo
end

puts separated[:names].inspect      # => ["apple", "banana", "orange"]
puts separated[:quantities].inspect # => [100, 50, 75]

初期値として、名前を格納する配列と数量を格納する配列を含むハッシュを渡しています。
要素ごとにキーと値を振り分けていき、最終的に二つの配列がまとめられたハッシュを得る仕組みです。

実務でよくある活用シーン

集計（サマリー）作業

売上データなど、行ごとの数値をまとめて集計するときによく使われます。
たとえば下記のように、配列に日別の売上情報が入っているケースです。


sales = [
  { date: "2025-01-01", amount: 2000 },
  { date: "2025-01-02", amount: 3000 },
  { date: "2025-01-03", amount: 1500 },
]

total_sales = sales.inject(0) do |sum, record|
  sum + record[:amount]
end

puts total_sales  # => 6500

このような簡単な合計だけでなく、たとえばカテゴリー別の合計をまとめるときなどにも、injectを使ってハッシュに集約する手段が取られます。

ログ情報や統計データの集約

各行に含まれる特定の要素を抽出し、それをひとまとめにしてレポートを作成する場合、injectは重宝します。
たとえば下記のように、アクセスログからステータスコードの出現回数をまとめるイメージです。


logs = [
  { status: 200, path: "/home" },
  { status: 404, path: "/unknown" },
  { status: 200, path: "/users" },
  { status: 500, path: "/error" }
]

status_count = logs.inject(Hash.new(0)) do |memo, log|
  memo[log[:status]] += 1
  memo
end

puts status_count
# => {200=>2, 404=>1, 500=>1}

この場合、初期値としてHash.new(0)を渡すことで、存在しないキーにアクセスしても自動的に0が返ってくるようになっています。
ログの行数が多くても、一行一行で必要な情報だけを集計し続ける形になります。

injectのメリットとデメリット

メリット

コード量の削減

ループを用意して変数に値を足し込んでいく処理を、inject一つでまとめられます。

変数のスコープを最小限に抑えられる

メソッドチェーンの一部として書くこともできるので、変数を都度作らなくて済む場合があります。

表現が宣言的

「これを集計したい」「変換したい」という意図が、ある程度シンプルな形で読めることが多いです。

デメリット

初心者にはわかりにくい場合がある

ブロック引数を二つ使って最終的な値を返す仕組みが、直観的でないこともあります。

複雑な処理をinjectに詰め込みすぎると読みにくい

一つのブロックに条件分岐や複雑なロジックを入れすぎると、むしろ可読性が落ちる可能性があります。

慣れるまでは動きを追いにくい

途中経過が一時変数などに入らないため、初心者の方にはステップごとに状態を追いづらいという声も聞かれます。

injectのエラー対処と注意点

配列が空の場合

空の配列に対してinjectを呼び出すと、初期値が指定されていないときにエラーや予想外の値になることがあります。
例えば配列の合計を求めたいと思っていたのに、配列が空だとnilが返ってきて「つまずく」というケースです。
こういう場合は初期値をしっかり指定しておけば、0などの想定された結果が得られやすいです。


empty_list = []
p empty_list.inject(0) { |sum, n| sum + n }  # => 0
p empty_list.inject { |sum, n| sum + n }    # => nil  (配列が空なので最初の要素が得られない)

要素が想定外の型の場合

配列やハッシュ内の要素が想定とは違う型だった場合、inject内で思わぬエラーが出るかもしれません。
たとえば数値を合計するつもりが、文字列が混在しているとTypeErrorにつながります。
このようなときは、injectを呼び出す前に型チェックを行うか、例外的な要素を無視するなどの対策を検討してください。

要素が混在している配列に対してinjectで単純な合計をとると、意図せずエラーが発生するかもしれません。

引数の位置と書き方

inject(初期値)のように初期値を入れるかどうかで挙動が違います。
また、ブロック引数は|acc, elem|や|memo, item|など自由に名前を付けられますが、どちらが蓄積用でどちらが要素かを明確にしておくほうがミスが減ります。

メソッドチェーンとの組み合わせ

injectはメソッドチェーンの一部に組み込んで、コードをコンパクトにまとめることも可能です。
ただし、読み手が混乱しないように、無理に一行で書かないほうがよい場合もあります。

inject + mapなど

次の例では配列の要素をmapで加工したあと、injectで合計を求める流れをメソッドチェーンで書いています。


prices = [100, 200, 300]

result = prices
  .map { |p| p * 1.1 }
  .inject(0) { |sum, price| sum + price }

puts result  # => 660.0

これは、配列要素を先にp * 1.1（たとえば税込価格にしたいなど）へ変換し、そのあと全体を合計しています。

inject + selectなど

似たように、条件で要素を絞ってからinjectする方法もあります。


numbers = [1, 2, 3, 4, 5, 6]

even_sum = numbers
  .select { |n| n.even? }
  .inject(0) { |sum, n| sum + n }

puts even_sum  # => 12

「配列から偶数だけを取り出す」→「合計を求める」というステップを、分かりやすくつなげられます。

メソッドチェーンが増えすぎると可読性が下がるので、複雑な場合は途中で変数に代入するなどの工夫も検討しましょう。

injectの応用的な使い方

配列の並び替えにも応用可能？

一般的にはソートにはsortメソッドを使いますが、要素を自前の処理で並び替えたいケースもあります。
そのときにinjectを使って新しい配列を構築しながら挿入位置を決める、というロジックを書くことができます。
ただし、標準のsortメソッドがあるので、injectを並び替えに使うのはややトリッキーでしょう。
あくまで「要素の順序をカスタマイズしながら、同時に集約したい」ようなときに限定的に活用します。

複数のコレクションを一度に処理する

Rubyでは複数のコレクションをまとめて操作したいときにzipメソッドを使うことがあります。
zipで複数の配列を結合したあとの配列をinjectで処理することで、異なる情報を合算してまとめるといったことが可能です。


ids = [1, 2, 3]
names = ["Alice", "Bob", "Carol"]
ages = [20, 25, 30]

user_list = ids.zip(names, ages).inject([]) do |memo, (id, name, age)|
  memo << { id: id, name: name, age: age }
end

puts user_list.inspect
# => [{:id=>1, :name=>"Alice", :age=>20}, {:id=>2, :name=>"Bob", :age=>25}, {:id=>3, :name=>"Carol", :age=>30}]

このように、複数の配列を同時に走査しながら新しい配列やハッシュを作りたいときにもinjectが活躍します。

injectを使うかどうかの判断基準

Rubyでは、同じように配列を処理するメソッドがたくさんあります。
map、select、each_with_objectなど、それぞれ目的に合わせて書きやすいメソッドを使った方が読みやすい場合もあります。
injectを使うかどうかは**「シンプルに表現できるか」「処理が単一のまとまった目的か」**といった点が判断基準です。

ただの変換ならmap
条件で絞るならselect
データを集計して一つにまとめるならinject

と大まかに考えると、コードの意図がより分かりやすくなるでしょう。

injectを使う際に意識したい可読性

injectを使うとコードがコンパクトになる反面、少し複雑な処理を詰め込みすぎると、かえって読みにくくなることがあります。
変数名をわかりやすくする、あるいは途中で分割して複数行に書くなど、チーム内のコーディングスタイルに合わせることも重要です。

たとえば、下記のように複数の手順をinjectのブロック内に書きすぎると混乱を招きやすいです。


# 例：やや複雑なinject
result = data.inject({}) do |memo, item|
  memo[item[:category]] ||= []
  if item[:sub_category] && item[:value] > 10
    memo[item[:category]] << { sub: item[:sub_category], val: item[:value] }
  else
    memo[item[:category]] << { val: item[:value] }
  end
  memo
end

こうした場合は、ブロックの外にロジックをまとめたり、selectやmapと組み合わせたりすると読みやすくなることがあります。

まとめ

injectメソッドは、RubyのEnumerableモジュールの中でもとくに強力な機能の一つといえます。
配列やハッシュなどの要素を順番に処理しながら、一つの値に集約していくプロセスを簡潔に書けるのが特徴です。

一方で、初心者の方にとっては、ブロック引数が二つ（蓄積用の値と要素）ある構造が最初は理解しづらいかもしれません。
「初期値をどうするか」「ブロックで何を返して次へ渡すのか」など、最初は戸惑うこともあるでしょう。

しかし、慣れてくればループと変数の更新処理を一括してまとめられるので、コード量を減らしつつ意図が明確な書き方ができるようになります。
数値の合計、文字列の連結、ハッシュの生成、ログの集計など、実務でもよく出てくるシーンで活用できるため、ぜひ一度試してみてください。

特に、配列やハッシュのデータを最終的に1つの値にまとめたいときにはinjectが候補に挙がります。
使い慣れるほどに表現力が増していくメソッドなので、この記事で紹介したサンプルコードを少しずつアレンジしてみるとイメージがつかみやすくなるのではないでしょうか。

injectが持つ「簡潔さ」と「読みやすさ」のバランスを意識しながら、ぜひ自分のプロジェクトでも活用してみてください。