Dig method for nested access in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to access the nested value using dig.

Ruby

data = { user: { profile: { name: 'Alice' } } }
puts data.[1](:user, :profile, :name)

Drag options to blanks, or click blank then click option'

Afetch

Bdig

Cget

Daccess

Attempts:

3 left

💡 Hint

Common Mistakes

Using fetch instead of dig causes errors if keys are missing.

Using get or access which are not Ruby Hash methods.

The dig method allows you to safely access nested hash values by passing the keys in order.

2fill in blank

medium

Complete the code to safely get the city from nested data using dig.

Ruby

address = { location: { city: 'Paris', country: 'France' } }
city = address.[1](:location, :city)
puts city

Drag options to blanks, or click blank then click option'

Afetch

Bget

Cdig

Dfind

Attempts:

3 left

💡 Hint

Common Mistakes

Using fetch which raises error if key is missing.

Using get or find which are not valid for nested hash access.

dig safely returns the nested value or nil if any key is missing.

3fill in blank

hard

Fix the error in the code to correctly use dig for nested access.

Ruby

profile = { info: { age: 30 } }
age = profile.[1][:info, :age]
puts age

Drag options to blanks, or click blank then click option'

Adig

Bfetch

Cget

Daccess

Attempts:

3 left

💡 Hint

Common Mistakes

Using square brackets instead of parentheses with dig.

Using fetch or get which do not support multiple nested keys.

The dig method should be called with parentheses and keys as arguments, not with square brackets.

4fill in blank

hard

Fill both blanks to create a nested hash and access a value using dig.

Ruby

data = { [1]: { [2]: 'Ruby' } }
puts data.dig(:language, :name)

Drag options to blanks, or click blank then click option'

Alanguage

Bname

Ccode

Dversion

Attempts:

3 left

💡 Hint

Common Mistakes

Using keys that do not match the dig arguments.

Swapping the keys order.

The keys :language and :name match the dig arguments to access the value 'Ruby'.

5fill in blank

hard

Fill all three blanks to use dig to access a deeply nested value.

Ruby

config = { settings: { display: { brightness: 75 } } }
value = config.[1](:settings, [2], [3])
puts value

Drag options to blanks, or click blank then click option'

Adig

B:display

C:brightness

D:contrast

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect keys that do not exist in the hash.

Using fetch or square brackets instead of dig.

Use dig with keys :settings, :display, and :brightness to get the value 75.

Practice

1. What does the Ruby dig method do when used on a nested hash or array?

easy

A. It safely accesses nested elements and returns nil if any key or index is missing.

B. It deletes the nested element at the given keys or indexes.

C. It converts the nested hash or array into a flat array.

D. It raises an error if any nested key or index is missing.

Solution

1. Step 1: Understand the purpose of dig

   The dig method is designed to access nested data structures like hashes or arrays without raising errors if a key or index is missing.

2. Step 2: Behavior on missing keys or indexes

   If any part of the nested path does not exist, dig returns nil instead of raising an error.

3. Final Answer:

   It safely accesses nested elements and returns nil if any key or index is missing. -> Option A

4. Quick Check:

   dig returns nil on missing keys/indexes [OK]

Hint: Remember: dig returns nil if path missing, no error [OK]

Common Mistakes:

• Thinking dig deletes elements
• Expecting dig to flatten nested structures
• Assuming dig raises errors on missing keys

2. Which of the following is the correct syntax to use dig on a hash h = {a: {b: 2}} to get the value 2?

easy

A. h.dig(:a).dig(b)

B. h.dig[:a][:b]

C. h[:a].dig(b)

D. h.dig(:a, :b)

Solution

1. Step 1: Check the correct method call syntax

   The dig method is called with arguments representing the nested keys or indexes, separated by commas inside parentheses.

2. Step 2: Validate each option

   h.dig(:a, :b) uses h.dig(:a, :b), which is the correct syntax. h.dig[:a][:b] uses square brackets incorrectly. h[:a].dig(b) uses b without the leading colon :, causing NameError. h.dig(:a).dig(b) chains dig calls unnecessarily and uses b without :, causing NameError.

3. Final Answer:

   h.dig(:a, :b) -> Option D

4. Quick Check:

   dig called with keys as arguments [OK]

Hint: Use parentheses and commas for dig keys: dig(:a, :b) [OK]

Common Mistakes:

• Using square brackets after dig
• Chaining dig calls unnecessarily
• Forgetting colons for symbol keys in dig

3. Given the code:

data = {user: {profile: {name: "Alice", age: 30}}}
puts data.dig(:user, :profile, :name)

What will be the output?

medium

A. 30

B. nil

C. Alice

D. Error

Solution

1. Step 1: Trace the dig method call

   The dig method looks for the key :user in data, then :profile inside that, then :name inside profile.

2. Step 2: Extract the value at the nested keys

   All keys exist, so dig returns the string "Alice".

3. Final Answer:

   Alice -> Option C

4. Quick Check:

   dig returns nested value "Alice" [OK]

Hint: Follow keys step-by-step to find nested value [OK]

Common Mistakes:

• Expecting nil if keys exist
• Confusing age with name value
• Thinking dig raises error on existing keys

4. Consider this code snippet:

info = {a: {b: 1}}
puts info.dig(:a, :c)

What is the issue and how to fix it?

medium

A. Returns nil because :c key is missing; no fix needed

B. No issue; output is 1

C. Raises error; fix by checking keys manually

D. Syntax error; fix by adding parentheses

Solution

1. Step 1: Analyze the dig call with missing key

   The key :c does not exist inside the nested hash under :a.

2. Step 2: Understand dig behavior on missing keys

   Instead of raising an error, dig returns nil safely when a key is missing.

3. Final Answer:

   Returns nil because :c key is missing; no fix needed -> Option A

4. Quick Check:

   dig returns nil on missing keys safely [OK]

Hint: dig returns nil on missing keys; no error [OK]

Common Mistakes:

• Expecting an error on missing keys
• Trying to manually check keys before dig
• Confusing nil output with error

5. You have a nested data structure:

settings = {theme: {colors: [{name: "red", code: "#f00"}, {name: "green", code: "#0f0"}]}}

Which dig call correctly retrieves the color code for the second color?

hard

A. settings.dig(:theme, :colors)[1][code]

B. settings.dig(:theme, :colors, 1, :code)

C. settings.dig(:theme, :colors, :code, 1)

D. settings.dig(:theme, :colors, 2, :code)

Solution

1. Step 1: Understand the nested structure

   colors is an array of hashes. The second color is at index 1 (arrays start at 0).

2. Step 2: Use dig with correct keys and index

   To get the code of the second color, use dig(:theme, :colors, 1, :code). settings.dig(:theme, :colors, 1, :code) matches this.

3. Final Answer:

   settings.dig(:theme, :colors, 1, :code) -> Option B

4. Quick Check:

   dig accesses nested array index and hash key [OK]

Hint: Use array index as integer in dig for arrays [OK]

Common Mistakes:

• Using wrong index (2 instead of 1)
• Passing keys in wrong order
• Trying to dig with symbol on array