Why strings are mutable in Ruby - See It in Action

Why strings are mutable in Ruby

📖 Scenario: Imagine you are writing a program that needs to change words or sentences many times, like editing a message or building a sentence step by step.

🎯 Goal: You will learn why strings in Ruby can be changed after they are created, and how to see this in action with simple code.

📋 What You'll Learn

Create a string variable with a specific value

Modify the string by changing part of it

Show the string before and after the change

Understand that strings in Ruby can be changed (mutable)

💡 Why This Matters

🌍 Real World

Many programs need to change text often, like chat apps, text editors, or games showing messages.

💼 Career

Understanding mutable strings helps you write efficient Ruby code that handles text well, a common task in software development.

1

Create a string variable

Create a string variable called message and set it to the value "Hello".

Ruby

# Create a string variable called message and set it to "Hello"
# Your code here

Hint

Use = to assign the string "Hello" to the variable message.

2

Add a helper variable for new text

Create a variable called new_text and set it to the value " World" (note the space before World).

Ruby

message = "Hello"
# Create a variable called new_text and set it to " World"
# Your code here

Hint

Remember to include the space before the word "World" in the string.

3

Modify the string using mutation

Use the message variable and add new_text to it by using the concat method to change message itself.

Ruby

message = "Hello"
new_text = " World"
# Use message.concat(new_text) to add new_text to message
# Your code here

Hint

The concat method changes the original string instead of making a new one.

4

Print the modified string

Print the message variable to show the changed string.

Ruby

message = "Hello"
new_text = " World"
message.concat(new_text)
# Print the message variable
# Your code here

Hint

Use puts message to print the string.

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