Clearing arrays of arrays that consist of nil

Question

For example, I have an array:

[[nil, nil], [1, 2], [nil, nil], [nil, nil]] 

What is the best way to clean it? An array should only have arrays that are not composed of zero. After cleaning, it should be:

[[1,2]]

Sort of:

[[nil, nil], [1, 2], [nil, nil], [nil, nil]].each {|x| x - [nil]} 

Answer 1

Array methods that remove elements nilare called compact . However, this is not enough for this situation, because you have an array of arrays. Also, you want select non-nil arrays or reject arrays that are nil. You can easily combine them as follows:

[[nil, nil], [1, 2], [nil, nil], [nil, nil]].reject { |arr| arr.compact.empty? }

, OR nil s. , , [1, nil, 2], .

, nil, , , . , bang compact, :

.reject { |arr| arr.compact!.empty? }

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

sagarpandya82, all any?, , nil, - nil nil s.

:

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

, 2D-, :

-, nil s:

arr.reject { |arr| arr.all?(&:nil?) }

Rid sub-arrays, nil s:

arr.reject { |arr| arr.any?(&:nil?) }

Answer 3

• compact nil .
• map , . , ... .
• reject , "false" .
• select , "" ( ).

, nil s ( -subarrays),

list = [[1,2], [nil], [1,nil,2]]
list.map(&:compact).reject(&:empty?) #=> [[1,2], [1,2]]

compacted_list = list.map do |element|
  element.compact
end
non_empty_list = compacted_list.reject do |element|
  element.empty?
end

[nil, nil] /

list.reject{|element| element == [nil, nil]}

, nil ( , )

list.select{|element| element != [nil, nil])

! (, reject!), , , (, new_list = old_list.reject()).

Answer 4

-, .

, , (), nil, nil s, , :

[[nil, nil], [1, 2], [nil, nil], [nil, nil]].select(&:first)
  #=> [!1, 2]]

, nil, , :

[[3, nil], [1, 2], [3, 4, 5, nil]].reject { |a| a.any?(&:nil?) }
  #=> [!1, 2]]

nil , :

[[3, nil], [1, 2], [nil], [nil, 3, 4]].map(&:compact)
  #=> [[3], [1, 2], [], [3, 4]]

nil , , :

[[3, nil], [1, 2], [nil], [nil, 3, 4]].map(&:compact).reject(&:empty?)
  #=> [[3], [1, 2], [3, 4]]

Answer 5

facets, , .

, Array # recurse, :

arr = ["a", ["b", "c", nil], nil]
arr.recurse{ |a| a.compact! }
#=> ["a", ["b", "c"]]

- .

, Ruby. , require 'facets/array/recurse', Array#recurse . - .

However, this is a useful method, and it is easy to define in such a way that it takes an array as an argument instead of working with a value self. You can then use it to identify two methods that together achieve your goal:

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:

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 working

original: [[nil, nil], [1, 2], [nil, nil], [nil, nil]]
compacted: [[], [1, 2], [], []]
nonempties: [[1, 2]]