Cleaning Arrays of Arrays which consist of nils - arrays

Question

For example I have an array:
[[nil, nil], [1, 2], [nil, nil], [nil, nil]]
What is the best way to clean it? Array must have only arrays which do not consist of nil. After cleaning it has to be:
[[1,2]]
Something like:
[[nil, nil], [1, 2], [nil, nil], [nil, nil]].each {|x| x - [nil]}

Answer 1

The methods on arrays that remove nil elements is called compact. However, that is not quite enough for this situation because you have an array of arrays. In addition you will want to select the non-nil arrays, or reject the arrays that are nil. You can easily combine the two in the following way:
[[nil, nil], [1, 2], [nil, nil], [nil, nil]].reject { |arr| arr.compact.empty? }
This will only work if you have sub arrays of numbers OR nils. If your sub arrays contain both e.g. [1, nil, 2], then this solution will keep the entire sub array.
It is possible to mutate the sub array to remove nil while you iterate over the sub arrays, but it can be considered practice to mutate while you iterate. Nevertheless, the way to do this would be to use the bang version of the compact method which mutates the original object:
.reject { |arr| arr.compact!.empty? }
This will take [[1, 2, nil, 3]] and return [[1, 2, 3]].
As sagarpandya82 pointed out, you can also use the all or any? methods for simply checking if everything is nil, or if anything is nil instead of removing the nils.
To recap:
original_array = [[nil, nil],[1, nil, 2], [1, 2, 3]]
original_array.reject { |arr| arr.all?(:nil) } # returns [[1, nil, 2], [1, 2, 3]]
original_array.reject { |arr| arr.compact.empty? } # returns [[1, nil, 2], [1, 2, 3]]
original_array.reject { |arr| arr.any?(:nil) } # returns [[1, 2, 3]]
original_array.reject { |arr| arr.compact!.empty? } # returns [[1, 2, 3], [1, 2]]

Answer 2

Assuming you're only interested in 2D-Arrays then:
Rid sub-arrays consisting of only nils:
arr.reject { |arr| arr.all?(&:nil?) }
Rid sub-arrays consisting of any nils:
arr.reject { |arr| arr.any?(&:nil?) }

Answer 3

compact will remove nil elements from an array.
map will run over each item in an array and return a fresh array by applying code on the item of the array. Note that in your example elements of the array are itself ... Arrays.
reject will return a new array without the elements that your given code answers 'false' to.
select will return a new array with the elements that your given code 'likes' (kinda opposite of reject).
So if you just want to remove all nils from an array and its subarray (but not sub-subarrays), you could call
list = [[1,2], [nil], [1,nil,2]]
list.map(&:compact).reject(&:empty?) #=> [[1,2], [1,2]]
which is the same as
compacted_list = list.map do |element|
element.compact
end
non_empty_list = compacted_list.reject do |element|
element.empty?
end
If you want to remove all [nil, nil] entries from the list/array
list.reject{|element| element == [nil, nil]}
or if it is more about selecting the non-nil elements (this is really just about intent-revealing code)
list.select{|element| element != [nil, nil])
Most of these functions have an ! counterpart (like reject!) which does the modification in place, which means you do not have to assign the return value (like in new_list = old_list.reject()).

Answer 4

There appear to be differing interpretations of the question.
If, as suggested by the question's example, all elements (arrays) that contain one nil contain only nils, and those elements are to be excluded, this would do that:
[[nil, nil], [1, 2], [nil, nil], [nil, nil]].select(&:first)
#=> [!1, 2]]
If all elements that contain at least one nil are to be excluded, this would do that:
[[3, nil], [1, 2], [3, 4, 5, nil]].reject { |a| a.any?(&:nil?) }
#=> [!1, 2]]
If all nils are to be removed from each element, this would do that:
[[3, nil], [1, 2], [nil], [nil, 3, 4]].map(&:compact)
#=> [[3], [1, 2], [], [3, 4]]
If all nils are to be removed from each element, and then all empty arrays are to be removed, this would do that:
[[3, nil], [1, 2], [nil], [nil, 3, 4]].map(&:compact).reject(&:empty?)
#=> [[3], [1, 2], [3, 4]]

Answer 5

I was recently looking at facets, a ruby gem that provides a lot of core ruby language extensions.
One of the examples they give is for the Array#recurse method, I'll show it below:
arr = ["a", ["b", "c", nil], nil]
arr.recurse{ |a| a.compact! }
#=> ["a", ["b", "c"]]
This gets about half the job done in your case - you also want to remove non empty arrays.
Facets works by patching core Ruby methods. That means as soon as you run require 'facets/array/recurse', any previously defined Array#recurse method will be overridden. Patching core methods is generally ill-advised because of the possibility of naming conflicts.
Still, it's a useful method, and it's easy to define it in such a way that it takes an array as an argument instead of operating on the value of self. You can then use it to define two methods which together fulfill your purpose:
module ArrayUtils
def recurse(array, *types, &block)
types = [array.class] if types.empty?
a = array.reduce([]) do |arr, value|
case value
when *types
arr << recurse(value, *types, &block)
else
arr << value
end
arr
end
yield a
end
def recursive_compact(array)
recurse(array, &:compact)
end
def recursive_remove_nonempty(array)
recurse(array) do |arr|
arr.reject do |x|
x.is_a?(Array) && x.empty?
end
end
end
end
Testing it out:
include ArrayUtils
orig = [[nil, nil], [1, 2], [nil, nil], [nil, nil]]
compacted = recursive_compact(orig)
nonempties = recursive_remove_nonempty compacted
puts "original: #{orig.inspect}"
puts "compacted: #{compacted.inspect}"
puts "nonempties: #{nonempties.inspect}"
and running
original: [[nil, nil], [1, 2], [nil, nil], [nil, nil]]
compacted: [[], [1, 2], [], []]
nonempties: [[1, 2]]