Immutable data with freeze in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of freezing a string and then modifying it?

Consider the following Ruby code. What will be the output when it is run?

Ruby

str = "hello"
str.freeze
begin
  str << " world"
rescue => e
  puts e.class
end

A hello world

B TypeError

C No output

D RuntimeError

💡 Hint

Freezing an object prevents modifications. What happens if you try to change a frozen string?

In Ruby, freezing a string prevents it from being modified. Trying to append to a frozen string raises a RuntimeError.

❓ Predict Output

intermediate

What happens when you freeze an array and try to modify it?

Look at this Ruby code. What will be printed when it runs?

Ruby

arr = [1, 2, 3]
arr.freeze
begin
  arr.push(4)
rescue => e
  puts e.class
end

A RuntimeError

B TypeError

C [1, 2, 3, 4]

D No output

💡 Hint

Freezing an array stops changes like adding elements. What error is raised if you try?

A frozen array cannot be changed. Trying to push a new element raises a RuntimeError.

🧠 Conceptual

advanced

Which statement about freezing nested objects is true?

Given a frozen array that contains other arrays, which statement is correct?

A Freezing the outer array converts nested arrays into frozen arrays automatically.

B Freezing the outer array also freezes all nested arrays inside it.

C Nested arrays remain mutable unless they are individually frozen.

D Freezing the outer array prevents adding new nested arrays but allows modifying existing nested arrays.

💡 Hint

Think about whether freeze applies recursively or only to the object itself.

In Ruby, freeze only affects the object it is called on. Nested objects remain mutable unless frozen separately.

❓ Predict Output

advanced

What is the output when freezing a hash and modifying a nested array value?

Analyze this Ruby code and determine the output:

Ruby

h = {a: [1, 2], b: [3, 4]}
h.freeze
begin
  h[:a] << 5
rescue => e
  puts e.class
end
puts h[:a].inspect

A

RuntimeError
[1, 2]

B [1, 2, 5]

C

RuntimeError
[1, 2, 5]

D

TypeError
[1, 2]

💡 Hint

Freezing a hash stops changing keys or values, but what about modifying the objects inside the hash?

The hash is frozen, so you cannot add or remove keys, but the arrays inside are still mutable and can be changed.

🔧 Debug

expert

Why does this code raise an error when freezing a nested structure?

This Ruby code tries to freeze a nested array structure. Why does it raise an error?

Ruby

def deep_freeze(obj)
  obj.freeze
  if obj.is_a?(Array)
    obj.each { |e| deep_freeze(e) }
  elsif obj.is_a?(Hash)
    obj.each { |k, v| deep_freeze(k); deep_freeze(v) }
  end
end

nested = [1, [2, 3], {a: 4}]
deep_freeze(nested)
nested[1] << 5

A It raises a RuntimeError because nested[1] is frozen and cannot be modified.

B It raises a TypeError because deep_freeze does not handle arrays correctly.

C It raises a NoMethodError because freeze is not defined for integers.

D It does not raise an error; the code runs successfully.

💡 Hint

Check what deep_freeze does to nested arrays and what happens when you try to modify a frozen array.

The deep_freeze method freezes the entire nested structure recursively. Trying to modify nested[1], which is a frozen array, raises a RuntimeError.