sorting übersicht - JavaScript-Objekt nach Eigenschaftenwert sortieren





methoden auslesen (21)


Ich folge der Lösung von slebetman (lesen Sie es für alle Details), aber angepasst, da Ihr Objekt nicht verschachtelt ist.

// First create the array of keys/values so that we can sort it:
var sort_array = [];
for (var key in list) {
    sort_array.push({key:key,value:list[key]});
}

// Now sort it:
sort_array.sort(function(x,y){return x.value - y.value});

// Now process that object with it:
for (var i=0;i<sort_array.length;i++) {
    var item = list[sort_array[i].key];

    // now do stuff with each item
}

Wenn ich ein JavaScript-Objekt habe wie:

var list = {
  "you": 100, 
  "me": 75, 
  "foo": 116, 
  "bar": 15
};

Gibt es eine Möglichkeit, die Eigenschaften nach Wert zu sortieren? Damit ich am Ende bin

list = {
  "bar": 15, 
  "me": 75, 
  "you": 100, 
  "foo": 116
};

Ich habe einen wirklich hirnverbrannten Moment dabei.




Mit query-js können Sie es so machen

list.keys().select(function(k){
    return {
        key: k,
        value : list[k]
    }
}).orderBy(function(e){ return e.value;});

Hier finden Sie einen einführenden Artikel zu query-js




OK , wie Sie vielleicht wissen, Javascript hat sort () -Funktion, um Arrays zu sortieren, aber nichts für das Objekt ...

In diesem Fall müssen wir also ein Array von Schlüsseln erhalten und sie sortieren, deshalb gibt Ihnen die Apis die meiste Zeit Objekte in einem Array, weil Array mehr native Funktionen als Objekt-Literal verwendet. Die schnelle Lösung verwendet den Schlüssel Object.key, der ein Array der Objektschlüssel zurückgibt. Ich erstelle unten die ES6- Funktion, die den Job für Sie erledigt. Sie verwendet native Funktionen sort () und reduce () in Javascript:

function sortObject(obj) {
  return Object.keys(obj)
    .sort().reduce((a, v) => {
    a[v] = obj[v];
    return a; }, {});
}

Und jetzt kannst du es so benutzen:

let myObject = {a: 1, c: 3, e: 5, b: 2, d: 4};
let sortedMyObject = sortObject(myObject);

Überprüfen Sie das sortedMyObject und Sie sehen das Ergebnis sortiert nach Schlüsseln wie folgt:

{a: 1, b: 2, c: 3, d: 4, e: 5}

Auf diese Weise wird das Hauptobjekt nicht berührt und wir bekommen tatsächlich ein neues Objekt.

Ich erstelle auch das Bild unten, um die Funktionsschritte klarer zu machen, falls du es ein bisschen ändern musst, um es auf deine Art zu bearbeiten:




Hier ist die Möglichkeit, das Objekt zu sortieren und im Gegenzug das sortierte Objekt zu erhalten

let sortedObject = {}
sortedObject = Object.keys(yourObject).sort((a, b) => {
                        return yourObject[a] - yourObject[b] 
                    }).reduce((prev, curr, i) => {
                        prev[i] = yourObject[curr]
                        return prev
                    }, {});

Sie können Ihre Sortierfunktion nach Ihren Anforderungen anpassen




viele ähnliche und nützliche Funktionen: https://github.com/shimondoodkin/groupbyfunctions/

function sortobj(obj)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        if(a[1]>b[1]) return -1;if(a[1]<b[1]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}

function sortobjkey(obj,key)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        k=key;      if(a[1][k]>b[1][k]) return -1;if(a[1][k]<b[1][k]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}



Objekt nach Wert sortiert (DESC)

function sortObject(list) {
  var sortable = [];
  for (var key in list) {
    sortable.push([key, list[key]]);
  }

  sortable.sort(function(a, b) {
    return (a[1] > b[1] ? -1 : (a[1] < b[1] ? 1 : 0));
  });

  var orderedList = {};
  for (var i = 0; i < sortable.length; i++) {
    orderedList[sortable[i][0]] = sortable[i][1];
  }

  return orderedList;
}



Ich habe nur dafür ein Plugin erstellt, es akzeptiert 1 arg, das ein unsortiertes Objekt ist, und gibt ein Objekt zurück, das nach Prop-Wert sortiert wurde. Dies funktioniert bei allen zweidimensionalen Objekten wie {"Nick": 28, "Bob": 52} ...

