Frage Objekte in Array nach mehreren Schlüsseln sortieren (Underscore.js)

[Chronos]

Hallo Forum,

ich habe ein Array welches mehrere Zeiten als Objekte enthält, jedes Objekt hat ein Feld 'available_in' und 'available_for'.
Mit Hilfe von Underscore.js möchte ich das Objekt nach 'available_in' aufsteigend und gleichzeitig 'available_for' absteigend sortieren.

Ich habe dazu ein JS-Bin erstellt in dem eigentlich alles auch noch mal zu sehen ist:
http://jsbin.com/wibeqig/edit?js,output

Der relevante Part noch ein mal hier:

let times = [
    { 'available_in' : 195, 'available_for': Infinity},
    { 'available_in' : 90, 'available_for': 30},
    { 'available_in' : 90, 'available_for': Infinity}
]
 
let times_sorted =
    _(times).chain()
        .sortBy('available_in')
        .sortBy('available_for')
        .value();

console.table(times_sorted);

dazu muss natürlich Underscore.js eingebunden sein.

Falls das ganze auch einfach UND flexibel mit ES6/7 geht und ich nach belieben auf- und absteigend mehrere Schlüssel sortieren kann ohne 50 Zeilen + zu schreiben, würde ich das auch gern wissen.

Vielen Dank schon mal für eure Hilfe.

 

[Chronos]

Okay... ich habe etwas gefunden aber so richtig verstehen tue ich es nicht:

let times_sorted = times.sort((x, y) => {
                let n = x.available_in - y.available_in;
                if (n !== 0) {
                    return n;
                }
                
                return y.available_for - x.available_for;
            });

Falls jemand die ursprüngliche Antwort weiß bitte mir sagen ansonsten helft mir bitte das hier zu verstehen

 

[Tronjer]

ansonsten helft mir bitte das hier zu verstehen

Lambda-Funktionen sind neu in ES6 und benötigen der Browserkompatibilität wegen einen Transpiler wie TypeScript, Babel oder Traceur.

Anstatt Underscore nimm lieber Lodash, das hat sich mittlerweile als Standard etabliert.
https://lodash.com/

 

[Chronos]

Anstatt Underscore nimm lieber Lodash, das hat sich mittlerweile als Standard etabliert.
https://lodash.com/

Danke für die Info, das war mir zwar ein Begriff aber das es einen Ersatz darstellt wusste ich nicht.

 

[Chronos]

Die Lösung mit dem Standard-Sort wollte ich auch gerade vorschlagen.

Okay das habe ich denke ich soweit verstanden. Kannst du mir sagen, wieso ich nichts zurückbekomme, wenn ich es als Funktion benutzte?

function sort_by_multiple_keys(obj, first_key, second_key) {
    obj.sort((x, y) => {
        let n = x[first_key] - y[first_key];
        
        if (n !== 0) {
            return n;
        }
        
        return y[second_key] - x[second_key];
    });
}

let occupied_rooms_sorted = sort_by_multiple_keys(
    occupied_rooms,
    'available_in',
    'available_for'
);

wenn ich es hingegen so mache, wie ich es in meiner anderen Antwort schrieb, geht es.

 

[Chronos]

Ohne es getestet zu haben: Du verwendest den Rückgabewert von sort_by_multiple_keys in einer Zuweisung. Dann musst Du auch in der Funktion den Rückgabewert setzen:

function sort_by_multiple_keys(obj, first_key, second_key) {
    return obj.sort((x, y) => {
        let n = x[first_key] - y[first_key];
    
        if (n !== 0) {
            return n;
        }
    
        return y[second_key] - x[second_key];
    });
}

Danke das funktioniert natürlich, daran habe ich gar nicht gedacht :) danke sehr! Jetzt schreib ich die Funktion noch so um, dass ich wahlweise den einen und oder den anderen Key auf- oder absteigend sortieren kann.

Edit: ich lasse das Thema trotzdem mal offen, weil es ja eigentlich um Underscore.js ging (auch wenn ich das jetzt nicht mehr benutzen werde)