Sortieren Sie das Array von Objekten nach einem einzelnen Schlüssel mit Datumswert

257

Ich habe ein Array von Objekten mit mehreren Schlüsselwertpaaren und muss sie nach 'update_at' sortieren:

[
    {
        "updated_at" : "2012-01-01T06:25:24Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-09T11:25:13Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-05T04:13:24Z",
        "foo" : "bar"
    }
]

Was ist der effizienteste Weg, dies zu tun?

Keks Monster
quelle
@ Topener Dieser Link sieht aus wie es ist zu einer Frage über PHP
David Brainer
Mein Fehler .. hat es nicht richtig gelesen
Rene Pot

Antworten:

338

Sie können verwenden Array.sort.

Hier ist ein Beispiel:

var arr = [{
    "updated_at": "2012-01-01T06:25:24Z",
    "foo": "bar"
  },
  {
    "updated_at": "2012-01-09T11:25:13Z",
    "foo": "bar"
  },
  {
    "updated_at": "2012-01-05T04:13:24Z",
    "foo": "bar"
  }
]

arr.sort(function(a, b) {
  var keyA = new Date(a.updated_at),
    keyB = new Date(b.updated_at);
  // Compare the 2 dates
  if (keyA < keyB) return -1;
  if (keyA > keyB) return 1;
  return 0;
});

console.log(arr);

Rakete Hazmat
quelle
17
Könnten Sie nicht keyA - keyB(oder möglicherweise keyB - keyA) verwenden? Die Datumsobjekte haben eine valueOf()Methode.
Saktinpk
Rückgabe a. aktualisierte_at <b. aktualisiert am ? 1: -1 funktioniert bei mir. Keine Notwendigkeit, in ein Datumsformat zu analysieren.
Oliversisson
Die Fähigkeit, dies einfach zu tun, a-bist wirklich wichtig, wenn Sie langen Code vermeiden möchten. Obwohl langer Code in diesem Fall nicht unbedingt schlecht ist, denke ich, dass die Ausführlichkeit das Verständnis erschwert. Ich benutze derzeit values.sort((a,b)=>a.attr-b.attr). Es wird mühsam, jedes Mal 5 Zeilen schreiben zu müssen, wenn Sie ein Array sortieren müssen.
AnnanFay
Dieses Beispiel ist nicht effektiv und führt viele unnötige Berechnungen durch. Die Sortierung kann eine beliebige positive oder negative Zahl als gültiges Ergebnis annehmen. Ihre zusätzlichen Berechnungen, um 1,0, -1 zu erzwingen, werden nicht benötigt und fügen einfach zusätzliche Berechnungen pro Ausführung hinzu.
Patrick W. McMahon
Funktioniert großartig, danke
Andy
158

Eine wirklich ähnliche Frage habe ich hier bereits beantwortet: Einfache Funktion zum Sortieren eines Arrays von Objekten

Für diese Frage habe ich diese kleine Funktion erstellt, die das tun kann, was Sie wollen:

function sortByKey(array, key) {
    return array.sort(function(a, b) {
        var x = a[key]; var y = b[key];
        return ((x < y) ? -1 : ((x > y) ? 1 : 0));
    });
}
David Brainer
quelle
11
Sie, Sir, sind der Mann. blogs.citypages.com/blotter/assets_c/2009/02/…
Dom
2
Wie würden Sie das umkehren?
4
Um die Groß- und Kleinschreibung nicht zu berücksichtigen, können Sie x- und y-Variablen .toLowerCase () hinzufügen
Jacob van Lingen
4
Um Sortierfunktionen wie diese umzukehren, multiplizieren Sie einfach das Ergebnis mit -1:)
Svish
5
Oder nehmen Sie einfach die Ausgabe und nutzen Sie die array = array.reverse()Funktion.
Luke Stevenson
31

Die Methode Array.sort () sortiert die Elemente eines Arrays an Ort und Stelle und gibt das Array zurück. Seien Sie vorsichtig mit Array.sort (), da es nicht unveränderlich ist . Verwenden Sie für unveränderliche Sortierung unveränderliche Sortierung .

