Merge and update methods in Ruby - Step-by-Step Execution

Concept Flow - Merge and update methods

Start with Hash A and Hash B

↓

Call merge or update on Hash A with Hash B

↓

For each key in Hash B

↓

If key exists in A?

Yes→Replace value in A

↓

Add key-value to A

↓

Return new Hash (merge) or modify A (update)

↓

End

Start with two hashes. For each key in the second hash, add or replace the key-value in the first hash. Merge returns a new hash; update changes the original.

Execution Sample

Ruby

a = {x: 1, y: 2}
b = {y: 3, z: 4}
c = a.merge(b)
a.update(b)

Shows how merge returns a new hash combining a and b, while update changes a itself.

Execution Table

Step	Operation	Hash A	Hash B	Result	Notes
1	Initial Hashes	{:x=>1, :y=>2}	{:y=>3, :z=>4}	-	Start with two hashes
2	Call a.merge(b)	{:x=>1, :y=>2}	{:y=>3, :z=>4}	{:x=>1, :y=>3, :z=>4}	Returns new hash with b's keys merged, y replaced
3	a after merge	{:x=>1, :y=>2}	-	-	a is unchanged after merge
4	Call a.update(b)	{:x=>1, :y=>2}	{:y=>3, :z=>4}	{:x=>1, :y=>3, :z=>4}	a is changed in place, y replaced, z added
5	a after update	{:x=>1, :y=>3, :z=>4}	-	-	a now includes changes from b

💡 All keys from b processed; merge returns new hash; update modifies a in place.

Variable Tracker

Variable	Start	After merge	After update	Final
a	{:x=>1, :y=>2}	{:x=>1, :y=>2}	{:x=>1, :y=>3, :z=>4}	{:x=>1, :y=>3, :z=>4}
b	{:y=>3, :z=>4}	{:y=>3, :z=>4}	{:y=>3, :z=>4}	{:y=>3, :z=>4}
c	-	{:x=>1, :y=>3, :z=>4}	-	{:x=>1, :y=>3, :z=>4}

Key Moments - 3 Insights

Why does the hash 'a' not change after calling 'merge'?

Because 'merge' returns a new hash with combined keys and values but does not modify the original hash 'a' (see execution_table step 3).

How does 'update' differ from 'merge' in terms of modifying the original hash?

'update' changes the original hash 'a' by adding or replacing keys from 'b' directly (see execution_table step 4 and 5), unlike 'merge' which returns a new hash.

What happens to keys that exist in both hashes during merge or update?

