Compact for removing nil values in Ruby

Introduction

Sometimes, lists have empty spots called nil in Ruby. compact helps clean the list by removing these empty spots.

When you have a list of items and want to ignore empty or missing values.

When you get data from a form or user input that might have blanks.

When you want to prepare a list for counting or showing only real items.

Syntax

Ruby

array.compact

This method returns a new array without nil values.

It does not change the original array unless you use compact!.

Examples

Removes all nil values and returns [1, 2, 3].

Ruby

[1, nil, 2, nil, 3].compact

All values are nil, so it returns an empty array [].

Ruby

[nil, nil, nil].compact

compact! changes the original array by removing nil values.

Ruby

array = [1, nil, 2]
array.compact!
puts array.inspect

Sample Program

This program shows how compact removes nil values from the list without changing the original.

Ruby

numbers = [10, nil, 20, nil, 30]
clean_numbers = numbers.compact
puts "Original: #{numbers.inspect}"
puts "Cleaned: #{clean_numbers.inspect}"

Important Notes

If you want to remove nil values and change the original array, use compact!.

If there are no nil values, compact! returns nil.

Summary

compact removes nil values from arrays.

It returns a new array and keeps the original unchanged.

Use compact! to change the original array directly.

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