Diese Methode dient zum Sortieren des Arrays nach Ihrem aktuellen updated_atISO-Format. Wir new Data(iso_string).getTime()konvertieren die ISO-Zeit in einen Unix-Zeitstempel. Ein Unix-Zeitstempel ist eine Zahl, mit der wir einfach rechnen können. Wir subtrahieren den ersten und zweiten Zeitstempel, der das Ergebnis ist; Wenn der erste Zeitstempel größer als der zweite ist, ist die Rückgabezahl positiv. Wenn die zweite Zahl größer als die erste ist, ist der Rückgabewert negativ. Wenn die beiden gleich sind, ist die Rendite Null. Dies stimmt perfekt mit den erforderlichen Rückgabewerten für die Inline-Funktion überein.

Für ES6 :

arr.sort((a,b) => new Date(a.updated_at).getTime() - new Date(b.updated_at).getTime());

Für ES5 :

arr.sort(function(a,b){ 
 return new Date(a.updated_at).getTime() - new Date(b.updated_at).getTime();
});

Wenn Sie Ihre updated_atUnix-Zeitstempel ändern , können Sie dies tun:

Für ES6 :

arr.sort((a,b) => a.updated_at - b.updated_at);

Für ES5 :

arr.sort(function(a,b){ 
 return a.updated_at - b.updated_at;
});

Zum Zeitpunkt dieses Beitrags unterstützen moderne Browser ES6 nicht. Um ES6 in modernen Browsern zu verwenden, verwenden Sie babel, um den Code in ES5 zu transpilieren. Erwarten Sie in naher Zukunft Browserunterstützung für ES6.

Array.sort () sollte einen Rückgabewert von einem von 3 möglichen Ergebnissen erhalten:

  • Eine positive Zahl (erster Punkt> zweiter Punkt)
  • Eine negative Zahl (erster Punkt <zweiter Punkt)
  • 0, wenn die beiden Elemente gleich sind

Beachten Sie, dass der Rückgabewert der Inline-Funktion eine beliebige positive oder negative Zahl sein kann. Array.Sort () ist es egal, wie die Rückgabe lautet. Es ist nur wichtig, ob der Rückgabewert positiv, negativ oder null ist.

Für unveränderliche Sortierung: (Beispiel in ES6)

const sort = require('immutable-sort');
const array = [1, 5, 2, 4, 3];
const sortedArray = sort(array);

Sie können es auch so schreiben:

import sort from 'immutable-sort';
const array = [1, 5, 2, 4, 3];
const sortedArray = sort(array);

Der Import von ist eine neue Möglichkeit, Javascript in ES6 aufzunehmen, und lässt Ihren Code sehr sauber aussehen. Mein persönlicher Favorit.

Die unveränderliche Sortierung mutiert das Quellarray nicht, sondern gibt ein neues Array zurück. Die Verwendung constwird für unveränderliche Daten empfohlen.

Patrick W. McMahon
quelle
19

Hier ist eine leicht modifizierte Version der Antwort von @David Brainer-Bankers, die alphabetisch nach Zeichenfolge oder numerisch nach Zahlen sortiert und sicherstellt, dass Wörter, die mit Großbuchstaben beginnen, nicht über Wörtern sortiert werden, die mit Kleinbuchstaben beginnen (z. B. "apple, Early"). würde in dieser Reihenfolge angezeigt werden).

function sortByKey(array, key) {
    return array.sort(function(a, b) {
        var x = a[key];
        var y = b[key];

        if (typeof x == "string")
        {
            x = (""+x).toLowerCase(); 
        }
        if (typeof y == "string")
        {
            y = (""+y).toLowerCase();
        }

        return ((x < y) ? -1 : ((x > y) ? 1 : 0));
    });
}
Brad Parks
quelle
3
Die vorgeschlagene Lösung kann einen Fehler ergeben, wenn a [Schlüssel] und b [Schlüssel] nicht beide Zeichenfolgen sind. Ich schlage vor, y = y.toLowerCase () durch y = ("" + y) .toLowerCase () zu
ersetzen
sort kann jede positive oder negative Zahl als gültige Rückgabe akzeptieren. Es sind zusätzliche Berechnungen erforderlich, um zu erzwingen, dass 1,0, -1 nicht benötigt werden. Sie haben einen einfachen Rückgabewert überkompliziert. Es ist am besten, keine zusätzlichen Berechnungen hinzuzufügen, die nichts bewirken.
Patrick W. McMahon
15

