Symbol keys vs string keys decision in Ruby - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of hash key access with symbol vs string

What is the output of this Ruby code?

Ruby

h = { foo: 'bar' }
puts h[:foo]
puts h['foo']

A

bar

B

bar

nil

C

nil
bar

D

nil
nil

💡 Hint

Remember that symbol keys and string keys are different in Ruby hashes.

In Ruby, a hash with symbol keys does not recognize string keys as the same. So h[:foo] returns 'bar', but h['foo'] returns nil.

🧠 Conceptual

intermediate

Why choose symbol keys over string keys?

Which of the following is the main reason to prefer symbol keys over string keys in Ruby hashes?

A Symbols are immutable and reused, saving memory compared to strings.

B Symbols are mutable and can be changed at runtime.

C Symbols automatically convert to strings when used as keys.

D Symbols allow faster string concatenation.

💡 Hint

Think about memory and performance when using symbols as keys.

Symbols are immutable and reused internally, so using them as hash keys saves memory and can improve performance compared to strings.

❓ Predict Output

advanced

Effect of string keys mutation on hash keys

What is the output of this Ruby code?

Ruby

key = 'name'
h = { key => 'Alice' }
key << '!' 
puts h['name']
puts h['name!']

A

Alice

nil

B

nil

Alice

C

nil

nil

D

Alice

Alice

💡 Hint

Consider what happens when you mutate the string used as a key after the hash is created.

The hash key is the original string 'name'. Mutating the string variable after adding it as a key does not change the existing key in the hash. So h['name'] returns 'Alice', but h['name!'] returns nil.

🔧 Debug

advanced

Why does this hash key lookup fail?

Given this code, why does h[:name] return nil?

Ruby

h = { 'name' => 'Bob' }
puts h[:name]

A Because the key :name is misspelled.

B Because the hash key is a symbol, but lookup uses a string key.

C Because the hash is empty.

D Because the hash key is a string, but lookup uses a symbol key.

💡 Hint

Check the type of the key used when creating the hash and when accessing it.

The hash key is the string 'name', but the lookup uses the symbol :name. These are different keys in Ruby hashes, so h[:name] returns nil.

🚀 Application

expert

Count keys that are symbols in a mixed hash

Given this hash, how many keys are symbols?

Ruby

h = { foo: 1, 'bar' => 2, :baz => 3, 'qux' => 4 }

A 1

B 3

C 2

D 4

💡 Hint

Look carefully at each key's type: symbol or string.

The keys foo: and :baz are symbols. The keys 'bar' and 'qux' are strings. So there are 2 symbol keys.

Practice

1. Which key type is best to use in a Ruby hash when the keys are fixed and known in advance?

easy

A. Symbols, because they are faster and use less memory.

B. Strings, because they are easier to type.

C. Integers, because they are numeric.

D. Arrays, because they can hold multiple values.

Solution

1. Step 1: Understand key types in Ruby hashes

   Symbols are immutable and unique, making them efficient for fixed keys.

2. Step 2: Compare symbols and strings for fixed keys

   Symbols use less memory and are faster than strings when keys do not change.

3. Final Answer:

   Symbols, because they are faster and use less memory. -> Option A

4. Quick Check:

   Fixed keys = Symbols [OK]

Hint: Use symbols for fixed keys to save memory and speed [OK]

Common Mistakes:

• Using strings for fixed keys wastes memory
• Confusing symbols with strings
• Thinking integers or arrays are valid hash keys here

2. Which of the following is the correct NEW STYLE syntax to define a Ruby hash with symbol keys?

easy

A. { 'name' => 'Alice', 'age' => 30 }

B. { name: 'Alice', age: 30 }

C. { :name => 'Alice', :age => 30 }

D. { name => 'Alice', age => 30 }

Solution

1. Step 1: Recognize Ruby symbol key syntax

   Ruby allows symbol keys with the syntax key: value (new style) or :key => value (old style).

2. Step 2: Identify the correct syntax among options

   { name: 'Alice', age: 30 } uses the modern symbol key syntax: name: 'Alice', age: 30.

3. Final Answer:

   { name: 'Alice', age: 30 } -> Option B

4. Quick Check:

   Symbol keys use key: value syntax [OK]

Hint: Use key: value for symbol keys in Ruby hashes [OK]

Common Mistakes:

• Using strings with => instead of symbols
• Missing colon before symbol keys
• Using variables as keys without symbols

3. What will be the output of this Ruby code?

person = { name: 'Bob', 'age' => 25 }
puts person[:name]
puts person['age']
puts person['name']

medium

A. Bob
25
Bob

B. nil
25
Bob

C. Bob
25

D. Bob
25
nil

Solution

1. Step 1: Understand hash keys and access

   The hash has a symbol key :name and a string key 'age'. Access must match key type exactly.

2. Step 2: Evaluate each puts statement

   person[:name] returns 'Bob'; person['age'] returns 25; person['name'] returns nil because 'name' key as string does not exist.

3. Final Answer:

   Bob 25 nil -> Option D

4. Quick Check:

   Key type must match to access value [OK]

Hint: Access hash values with exact key type used [OK]

Common Mistakes:

• Assuming symbol and string keys are interchangeable
• Expecting 'name' string key to exist when only :name symbol key is present
• Confusing output nil with empty string

4. Given this Ruby hash, what is the error in accessing the value?

settings = { 'theme' => 'dark', :font_size => 12 }
puts settings.fetch(:theme)

medium

A. KeyError because :theme symbol key does not exist.

B. No error; outputs 'dark'.

C. SyntaxError due to mixed key types.

D. RuntimeError because font_size is a symbol.

Solution

1. Step 1: Check hash keys and access

   The hash has a string key 'theme' and a symbol key :font_size.

2. Step 2: Identify the accessed key and result

   Accessing settings.fetch(:theme) looks for symbol :theme, which does not exist, raising a KeyError.

3. Final Answer:

   KeyError because :theme symbol key does not exist. -> Option A

4. Quick Check:

   Access key type must match stored key type [OK]

Hint: Match key type exactly when accessing hash values [OK]

Common Mistakes:

• Assuming string and symbol keys are interchangeable
• Expecting no error when accessing missing key
• Confusing syntax errors with key access errors

5. You have a Ruby hash where keys come from user input and can vary. Which key type should you use and why?

user_data = { ??? }

hard

A. Use symbols because they are faster and memory efficient.

B. Use arrays as keys to hold multiple user inputs.

C. Use strings because user input keys can change dynamically.

D. Use integers because they are simple and fixed.

Solution

1. Step 1: Understand key type suitability for dynamic keys

   Symbols are immutable and reused, so creating many from user input can cause memory bloat.

2. Step 2: Choose key type for user input keys

   Strings are better for dynamic or user input keys because they do not create permanent symbols.

3. Final Answer:

   Use strings because user input keys can change dynamically. -> Option C

4. Quick Check:

   Dynamic keys = Strings [OK]

Hint: Use strings for keys from user input to avoid memory issues [OK]

Common Mistakes:

• Using symbols for dynamic keys causing memory leaks
• Assuming integers or arrays are suitable keys here
• Ignoring key type impact on memory and performance