Sorting an array of hashes in ruby

Question

I have an array of hashes which look like:

ward = {id: id, name: record["Externalization"], mnemonic: record["Mnemonic"],
   seqno: record["SeqNo"]}

All fields are strings.

Now I want to sort them first on seqno and then on name. seqno can be nil (if seqno is nil, then this ward must come after the ones having a seqno).

What I have so far is:

wardList.sort! do |a,b| 
  return (a[:name] <=> b[:name]) if (a[:seqno].nil? && b[:seqno].nil?) 
  return -1 if a[:seqno].nil?
  return 1 if b[:seqno].nil?
  (a[:seqno] <=> b[:seqno]).nonzero? ||
    (a[:name] <=> b[:name])
end

But this gives me the error: can't convert Symbol into Integer

Niklas B. · Accepted Answer · 2012-03-21 16:27:03Z

2

First, normalize your data, you can't work with integers as strings here:

wardList = wardList.map { |x| x.merge({:id    => x[:id].to_i, 
                                       :seqno => x[:seqno].try(:to_i) }) }

Then you can use sort_by, which supports lexicographical sorting:

wardList.sort_by! { |x| [x[:seqno] || Float::INFINITY, x[:name]] }

Example:

irb(main):034:0> a = [{:seqno=>5, :name=>"xsd"}, 
                      {:seqno=>nil, :name=>"foo"}, 
                      {:seqno=>nil, :name=>"bar"}, 
                      {:seqno=>1, :name=>"meh"}]
irb(main):033:0> a.sort_by { |x| [x[:seqno] || Float::INFINITY, x[:name]] }
=> [{:seqno=>1, :name=>"meh"},
    {:seqno=>5, :name=>"xsd"},
    {:seqno=>nil, :name=>"bar"},
    {:seqno=>nil, :name=>"foo"}]

edited Mar 21, 2012 at 16:27

answered Mar 21, 2012 at 15:35

Niklas B.

95.8k18 gold badges201 silver badges228 bronze badges

Sign up to request clarification or add additional context in comments.

23 Comments

Lieven Cardoen Over a year ago

Yes, but what if a[:seqno] is nil?

tokland Over a year ago

@Lieven, why nasty? how do you compare a number with nil? it's only natural to set a default value to cover this case.

Niklas B. Over a year ago

@Lieven: So now you have two one-line solutions to solve this task perfectly simple and elegant. Congratulations.

Niklas B. Over a year ago

@Lieven: You seem to be lacking some basic understanding of the tools you are working with. Check my answer for an example of how to transform the data properly.

Niklas B. Over a year ago

@Lieven: Exactly the values false and nil are considered boolean false in Ruby. So with the first operand being nil, the second operand is not even evaluated. By the way, the expression doesn't return false, it returns the first falsy value (nil in this case).

|

PinnyM · Accepted Answer · 2012-03-21 16:15:17Z

1

This should work:

sorted = wardList.sort_by{|a| [a[:seqno] ? 0 : 1, a[:seqno], a[:name]] }

or for some rubies (e.g. 1.8.7):

sorted = wardList.sort_by{|a| [a[:seqno] ? 0 : 1, a[:seqno] || 0, a[:name]] }

edited Mar 21, 2012 at 16:15

answered Mar 21, 2012 at 15:31

PinnyM

35.6k4 gold badges77 silver badges84 bronze badges

16 Comments

PinnyM Over a year ago

Edited, that should include what you need

PinnyM Over a year ago

sorts first on nil? status of :seqno (as string - 'false' will always precede 'true'), then on :seqno, then on :name

Lieven Cardoen Over a year ago

Great solution. But how come it doesn't crash on a[:seqno] when it's nil?

PinnyM Over a year ago

sort_by uses tuple comparison, as opposed to standard sort comparison. Apparently tuples are allowed to contain nil (but not true or false), although I'm not sure myself how the comparison implementation actually does this. nil will normally precede non-nil, which is why we need to first sort on nil status

Niklas B. Over a year ago

Oh, by the way, looking back at the question it should really be a[:seqno] ? 0 : 1

|

Patrick Oscity · Accepted Answer · 2012-03-21 16:13:06Z

0

I don't think you should use return here, it causes the block to return to the iterator, the iterator to return to the enclosing method and the enclosing method to return to its caller. Use next instead which only causes the block to return to the iterator (sort! in this case) and do something like:

wardList.sort! do |x,y|
  next  1 if x[:seqno].nil?
  next -1 if y[:seqno].nil?
  comp = x[:seqno] <=> y[:seqno]
  comp.zero? ? x[:name] <=> y[:name] : comp
end

edited Mar 21, 2012 at 16:13

answered Mar 21, 2012 at 16:06

Patrick Oscity

54.9k19 gold badges149 silver badges173 bronze badges

1 Comment

Niklas B. Over a year ago

This gives the wrong result if x[:seqno].nil? && !y[:seqno].nil?

Collectives™ on Stack Overflow

Sorting an array of hashes in ruby

3 Answers 3

23 Comments

16 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

23 Comments

16 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related