基于嵌套值或升高值的深度排序多维数组

Question

So I just had one of those "this will DEFINITELY work" moments of excitement only to be followed with severe disappointment. I've been trying to figure out how to sort an array of arrays containing arrays for a little bit now and figured I'd see if SO wanted to help me :)

Data structure:

var array = [{ name: "sunday",   data: [{x: 5, y: 7}, { x: 6, y: 12 }, { x: 6, y: 22 }]},
             { name: "tuesday",  data: {x: 1, y: 15}},
             { name: "monday",   data: {x: 3, y: 25}},
             { name: "thursday", data: {x: 7, y: 5}},
             { name: "friday",   data: {x: 2, y: 2}}]; 

Snippet of sorrow:

function compare(a,b) {
    var c = undefined != a.data.length ? Math.max.apply(Math,a.data.map(function(o){return o.y;})) : a.y;
    var d = undefined != b.data.length ? Math.max.apply(Math,b.data.map(function(o){return o.y;})) : b.y;

    if (c > d)
        return -1;
    if (c < d)
        return 1;
    return 0;
}

So the idea is fairly basic, I want to sort an array based on the max y value. Problem is I have a variable amount of x/y pairs for each array entry...so I need to compare based on possible deep(er) nested values.

Essentially the comparer checks if data is an array or not, if it is it uses some math illusions and pops out the max value of the y's contained within...if it's not it just takes the y value.

That works. So does the extremely basic if a > b return -1 pattern I currently have implemented in the comparer. But SURPRISE...together they hate me. Any ideas would be appreciated.

EDIT: Failure in action - http://jsfiddle.net/TpF8g/

Answer 1

So you're trying to sort a list of objects based on a property called y , and each of those objects may have a variable number of y . Furthermore, if there are > 1 y , you want to consider the maximum.

Here's how I would write the compare function:

function compare(a, b) {
    // Get our maximum y value
    var getMaxY = function(data) {
        // Check if array
        if (data instanceof Array) {
            // Sort our inner array
            data.sort(function(a, b) {
                return a.y - b.y;
            });
            // Get the last one
            return data[data.length - 1].y;
        }
        // Else return y
        return data.y;
    }
    // Compare the maximum y values
    return getMaxY(a.data) - getMaxY(b.data);
}

Answer 2

You were just missing a data property:

function compare(a,b) {
    var c = undefined != a.data.length ? Math.max.apply(Math,a.data.map(function(o){return o.y;})) : a.data.y;
    var d = undefined != b.data.length ? Math.max.apply(Math,b.data.map(function(o){return o.y;})) : b.data.y;

    if (c > d)
        return -1;
    if (c < d)
        return 1;
    return 0;
}

A shorter version could be:

function compare(a,b) {

  function byY(d1, d2){ return d1.y - d2.y; }
  // quick and dirty
  var c = a.data.length ? a.data.sort(byY)[a.data.length-1].y : a.data.y;
  var d = b.data.length ? b.data.sort(byY)[b.data.length-1].y : b.data.y;

  return d - c;
}