How to Add One Array to Another in Ruby Without Creating a Nested Array

By the end of this page, you will understand why push and flatten! produced nil, how Ruby array methods behave when combining arrays, and when to use concat, +, push, or the splat operator to get the result you want.

In Ruby, there is an important difference between:

• adding an array as one element
• adding the elements of an array into another array

That difference is the reason beginners often get nested arrays or unexpected nil values.

The key idea

If you do this:

somearray.push(anotherarray)

Ruby treats anotherarray as a single object and adds it as one item:

["some", "thing", ["another", "thing"]]

That creates a nested array.

If you want to add each element individually, use a method designed for that, such as:

somearray.concat(anotherarray)

Result:

["some", "thing", "another", "thing"]

Why flatten! returned nil

The method flatten! modifies an array in place . If the array is already flat, Ruby returns .

Think of an array like a shopping bag.

• push(item) puts one item into the bag.
• If that item is another bag, you now have a bag inside a bag.
• concat(other_bag_contents) empties the contents of the second bag into the first bag.
• flatten is like opening smaller bags inside the bag and spreading their contents out.

Now imagine flatten! saying:

• "I only report back with the bag if I had to rearrange something."
• "If everything was already flat, I return nil."

So when you used push(anotherarray.flatten!), Ruby basically did this:

• looked at the second bag
• saw it was already flat
• returned nil
• pushed nil into the first bag

That is why you got nil instead of the array elements.

Common ways to combine arrays in Ruby

1. Use concat to add elements into the same array

a = ["some", "thing"]
b = ["another", "thing"]

a.concat(b)

p a
# ["some", "thing", "another", "thing"]

concat modifies a.

2. Use + to create a new combined array

a = ["some", "thing"]
b = ["another", "thing"]

c = a + b

p c
# ["some", "thing", "another", "thing"]

This does not modify a or b.

3. Use push to add one item

a = ["some", "thing"]
b = ["another", "thing"]

a.push(b)

p a

Consider this code:

somearray = ["some", "thing"]
anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

Step 1: Create somearray

somearray = ["some", "thing"]

Current value:

["some", "thing"]

Step 2: Create anotherarray

anotherarray = ["another", "thing"]

Current value:

["another", "thing"]

Step 3: Evaluate anotherarray.flatten!

anotherarray.flatten!

Ruby checks whether anotherarray contains nested arrays.

Arrays are combined constantly in Ruby applications.

Building a list of tags

default_tags = ["ruby", "backend"]
user_tags = ["api", "json"]

all_tags = default_tags + user_tags

Combining validation errors

errors = []
errors.concat(name_errors)
errors.concat(email_errors)

Merging search results

results = []
results.concat(products)
results.concat(categories)

Collecting CLI arguments

base_args = ["--verbose"]
extra_args = ["--output", "report.txt"]

args = base_args + extra_args

Processing API data

all_records = []
all_records.concat(page_1_records)
all_records.concat(page_2_records)

In each case, you need to decide whether:

• you want to mutate the original array with concat
• or create a new array with +

In real projects, developers choose array-combining methods based on intent.

Use concat when mutation is intentional

items = []
items.concat(load_defaults)
items.concat(load_user_items)

This is common when building up one array over time.

Use + when you want immutability

final_roles = default_roles + extra_roles

This is clearer when you want to keep the original arrays unchanged.

Use guard clauses before combining

return [] if records.nil?

Or:

items.concat(new_items) if new_items

This helps avoid errors when values may be nil.

Use splat for method arguments

params = ["name", "email"]
log_fields(*params)

The splat operator is useful when a method expects separate values rather than an array.

Common pattern: collect then flatten later

1. Using push when you mean concat

Broken code:

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

a.push(b)
p a
# [1, 2, [3, 4]]

Why it happens:

• push adds b as one element

Fix:

a.concat(b)
# [1, 2, 3, 4]

2. Expecting flatten! to always return an array

Broken code:

a = [1, 2]
p a.flatten!
# nil

Why it happens:

• flatten! returns nil when nothing changes

Fix:

p a.flatten
# [1, 2]

Quick reference

Add one item

array.push(item)
array << item

Add all elements from another array

array.concat(other_array)

Create a new combined array

new_array = array1 + array2

Expand array into separate arguments

array.push(*other_array)

Flatten nested arrays

flat = array.flatten      # new array
array.flatten!            # modifies original, may return nil

Important rules

• push adds one object
• concat adds elements from another array
• + returns a new array
• flatten! returns nil if no changes were made
• << can create nested arrays if you append an array

How do I append one array to another in Ruby without nesting?

Use concat or +:

a.concat(b)
# or
c = a + b

Why does flatten! return nil in Ruby?

flatten! returns nil when the array was already flat and Ruby did not need to change anything.

What is the difference between push and concat in Ruby?

push adds one object as a single element. concat adds each element from another array.

Does + modify the original array in Ruby?

No. + creates and returns a new array.

Is << the same as concat?

No. << adds one item. If that item is an array, you get a nested array.

• Ruby arrays — The core data structure involved in storing ordered values.
• Array mutation — Important for understanding which methods change the original object.
• Destructive vs non-destructive methods — Helps explain flatten! versus flatten and concat versus +.
• Splat operator (*) — Useful for expanding array elements into separate arguments.
• Nil in Ruby — Relevant because flatten! can return nil.
• Enumerable methods — Many Ruby collection patterns build on understanding arrays first.
• Nested arrays — Directly related to why push can produce multi-dimensional results.
• Method return values in Ruby — Essential for understanding why chaining methods can behave unexpectedly.