दिनांक मान के साथ एकल कुंजी द्वारा वस्तुओं की क्रमबद्ध सरणी

Question

मेरे पास कई प्रमुख मूल्य वाले ऑब्जेक्ट्स की एक सरणी है, और मुझे 'update_at' के आधार पर उन्हें सॉर्ट करने की आवश्यकता है:

[
    {
        "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"
    }
]

ऐसा करने का सबसे कुशल तरीका क्या है?

Comments

@Topener यह लिंक ऐसा दिखता है जैसे यह PHP के बारे में एक सवाल है

— डेविड ब्रेनर

मेरी गलती .. इसे सही ढंग से नहीं पढ़ा

— रेने पॉट

Answer 1

आप उपयोग कर सकते हैं Array.sort।

यहाँ एक उदाहरण है:

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);

Comments

आप keyA - keyB(या संभवतः keyB - keyA) का उपयोग नहीं कर सके ? दिनांक ऑब्जेक्ट में एक valueOf()विधि है।

— सोकटिनपेक

वापस आ जाओ। updated_at <b। update_at? 1: -1 मेरे लिए काम करता है। दिनांक प्रारूप में पार्स करने की आवश्यकता नहीं है।

— ओलिवसिसन

a-bयदि आप लंबे कोड से बचना चाहते हैं तो बस करने की क्षमता वास्तव में महत्वपूर्ण है। हालांकि लंबे समय तक कोड जरूरी नहीं है कि इस मामले में मुझे लगता है कि क्रियाशीलता को समझना मुश्किल हो जाता है। मैं वर्तमान में उपयोग करता हूं values.sort((a,b)=>a.attr-b.attr)। हर बार 5 लाइनें लिखने के बाद आपको किसी सरणी को छाँटने की आवश्यकता होती है।

— अन्नानफे

यह उदाहरण प्रभावी नहीं है और बहुत सारी अनावश्यक गणना करता है। सॉर्ट किसी भी सकारात्मक या नकारात्मक संख्या को एक वैध परिणाम के रूप में ले सकता है। आपके अतिरिक्त गणनाओं को इसे 1,0 करने के लिए बाध्य करने के लिए, -1 की आवश्यकता नहीं है और बस निष्पादन के लिए अतिरिक्त गणना जोड़ता है।

— पैट्रिक डब्ल्यू। मैकमोहन 3

महान थजंक आप पर काम करता है

— एंडी

Answer 2

मैंने पहले से ही यहां एक समान प्रश्न का उत्तर दिया: वस्तुओं की एक सरणी को सॉर्ट करने के लिए सरल कार्य

उस सवाल के लिए मैंने यह छोटा सा फंक्शन बनाया जो आप चाहते हैं:

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));
    });
}

Comments

आप, साहब, आदमी हैं। blogs.citypages.com/blotter/assets_c/2009/02/…

— Dom

आप इसे कैसे उलट देंगे?

इसे असंवेदनशील बनाने के लिए, आप .toLowerCase () को x और y वेरिएबल्स में जोड़ सकते हैं

— याकूब वैन लिंगन

इन जैसे छंटनी कार्यों को उलटने के लिए, बस परिणाम को -1:)

— Svish

या सिर्फ आउटपुट लेते हैं और array = array.reverse()फ़ंक्शन का उपयोग करते हैं।

— ल्यूक स्टीवेन्सन

Answer 3

Array.sort () विधि जगह में एक सरणी के तत्वों सॉर्ट करता और सरणी देता है। Array.sort () के साथ सावधान रहें क्योंकि यह अपरिवर्तनीय नहीं है । अपरिवर्तनीय तरह उपयोग के लिए अपरिवर्तनीय-तरह ।

यह विधि आपके वर्तमान का उपयोग करके सरणी को क्रमबद्ध करने के लिए है updated_at आईएसओ प्रारूप में । हम new Data(iso_string).getTime()आईएसओ समय को यूनिक्स टाइमस्टैम्प में बदलने के लिए उपयोग करते हैं । एक यूनिक्स टाइमस्टैम्प एक संख्या है जिस पर हम सरल गणित कर सकते हैं। हम पहले और दूसरे टाइमस्टैम्प को घटाते हैं, जिसका परिणाम है; यदि पहला टाइमस्टैम्प दूसरे से बड़ा है तो रिटर्न संख्या सकारात्मक होगी। यदि दूसरी संख्या पहली से बड़ी है तो रिटर्न वैल्यू नेगेटिव होगी। यदि दोनों समान हैं तो प्रतिफल शून्य होगा। यह इनलाइन फ़ंक्शन के लिए आवश्यक रिटर्न मानों के साथ पूरी तरह से बदल जाता है।

के लिए ES6 :

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

के लिए ES5 :

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

अगर आप अपना updated_at यूनिक्स टाइमस्टैम्प हैं तो आप ऐसा कर सकते हैं:

के लिए ES6 :

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

के लिए ES5 :

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

