दिनांक संपत्ति द्वारा किसी सरणी को कैसे सॉर्ट करें

Question

कहो कि मेरे पास कुछ वस्तुओं की एक सरणी है:

var array = [{id: 1, date: Mar 12 2012 10:00:00 AM}, {id: 2, date: Mar 8 2012 08:00:00 AM}];

वर्तमान दिनांक और समय के निकटतम दिनांक से मैं तिथि तत्व के अनुसार इस सरणी को कैसे क्रमबद्ध कर सकता हूं? ध्यान रखें कि सरणी में कई ऑब्जेक्ट हो सकते हैं, लेकिन सरलता के लिए मैंने 2 का उपयोग किया।

क्या मैं सॉर्ट फ़ंक्शन और एक कस्टम तुलनित्र का उपयोग करूंगा?

अपडेट करें:

अपने विशिष्ट मामले में, मैं सबसे हाल ही में सबसे पुराने से व्यवस्थित तारीखें चाहता था। यह समाप्त हो गया कि मुझे साधारण फ़ंक्शन के तर्क को उलटना पड़ा:

array.sort(function(a, b) {
    a = new Date(a.dateModified);
    b = new Date(b.dateModified);
    return a>b ? -1 : a<b ? 1 : 0;
});

यह सबसे हाल की तारीखों को क्रमबद्ध करता है।

Comments

यदि आप दिनांक निर्माणकर्ता का उपयोग करते हैं, तो इस पहले stackoverflow.com/questions/5619202/… की

— ohkts11

सबसे तेज़ तरीका आइसोमॉर्फिक सॉर्ट-एरे- मॉड्यूल का उपयोग करना है जो किसी भी प्रकार के इनपुट, कंप्यूटेड फ़ील्ड और कस्टम सॉर्ट ऑर्डर का समर्थन करते हुए ब्राउज़र और नोड दोनों में मूल रूप से काम करता है।

— लॉयड

Answer 1

सरलतम उत्तर

array.sort(function(a,b){
  // Turn your strings into dates, and then subtract them
  // to get a value that is either negative, positive, or zero.
  return new Date(b.date) - new Date(a.date);
});

अधिक सामान्य उत्तर

array.sort(function(o1,o2){
  if (sort_o1_before_o2)    return -1;
  else if(sort_o1_after_o2) return  1;
  else                      return  0;
});

या और अधिक:

array.sort(function(o1,o2){
  return sort_o1_before_o2 ? -1 : sort_o1_after_o2 ? 1 : 0;
});

सामान्य, शक्तिशाली जवाब

सभी सरणियों पर श्वार्ट्जियन परिवर्तनsortBy का उपयोग करते हुए एक कस्टम नॉन-एन्युमरेबल फ़ंक्शन को परिभाषित करें :

(function(){
  if (typeof Object.defineProperty === 'function'){
    try{Object.defineProperty(Array.prototype,'sortBy',{value:sb}); }catch(e){}
  }
  if (!Array.prototype.sortBy) Array.prototype.sortBy = sb;

  function sb(f){
    for (var i=this.length;i;){
      var o = this[--i];
      this[i] = [].concat(f.call(o,o,i),o);
    }
    this.sort(function(a,b){
      for (var i=0,len=a.length;i<len;++i){
        if (a[i]!=b[i]) return a[i]<b[i]?-1:1;
      }
      return 0;
    });
    for (var i=this.length;i;){
      this[--i]=this[i][this[i].length-1];
    }
    return this;
  }
})();

इसका उपयोग ऐसे करें:

array.sortBy(function(o){ return o.date });

यदि आपकी तारीख सीधे तुलनीय नहीं है, तो इससे तुलनात्मक तारीख बनाएं

array.sortBy(function(o){ return new Date( o.date ) });

यदि आप मानों की एक सरणी लौटाते हैं, तो आप इसका उपयोग कई मानदंडों के आधार पर करने के लिए भी कर सकते हैं:

// Sort by date, then score (reversed), then name
array.sortBy(function(o){ return [ o.date, -o.score, o.name ] };

अधिक जानकारी के लिए http://phrogz.net/JS/Array.prototype.sortBy.js देखें ।

Comments

सिर्फ return b-a;साधारण उत्तर में क्यों नहीं ?

— corbacho

सॉर्ट विधि के अंदर नई दिनांक ऑब्जेक्ट बनाने की अनुशंसा न करें। विशेष रूप से उस कारण से उत्पादन प्रदर्शन के मुद्दों को मारा है। सॉर्ट विधि के अंदर मेमोरी (और GC) आवंटित न करें।

— मिकमर्को

पहला उदाहरण वाक्यविन्यास कोणीय 7 पर त्रुटि देता है: एक अंकगणितीय ऑपरेशन का बायाँ भाग 'कोई', 'संख्या', 'बिगिन्ट' या एक

— एनुम

@MikeMurko आपने इसे ठीक करने के लिए क्या किया?

— सिरिनि

@SURENDRANATHSONAWANE तारीख को यूनिक्स टाइमस्टैम्प में परिवर्तित करें: नई तारीख (b.date) .getTime () - new Date (a.date) .getTime () लौटें;

— रॉबर्ट ओस्ट्रोवी

Answer 2

@Phrogz जवाब दोनों महान हैं, लेकिन यहाँ एक महान, अधिक संक्षिप्त जवाब है:

array.sort(function(a,b){return a.getTime() - b.getTime()});

एरो फंक्शन तरीका का उपयोग करना

array.sort((a,b)=>a.getTime()-b.getTime());

यहां पाया गया: जावास्क्रिप्ट में सॉर्ट डेट

Comments

सीधे गणित करने a - bसे भी काम चल जाता। तो, array.sort((a, b) => a - b)(es6)

— 9

टाइपस्क्रिप्ट का उपयोग करते समय यह एक अच्छा समाधान है।

— मार्टेनपाउव

Answer 3

JSON सही करने के बाद यह आपके लिए काम करना चाहिए:

var array = [{id: 1, date:'Mar 12 2012 10:00:00 AM'}, {id: 2, date:'Mar 8 2012 08:00:00 AM'}];


array.sort(function(a, b) {
    var c = new Date(a.date);
    var d = new Date(b.date);
    return c-d;
});

Answer 4

आपके डेटा को कुछ सुधार चाहिए:

var array = [{id: 1, date: "Mar 12 2012 10:00:00 AM"},{id: 2, date: "Mar 28 2012 08:00:00 AM"}];

डेटा को सही करने के बाद, आप इस कोड का उपयोग कर सकते हैं:

function sortFunction(a,b){  
    var dateA = new Date(a.date).getTime();
    var dateB = new Date(b.date).getTime();
    return dateA > dateB ? 1 : -1;  
}; 

var array = [{id: 1, date: "Mar 12 2012 10:00:00 AM"},{id: 2, date: "Mar 28 2012 08:00:00 AM"}];
array.sort(sortFunction);​

Comments

0जहां आवश्यक हो वापस जाने के लिए मत भूलना !

— बर्गी

टाइपस्क्रिप्ट का उपयोग करने वाले किसी भी व्यक्ति के लिए, मैं इस फ़ंक्शन का उपयोग करके तिथि के अनुसार क्रमबद्ध करने में सक्षम था, जबकि दिनांक घटाव का उपयोग करने वाले अन्य विफल रहे।

— Danchat

Answer 5

मैं GitHub की सलाह देता हूं : ऐरे सॉर्ट करें - एक सर्वोत्तम कार्यान्वयन sortByविधि जो श्वार्ट्जियन ट्रांसफॉर्मेशन का उपयोग करती है

लेकिन अभी के लिए हम इस दृष्टिकोण की कोशिश करने जा रहे हैं Gist: SortBy-old.js ।
आइए कुछ संपत्ति द्वारा ऑब्जेक्ट्स को व्यवस्थित करने में सक्षम होने के लिए सरणियों को सॉर्ट करने के लिए एक विधि बनाएं।

छँटाई समारोह बनाना

var sortBy = (function () {
  var toString = Object.prototype.toString,
      // default parser function
      parse = function (x) { return x; },
      // gets the item to be sorted
      getItem = function (x) {
        var isObject = x != null && typeof x === "object";
        var isProp = isObject && this.prop in x;
        return this.parser(isProp ? x[this.prop] : x);
      };

  /**
   * Sorts an array of elements.
   *
   * @param {Array} array: the collection to sort
   * @param {Object} cfg: the configuration options
   * @property {String}   cfg.prop: property name (if it is an Array of objects)
   * @property {Boolean}  cfg.desc: determines whether the sort is descending
   * @property {Function} cfg.parser: function to parse the items to expected type
   * @return {Array}
   */
  return function sortby (array, cfg) {
    if (!(array instanceof Array && array.length)) return [];
    if (toString.call(cfg) !== "[object Object]") cfg = {};
    if (typeof cfg.parser !== "function") cfg.parser = parse;
    cfg.desc = !!cfg.desc ? -1 : 1;
    return array.sort(function (a, b) {
      a = getItem.call(cfg, a);
      b = getItem.call(cfg, b);
      return cfg.desc * (a < b ? -1 : +(a > b));
    });
  };

}());

बिना डेटा के सेटिंग करना

var data = [
  {date: "2011-11-14T17:25:45Z", quantity: 2, total: 200, tip: 0,   type: "cash"},
  {date: "2011-11-14T16:28:54Z", quantity: 1, total: 300, tip: 200, type: "visa"},
  {date: "2011-11-14T16:30:43Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T17:22:59Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:53:41Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:48:46Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "visa"},
  {date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab"},
  {date: "2011-11-14T16:58:03Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:20:19Z", quantity: 2, total: 190, tip: 100, type: "tab"},
  {date: "2011-11-14T17:07:21Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: 0,   type: "cash"}
];

उसका इस्तेमाल कर रहे हैं

अंत में, हम "date"संपत्ति के रूप में , सरणी की व्यवस्था करते हैंstring

//sort the object by a property (ascending)
//sorting takes into account uppercase and lowercase
sortBy(data, { prop: "date" });

यदि आप पत्र मामले को अनदेखा करना चाहते हैं, तो "parser"कॉलबैक सेट करें :

//sort the object by a property (descending)
//sorting ignores uppercase and lowercase
sortBy(data, {
    prop: "date",
    desc: true,
    parser: function (item) {
        //ignore case sensitive
        return item.toUpperCase();
    }
});

यदि आप "दिनांक" फ़ील्ड को इस Dateप्रकार लिखना चाहते हैं:

//sort the object by a property (ascending)
//sorting parses each item to Date type
sortBy(data, {
    prop: "date",
    parser: function (item) {
        return new Date(item);
    }
});

यहाँ आप उपरोक्त उदाहरण के साथ खेल सकते हैं:
jsbin.com/lesebi

Comments

IE11 में लाइन के साथ एक मुद्दा था: अगर (toString.call (cfg)! == "[ऑब्जेक्ट ऑब्जेक्ट]") cfg = {}; यदि आप इसे (Object.prototype.toString.call (cfg)! == "[[ऑब्जेक्ट ऑब्जेक्ट]") cfg = {} के साथ प्रतिस्थापित करते हैं; आप IE11 के साथ ही सभी अच्छे होंगे।

— skribbz14

उत्कृष्ट समाधान

— मूसा मचुआ

Answer 6

यह तब करना चाहिए जब आपकी तारीख इस प्रारूप (dd / mm / yyyy) में हो।

  sortByDate(arr) {
    arr.sort(function(a,b){
      return Number(new Date(a.readableDate)) - Number(new Date(b.readableDate));
    });

    return arr;
  }

फिर कॉल करो sortByDate(myArr);

Answer 7

आप अंडरस्कोर js में सॉर्टबाय का उपयोग कर सकते हैं।

http://underscorejs.org/#sortBy

नमूना:

var log = [{date: '2016-01-16T05:23:38+00:00', other: 'sample'}, 
           {date: '2016-01-13T05:23:38+00:00',other: 'sample'}, 
           {date: '2016-01-15T11:23:38+00:00', other: 'sample'}];

console.log(_.sortBy(log, 'date'));

Comments

इसे करने का सही और छोटा तरीका!

— भाविक कालरिया

Answer 8

मैं इसे यहाँ जोड़ने जा रहा हूँ, क्योंकि कुछ उपयोग इस छँटाई विधि को उलटने के तरीके से काम करने में सक्षम नहीं हो सकते हैं।

'ऊपर आने' के आधार पर, हम बस a & b स्वैप कर सकते हैं, जैसे:

your_array.sort ( (a, b) => {
      return new Date(a.DateTime) - new Date(b.DateTime);
});

ध्यान दें कि aअब बाईं ओर है, और bदाईं ओर है: D!

Answer 9

मैं व्यक्तिगत रूप से तारीखों को क्रमबद्ध करने के लिए निम्नलिखित दृष्टिकोण का उपयोग करता हूं।

let array = ["July 11, 1960", "February 1, 1974", "July 11, 1615", "October 18, 1851", "November 12, 1995"];

array.sort(function(date1, date2) {
   date1 = new Date(date1);
   date2 = new Date(date2);
   if (date1 > date2) return 1;
   if (date1 < date2) return -1;
})

Answer 10

मैं नीचे लाइनों का उपयोग कर छँटाई में सक्षम था:

array.sort(function(a, b)
{
   if (a.DueDate > b.DueDate) return 1;
   if (a.DueDate < b.DueDate) return -1;
})

Answer 11

Adding absolute will give better results

var datesArray =[
      {"some":"data1","date": "2018-06-30T13:40:31.493Z"},
      {"some":"data2","date": "2018-07-04T13:40:31.493Z"},
      {"some":"data3","date": "2018-06-27T13:40:54.394Z"}
   ]

var sortedJsObjects = datesArray.sort(function(a,b){ 
    return Math.abs(new Date(a.date) - new Date(b.date)) 
});

Answer 12

जो कोई भी तिथि (यूके प्रारूप) के अनुसार क्रमबद्ध करना चाहता है, मैंने निम्नलिखित का उपयोग किया:

//Sort by day, then month, then year
for(i=0;i<=2; i++){
    dataCourses.sort(function(a, b){

        a = a.lastAccessed.split("/");
        b = b.lastAccessed.split("/");

        return a[i]>b[i] ? -1 : a[i]<b[i] ? 1 : 0;
    }); 
}

Answer 13

मैंने सिर्फ ऊपर दिखाए गए श्वार्ट्ज़ियन परिवर्तन को कार्य के रूप में लिया है। यह इनपुट के रूप में एक array, सॉर्टिंग functionऔर बूलियन लेता है :

function schwartzianSort(array,f,asc){
    for (var i=array.length;i;){
      var o = array[--i];
      array[i] = [].concat(f.call(o,o,i),o);
    }
    array.sort(function(a,b){
      for (var i=0,len=a.length;i<len;++i){
        if (a[i]!=b[i]) return a[i]<b[i]?asc?-1:1:1;
      }
      return 0;
    });
    for (var i=array.length;i;){
      array[--i]=array[i][array[i].length-1];
    }
    return array;
  }

function schwartzianSort(array, f, asc) {
  for (var i = array.length; i;) {
    var o = array[--i];
    array[i] = [].concat(f.call(o, o, i), o);
  }
  array.sort(function(a, b) {
    for (var i = 0, len = a.length; i < len; ++i) {
      if (a[i] != b[i]) return a[i] < b[i] ? asc ? -1 : 1 : 1;
    }
    return 0;
  });
  for (var i = array.length; i;) {
    array[--i] = array[i][array[i].length - 1];
  }
  return array;
}

arr = []
arr.push({
  date: new Date(1494434112806)
})
arr.push({
  date: new Date(1494434118181)
})
arr.push({
  date: new Date(1494434127341)
})

console.log(JSON.stringify(arr));

arr = schwartzianSort(arr, function(o) {
  return o.date
}, false)
console.log("DESC", JSON.stringify(arr));

arr = schwartzianSort(arr, function(o) {
  return o.date
}, true)
console.log("ASC", JSON.stringify(arr));

Answer 14

शुक्रिया गणेश सनप। पुराने से नए तक दिनांक फ़ील्ड द्वारा आइटम सॉर्ट करना। इसका इस्तेमाल करें

 myArray = [{transport: "Air",
             load: "Vatican Vaticano",
             created: "01/31/2020"},
            {transport: "Air",
             load: "Paris",
             created: "01/30/2020"}] 

        myAarray.sort(function(a, b) {
            var c = new Date(a.created);
            var d = new Date(b.created);
            return c-d;
        });

Comments

माइनस क्या है?

— 19нов Алексей

Answer 15

यदि मेरी तरह आपके पास भी दिनांक के साथ एक सरणी है, YYYY[-MM[-DD]]जहां आप कम विशिष्ट लोगों से पहले अधिक विशिष्ट तिथियों का आदेश देना चाहते हैं, तो मैं इस आसान फ़ंक्शन के साथ आया हूं:

function sortByDateSpecificity(a, b) {
  const aLength = a.date.length
  const bLength = b.date.length
  const aDate = a.date + (aLength < 10 ? '-12-31'.slice(-10 + aLength) : '')
  const bDate = b.date + (bLength < 10 ? '-12-31'.slice(-10 + bLength) : '')
  return new Date(aDate) - new Date(bDate)
}

Answer 16

["12 Jan 2018" , "1 Dec 2018", "04 May 2018"].sort(function(a,b) {
    return new Date(a).getTime() - new Date(b).getTime()
})

Comments

कृपया अपना उत्तर संक्षेप में बताएं और अपने कोड का प्रारूपण जांचें।

— dthulke

पुरानी तारीखों में असफल रहेंगे।

— ओलिवर डिक्सन