Verwenden Sie Unterstrich js oder lodash,

var arrObj = [
    {
        "updated_at" : "2012-01-01T06:25:24Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-09T11:25:13Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-05T04:13:24Z",
        "foo" : "bar"
    }
];

arrObj = _.sortBy(arrObj,"updated_at");

_.sortBy() gibt ein neues Array zurück

siehe http://underscorejs.org/#sortBy und lodash docs https://lodash.com/docs#sortBy

Mohammed Safeer
quelle
6

Mit ES2015-Unterstützung kann dies erfolgen durch:

foo.sort((a, b) => a.updated_at < b.updated_at ? -1 : 1)
Knowbody
quelle
1
Keine Notwendigkeit für die Inline, wenn das <durch - ersetzt und 'entfernt wird? -1: 1 "Sie erhalten eine gültige Rückgabe. In diesem Beispiel werden Elemente verschoben, die möglicherweise gleich sind und daher zu unerwarteten Ergebnissen führen können. Für gleiche Elemente sollte eine 0 zurückgegeben werden.
Patrick W. McMahon
Vielen Dank für die Erklärung
Knowbody
Wenn update_at eine ISO-Zeit ist, funktioniert dies nicht. In diesem Beispiel werden Unix-Zeitstempel angenommen, aber das OP hat Daten im ISO-Format veröffentlicht. Sie müssten also in Unix-Zeitstempel konvertieren, um einen Vergleich durchzuführen. Dies kann durchgeführt new Date(iso_str).getTime()werden, um einen Unix-Zeitstempel zurückzugeben.
Patrick W. McMahon
5

Daten importiert

[
    {
        "gameStatus": "1",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 11:32:04"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:08:24"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:35:40"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 10:42:53"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 10:54:09"
    },
    {
        "gameStatus": "0",
        "userId": "1a2fefb0-5ae2-47eb-82ff-d1b2cc27875a",
        "created_at": "2018-12-19 18:46:22"
    },
    {
        "gameStatus": "1",
        "userId": "7118ed61-d8d9-4098-a81b-484158806d21",
        "created_at": "2018-12-20 10:50:48"
    }
]

FÜR Aufsteigende Reihenfolge

arr.sort(function(a, b){
    var keyA = new Date(a.updated_at),
        keyB = new Date(b.updated_at);
    // Compare the 2 dates
    if(keyA < keyB) return -1;
    if(keyA > keyB) return 1;
    return 0;
});

Beispiel für Asc Order

[
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 10:42:53"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:08:24"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:35:40"
    },
    {
        "gameStatus": "0",
        "userId": "1a2fefb0-5ae2-47eb-82ff-d1b2cc27875a",
        "created_at": "2018-12-19 18:46:22"
    },
    {
        "gameStatus": "1",
        "userId": "7118ed61-d8d9-4098-a81b-484158806d21",
        "created_at": "2018-12-20 10:50:48"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 10:54:09"
    },
    {
        "gameStatus": "1",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 11:32:04"
    }
]

FÜR absteigende Reihenfolge

arr.sort(function(a, b){
    var keyA = new Date(a.updated_at),
        keyB = new Date(b.updated_at);
    // Compare the 2 dates
    if(keyA > keyB) return -1;
    if(keyA < keyB) return 1;
    return 0;
});

Beispiel für Desc Order