इस पोस्ट के समय, आधुनिक ब्राउज़र ES6 का समर्थन नहीं करते हैं। आधुनिक ब्राउज़रों में ईएस 6 का उपयोग करने के लिए ईएस 5 को कोड ट्रांसपाइल करने के लिए बेबल का उपयोग करें । निकट भविष्य में ES6 के लिए ब्राउज़र समर्थन की अपेक्षा करें।

Array.sort () को 3 संभावित परिणामों में से एक का रिटर्न मान पुनः प्राप्त करना चाहिए:

• एक सकारात्मक संख्या (पहला आइटम> दूसरा आइटम)
• एक ऋणात्मक संख्या (पहला आइटम <दूसरा आइटम)
• 0 यदि दो आइटम बराबर हैं

ध्यान दें कि इनलाइन फ़ंक्शन पर रिटर्न मान किसी भी सकारात्मक या नकारात्मक संख्या हो सकता है। Array.Sort () को परवाह नहीं है कि रिटर्न नंबर क्या है। यह केवल तभी परवाह करता है जब रिटर्न वैल्यू सकारात्मक, नकारात्मक या शून्य हो।

अपरिवर्तनीय प्रकार के लिए: (ES6 में उदाहरण)

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

आप इसे इस तरह भी लिख सकते हैं:

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

आपके द्वारा देखा गया आयात ES6 में जावास्क्रिप्ट को शामिल करने का एक नया तरीका है और इससे आपका कोड बहुत साफ दिखता है। मेरा व्यक्तिगत पसंदीदा।

अपरिवर्तनीय प्रकार स्रोत सरणी को म्यूट नहीं करता है, बल्कि यह एक नया सरणी देता है। का उपयोग constअपरिवर्तनीय डेटा पर करने की सिफारिश की जाती है।

Answer 4

यहां @David Brainer-Bankers का थोड़ा संशोधित संस्करण है जो वर्णक्रम के अनुसार वर्णक्रम के अनुसार, या संख्या द्वारा संख्यात्मक रूप से लिखते हैं, और यह सुनिश्चित करता है कि कैपिटल अक्षरों से शुरू होने वाले शब्द कम केस लेटर (जैसे "ऐप्पल, अर्ली" के साथ शुरू होने वाले शब्दों से ऊपर सॉर्ट न करें। उस क्रम में प्रदर्शित किया जाएगा)।

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));
    });
}

Comments

प्रस्तावित समाधान एक त्रुटि दे सकता है यदि [कुंजी] और b [कुंजी] दोनों तार नहीं हैं। मैं y = y.toLowerCase () y = ("" + y) .toLowerCase ()

— user8074

सॉर्ट किसी भी सकारात्मक या नकारात्मक संख्या को वैध रिटर्न के रूप में स्वीकार कर सकता है। आप अतिरिक्त गणना के लिए इसे 1,0 करने के लिए मजबूर कर सकते हैं, -1 की जरूरत नहीं है। आप एक साधारण रिटर्न मान को जटिल करते हैं। यह अतिरिक्त गणनाओं को जोड़ने के लिए सबसे अच्छा है जो कुछ भी नहीं करते हैं।

— पैट्रिक डब्ल्यू मैकमोहन

Answer 5

अंडरस्कोर js या लॉश का उपयोग करें,

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() एक नई सरणी देता है

संदर्भ http://underscorejs.org/#sortBy और लॉश डॉक्स https://lodash.com/docs#sortBy

Answer 6

ES2015 समर्थन के साथ यह किया जा सकता है:

foo.sort((a, b) => a.updated_at < b.updated_at ? -1 : 1)

Comments

इनलाइन की कोई आवश्यकता नहीं है यदि <के साथ बदलें - और निकालें '? -1: 1 "आपको एक वैध रिटर्न मिलेगा। यह उदाहरण उन वस्तुओं को स्थानांतरित करता है जो समान हो सकते हैं और इसलिए अप्रत्याशित परिणाम दे सकते हैं। समान वस्तुओं के लिए 0 वापस किया जाना चाहिए।

— पैट्रिक डब्ल्यू मैकमोहन

समझाने के लिए धन्यवाद

— जानिए

अगर update_at एक ISO समय है तो यह काम नहीं करेगा। यह उदाहरण यूनिक्स टाइमस्टैम्प मानता है लेकिन ओपी ने डेटा पोस्ट किया जो आईएसओ प्रारूप में था। इसलिए आपको तुलना करने के लिए यूनिक्स टाइमस्टैम्प में बदलना होगा। यह new Date(iso_str).getTime()एक यूनिक्स टाइमस्टैम्प लौटाएगा इसके साथ किया जा सकता है ।

— पैट्रिक डब्ल्यू। मैकमोहन

Answer 7

डेटा आयात किया गया

[
    {
        "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"
    }
]

आरोही क्रम के लिए

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;
});

Asc ऑर्डर के लिए उदाहरण

[
    {
        "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"
    }
]

---

