मैं अंडरस्कोर। Js का उपयोग करके asc और desc सॉर्ट कैसे कर सकता हूं?

Question

मैं इस समय अपने जोंस सॉर्टिंग के लिए अंडरस्कोरज का उपयोग कर रहा हूं। अब मैंने अंडरस्कोर.जेएस का उपयोग करके ए ascendingऔर descendingसॉर्टिंग करने को कहा है । मैं प्रलेखन में उसी के बारे में कुछ नहीं देखता हूं। इसे कैसे प्राप्त किया जा सकता है?

Comments

कृपया एक उदाहरण जोड़ें कि आप क्या और कैसे छांट रहे हैं।

— जॉन

आप क्या छाँट रहे हैं? नंबर? तार? खजूर? कुछ और?

— म्यू बहुत छोटा है

@muistooshort मैं वस्तुओं की एक सरणी सॉर्ट कर रहा हूं। तो SortBy विधि पूरी तरह से आरोही क्रम के लिए मेरे मापदंड के अनुरूप है, लेकिन दूसरे तरीके से नहीं।

— राहुल

यदि आप एक संख्या के अनुसार छँटाई कर रहे हैं तो आपका sortByकार्य हो सकता है return -nलेकिन यह तार के लिए काम नहीं करेगा; इसलिए सवाल यह है कि आप किस तरह की चीजों को छांट रहे हैं।

— म्यू बहुत छोटा है

लोडश के साथ आप शॉर्टहैंड का उपयोग कर सकते हैं _.sortBy([1,4,3,2]).reverse()या _.chain([1,4,3,2]).sortBy().reverse().value()यदि आप reverse()ऐरे के प्रोटोटाइप का उपयोग नहीं करना चाहते हैं ।

— GFoley83

Answer 1

आप उपयोग कर सकते हैं .sortBy, यह हमेशा एक आरोही सूची लौटाएगा :

_.sortBy([2, 3, 1], function(num) {
    return num;
}); // [1, 2, 3]

लेकिन आप इसे उतरने के लिए .reverse मेथड का उपयोग कर सकते हैं :

var array = _.sortBy([2, 3, 1], function(num) {
    return num;
});

console.log(array); // [1, 2, 3]
console.log(array.reverse()); // [3, 2, 1]

या जब संख्याओं के साथ काम करते हैं तो सूची में उतरने के लिए वापसी के लिए एक नकारात्मक संकेत जोड़ते हैं:

_.sortBy([-3, -2, 2, 3, 1, 0, -1], function(num) {
    return -num;
}); // [3, 2, 1, 0, -1, -2, -3]

हुड के तहत .sortByनिर्मित में उपयोग करता है .sort([handler]):

// Default is ascending:
[2, 3, 1].sort(); // [1, 2, 3]

// But can be descending if you provide a sort handler:
[2, 3, 1].sort(function(a, b) {
    // a = current item in array
    // b = next item in array
    return b - a;
});

Comments

अंतिम समाधान यानी वापस लौटे संख्या में निगेटिव संकेत जोड़ना सही है।

— विनेश

आप ऐसा क्यों सोचेंगे कि यह बबल सॉर्ट है? .sortBy()अंतर्निहित हुड कॉल के तहत Array.sort(), जिनमें से एल्गोरिथ्म ब्राउज़र विक्रेताओं पर निर्भर है, लेकिन बुलबुला सॉर्ट उनकी पसंद होने की संभावना नहीं है।

— रेने सारसो

क्या इससे समय की जटिलता नहीं बढ़ती है? यह सूची को दो बार सॉर्ट करने का कारण बनता है।

— user1477388

@ user1477388 मुझे यकीन नहीं है कि आपके द्वारा दो बार छांटे जाने का क्या मतलब है?

— andlrc

@andlrc इसलिए, जब आप कॉल करते हैं _.sortBy(arr, function), तो मुझे लगता है कि यह प्रत्येक आइटम पर लूप करता है और सॉर्ट किए गए सरणी को वापस करने के लिए कुछ तर्क निष्पादित करता है। फिर, जब आप Array.prototype.reverse()इसे कहते हैं तो संभवतः प्रत्येक आइटम पर फिर से लूप होता है और उलटे सरणी को वापस करने के लिए कुछ तर्क निष्पादित करता है। इसलिए, आप सरणी को दो बार लूप कर रहे हैं।