[
    {
        "gameStatus": "1",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 11:32:04"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 10:54:09"
    },
    {
        "gameStatus": "1",
        "userId": "7118ed61-d8d9-4098-a81b-484158806d21",
        "created_at": "2018-12-20 10:50:48"
    },
    {
        "gameStatus": "0",
        "userId": "1a2fefb0-5ae2-47eb-82ff-d1b2cc27875a",
        "created_at": "2018-12-19 18:46:22"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:35:40"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:08:24"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 10:42:53"
    }
]
Anandan K.
quelle
3

Wie in dieser Antwort angegeben, können Sie verwenden Array.sort.

arr.sort(function(a,b){return new Date(a.updated_at) - new Date(b.updated_at)})

arr = [
    {
        "updated_at" : "2012-01-01T06:25:24Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-09T11:25:13Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-05T04:13:24Z",
        "foo" : "bar"
    }
];
arr.sort(function(a,b){return new Date(a.updated_at) - new Date(b.updated_at)});
console.log(arr);

Ishpreet
quelle
2

Nur eine andere, mathematischere Art, dasselbe zu tun, aber kürzer :

arr.sort(function(a, b){
    var diff = new Date(a.updated_at) - new Date(b.updated_at);
    return diff/(Math.abs(diff)||1);
});

oder im glatten Lambda-Pfeil-Stil:

arr.sort((a, b) => {
    var diff = new Date(a.updated_at) - new Date(b.updated_at);
    return diff/(Math.abs(diff)||1);
});

Diese Methode kann mit jeder numerischen Eingabe durchgeführt werden

Danny Mor
quelle
unterbewertete Antwort
two7s_clash
2

Ich habe in Typescript eine Sortierfunktion erstellt, mit der wir Zeichenfolgen, Datumsangaben und Zahlen in einer Reihe von Objekten suchen können. Es kann auch nach mehreren Feldern sortiert werden.

export type SortType = 'string' | 'number' | 'date';
export type SortingOrder = 'asc' | 'desc';

export interface SortOptions {
  sortByKey: string;
  sortType?: SortType;
  sortingOrder?: SortingOrder;
}


class CustomSorting {
    static sortArrayOfObjects(fields: SortOptions[] = [{sortByKey: 'value', sortType: 'string', sortingOrder: 'desc'}]) {
        return (a, b) => fields
          .map((field) => {
            if (!a[field.sortByKey] || !b[field.sortByKey]) {
              return 0;
            }

            const direction = field.sortingOrder === 'asc' ? 1 : -1;

            let firstValue;
            let secondValue;

            if (field.sortType === 'string') {
              firstValue = a[field.sortByKey].toUpperCase();
              secondValue = b[field.sortByKey].toUpperCase();
            } else if (field.sortType === 'number') {
              firstValue = parseInt(a[field.sortByKey], 10);
              secondValue = parseInt(b[field.sortByKey], 10);
            } else if (field.sortType === 'date') {
              firstValue = new Date(a[field.sortByKey]);
              secondValue = new Date(b[field.sortByKey]);
            }
            return firstValue > secondValue ? direction : firstValue < secondValue ? -(direction) : 0;

          })
          .reduce((pos, neg) => pos ? pos : neg, 0);
      }
    }
}

Verwendung:

const sortOptions = [{
      sortByKey: 'anyKey',
      sortType: 'string',
      sortingOrder: 'asc',
    }];

arrayOfObjects.sort(CustomSorting.sortArrayOfObjects(sortOptions));
Ansuman
quelle
1

Das Sortieren nach einem ISO-formatierten Datum kann teuer sein, es sei denn, Sie beschränken die Clients auf die neuesten und besten Browser, die durch Datumsanalyse der Zeichenfolge den richtigen Zeitstempel erstellen können.

Wenn Sie sich Ihrer Eingabe sicher sind und wissen, dass es sich immer um JJJJ-MM-TTTHH: MM: SS und GMT (Z) handelt, können Sie die Ziffern aus jedem Element extrahieren und wie Ganzzahlen vergleichen

array.sort(function(a,b){
    return a.updated_at.replace(/\D+/g,'')-b.updated_at.replace(/\D+/g,'');
});