var sloppyObj = {
    'C': 78,
    'A': 3,
    'B': 4
};

// Extend object to support sort method
function sortObj(obj) {
    "use strict";

    function Obj2Array(obj) {
        var newObj = [];
        for (var key in obj) {
            if (!obj.hasOwnProperty(key)) return;
            var value = [key, obj[key]];
            newObj.push(value);
        }
        return newObj;
    }

    var sortedArray = Obj2Array(obj).sort(function(a, b) {
        if (a[1] < b[1]) return -1;
        if (a[1] > b[1]) return 1;
        return 0;
    });

    function recreateSortedObject(targ) {
        var sortedObj = {};
        for (var i = 0; i < targ.length; i++) {
            sortedObj[targ[i][0]] = targ[i][1];
        }
        return sortedObj;
    }
    return recreateSortedObject(sortedArray);
}

var sortedObj = sortObj(sloppyObj);

alert(JSON.stringify(sortedObj));

Hier ist eine Demo der Funktion funktioniert wie erwartet http://codepen.io/nicholasabrams/pen/RWRqve?editors=001




JavaScript-Objekte sind per Definition ungeordnet (siehe ECMAScript-Sprachspezifikation , Abschnitt 8.6). Die Sprachspezifikation garantiert nicht einmal, dass, wenn Sie zweimal nacheinander über die Eigenschaften eines Objekts iterieren, sie beim zweiten Mal in derselben Reihenfolge erscheinen.

Wenn Sie Dinge benötigen, die sortiert werden müssen, verwenden Sie ein Array und die Array.prototype.sort-Methode.




Underscore.js oder Lodash.js für erweiterte Array- oder Objektsortierungen

 var data={
        "models": {

            "LTI": [
                "TX"
            ],
            "Carado": [
                "A",
                "T",
                "A(пасс)",
                "A(груз)",
                "T(пасс)",
                "T(груз)",
                "A",
                "T"
            ],
            "SPARK": [
                "SP110C 2",
                "sp150r 18"
            ],
            "Autobianchi": [
                "A112"
            ]
        }
    };

    var arr=[],
        obj={};
    for(var i in data.models){
      arr.push([i, _.sortBy(data.models[i],function (el){return el;})]);
    }
    arr=_.sortBy(arr,function (el){
      return el[0];
    });
    _.map(arr,function (el){return obj[el[0]]=el[1];});
     console.log(obj);

demo




Der Vollständigkeit halber gibt diese Funktion ein sortiertes Array von Objekteigenschaften zurück:

function sortObject(obj) {
    var arr = [];
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            arr.push({
                'key': prop,
                'value': obj[prop]
            });
        }
    }
    arr.sort(function(a, b) { return a.value - b.value; });
    //arr.sort(function(a, b) { a.value.toLowerCase().localeCompare(b.value.toLowerCase()); }); //use this to sort as strings
    return arr; // returns array
}

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var arr = sortObject(list);
console.log(arr); // [{key:"bar", value:15}, {key:"me", value:75}, {key:"you", value:100}, {key:"foo", value:116}]

Jfiddle mit dem obigen Code ist hier . Diese Lösung basiert auf diesem Artikel .

Aktualisierte Geige zum Sortieren von Strings ist hier. Sie können beide zusätzlichen .toLowerCase () - Konvertierungen für die Groß- / Kleinschreibung zwischen Groß- und Kleinschreibung entfernen.




Verschieben Sie sie in ein Array, sortieren Sie das Array und verwenden Sie dieses Array dann für Ihre Zwecke. Hier ist eine Lösung:

var maxSpeed = {
    car: 300, 
    bike: 60, 
    motorbike: 200, 
    airplane: 1000,
    helicopter: 400, 
    rocket: 8 * 60 * 60
};
var sortable = [];
for (var vehicle in maxSpeed) {
    sortable.push([vehicle, maxSpeed[vehicle]]);
}

sortable.sort(function(a, b) {
    return a[1] - b[1];
});

//[["bike", 60], ["motorbike", 200], ["car", 300],
//["helicopter", 400], ["airplane", 1000], ["rocket", 28800]]

Sobald Sie das Array haben, können Sie das Objekt in der von Ihnen gewünschten Reihenfolge aus dem Array wiederherstellen und erreichen genau das, was Sie tun wollten. Das würde in allen Browsern funktionieren, die ich kenne, aber es wäre abhängig von einer Implementierungsart und könnte jederzeit brechen. Sie sollten niemals Annahmen über die Reihenfolge der Elemente in einem JavaScript-Objekt treffen.