अवरोही क्रम के लिए

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;
});

डेस ऑर्डर के लिए उदाहरण

[
    {
        "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"
    }
]

Answer 8

के रूप में यह जवाब के राज्यों, आप उपयोग कर सकते हैं 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);

Answer 9

बस एक और, अधिक गणितीय , एक ही काम करने का तरीका लेकिन कम :

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

या चालाक लैम्ब्डा तीर शैली में:

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

यह विधि किसी भी संख्यात्मक इनपुट के साथ की जा सकती है

Comments

— रेखांकित

Answer 10

आज का सवाल है, @knowbody (के जवाब https://stackoverflow.com/a/42418963/6778546 ) और @Rocket Hazmat ( https://stackoverflow.com/a/8837511/6778546 ) ES2015 समर्थन के लिए प्रदान करने के लिए जोड़ा जा सकता है और सही तारीख से निपटने:

arr.sort((a, b) => {
   const dateA = new Date(a.updated_at);
   const dateB = new Date(b.updated_at);
   return dateA - dateB;
});

Answer 11

मैंने टाइपस्क्रिप्ट में एक सॉर्टिंग फ़ंक्शन बनाया है जिसका उपयोग हम ऑब्जेक्ट्स की सरणी में स्ट्रिंग्स, दिनांक और संख्याओं को खोजने के लिए कर सकते हैं। यह कई क्षेत्रों पर भी सॉर्ट कर सकता है।

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);
      }
    }
}

उपयोग:

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

arrayOfObjects.sort(CustomSorting.sortArrayOfObjects(sortOptions));

Answer 12

जब तक आप क्लाइंट को नवीनतम और सबसे अच्छे ब्राउज़रों तक सीमित नहीं करते हैं, तब तक एक आईएसओ फॉर्मेट की गई तिथि के अनुसार छंटनी महंगी हो सकती है, जो स्ट्रिंग को डेट-पार्स करके सही टाइमस्टैम्प बना सकती है।

यदि आप अपने इनपुट के बारे में सुनिश्चित हैं , और आप जानते हैं कि यह हमेशा yyyy-mm-ddThh होगा: mm: ss और GMT (Z) आप प्रत्येक सदस्य से अंक निकाल सकते हैं और पूर्णांक की तरह उनकी तुलना कर सकते हैं

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

यदि तिथि को अलग-अलग स्वरूपित किया जा सकता है, तो आपको आईएसओ चुनौतीपूर्ण लोगों के लिए कुछ जोड़ने की आवश्यकता हो सकती है:

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;
        }
    }
}
}

Comments

क्या आप सिर्फ इस्तेमाल नहीं कर सकते Date.parse?

— रॉकेट हज़मत

Answer 13

पूर्णता के लिए यहाँ छंटनी का एक संभावित संक्षिप्त सामान्य कार्यान्वयन है:

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

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

ध्यान दें कि यह सरणियों के सॉर्ट विधि का उपयोग करता है जो जगह में सॉर्ट करता है। प्रतिलिपि के लिए आप एक प्रतिलिपि बनाने के लिए arr.concat () या arr.slice (0) या इसी तरह की विधि का उपयोग कर सकते हैं।

Answer 14

इसके साथ हम छँटाई के लिए उपयोग करने के लिए एक महत्वपूर्ण फ़ंक्शन पास कर सकते हैं

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;
    }); 
}

उदाहरण के लिए यदि हमारे पास है

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}} ]

हम कर सकते हैं

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}} ]
*/

या

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}} ]
*/

या

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
*/

Answer 15

आप इस समस्या को हल करने के लिए लॉडश उपयोगिता पुस्तकालय का उपयोग कर सकते हैं (यह काफी कुशल पुस्तकालय है):

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>

आप यहाँ प्रलेखन पा सकते हैं: https://lodash.com/docs/4.17.15#orderBy

Answer 16

आप एक क्लोजर बना सकते हैं और इसे इस तरह से पास कर सकते हैं कि यहां मेरा उदाहरण काम कर रहा है

$.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));
});

Answer 17

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);

Answer 18

• उपयोग Array.sort()किसी सरणी को सॉर्ट करने के लिए
• फ़ंक्शन को शुद्ध बनाने के लिए प्रसार ऑपरेटर ( …) का उपयोग करके क्लोन सरणी
• इच्छित कुंजी के आधार पर छाँटें ( updated_at)
• डेट स्ट्रिंग को डेट ऑब्जेक्ट में बदलें
• Array.sort() वर्तमान और अगले आइटम से दो गुणों को घटाकर काम करता है अगर यह एक संख्या / वस्तु है जिस पर आप अतालतापूर्ण संचालन कर सकते हैं

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' } ]
*/

Answer 19

मैं एक ही चीज़ के साथ सामना करता हूं, इसलिए मैं इसे एक जेनेरिक के साथ संभालता हूं और मैं इसके लिए एक फ़ंक्शन बनाता हूं:

//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;
    })
}