Sort array of hashes with nil values last

Question

I wrote a method which sorts an array of hashes by given hash keys. The method should put nil values at the end.

def sort(records, *attrs)
  records.sort do |a,b|
    result = 0
    attrs.each do |attr|
      unless a[attr] == b[attr]
        result = if a[attr].nil?
                   1
                 elsif b[attr].nil?
                   -1
                 else
                  a[attr] <=> b[attr]
                 end
        break
      end
    end
    result
  end
end

p sort([{:a => 1},{:a => nil},{:a => 2}], :a)
#=> [{:a=>1}, {:a=>2}, {:a=>nil}]
p sort([{:a => nil},{:a => 'x'},{:a => 'a'}], :a)
#=> [{:a=>"a"}, {:a=>"x"}, {:a=>nil}]

My solution looks quite complex. Is there a better way to achieve the ordering in Ruby?

Answer 1

Set Unions

Looking at your code, when you loop through the attrs, you are breaking after you find the first key that is in a and in b and in the passed attrs. This is also known as the union of the arrays. As such you can simplify the inner loop with:

(attrs & a.keys & b.keys).first

Shorthand if/elseif syntax

You can use the keyword then in conjunction with if and elsif to cut down on the whitespace of your if-eslif chain. The syntax would look like:

if attr.nil? then 0
elsif a[attr].nil? then 1
elsif b[attr].nil? then -1
else a[attr] <=> b[attr] end

Putting it all together

def sort(records, *attrs)
  records.sort do |a, b|
    attr = (attrs & a.keys & b.keys).first
    if attr.nil? then 0
    elsif a[attr].nil? then 1
    elsif b[attr].nil? then -1
    else a[attr] <=> b[attr] end
  end
end

Answer 2

You can create temporary sorting columns:

def sort records, *attrs
  records.sort_by do |h|
    h.values_at(*attrs).map do |v|
      v.nil? ? [2] : [1, v]
    end
  end
end

Here I added columns with values 1 or 2 to the left for higher priority -- could add to the right or even in between for more complex sorting.

Answer 3

Thanks for the suggestions. After all I implemented it the following way. It combines the solutions of Zack and Nakilon.

def sort(records, *attrs)
  records.sort do |a,b|
    k = attrs.find { |e| a[e] != b[e] }                    # 1.
    k ? [a[k] ? 0 : 1, a[k]] <=> [b[k] ? 0 : 1, b[k]] : 0  # 2.
  end
end

1. Select the attribute that differs (Similar to the union idea of Zack)
2. Introduce a pseudo value for comparison with nil values (Taken from Nakilons post)