Joel P. wrote in post #1112686:
masta Blasta wrote in post #1112677:
Joel P. wrote in post #1112665:
If the items within each array belong to each other, how about a
multidimensional array?
arr = [
[ Obj1(prop1, prop2, id), OthrObj1(prop1, prop2, ref_id) ],
[ Obj2(prop1, prop2, id), OthrObj2(prop1, prop2, ref_id) ],
[ Obj3(prop1, prop2, id), OthrObj3(prop1, prop2, ref_id) ]
]
All the sorting is dealt with together then:
sorted_arr = arr.sort_by { |obj1, obj2| obj1.id }
I don’t quite understand everything that’s happening here. Can you
elaborate a bit more on your solution.
I’m going by your comment here:
“The objects in arr2 have a 1-1 relationship with the objects in arr1”
If the objects are interlinked, rather than trying to keep two separate
arrays and sorting them side-by-side (which can easily go wrong), you
could simply connect the pairs into their own arrays all inside another
array.
This has the benefit that once you put the pair into their own array,
they are connected without you having to worry about having to do
everything the same with array1 and array2.
Then you can iterate through the large array like this:
arr.each { |subarray| some_method( subarray[0], subarray[1] ) }
In this example you can access each of the smaller arrays inside your
array. [0] is each object and [1] is each otherobject
Or like this:
arr.each { |object, otherobject| some_method( object, otherobject ) }
This example is functionally the same as the previous one, but you’re
using parallel assignment to place each object from the array into its
own variable so it’s easier to read.
Using this approach, you can sort the larger array containing objects
and otherobjects by whatever criteria you want, and they’ll stay
together as a pair within the larger array.
This will sort each array within the parent by the first object’s id:
arr = arr.sort_by { |object, otherobject| object.id }
This does the same thing, but with the second object’s id:
arr = arr.sort_by { |object, otherobject| otherobject.id }
The best way to grasp how this is works is to do it in IRB and play
around with the results.
I just learned something new about ordering arrays! However this doesn’t
actually solve the original problem. Your solution expects both arrays
to be properly sorted, and then keeps them together if one or the other
is re-ordered.
Originally only one of the arrays was properly sorted, and the other had
then to be ordered to match.
Here is some better sample data:
terms = [
{:id=>3, :name=>“term1”, :version=>2},
{:id=>4, :name=>“term2”, :version=>2},
{:id=>8, :name=>“term3”, :version=>1}
]
arr2 = [
{:term_id=>4, :name=>“assoc1”},
{:term_id=>8, :name=>“assoc2”},
{:term_id=>3, :name=>“assoc3”}
]
so ‘terms’ is properly sorted, and now we want arr2 to follow that
order. So after our operation arr2 should look like:
arr2 = [
{:term_id=>3, :name=>“assoc3”},
{:term_id=>4, :name=>“assoc1”},
{:term_id=>8, :name=>“assoc2”}
]
These are ActiveRecord objects. A SQL solution is possible but the query
is painfully long due to complex associations. Since the arrays are
usually small 3-5 records, i was hoping i could just sort them
programmatically.
