Array.flatten / uniq / compact

# Flattens a nested array into one dimension.
array.flatten       # Removes all levels of nesting.
array.flatten(depth)  # Flattens up to the specified depth.

# Returns a new array with duplicate elements removed.
array.uniq
array.uniq { |element| key }  # Specifies the uniqueness criterion via a block.

# Returns a new array with nil elements removed.
array.compact

# flatten: Flattens a nested array.
nested = [1, [2, 3], [4, [5, 6]]]
puts nested.flatten.inspect      # [1, 2, 3, 4, 5, 6]
puts nested.flatten(1).inspect   # [1, 2, 3, 4, [5, 6]] (one level only)

# uniq: Removes duplicate elements.
with_dups = [1, 2, 2, 3, 3, 3, 4]
puts with_dups.uniq.inspect  # [1, 2, 3, 4]

# Specify a uniqueness criterion via a block (case-insensitive comparison).
words = ["apple", "Apple", "banana", "BANANA"]
puts words.uniq { |w| w.downcase }.inspect  # ["apple", "banana"]

# compact: Removes nil elements.
data = [1, nil, 2, nil, 3]
puts data.compact.inspect  # [1, 2, 3]

# Combined example: Cleaning an API response.
raw_data = [[1, 2], [3, nil, 4], [2, 5]]
cleaned = raw_data.flatten.compact.uniq.sort
puts cleaned.inspect  # [1, 2, 3, 4, 5]

flatten, uniq, and compact are all non-destructive methods — they return a new array without modifying the original. Each has a destructive counterpart with a trailing !.

uniq keeps the first occurrence of each element and removes subsequent duplicates. You can pass a block to define a custom comparison key, making it useful for case-insensitive comparisons or deduplication based on a specific field.

flatten!, uniq!, and compact! return nil if no changes were made. Be careful when using them in method chains. If you need a guaranteed array return value, use the non-destructive versions instead.

For adding and removing array elements, see 'insert / delete / delete_at'. For joining arrays, see 'concat / + / zip'.