Wenn das Datum anders formatiert werden könnte, müssen Sie möglicherweise etwas für iso-herausgeforderte Personen hinzufügen:

Date.fromISO: function(s){
    var day, tz,
    rx=/^(\d{4}\-\d\d\-\d\d([tT ][\d:\.]*)?)([zZ]|([+\-])(\d\d):(\d\d))?$/,
    p= rx.exec(s) || [];
    if(p[1]){
        day= p[1].split(/\D/).map(function(itm){
            return parseInt(itm, 10) || 0;
        });
        day[1]-= 1;
        day= new Date(Date.UTC.apply(Date, day));
        if(!day.getDate()) return NaN;
        if(p[5]){
            tz= (parseInt(p[5], 10)*60);
            if(p[6]) tz+= parseInt(p[6], 10);
            if(p[4]== '+') tz*= -1;
            if(tz) day.setUTCMinutes(day.getUTCMinutes()+ tz);
        }
        return day;
    }
    return NaN;
}
if(!Array.prototype.map){
    Array.prototype.map= function(fun, scope){
        var T= this, L= T.length, A= Array(L), i= 0;
        if(typeof fun== 'function'){
            while(i< L){
                if(i in T){
                    A[i]= fun.call(scope, T[i], i, T);
                }
                ++i;
            }
            return A;
        }
    }
}
}
kennebec
quelle
2
Könntest du nicht einfach benutzen Date.parse?
Rocket Hazmat
1

Der Vollständigkeit halber ist hier eine mögliche kurze generische Implementierung von sortBy:

function sortBy(list, keyFunc) {
  return list.sort((a,b) => keyFunc(a) - keyFunc(b));
}

sortBy([{"key": 2}, {"key": 1}], o => o["key"])

Beachten Sie, dass hierfür die Sortiermethode für Arrays verwendet wird, die an Ort und Stelle sortiert wird. Für eine Kopie können Sie arr.concat () oder arr.slice (0) oder eine ähnliche Methode verwenden, um eine Kopie zu erstellen.

Legion
quelle
1

Damit können wir eine Schlüsselfunktion übergeben, die für die Sortierung verwendet werden soll

Array.prototype.sortBy = function(key_func, reverse=false){
    return this.sort( (a, b) => {
        var keyA = key_func(a),
            keyB = key_func(b);
        if(keyA < keyB) return reverse? 1: -1;
        if(keyA > keyB) return reverse? -1: 1;
        return 0;
    }); 
}

Dann zum Beispiel, wenn wir haben

var arr = [ {date: "01/12/00", balls: {red: "a8",  blue: 10}},
            {date: "12/13/05", balls: {red: "d6" , blue: 11}},
            {date: "03/02/04", balls: {red: "c4" , blue: 15}} ]

Wir können es tun

arr.sortBy(el => el.balls.red)
/* would result in
[ {date: "01/12/00", balls: {red: "a8", blue: 10}},
  {date: "03/02/04", balls: {red: "c4", blue: 15}},
  {date: "12/13/05", balls: {red: "d6", blue: 11}} ]
*/

oder

arr.sortBy(el => new Date(el.date), true)   // second argument to reverse it
/* would result in
[ {date: "12/13/05", balls: {red: "d6", blue:11}},
  {date: "03/02/04", balls: {red: "c4", blue:15}},
  {date: "01/12/00", balls: {red: "a8", blue:10}} ]
*/

oder

arr.sortBy(el => el.balls.blue + parseInt(el.balls.red[1]))
/* would result in
[ {date: "12/13/05", balls: {red: "d6", blue:11}},    // red + blue= 17
  {date: "01/12/00", balls: {red: "a8", blue:10}},    // red + blue= 18
  {date: "03/02/04", balls: {red: "c4", blue:15}} ]   // red + blue= 19
*/
aljgom
quelle
1

Sie können die Lodash- Dienstprogrammbibliothek verwenden, um dieses Problem zu lösen (es ist eine recht effiziente Bibliothek):