Dies könnte ein einfacher Weg sein, um es als ein echtes geordnetes Objekt zu handhaben. Nicht sicher, wie langsam es ist. könnte auch besser mit einer while-Schleife sein.

Object.sortByKeys = function(myObj){
  var keys = Object.keys(myObj)
  keys.sort()
  var sortedObject = Object()
  for(i in keys){
    key = keys[i]
    sortedObject[key]=myObj[key]
   }

  return sortedObject

}

Und dann fand ich diese Umkehrfunktion von: http://nelsonwells.net/2011/10/swap-object-key-and-values-in-javascript/

Object.invert = function (obj) {

  var new_obj = {};

  for (var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      new_obj[obj[prop]] = prop;
    }
  }

  return new_obj;
};

Damit

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var invertedList = Object.invert(list)
var invertedOrderedList = Object.sortByKeys(invertedList)
var orderedList = Object.invert(invertedOrderedList)



Update mit ES6: Wenn es Ihr Anliegen ist, ein sortiertes Objekt zu durchlaufen (weshalb ich mir vorstellen könnte, dass Sie Ihre Objekteigenschaften sortiert haben möchten), können Sie das Map Objekt verwenden.

Sie können Ihre (Schlüssel-, Wert-) Paare in sortierter Reihenfolge einfügen und dann eine for..of Schleife for..of , um for..of , dass sie in der Reihenfolge for..of werden, in der Sie sie eingefügt haben

var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (var [key, value] of myMap) {
  console.log(key + " = " + value);
}
// 0 = zero 
// 1 = one



Das ECMAScript 2017 führt Object.values / Object.entries . Wie der Name andeutet, fasst der erstere alle Werte eines Objekts zu einem Array zusammen, während der zweite das gesamte Objekt in ein Array von [key, value] Arrays umwandelt; Pythons Äquivalent zu dict.values() und dict.items() .

Die Funktionen erleichtern das Sortieren von Hashwerten in ein geordnetes Objekt. Derzeit unterstützt nur ein kleiner Teil der JavaScript-Plattformen sie , aber Sie können es auf Firefox 47+ versuchen.

let obj = {"you": 100, "me": 75, "foo": 116, "bar": 15};

let entries = Object.entries(obj);
// [["you",100],["me",75],["foo",116],["bar",15]]

let sorted = entries.sort((a, b) => a[1] - b[1]);
// [["bar",15],["me",75],["you",100],["foo",116]]



Wir möchten nicht die gesamte Datenstruktur duplizieren oder ein Array verwenden, für das wir ein assoziatives Array benötigen.

Hier ist ein anderer Weg, um das gleiche wie Bonna zu tun:

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(list).sort(function(a,b){return list[a]-list[b]})
alert(keysSorted);     // bar,me,you,foo



var list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};

function sortAssocObject(list) {
    var sortable = [];
    for (var key in list) {
        sortable.push([key, list[key]]);
    }

    sortable.sort(function(a, b) {
        return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0));
    });

    var orderedList = {};
    for (var i = 0; i < sortable.length; i++) {
        orderedList[sortable[i][0]] = sortable[i][1];
    }

    return orderedList;
}

sortAssocObject(list);

// {bar: 15, me: 75, you: 100, foo: 116}



Eine andere Möglichkeit, dies zu lösen: -

var res = [{"s1":5},{"s2":3},{"s3":8}].sort(function(obj1,obj2){ 
 var prop1;
 var prop2;
 for(prop in obj1) {
  prop1=prop;
 }
 for(prop in obj2) {
  prop2=prop;
 }
 //the above two for loops will iterate only once because we use it to find the key
 return obj1[prop1]-obj2[prop2];
});

// res wird das Ergebnis-Array haben




Hier ist ein weiteres Beispiel:

function sortObject(obj) {
  var arr = [];
  var prop;
  for (prop in obj) {
    if (obj.hasOwnProperty(prop)) {
      arr.push({
        'key': prop,
        'value': obj[prop]
      });
    }
  }
  arr.sort(function(a, b) {
    return a.value - b.value;
  });
  return arr; // returns array
}
var list = {
  car: 300,
  bike: 60,
  motorbike: 200,
  airplane: 1000,
  helicopter: 400,
  rocket: 8 * 60 * 60
};
var arr = sortObject(list);
console.log(arr);




Ihre Objekte können eine beliebige Anzahl von Eigenschaften haben, und Sie können wählen, nach welcher Objekteigenschaft Sie wollen, nach Zahl oder Zeichenfolge, wenn Sie die Objekte in ein Array setzen. Betrachten Sie dieses Array:

var arrayOfObjects = [   
    {
        name: 'Diana',
        born: 1373925600000, // Mon, Jul 15 2013
        num: 4,
        sex: 'female'
    },
    {

        name: 'Beyonce',
        born: 1366832953000, // Wed, Apr 24 2013
        num: 2,
        sex: 'female'
    },
    {            
        name: 'Albert',
        born: 1370288700000, // Mon, Jun 3 2013
        num: 3,
        sex: 'male'
    },    
    {
        name: 'Doris',
        born: 1354412087000, // Sat, Dec 1 2012
        num: 1,
        sex: 'female'
    }
];

Sortieren nach Datum geboren, älteste zuerst

// use slice() to copy the array and not just make a reference
var byDate = arrayOfObjects.slice(0);
byDate.sort(function(a,b) {
    return a.born - b.born;
});
console.log('by date:');
console.log(byDate);

Nach Name sortieren

var byName = arrayOfObjects.slice(0);
byName.sort(function(a,b) {
    var x = a.name.toLowerCase();
    var y = b.name.toLowerCase();
    return x < y ? -1 : x > y ? 1 : 0;
});

console.log('by name:');
console.log(byName);

http://jsfiddle.net/xsM5s/16/




Eine "Pfeil" - Version der answer von @marcusR als Referenz

var myObj = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(myObj).sort((a,b) => myObj[a]-myObj[b])
alert(keysSorted);     // bar,me,you,foo

UPDATE: EDIT April 2017 - Dies gibt ein sortiertes Objekt myObj , das oben definiert wurde.

Object
 .keys(myObj)
 .sort((a, b) => myObj[a]-myObj[b])
 .reduce((_sortedObj, key) => ({
   ..._sortedObj, 
   [key]: myObj[key]
 }), {})

Probieren Sie es hier aus!




Ich möchte eine etwas fundiertere Antwort geben, die die anderen Antworten ergänzt. Ich hatte gehofft, die populärste Antwort zu bearbeiten, schlug aber fehl. Ich habe versucht, es so umfassend und vollständig wie möglich zu gestalten.

Weitere Informationen finden Sie in der MDN-Dokumentation .

"use strict" eine in ECMAScript 5 eingeführte Direktive.

Richtlinien ähneln Aussagen, unterscheiden sich jedoch.

  • use strict enthält keine Schlüsselwörter: Die Direktive ist eine einfache Ausdrucksanweisung, die aus einem speziellen String-Literal (in einfachen oder doppelten Anführungszeichen) besteht. JavaScript-Engines, die ECMAScript 5 nicht implementieren, sehen lediglich eine Ausdrucksanweisung ohne Nebeneffekte. Es wird erwartet, dass zukünftige Versionen der ECMAScript-Standards die use als echtes Schlüsselwort einführen. die Zitate würden damit überflüssig werden.
  • use strict kann nur am Anfang eines Skripts oder einer Funktion verwendet werden, dh es muss vor jeder anderen (echten) Anweisung stehen. Es muss nicht die erste Anweisung in einem Funktionsskript sein: Es können andere Anweisungsausdrücke vorangestellt werden, die aus String-Literalen bestehen (und JavaScript-Implementierungen können sie als implementierungsspezifische Anweisungen behandeln). String-Literals-Anweisungen, die auf eine erste echte Anweisung (in einem Skript oder einer Funktion) folgen, sind einfache Ausdrucks-Anweisungen. Dolmetscher dürfen sie nicht als Richtlinien interpretieren und haben keine Wirkung.

Die Anweisung use strict zeigt an, dass der folgende Code (in einem Skript oder einer Funktion) strikter Code ist. Der Code auf der höchsten Ebene eines Skripts (Code, der nicht in einer Funktion enthalten ist) wird als strikter Code betrachtet, wenn das Skript eine Anweisung für die use strict Anweisungen enthält. Der Inhalt einer Funktion wird als strikter Code betrachtet, wenn die Funktion selbst in einem strengen Code definiert ist oder wenn die Funktion eine Anweisung für eine use strict enthält. Code, der an eine eval() -Methode übergeben wird, gilt als strikter Code, wenn eval() von einem strengen Code aus aufgerufen wurde oder die Anweisung use strict selbst enthält.

