Compact for removing nil values in Ruby - Mini Project: Build & Apply

Compact for removing nil values

📖 Scenario: You have a list of items where some are missing (nil). You want to clean this list by removing all the missing items.

🎯 Goal: Build a Ruby program that uses compact to remove all nil values from an array.

📋 What You'll Learn

Create an array called items with some nil values

Create a variable called clean_items that uses compact on items

Print the clean_items array

💡 Why This Matters

🌍 Real World

Cleaning data lists by removing missing or empty values is common in many programs, like filtering user inputs or processing data files.

💼 Career

Knowing how to clean arrays efficiently helps in data processing, web development, and scripting tasks where data quality matters.

1

Create the array with nil values

Create an array called items with these exact elements: "apple", nil, "banana", nil, "cherry"

Ruby

# Create the array called items with some nil values
# Your code here

Hint

Use square brackets [] to create the array and include nil where needed.

2

Use compact to remove nil values

Create a variable called clean_items and set it to items.compact to remove all nil values

Ruby

items = ["apple", nil, "banana", nil, "cherry"]
# Create clean_items by calling compact on items
# Your code here

Hint

Use the compact method on the items array and assign it to clean_items.

3

Print the cleaned array

Write a puts statement to print the clean_items array

Ruby

items = ["apple", nil, "banana", nil, "cherry"]
clean_items = items.compact
# Print clean_items
# Your code here

Hint

Use puts clean_items to display the array elements, each on its own line.

4

Print the cleaned array as a single line

Write a puts statement to print the clean_items array as a single line using inspect

Ruby

items = ["apple", nil, "banana", nil, "cherry"]
clean_items = items.compact
puts clean_items
# Print clean_items as a single line
# Your code here

Hint

Use puts clean_items.inspect to print the array on one line with brackets.

Practice

1.

What does the Ruby method compact do when called on an array?

easy

A. It returns a new array without any nil values.

B. It removes all duplicate values from the array.

C. It sorts the array in ascending order.

D. It changes all nil values to zero.

Solution

1. Step 1: Understand the purpose of compact

   The compact method creates a new array by removing all nil values from the original array.

2. Step 2: Compare with other options

   Other options describe different array methods or behaviors, but only compact removes nil values without modifying the original array.

3. Final Answer:

   It returns a new array without any nil values. -> Option A

4. Quick Check:

   compact removes nil values = B [OK]

Hint: Remember: compact removes nil, keeps original unchanged [OK]

Common Mistakes:

• Confusing compact with uniq (removes duplicates)
• Thinking compact sorts the array
• Believing compact replaces nil with zero

2.

Which of the following is the correct syntax to remove nil values from an array arr without changing arr itself?

arr = [1, nil, 2, nil, 3]

easy

A. arr.delete(nil)

B. arr.compact!

C. arr.remove_nil

D. arr.compact

Solution

1. Step 1: Identify method that returns new array without nil

   compact returns a new array without nil values and does not modify the original array.

2. Step 2: Understand difference with compact!

   compact! modifies the original array, so it changes arr. delete(nil) removes nil but modifies arr. remove_nil is not a Ruby method.

3. Final Answer:

   arr.compact -> Option D

4. Quick Check:

   compact returns new array, compact! modifies [OK]

Hint: Use compact for new array, compact! to modify original [OK]

Common Mistakes:

• Using compact! when original array should stay unchanged
• Using delete(nil) which modifies the original array
• Assuming remove_nil is a valid Ruby method

3.

What is the output of the following Ruby code?

arr = [nil, 5, nil, 10]
new_arr = arr.compact
puts new_arr.inspect
puts arr.inspect

medium

A. [5, 10]
[nil, 5, nil, 10]

B. [nil, 5, nil, 10]
[5, 10]

C. [5, 10]
[5, 10]

D. [nil, nil]
[nil, 5, nil, 10]

Solution

1. Step 1: Understand what compact returns

   compact returns a new array without nil values, so new_arr is [5, 10].

2. Step 2: Check if original array changes

   The original array arr remains unchanged as [nil, 5, nil, 10].

3. Final Answer:

   [5, 10] [nil, 5, nil, 10] -> Option A

4. Quick Check:

   compact returns new array, original unchanged = A [OK]

Hint: compact returns new array; original stays same [OK]

Common Mistakes:

• Assuming original array changes after compact
• Confusing compact with compact! which modifies original
• Misreading output order

4.

Consider this Ruby code snippet:

arr = [1, nil, 2, nil, 3]
arr.compact
puts arr.inspect

Why does the output still include nil values?

medium

A. Because arr was reassigned incorrectly.

B. Because compact does not remove nil values at all.

C. Because compact returns a new array but does not modify arr.

D. Because puts cannot print arrays correctly.

Solution

1. Step 1: Understand compact behavior

   compact returns a new array without nil values but does not change the original array.

2. Step 2: Check why arr still has nil

   Since arr.compact was called without assignment, arr remains unchanged and still contains nil.

3. Final Answer:

   Because compact returns a new array but does not modify arr. -> Option C

4. Quick Check:

   compact returns new array, original unchanged = D [OK]

Hint: Use compact! or assign compact result to change original [OK]

Common Mistakes:

• Thinking compact modifies original array
• Believing puts cannot print arrays properly
• Assuming arr was reassigned automatically

5.

You have an array data = [nil, 0, false, '', nil, 5]. You want to remove only nil values but keep 0, false, and empty strings. Which code correctly does this?

hard

A. clean_data = data.reject!(&:nil?)

B. clean_data = data.compact

C. clean_data = data.select { |v| v }

D. clean_data = data.delete_if { |v| v.nil? }

Solution

1. Step 1: Understand what compact does

   compact removes only nil values and keeps all other values including 0, false, and empty strings.

2. Step 2: Analyze other options

   select { |v| v } removes all falsy values (nil, false, 0 is truthy in Ruby but empty string is truthy), so it removes false. reject!(&:nil?) modifies the original array. delete_if { |v| v.nil? } modifies original array.

3. Step 3: Choose best option for new array without nil

   compact is simplest and returns new array without modifying original.

4. Final Answer:

   clean_data = data.compact -> Option B

5. Quick Check:

   compact removes nil only, keeps false and empty string = C [OK]

Hint: Use compact to remove nil only, keep false and empty strings [OK]

Common Mistakes:

• Using select which removes false values
• Using delete_if which modifies original array
• Using reject! which modifies the original array