const data = [{
    "updated_at": "2012-01-01T06:25:24Z",
    "foo": "bar"
  },
  {
    "updated_at": "2012-01-09T11:25:13Z",
    "foo": "bar"
  },
  {
    "updated_at": "2012-01-05T04:13:24Z",
    "foo": "bar"
  }
]

const ordered = _.orderBy(
  data,
  function(item) {
    return item.updated_at;
  }
);

console.log(ordered)
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>

Dokumentation finden Sie hier: https://lodash.com/docs/4.17.15#orderBy

Chetan
quelle
0

Sie können einen Verschluss erstellen und ihn so weitergeben. Hier ist mein Beispiel

$.get('https://data.seattle.gov/resource/3k2p-39jp.json?$limit=10&$where=within_circle(incident_location, 47.594972, -122.331518, 1609.34)', 
  function(responce) {

    var filter = 'event_clearance_group', //sort by key group name
    data = responce; 

    var compare = function (filter) {
        return function (a,b) {
            var a = a[filter],
                b = b[filter];

            if (a < b) {
                return -1;
            } else if (a > b) {
                return 1;
            } else {
                return 0;
            }
        };
    };

    filter = compare(filter); //set filter

    console.log(data.sort(filter));
});
Michael Guild
quelle
0
var months = [
    {
        "updated_at" : "2012-01-01T06:25:24Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-09T11:25:13Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-05T04:13:24Z",
        "foo" : "bar"
    }];
months.sort((a, b)=>{
    var keyA = new Date(a.updated_at),
        keyB = new Date(b.updated_at);
    // Compare the 2 dates
    if(keyA < keyB) return -1;
    if(keyA > keyB) return 1;
    return 0;
});
console.log(months);
Prasad
quelle
0
  • Verwenden Sie Array.sort()diese Option, um ein Array zu sortieren
  • Klonen Sie das Array mit dem Spread-Operator ( ), um die Funktion rein zu machen
  • Nach gewünschter Taste sortieren ( updated_at)
  • Konvertieren Sie die Datumszeichenfolge in das Datumsobjekt
  • Array.sort() Subtrahiert zwei Eigenschaften vom aktuellen und nächsten Element, wenn es sich um eine Zahl / ein Objekt handelt, an dem Sie arrhythmische Operationen ausführen können
const input = [
  {
    updated_at: '2012-01-01T06:25:24Z',
    foo: 'bar',
  },
  {
    updated_at: '2012-01-09T11:25:13Z',
    foo: 'bar',
  },
  {
    updated_at: '2012-01-05T04:13:24Z',
    foo: 'bar',
  }
];

const sortByUpdatedAt = (items) => [...items].sort((itemA, itemB) => new Date(itemA.updated_at) - new Date(itemB.updated_at));

const output = sortByUpdatedAt(input);

console.log(input);
/*
[ { updated_at: '2012-01-01T06:25:24Z', foo: 'bar' }, 
  { updated_at: '2012-01-09T11:25:13Z', foo: 'bar' }, 
  { updated_at: '2012-01-05T04:13:24Z', foo: 'bar' } ]
*/
console.log(output)
/*
[ { updated_at: '2012-01-01T06:25:24Z', foo: 'bar' }, 
  { updated_at: '2012-01-05T04:13:24Z', foo: 'bar' }, 
  { updated_at: '2012-01-09T11:25:13Z', foo: 'bar' } ]
*/
marcobiedermann
quelle
0

Ich stehe vor der gleichen Sache, also behandle ich dies mit einem generischen Warum und baue eine Funktion dafür:

//example:
//array: [{name: 'idan', workerType: '3'}, {name: 'stas', workerType: '5'}, {name: 'kirill', workerType: '2'}]
//keyField: 'workerType'
// keysArray: ['4', '3', '2', '5', '6']
sortByArrayOfKeys = (array, keyField, keysArray) => {
    array.sort((a, b) => {
        const aIndex = keysArray.indexOf(a[keyField])
        const bIndex = keysArray.indexOf(b[keyField])
        if (aIndex < bIndex) return -1;
        if (aIndex > bIndex) return 1;
        return 0;
    })
}
Idan
quelle