— user1477388

Answer 2

अंडरस्कोर का उपयोग करके अवरोही क्रम -1 से वापसी मूल्य को गुणा करके किया जा सकता है।

//Ascending Order:
_.sortBy([2, 3, 1], function(num){
    return num;
}); // [1, 2, 3]


//Descending Order:
_.sortBy([2, 3, 1], function(num){
    return num * -1;
}); // [3, 2, 1]

यदि आप स्ट्रिंग्स नंबरों को छांट रहे हैं, तो आप यूनिकोड मान प्राप्त करने के लिए charCodeAt () विधि का उपयोग कर सकते हैं।

//Descending Order Strings:
_.sortBy(['a', 'b', 'c'], function(s){ 
    return s.charCodeAt() * -1;
});

Comments

मैं वर्णानुक्रम में सॉर्ट करने की कोशिश कर रहा हूं - -1 से गुणा करना एक वैध ऑपरेशन नहीं है। :)

— rythos42

उपयोग के मामले में इसका मूल्य है लेकिन प्रश्न में निर्दिष्ट नहीं है। हालांकि, एक स्ट्रिंग को -1 से गुणा करना एक मान्य ऑपरेशन है। यह NaN लौटाता है, जो एक वैध परिणाम है।

— jEremyB

सरणी वापस असाइन करने के लिए भी याद रखें! SOME_ARR = _.sortBy (SOME_ARR, function (num) {SOME_FUNC}});

— अकम

charCodeAt "स्ट्रिंग में निर्दिष्ट इंडेक्स पर वर्ण के यूनिकोड को लौटाएगा" ताकि इसे एक स्ट्रिंग में वर्णों द्वारा सॉर्ट करने के लिए इस्तेमाल किया जा सके, लेकिन जैसा कि दिखाया गया है कि यह "स्ट्रिंग द्वारा सॉर्ट नहीं करता " यह स्ट्रिंग में एक चरित्र द्वारा सॉर्ट करता है

— एंथनी

यह केवल पहले चरित्र के अनुसार होता है, और यह संवेदनशील होता है।

— एडन

Answer 3

सरणी के प्रोटोटाइप के रिवर्स विधि संशोधित सरणी और रिटर्न यह के लिए एक संदर्भ है, तो आप ऐसा कर सकते हैं, जिसका अर्थ है:

var sortedAsc = _.sortBy(collection, 'propertyName');
var sortedDesc = _.sortBy(collection, 'propertyName').reverse();

इसके अलावा, अंडरस्कोर प्रलेखन पढ़ता है:

इसके अलावा, ऐरे प्रोटोटाइप के तरीकों को जंजीर अंडरस्कोर ऑब्जेक्ट के माध्यम से अनुमानित किया जाता है, ताकि आप एक reverseया एक पर्ची कर सकेंpush अपनी श्रृंखला में , और सरणी को संशोधित करना जारी रख ।

जिसका मतलब है कि आप .reverse()जंजीर का इस्तेमाल कर सकते हैं :

var sortedDescAndFiltered = _.chain(collection)
    .sortBy('propertyName')
    .reverse()
    .filter(_.property('isGood'))
    .value();

Comments

यह सबसे सरल उपयोग के मामलों के लिए रिवर्स / अवरोही छंटाई के लिए सबसे सरल तरीका है।

— डैन एटकिंसन

केस-असंवेदनशील वर्णमाला प्रकार करने के लिए:_.sortBy(collection, item => item. propertyName.toLowerCase());

— XåpplI'-I0llwlg'I -

यह काम नहीं करता है अगर सरणी में नकारात्मक संख्याएं हैं।

— श्रुति कपूर

@SrutiKapoor हाँ यह करता है। क्यों नहीं होगा?

— एमिल लुंडबर्ग

प्रदर्शन-वार, पहले फ़िल्टर लागू करना और फिर (शेष) मानों को क्रमबद्ध करना बेहतर होगा।

