Merge and update methods in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the merge method do in Ruby hashes?

It combines two hashes into a new hash. If keys overlap, the values from the second hash overwrite those from the first. The original hashes stay unchanged.

beginner

How does merge! differ from merge in Ruby?

merge! updates the original hash in place by adding or replacing keys and values from another hash, while merge returns a new hash without changing the original.

beginner

What happens if two hashes have the same key when using merge?

The value from the second hash replaces the value from the first hash for that key in the resulting hash.

beginner

Can you provide a simple example of using merge in Ruby?

Yes! For example:

h1 = {a: 1, b: 2}
h2 = {b: 3, c: 4}
h3 = h1.merge(h2)
# h3 is {:a=>1, :b=>3, :c=>4}

intermediate

What is the return value of merge!?

merge! returns the updated original hash after merging the other hash into it.

What does hash1.merge(hash2) do in Ruby?

A Returns nil

B Updates hash1 in place with hash2's keys and values

C Deletes keys from hash1 that are in hash2

D Returns a new hash combining both, with hash2's values overwriting duplicates

The merge method returns a new hash combining both hashes, with values from the second hash overwriting duplicates.

Which method modifies the original hash in Ruby?

A merge!

B merge

C dup

D select

merge! modifies the original hash by merging another hash into it.

If h1 = {x: 1} and h2 = {x: 2}, what is h1.merge(h2)?

A {x: 2}

B {x: 1, x: 2}

C {x: 1}

D Error

The value for key :x from h2 overwrites the one from h1 in the merged hash.

What does merge! return after execution?

A A new hash

B The original hash updated

C An array of keys

D nil

merge! returns the original hash after it has been updated.

Which of these is true about merge and merge!?

A <code>merge</code> changes the original hash, <code>merge!</code> does not

B Both change the original hash

C <code>merge</code> returns a new hash, <code>merge!</code> changes the original hash

D Neither changes the original hash

merge returns a new hash without changing the original, while merge! updates the original hash.

Explain how the merge and merge! methods work in Ruby hashes.

Think about whether the original hash changes or not.

Describe a situation where you would prefer to use merge over merge!.

Consider if you want to keep your original data intact.

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