Why strings are mutable in Ruby - Quick Recap

Recall & Review

beginner

What does it mean that strings are mutable in Ruby?

It means you can change the content of a string after creating it without making a new string.

beginner

Why does Ruby allow strings to be mutable?

Ruby allows strings to be mutable to make it easier and faster to change text without creating new objects every time.

intermediate

How does string mutability affect memory usage in Ruby?

Mutable strings let Ruby reuse the same memory space when changing text, which can save memory compared to making new strings.

beginner

What is an example of changing a string in Ruby?

Example: name = "Bob"; name[0] = "J" changes name to "Job" without creating a new string.

intermediate

Can you make a string immutable in Ruby?

Yes, by calling .freeze on a string, you prevent it from being changed.

What does mutable mean for Ruby strings?

A Strings are stored as numbers

B You cannot change the string content after creation

C Strings are always copied when changed

D You can change the string content after creation

Mutable means you can change the string content after creating it.

Why are Ruby strings mutable by default?

A To improve performance by avoiding new object creation

B Because Ruby does not support immutable objects

C To make strings slower

D Because strings are stored as integers

Mutable strings help Ruby avoid creating new objects every time text changes, improving performance.

How can you prevent a Ruby string from being changed?

A Call .freeze on the string

B Use .mutable method

C Assign it to a constant

D Use .immutable method

Calling .freeze on a string makes it immutable, so it cannot be changed.

What happens when you change a character in a Ruby string?

A A new string is created automatically

B The original string is modified in place

C An error occurs

D The string is converted to an array

Changing a character modifies the original string directly because strings are mutable.

Which of these is a benefit of mutable strings in Ruby?

A Strings cannot be changed accidentally

B Strings are always thread-safe

C Less memory used when changing strings

D Strings are faster to read from disk

Mutable strings allow Ruby to reuse memory, reducing memory use when changing strings.

Explain why Ruby strings are mutable and how this affects performance and memory.

Think about how changing text without making new copies helps Ruby.

Describe how to make a Ruby string immutable and why you might want to do that.

Freezing a string stops it from being changed.

Practice

1. Why are strings mutable in Ruby?

easy

A. Because Ruby allows changing string content without creating new objects

B. Because strings are stored as numbers internally

C. Because Ruby does not support string variables

D. Because strings are immutable in Ruby

Solution

1. Step 1: Understand mutability concept in Ruby strings

   Ruby strings can be changed after creation, meaning their content can be updated without making a new string object.

2. Step 2: Identify why this is useful

   This allows efficient text updates and memory use, as you don't need to create new strings for every change.

3. Final Answer:

   Because Ruby allows changing string content without creating new objects -> Option A

4. Quick Check:

   Ruby strings are mutable = Because Ruby allows changing string content without creating new objects [OK]

Hint: Mutability means you can change strings directly [OK]

Common Mistakes:

• Confusing mutability with immutability
• Thinking strings are stored as numbers
• Believing Ruby strings cannot be changed

2. Which Ruby code correctly changes a string's content?

easy

A. str = "hello"; str.freeze

B. str = "hello"; str[0] = 'H'

C. str = "hello"; str.upcase

D. str = "hello"; str = str + '!'

Solution

1. Step 1: Check each code for mutability

   str = "hello"; str[0] = 'H' changes the first character directly, showing string mutability.

2. Step 2: Compare other options

   str = "hello"; str = str + '!' creates a new string; str = "hello"; str.upcase returns a new uppercase string without changing the original; str = "hello"; str.freeze freezes string making it immutable.

3. Final Answer:

   str = "hello"; str[0] = 'H' -> Option B

4. Quick Check:

   Direct index assignment changes string = str = "hello"; str[0] = 'H' [OK]

Hint: Use index assignment to change string characters [OK]

Common Mistakes:

• Using freeze which prevents changes
• Thinking concatenation changes original string
• Confusing upcase method with direct assignment

3. What is the output of this Ruby code?

str = "cat"
str[1] = 'o'
puts str

medium

A. cat

B. c t

C. cot

D. Error

Solution

1. Step 1: Understand string indexing and assignment

   str[1] = 'o' changes the character at index 1 (second character) from 'a' to 'o'.

2. Step 2: Apply the change and print

   Original string "cat" becomes "cot" after the change, so puts prints "cot".

3. Final Answer:

   cot -> Option C

4. Quick Check:

   Changing index 1 to 'o' = cot [OK]

Hint: Index 1 means second character in string [OK]

Common Mistakes:

• Expecting original string unchanged
• Confusing index positions starting at 1
• Thinking it causes an error

4. Find the error in this Ruby code that tries to change a string:

str = "dog"
str.freeze
str[0] = 'c'
puts str

medium

A. Cannot modify frozen string error

B. Syntax error on line 2

C. No error, output is "cog"

D. puts method is undefined

Solution

1. Step 1: Understand freeze method effect

   freeze makes the string immutable, so any modification causes an error.

2. Step 2: Identify error on modification attempt

   str[0] = 'c' tries to change the frozen string, causing a runtime error "can't modify frozen String".

3. Final Answer:

   Cannot modify frozen string error -> Option A

4. Quick Check:

   freeze prevents changes = error [OK]

Hint: freeze stops string changes, causing error on modification [OK]

Common Mistakes:

• Ignoring freeze effect
• Expecting string to change after freeze
• Thinking freeze causes syntax error

5. You want to update multiple characters in a Ruby string efficiently. Which approach best uses string mutability?

str = "hello"
# Update 'e' and 'o' to 'a' and 'u'

hard

A. str.freeze; str[1] = 'a'

B. str = str.sub('e', 'a').sub('o', 'u')

C. str = "hallu"

D. str[1] = 'a'; str[4] = 'u'

Solution

1. Step 1: Identify direct string mutation

   str[1] = 'a'; str[4] = 'u' changes characters by index directly, using mutability efficiently without creating new strings.

2. Step 2: Compare other options

   str = str.sub('e', 'a').sub('o', 'u') creates new strings with sub; str = "hallu" assigns a new string; str.freeze; str[1] = 'a' freezes string then tries to change causing error.

3. Final Answer:

   str[1] = 'a'; str[4] = 'u' -> Option D

4. Quick Check:

   Direct index assignment updates string efficiently [OK]

Hint: Change characters by index for efficient updates [OK]

Common Mistakes:

• Using sub which creates new strings
• Assigning new string instead of mutating
• Freezing string before modification