— सरन

Answer 4

अंडरस्कोर लाइब्रेरी के समान ही एक अन्य लाइब्रेरी है जिसे 'लाडश' कहा जाता है जिसमें एक विधि "ऑर्डरबाय" है जो पैरामीटर में यह निर्धारित करने के लिए लेता है कि किस क्रम में इसे सॉर्ट करना है। आप इसका उपयोग कर सकते हैं

_.orderBy('collection', 'propertyName', 'desc')

किसी कारण से, यह वेबसाइट डॉक्स पर प्रलेखित नहीं है।

Comments

मुझे लगता है कि आपने लॉश के साथ अंडरस्कोर को भ्रमित किया है । केवल उत्तरार्द्ध में उल्लिखित क्रम है ।

— थॉमस मार्टी

हाँ, मेरा बुरा। उत्तर को अपडेट करेगा। सही करने के लिए धन्यवाद :)

— मिंकेश जैन

orderBy, सुपर उपयोगी! रिवर्स का उपयोग करने से बहुत बेहतर है, क्योंकि यह स्थिर प्रकार की संपत्ति को संरक्षित करता है जिसे मैं खोज रहा हूं।

— फ्लिक

मेरे लिए किसी कारण से काम नहीं कर रहा है: उसका लताड़ (

— एलेक्सेला

Answer 5

अंडरस्कोर मिक्सिंस

@ Emil_lundberg के उत्तर पर विस्तार करते हुए, आप "मिक्सिन" भी लिख सकते हैं यदि आप अंडरस्कोर का उपयोग कर रहे हैं छँटाई के लिए एक कस्टम फंक्शन बनाने के लिए यदि यह एक तरह का सॉर्टिंग है जिसे आप कहीं अनुप्रयोग में दोहरा सकते हैं।

उदाहरण के लिए, हो सकता है कि आपके पास "ASC" या "DESC" के क्रम के साथ एक नियंत्रक या दृश्य सॉर्टिंग परिणाम हो, और आप उस प्रकार के बीच टॉगल करना चाहते हैं, आप कुछ इस तरह कर सकते हैं:

Mixin.js

_.mixin({
    sortByOrder: function(stooges, prop, order) {
      if (String(order) === "desc") {
          return _.sortBy(stooges, prop).reverse();
      } else if (String(order) === "asc") {
          return _.sortBy(stooges, prop);
      } else {
          return stooges;
      }
    }
})

उपयोग उदाहरण

var sort_order = "asc";
var stooges = [
  {name: 'moe', age: 40}, 
  {name: 'larry', age: 50}, 
  {name: 'curly', age: 60},
  {name: 'July', age: 35},
  {name: 'mel', age: 38}
 ];

_.mixin({
    sortByOrder: function(stooges, prop, order) {
    if (String(order) === "desc") {
        return _.sortBy(stooges, prop).reverse();
    } else if (String(order) === "asc") {
        return _.sortBy(stooges, prop);
    } else {
        return stooges;
    }
  }
})


// find elements
var banner = $("#banner-message");
var sort_name_btn = $("button.sort-name");
var sort_age_btn = $("button.sort-age");

function showSortedResults(results, sort_order, prop) {
    banner.empty();
    banner.append("<p>Sorting: " + prop + ', ' + sort_order + "</p><hr>")
  _.each(results, function(r) {
    banner.append('<li>' + r.name + ' is '+ r.age + ' years old.</li>');
  }) 
}

// handle click and add class
sort_name_btn.on("click", function() {
  sort_order = (sort_order === "asc") ? "desc" : "asc"; 
    var sortedResults = _.sortByOrder(stooges, 'name', sort_order);
  showSortedResults(sortedResults, sort_order, 'name');
})

sort_age_btn.on('click', function() {
    sort_order = (sort_order === "asc") ? "desc" : "asc"; 
    var sortedResults = _.sortByOrder(stooges, 'age', sort_order);
  showSortedResults(sortedResults, sort_order, 'age');
})

यहाँ एक JSField यह प्रदर्शित करता है: SortFy Mixin के लिए JSFiddle