How to Sum an Array of Numbers in Ruby

By the end of this page, you will understand how to add all numbers in a Ruby array using the most common and idiomatic approaches. You will learn when to use sum, how inject/reduce works, how manual accumulation with each compares, and what mistakes beginners often make.

In Ruby, summing an array means combining all its elements into one total value. This is a very common operation in programming because collections of numbers appear everywhere: prices, scores, quantities, durations, and statistics.

Ruby provides several ways to do this:

• sum — the simplest and most readable option in modern Ruby
• inject or reduce — a more general pattern for combining values
• each with a running total — a manual approach that shows what is happening internally

The key idea is accumulation: start with an initial value, then visit each item and add it to the total.

For example, given:

[2, 4, 6]

The sum is calculated like this:

• start at 0
• add 2 → 2
• add 4 → 6
• add 6 → 12

This matters because many real tasks are just variations of accumulation:

Think of an array like a row of coins on a table.

You want to know how much money you have in total.

There are three ways to do it:

• each: pick up each coin one by one and add it to a running pile
• sum: ask Ruby to count the pile for you
• inject/reduce: use a folding process where one total is carried forward through every item

The important mental image is this:

• the array contains many values
• summing turns those many values into one final value

So sum is like pressing a calculator button that totals the whole list.

Using sum

In modern Ruby, the cleanest way is:

array = [123, 321, 12_389]
puts array.sum

Output:

12833

This is usually the best choice because it is short, readable, and clearly expresses your intent.

Using inject or reduce

Before sum became common, Ruby developers often used inject:

array = [123, 321, 12_389]
puts array.inject(0) { |total, n| total + n }

Output:

12833

Explanation:

• 0 is the starting total
• total keeps the running result

Consider this example:

numbers = [5, 10, 20]
result = numbers.inject(0) { |total, n| total + n }
puts result

Here is what happens step by step:

1. numbers is set to [5, 10, 20]
2. inject(0) starts the accumulator at 0
3. Ruby takes the first element, 5
   • total = 0
   • n = 5
   • returns 0 + 5, which is 5
4. Ruby takes the second element, 10
   • total = 5
   • n = 10
   • returns 5 + 10, which is 15
5. Ruby takes the third element, 20

Summing arrays is used in many everyday programming tasks.

E-commerce totals

prices = [19.99, 5.50, 12.00]
total = prices.sum

Used for:

• shopping carts
• invoice totals
• checkout calculations

Analytics and reporting

daily_signups = [12, 18, 21, 9, 15]
weekly_total = daily_signups.sum

Used for:

• total visits
• total downloads
• total registrations

Time tracking

hours = [2.5, 3.0, 1.5, 4.0]
total_hours = hours.sum

Used for:

• freelance billing
• employee timesheets
• project reporting

Scores and game logic

scores = [100, 250, 75]
final_score = scores.sum

Used for:

In real Ruby projects, developers usually prefer the most expressive option for the job.

Common pattern: use sum for readability

total_price = items.sum { |item| item.price_cents }

This is common in Rails apps, scripts, and service objects because it clearly says: “sum these values.”

Validation before summing

If data may be missing or invalid, code often filters first:

values = [10, nil, 20, nil, 5]
total = values.compact.sum

This avoids errors from nil values.

Guard clauses

Developers often return early if there is nothing to sum:

def total_score(scores)
  return 0 if scores.empty?

  scores.sum
end

This makes intent obvious and handles edge cases cleanly.

Combining with map

A common pattern is to extract values, then sum them:

1. Using the wrong variable name

Broken code:

Copysum = 0
array.each { |a| sum += a }

Problem:

• Copysum and sum are different variables
• sum was never initialized

Correct version:

sum = 0
array.each { |a| sum += a }

2. Using a constant by mistake

In Ruby, names starting with a capital letter are treated as constants.

Broken style:

Sum = 0

Use a local variable instead:

sum = 0

3. Forgetting that arrays may contain non-numeric values

Broken code:

values = [10, "20", 30]
puts values.sum

sum vs inject

Quick reference

Sum an array of numbers

array = [1, 2, 3]
array.sum
# => 6

Sum with a block

items.sum { |item| item[:price] }

Sum manually with each

sum = 0
array.each { |n| sum += n }

Sum with inject

array.inject(0) { |total, n| total + n }

Remove nil values first

array.compact.sum

Convert strings to integers first

array.map(&:to_i).sum

Rules of thumb

• Prefer array.sum for simple numeric arrays

How do you sum an array in Ruby?

Use sum:

[1, 2, 3].sum
# => 6

What is the idiomatic Ruby way to add all array values?

In modern Ruby, array.sum is usually the most idiomatic and readable choice.

Can I use inject instead of sum in Ruby?

Yes. For example:

array.inject(0) { |total, n| total + n }

It works well, but sum is simpler when you only need addition.

What happens if the array is empty?

[].sum
# => 0

This is one reason sum is convenient.

How do I sum an array that contains nil values?

Remove nil values first:

• Arrays — summing works on array collections, so understanding arrays is the foundation.
• Enumerable — methods like sum, map, select, and inject come from Ruby's enumerable tools.
• inject / reduce — this is the general pattern behind combining many values into one.
• each — useful for understanding manual iteration and accumulation.
• map — often used before sum to transform data into numeric values.
• compact — helpful when arrays may contain nil values before summing.
• Variables — needed for manual accumulation with a running total.
• Blocks — Ruby uses blocks in each, sum, and inject to process elements.