The value from the second hash 'b' replaces the value in the first hash 'a' for those keys (see execution_table steps 2 and 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'a' after the merge operation?

A {:y=>3, :z=>4}

B {:x=>1, :y=>3, :z=>4}

C {:x=>1, :y=>2}

D nil

💡 Hint

Check the 'a after merge' row in the execution_table.

At which step does 'a' get modified in place?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look for the step where 'a.update(b)' is called in the execution_table.

If we changed 'b' to {y: 5, w: 6}, what would be the value of 'a' after update?

A {:x=>1, :y=>5, :w=>6}

B {:x=>1, :y=>3, :z=>4}

C {:x=>1, :y=>2}

D {:y=>5, :w=>6}

💡 Hint

Refer to variable_tracker and how update replaces and adds keys from 'b' to 'a'.

Concept Snapshot

Hash#merge returns a new hash combining keys from both hashes.
Keys in the second hash replace those in the first.
Hash#update modifies the original hash in place.
Use merge when you want a new hash; update to change existing.
Both handle key conflicts by replacing with second hash's value.

Full Transcript

This visual trace shows how Ruby's Hash methods merge and update work. We start with two hashes, a and b. When calling a.merge(b), Ruby creates a new hash combining keys from both, replacing any duplicate keys with values from b, but leaves a unchanged. When calling a.update(b), Ruby changes a itself by adding or replacing keys from b. The execution table tracks each step, showing that after merge, a stays the same, but after update, a includes b's keys and values. Key moments clarify that merge returns a new hash while update modifies the original. The visual quiz tests understanding of these differences and how keys are replaced or added. The snapshot summarizes the key points for quick recall.

Practice

1.

Which Ruby method returns a new hash by combining two hashes without changing the original?

easy

A. merge

B. merge!

C. update

D. replace

Solution

1. Step 1: Understand merge behavior

   merge returns a new hash combining two hashes without modifying the original.

2. Step 2: Compare with merge! and update

   Both merge! and update modify the original hash, so they don't return a new one.

3. Final Answer:

   merge -> Option A

4. Quick Check:

   merge returns new hash [OK]

Hint: Remember: merge returns new hash, merge! updates original [OK]

Common Mistakes:

• Confusing merge and merge! methods
• Thinking update returns a new hash
• Assuming replace merges hashes

2.

Which of the following is the correct syntax to update hash a with hash b in Ruby?

a = {x: 1}

b = {y: 2}

easy

A. a + b

B. a.merge!b

C. a.merge b

D. a.update(b)

Solution

1. Step 1: Check syntax for updating hash

   update is a method that modifies the original hash and takes another hash as argument with parentheses.

2. Step 2: Compare with other options

   merge! also updates but usually called with ! and parentheses are optional but update(b) is the most explicit and correct syntax here.

3. Final Answer:

   a.update(b) -> Option D

4. Quick Check:

   Use update() to modify original hash [OK]

Hint: Use update(hash) to change original hash [OK]

Common Mistakes:

• Using + operator to combine hashes (not valid)
• Forgetting parentheses in method call
• Confusing merge and update syntax

3.

What is the output of this Ruby code?

a = {a: 1, b: 2}

b = {b: 3, c: 4}

c = a.merge(b)

puts c

medium

A. {:a=>1, :b=>2, :c=>4}

B. {:a=>1, :b=>3}

C. {:a=>1, :b=>3, :c=>4}

D. {:b=>3, :c=>4}

Solution

1. Step 1: Understand merge behavior with overlapping keys

   merge returns a new hash combining keys; overlapping keys get values from the second hash.

2. Step 2: Apply to given hashes

   Key :b is in both hashes; value from b (3) replaces value from a (2). Keys :a and :c are included as is.

3. Final Answer:

   {:a=>1, :b=>3, :c=>4} -> Option C

4. Quick Check:

   Overlapping keys replaced by second hash [OK]

Hint: Overlapping keys take second hash's value in merge [OK]

Common Mistakes:

• Assuming original hash is changed by merge
• Not replacing overlapping key values
• Missing keys from either hash

4.

Identify the error in this Ruby code snippet:

a = {x: 10}

b = {y: 20}

a.merge! b

puts a

medium

A. Output will be empty hash

B. No error; code works correctly

C. Runtime error because merge! cannot be used with variables

D. Syntax error due to missing parentheses in merge!

Solution

1. Step 1: Check syntax of merge! method call

   merge! can be called without parentheses in Ruby, so a.merge! b is valid syntax.

2. Step 2: Verify runtime behavior

   merge! updates a with keys and values from b, so a becomes {x: 10, y: 20}. No errors occur.

3. Final Answer:

   No error; code works correctly -> Option B

4. Quick Check:

   merge! updates original hash without error [OK]

Hint: merge! can be called without parentheses [OK]

Common Mistakes:

• Thinking parentheses are mandatory
• Assuming merge! returns a new hash
• Expecting runtime error with variable argument

5.

You have two hashes:

h1 = {a: 1, b: 2, c: 3}

h2 = {b: 20, d: 4}

You want to update h1 with h2 but only keep keys from h2 that have values greater than 10. Which code correctly does this?

hard

A. h1.update(h2.select { |k, v| v > 10 })

B. h1.update(h2.reject { |k, v| v > 10 })

C. h1.merge(h2.select { |k, v| v > 10 })

D. h1.replace(h2.select { |k, v| v > 10 })

Solution

1. Step 1: Filter h2 keys with values > 10

   Use select { |k, v| v > 10 } to keep only keys with values greater than 10.

2. Step 2: Update h1 with filtered h2

   Use update to modify h1 in place with the filtered hash.

3. Step 3: Check other options

   merge! also updates but update is clearer; merge returns new hash and does not modify h1.

4. Final Answer:

   h1.update(h2.select { |k, v| v > 10 }) -> Option A

5. Quick Check:

   Filter then update original hash [OK]

Hint: Filter with select, then update original hash [OK]

Common Mistakes:

• Using merge instead of update (does not modify original)
• Not filtering keys before update
• Using reject incorrectly