Der strikte Modus von ECMAScript 5 ist eine eingeschränkte Teilmenge der JavaScript-Sprache, die relevante Sprachdefizite beseitigt und eine strengere Fehlerprüfung und höhere Sicherheit bietet. Im Folgenden sind die Unterschiede zwischen dem strikten Modus und dem normalen Modus aufgeführt (von denen die ersten drei besonders wichtig sind):

  • Sie können die with -statement nicht im strikten Modus verwenden.
  • Im strikten Modus müssen alle Variablen deklariert werden: Wenn Sie einem Bezeichner einen Wert zuweisen, der nicht als Variable, Funktion, Funktionsparameter, Catch-Klausel-Parameter oder Eigenschaft des globalen Object deklariert ist, erhalten Sie einen ReferenceError . Im Normalmodus wird der Bezeichner implizit als globale Variable (als Eigenschaft des globalen Object ) deklariert.
  • Im strikten Modus hat das Schlüsselwort den Wert in Funktionen, die als Funktionen (nicht als Methoden) aufgerufen wurden, undefined . (Im Normalmodus zeigt this immer auf das globale Object ). Dieser Unterschied kann verwendet werden, um zu testen, ob eine Implementierung den strikten Modus unterstützt:
var hasStrictMode = (function() { "use strict"; return this===undefined }());
  • Wenn eine Funktion mit call() oder apply im strikten Modus aufgerufen wird, ist this genau der Wert des ersten Arguments des call() von call() oder apply() . (Im normalen Modus werden null und undefined durch das globale Object und Werte, die keine Objekte sind, werden in Objekte umgewandelt.)

  • Im strikten Modus erhalten Sie einen TypeError , wenn Sie versuchen, Readonly-Eigenschaften zuzuweisen oder neue Eigenschaften für ein nicht erweiterbares Objekt zu definieren. (Im Normalmodus schlagen beide einfach ohne Fehlermeldung fehl.)

  • Im strikten Modus können Sie beim Übergeben von Code an eval() keine Variablen oder Funktionen im Gültigkeitsbereich des Aufrufers deklarieren oder definieren (wie im normalen Modus möglich). Stattdessen wird ein neuer Gültigkeitsbereich für eval() und die Variablen und Funktionen befinden sich in diesem Gültigkeitsbereich. Dieser Bereich wird zerstört, nachdem eval() Ausführung abgeschlossen hat.
  • Im strikten Modus enthält das Argumentobjekt einer Funktion eine statische Kopie der Werte, die an diese Funktion übergeben werden. Im normalen Modus verhält sich das arguments-object etwas "magisch": Die Elemente des Arrays und die benannten Funktionsparameter verweisen auf denselben Wert.
  • Im strikten Modus erhalten Sie einen SyntaxError wenn auf den delete ein nicht qualifizierter Bezeichner (ein Variablen-, Funktions- oder Funktionsparameter) folgt. Im normalen Modus würde der delete nichts bewirken und wird als false ausgewertet.
  • Im strikten Modus erhalten Sie einen TypeError wenn Sie versuchen, eine nicht konfigurierbare Eigenschaft zu löschen. (Im normalen Modus schlägt der Versuch einfach fehl und der delete wird als false ausgewertet.)
  • Im strikten Modus wird dies als syntaktischer Fehler betrachtet, wenn Sie versuchen, mehrere Eigenschaften mit demselben Namen für ein Objektliteral zu definieren. (Im normalen Modus gibt es keinen Fehler.)
  • Im strikten Modus wird es als syntaktischer Fehler betrachtet, wenn eine Funktionsdeklaration mehrere Parameter mit demselben Namen hat. (Im normalen Modus gibt es keinen Fehler.)
  • Im strikten Modus sind Oktal-Literale nicht zulässig (dies sind Literale, die mit 0x . (Im normalen Modus lassen manche Implementierungen Oktal-Literale zu.)
  • Im strikten Modus werden die Bezeichner eval und die arguments wie Schlüsselwörter behandelt. Sie können ihren Wert nicht ändern, ihnen keinen Wert zuweisen und sie nicht als Namen für Variablen, Funktionen, Funktionsparameter oder Bezeichner eines catch-Blocks verwenden.
  • Im strikten Modus gibt es weitere Einschränkungen für die Möglichkeiten, den Aufrufstack zu untersuchen. arguments.caller und arguments.callee verursachen einen TypeError in einer Funktion im strikten Modus. Darüber hinaus verursachen einige Aufrufer- und Argumenteigenschaften von Funktionen im strikten Modus einen TypeError wenn Sie versuchen, sie zu lesen.




javascript sorting properties object