पूर्णांकों की एक सरणी को सही ढंग से कैसे सॉर्ट करें


846

एक सरणी से सबसे अधिक और सबसे कम मूल्य प्राप्त करने की कोशिश करना, जो मुझे पता है कि केवल पूर्णांक शामिल होंगे जो मुझे लगता है कि कठिन है।

var numArray = [140000, 104, 99];
numArray = numArray.sort();
alert(numArray)

मैं यह दिखाने की उम्मीद करूंगा 99, 104, 140000। इसके बजाय यह दिखाता है 104, 140000, 99। तो ऐसा लगता है कि मान स्ट्रिंग के रूप में मानों को संभाल रहा है।

क्या वास्तव में पूर्णांक मान पर सॉर्ट फ़ंक्शन प्राप्त करने का एक तरीका है?


10
ध्यान दें कि शीर्ष में से कोई भी उत्तर सभी फ़्लोटिंग-पॉइंट मानों के साथ सही तरीके से व्यवहार नहीं करता है; विशेष रूप से, उनमें से कोई भी संभाल नहीं है NaN। एक उच्च रैंक वाले उत्तर को देखना अच्छा होगा जो इससे संबंधित है NaN
क्क्सप्लसोन

3
BTW, यदि आप बहुत सारे और बहुत सारे पूर्णांक छाँट रहे हैं, तो एक पूर्णांक छंटाई एल्गोरिथ्म का उपयोग करना होगा जैसे कि गिनती छाँटना । समय की गिनती प्रकार आपके सरणी के आकार के साथ रैखिक रूप से चलाने के लिए ले जाएगा: O (n)। जबकि यहां सभी समाधान तुलनात्मक प्रकार का उपयोग करते हैं जो कम कुशल है: O (n * log n)।
वेब_डिजाइनर

1
@Web_Designer काउंटिंग क्रम संख्या के संबंध में रैखिक है, न कि सरणी। उदाहरण के लिए, छांटना [1,1000000] में 2 से अधिक चरण होंगे, क्योंकि एल्गोरिथ्म को प्रत्येक सरणी इंडेक्स को 1 से 1000000 के बीच स्कैन करना होगा, यह देखने के लिए कि सेल का मान 0. से अधिक है
15

2
@yters एक हैशमैप का उपयोग करके, आप केवल उन पूर्णांकों पर ध्यान दे सकते हैं जो सरणी में सॉर्ट किए जा रहे हैं। यह क्रमबद्ध रैखिक wrt सरणी आकार बनाता है।
केविन

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

जवाबों:


1232

डिफ़ॉल्ट रूप से, सॉर्ट विधि तत्वों को वर्णानुक्रम में सॉर्ट करती है। संख्यात्मक रूप से क्रमबद्ध करने के लिए बस एक नई विधि जोड़ें, जो संख्यात्मक प्रकार (क्रमांक, नीचे दिखाए गए) को संभालता है -

var numArray = [140000, 104, 99];
numArray.sort(function(a, b) {
  return a - b;
});

console.log(numArray);

ES6 में, आप इसे तीर के कार्यों से सरल कर सकते हैं:

numArray.sort((a, b) => a - b); // For ascending sort
numArray.sort((a, b) => b - a); // For descending sort

प्रलेखन:

मोज़िला Array.prototype.sort()ने इस तुलनात्मक फ़ंक्शन को उन सरणियों के लिए अनुशंसित किया है जिनमें इन्फिनिटी या NaN शामिल नहीं है। (क्योंकि Inf - InfNaN है, 0 नहीं)।

कुंजी द्वारा वस्तुओं को छांटने के उदाहरण भी।


147
अच्छा लगा। लेकिन क्या वास्तव में जावास्क्रिप्ट से एक संख्यात्मक प्रकार प्राप्त करने का कोई आउट-ऑफ-द-बॉक्स तरीका नहीं है?
Peirix

39
आह यह बॉक्स से बाहर है! लेकिन अगर आप वास्तव में अव्यवहारिक हैं, तो आप अपने जावास्क्रिप्ट के आरंभ में सरणी वर्ग वर्ग के कार्यों को बाँध सकते हैं: // Array.prototype.sortNormal = function () {इसे वापस लौटाएँ। (फ़ंक्शन (a, b) {वापसी - b})} // अब कॉलिंग .sortNormal () किसी भी एरे पर इसे संख्यात्मक रूप से सॉर्ट करेगा
जैक फ्रेंज़न

13
क्यों ab और a> b नहीं। मैं ऑपरेशन मशीन त्रुटियों से बचने के लिए आखिरी सुझाव देता हूं
लुका दावानजो

35
@Velthune तुलना फ़ंक्शन -1, 0 या +1 वापस करना चाहिए। a> b केवल सही या गलत लौटाएगा।
इवान पेरेज़

48
एरो फंक्शन का उपयोग करके इस कोड को छोटा किया जा सकता है । numberArray.sort((a, b) => (a - b));वाह! मुझे लगता है कि यह आउट ऑफ द बॉक्स तरीका है। नोट: जांचें कि क्या आपका जेएस इंजन एरो फंक्शंस का समर्थन करता है।
Константин Ван

173

उपरोक्त सभी उत्तरों के आधार पर, उन्हें इस तरह एक पंक्ति में किया जा सकता है:

var numArray = [140000, 104, 99];

// ES5
numArray = numArray.sort(function (a, b) {  return a - b;  });

// ES2015
numArray = numArray.sort((a, b) => a - b);

//outputs: 99, 104, 140000

8
@bodyflex फिक्स्ड var arr = [140000, 104, 99].sort(function(a,b) { return a-b; });:। या अधिक कॉम्पैक्ट, ES6 मेंlet arr = [140000, 104, 99].sort((a,b) => a-b);
00500005

1
जैसा कि मैंने ऊपर एक टिप्पणी में कहा था, तीर के काम यहां एक खराब फिट हैं और मैं किसी को भी इस तरह से उपयोग करने से हतोत्साहित करूंगा। आप शब्दों को काटने के लिए तीर सिंटैक्स के एक साइड इफेक्ट का उपयोग कर रहे हैं functionऔर return, लेकिन वास्तव में तीर फ़ंक्शन को पास करने के सही उद्देश्य का उपयोग नहीं कर रहे हैं this। इस कोड का तात्पर्य है कि वहाँ कुछ thisसंदर्भ गुजर रहा है, लेकिन वहाँ नहीं है। अन्य डेवलपर्स के लिए आपके कोड को पढ़ने के लिए भ्रमित करना, बस कुछ वर्णों को बचाने के लिए। साइड इफेक्ट पर निर्भर न करें - उद्देश्य के साथ कोड!
बमबारी 5

12
@bberbery मुझे नहीं लगता है कि आपको विशेष रूप से संदर्भ परिवर्तन के लिए एक तीर फ़ंक्शन का उपयोग करने की आवश्यकता है ...
टेड

7
@ बंबारी, आप वास्तव में गलत समझ रहे हैं कि एरो फ़ंक्शन क्या कर रहा है। आपको लगता है कि यह किसी भी तरह से thisकार्य करता है लेकिन यह सच नहीं है। यह वास्तव में एक thisऔर argumentsवैरिएबल बनाने की उपेक्षा करता है जो आमतौर पर मूल चर को अधिलेखित करता है। एकमात्र कारण जो आप thisएक तीर फ़ंक्शन के अंदर उपयोग कर सकते हैं वह है लेक्सिकल स्कूपिंग।
22

2
@ बंबेरी जो अच्छी तरह से उम्र नहीं थी ... तीन साल बाद और आधुनिक जावास्क्रिप्ट विकास तीर कार्यों का उपयोग लगभग विशेष रूप से करता है। :)
किप

71

array.sort एक सांख्यिक सॉर्ट के लिए डिफ़ॉल्ट रूप से एक लेक्सोग्राफ़िक सॉर्ट करता है, अपना स्वयं का फ़ंक्शन प्रदान करता है। यहाँ एक सरल उदाहरण दिया गया है:

function compareNumbers(a, b)
{
    return a - b;
}

numArray.sort(compareNumbers);

यह भी ध्यान दें कि सॉर्ट काम करता है "जगह में", असाइनमेंट की कोई आवश्यकता नहीं है।


मुझे ऊपर दिए गए कोड की समझ नहीं थी, आरोही छँटनी "b - a - b" कैसे करता है?
विक्रमवी

यदि <b, तो तुलना करें एक ऋणात्मक संख्या देता है। यदि ए> बी, यह सकारात्मक होगा। तो बराबर है, यह 0. रिटर्न
पॉल डिक्सन

38

यह उत्तर कुछ मौजूदा उत्तरों के बराबर है, लेकिन ECMAScript 6 तीर फ़ंक्शंस बहुत अधिक कॉम्पैक्ट सिंटैक्स प्रदान करते हैं जो हमें पठनीयता का त्याग किए बिना इनलाइन सॉर्ट फ़ंक्शन को परिभाषित करने की अनुमति देता है:

numArray = numArray.sort((a, b) => a - b);

यह आज अधिकांश ब्राउज़रों में समर्थित है


1
"पठनीयता का त्याग किए बिना"। यह व्यक्तिपरक है। कुछ सरल पूर्णांकों के साथ यह पठनीय है। जब जटिल वस्तुओं के साथ काम करना और आप एक संपत्ति पर सॉर्ट करना चाहते हैं, तो इतना नहीं।
ट्रिस्टन

3
@ ट्रिस्टन, एक वस्तु की संपत्ति पर छंटनी अभी भी इस वाक्यविन्यास का उपयोग करके बहुत सफाई से किया जा सकता है। यदि आप जिस वस्तु को छांटना चाहते हैं, उसकी संपत्ति एक संख्या है जो आप कर सकते हैं: objArray=objArray.sort((a,b)=>a.numProperty - b.numProperty);और यदि संपत्ति एक स्ट्रिंग है जो आप कर सकते हैं: objArray=objArray.sort((a,b)=>a.strProperty.localeCompare(b.strProperty))‌​;यह कहा गया है, यह प्रश्न विशेष रूप से पूर्णांक के एक सरणी को छाँटने के बारे में पूछता है
jjjjs

34

मुझे आश्चर्य है कि हर कोई तुलनात्मक कवक पारित करने की सिफारिश क्यों करता है sort(), जो वास्तव में धीमी गति से छंटाई करता है!

संख्याओं को क्रमबद्ध करने के लिए, बस कोई भी टाइप करें :

var numArray = new Uint32Array([140000, 104, 99]);
numArray = numArray.sort();
alert(numArray)


4
टाइपराइटर का उपयोग करते हुए लगभग 5X की तरह गति बढ़ाएं। यदि आप और भी तेज hpc-एल्गोरिदम npm पैकेज पर जाना चाहते हैं, तो मूलांक सॉर्ट और काउंटिंग क्रमबद्ध करें कि यहां कई उत्तर सुझाए गए हैं।
ड्रैगनस्पिट

वाह, यह अस्तित्व में नहीं पता था!
10

21

सॉर्ट फ़ंक्शन के अजीब होने का कारण

से प्रलेखन :

[...] सरणी को प्रत्येक वर्ण के यूनिकोड कोड बिंदु मान के अनुसार क्रमबद्ध किया जाता है, प्रत्येक तत्व के स्ट्रिंग रूपांतरण के अनुसार।

यदि आप सरणी के यूनिकोड बिंदु मानों को प्रिंट करते हैं तो यह स्पष्ट हो जाएगा।

console.log("140000".charCodeAt(0));
console.log("104".charCodeAt(0));
console.log("99".charCodeAt(0));

//Note that we only look at the first index of the number "charCodeAt(  0  )"

यह रिटर्न: "49, 49, 57"।

49 (unicode value of first number at 140000)
49 (unicode value of first number at 104)
57 (unicode value of first number at 99)

अब, क्योंकि 140000 और 104 समान मान लौटाते हैं (49) यह पहले सूचकांक को काटता है और फिर से जाँच करता है:

console.log("40000".charCodeAt(0));
console.log("04".charCodeAt(0));

//Note that we only look at the first index of the number "charCodeAt(  0  )"

52 (unicode value of first number at 40000)
40 (unicode value of first number at 04)

यदि हम इसे क्रमबद्ध करते हैं, तो हमें मिलेगा:

40 (unicode value of first number at 04)
52 (unicode value of first number at 40000)

तो 104 140000 से पहले आता है।

तो अंतिम परिणाम होगा:

var numArray = [140000, 104, 99];
numArray = numArray.sort();
console.log(numArray)

104, 140000, 99

निष्कर्ष:

sort()केवल संख्याओं के पहले सूचकांक को देखकर छँटाई करता है। sort()परवाह नहीं करता है कि यदि एक पूरी संख्या दूसरे से बड़ी है, तो यह अंकों के यूनिकोड के मूल्य की तुलना करता है, और यदि दो समान यूनिकोड मान हैं, तो यह जांचता है कि क्या अगला अंक है और साथ ही इसकी तुलना करता है।

सही ढंग से सॉर्ट करने के लिए, आपको यहांsort() बताया गया पसंद करने के लिए एक तुलना फ़ंक्शन पास करना होगा ।


संकेत: यह केवल मेरा स्पष्टीकरण है, मैंने वास्तव में कोड को नहीं देखा था। तो इस जवाब पर पूरी तरह से भरोसा मत करो।
ब्लैक

17

मैं अक्स से सहमत हूं, हालांकि उपयोग करने के बजाय

return a - b;

आपको उपयोग करना चाहिए

return a > b ? 1 : a < b ? -1 : 0;

18
क्या आप बता सकते हैं कि किसी को आपके अधिक अपठनीय टर्नरी ऑपरेशन का उपयोग क्यों करना चाहिए ? जहां तक ​​मैं बता सकता हूं इसका एक ही परिणाम होगा।
स्टेफन्यू

6
यह उत्तर समान मूल्यों को भी ध्यान में रखता है और उन्हें उसी स्थान पर छोड़ देता है।
Maarten00

23
और ए - बी नहीं करता है?
ब्रायन रेनर

12
"वापसी अब" इस प्रश्न के विशेष रूप से मामले के लिए पर्याप्त हो सकता है (जावास्क्रिप्ट, और सभी इनपुट आइटम जो चींटियों के लिए जाना जाता है), लेकिन व्यक्तिगत रूप से मैं टेरनेरी रूप पसंद करता हूं क्योंकि यह अधिक कैनोनिकल है - यह अधिक मामलों में, अधिक प्रोग्रामिंग भाषाओं में काम करता है , अधिक डेटा प्रकारों के साथ। जैसे सी में, एब अतिप्रवाह कर सकता है, इस तरह की अंतहीन लूपिंग की ओर जाता है, स्मृति को दूषित करता है, दुर्घटनाग्रस्त हो जाता है, आदि ने कहा, यहां तक ​​कि टर्नरी फॉर्म भी काम नहीं करने जा रहा है अगर इसमें NaN या मिश्रित प्रकार शामिल हैं।
डॉन हैच

8
>और <अभी भी तारों के रूप में ए और बी की तुलना करें।
व्रिसेमिकेल

11

नई ES6 दुनिया में एक तरह से करने के लिए बहुत आसान है

numArray.sort((a,b) => a-b);

आप सभी की जरूरत है कि :)


10

जावास्क्रिप्ट में () विधि का डिफ़ॉल्ट व्यवहार किसी वर्ण में मानों को वर्णानुक्रम में क्रमबद्ध करना है।

संख्या के अनुसार क्रमबद्ध करने के लिए आपको एक संख्यात्मक प्रकार्य फ़ंक्शन को परिभाषित करना होगा (जो कि बहुत आसान है):

...
function sortNumber(a, b)
{
  return a - b;
}

numArray = numArray.sort(sortNumber);

8

Array.prototype.sort () सरणियों को सॉर्ट करने के लिए विधि पर जाना है, लेकिन ऐसे कुछ मुद्दे हैं जिनके बारे में हमें जागरूक होने की आवश्यकता है।

सॉर्टिंग क्रम डिफ़ॉल्ट लेक्सिकोग्राफ़िक द्वारा है और सरणी में मानों के प्रकारों की परवाह किए बिना संख्यात्मक नहीं है। यहां तक ​​कि अगर सरणी सभी संख्याएं हैं, तो सभी मान स्ट्रिंग में परिवर्तित हो जाएंगे और लेक्सोग्राफिक रूप से क्रमबद्ध हो जाएंगे।

तो क्या हमें नीचे की तरह () और रिवर्स () विधि को अनुकूलित करना चाहिए।

संदर्भित URL

सरणी के अंदर संख्याओं को छांटने के लिए

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

सरणी के अंदर संख्याओं को उलटने के लिए

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

संदर्भित URL


6

प्रश्न का उत्तर पहले ही दिया जा चुका है, सबसे छोटा तरीका है sort()विधि का उपयोग करना । लेकिन अगर आप अपनी संख्याओं को क्रमबद्ध करने के लिए और अधिक तरीके खोज रहे हैं, और आप साइकिल से प्यार करते हैं, तो निम्नलिखित की जांच करें

सम्मिलन सॉर्ट

आरोही:

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length; i++) {
    var target = numArray[i];
    for (var j = i - 1; j >= 0 && (numArray[j] > target); j--) {
        numArray[j+1] = numArray[j];
    }
    numArray[j+1] = target
}
console.log(numArray);

अवरोही:

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length; i++) {
    var target = numArray[i];
    for (var j = i - 1; j >= 0 && (numArray[j] < target); j--) {
        numArray[j+1] = numArray[j];
    }
    numArray[j+1] = target
}
console.log(numArray);

चयन छांटना:

आरोही:

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length - 1; i++) {
    var min = i;
    for (var j = i + 1; j < numArray.length; j++) {
        if (numArray[j] < numArray[min]) {
            min = j;
        }
    }
    if (min != i) {
        var target = numArray[i];
        numArray[i] = numArray[min];
        numArray[min] = target;
    }
}
console.log(numArray);

अवरोही:

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length - 1; i++) {
    var min = i;
    for (var j = i + 1; j < numArray.length; j++) {
        if (numArray[j] > numArray[min]) {
            min = j;
        }
    }
    if (min != i) {
        var target = numArray[i];
        numArray[i] = numArray[min];
        numArray[min] = target;
    }
}
console.log(numArray);

मज़े करो


क्या इनमें से कोई भी वास्तवsort() में टाइप किए गए एरे की तरह उपयोग करने की तुलना में छोटे सरणियों के लिए तेज़ है जैसे कि यह उत्तर बताता है । निश्चित रूप से वे मध्यम से बड़े सरणियों के लिए तेज़ नहीं होंगे क्योंकि ये O (n ^ 2) एल्गोरिदम हैं।
पीटर कॉर्डेस

5

नीचे दिया गया फ़ंक्शन 'संख्यात्मक रूप से' कॉलबैक फ़ंक्शन के रूप में प्रदान किए जाने पर कई मामलों में संख्याओं की सरणी को क्रमबद्ध करने के उद्देश्य से कार्य करता है:

function numerically(a, b){
    return a-b;
}

array.sort(numerically); 

लेकिन कुछ दुर्लभ उदाहरणों में, जहाँ सरणी में बहुत बड़ी और नकारात्मक संख्याएँ होती हैं, एक अतिप्रवाह त्रुटि हो सकती है क्योंकि ab का परिणाम सबसे छोटी संख्या की तुलना में छोटा होता है जिसे जावास्क्रिप्ट सामना कर सकता है।

तो संख्यात्मक कार्य लिखने का एक बेहतर तरीका इस प्रकार है:

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

1
जावास्क्रिप्ट संख्या फ्लोटिंग-पॉइंट हैं। IEEE754 ओवरफ्लो और अंडरफ्लो नियमों को परिभाषित करता है, जिनमें ओवरफ्लो + से-इनफिनिटी, और अंडरफ्लो को सबनॉर्मल या + -0.0 तक शामिल है। मुझे नहीं लगता कि दो संख्याओं का घटाव + -0.0 तक कम हो सकता है, भले ही वे दोनों बड़े और पास बराबर हों। दो डबल्स के बीच का अंतर हमेशा एक और नॉन-जीरो डबल (जब तक यह अधिक पसंद DBL_MIN - DBL_MAXनहीं होता है) के रूप में प्रतिनिधित्व करने योग्य है, लेकिन अंडरफ्लो संभव नहीं है। भयावह निरस्तीकरण परिणाम को अभेद्य बनाता है, अपने "महत्वपूर्ण अंकों" को खो देता है, लेकिन a-bहमेशा गैर-शून्य रहेगा और a = b के लिए सही संकेत होगा!
पीटर कॉर्डेस

4

अपरिभाषित, अशक्त, और NaN को संभालने के लिए: Null 0 की तरह व्यवहार करता है, NaN और अपरिभाषित समाप्त होता है।

array = [3, 5, -1, 1, NaN, 6, undefined, 2, null]
array.sort((a,b) => isNaN(a) || a-b)
// [-1, null, 1, 2, 3, 5, 6, NaN, undefined]

3

केवल तत्वों के एक सामान्य सरणी के लिए:

function sortArrayOfElements(arrayToSort) {
    function compareElements(a, b) {
        if (a < b)
            return -1;
        if (a > b)
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareElements);
}

e.g. 1:
var array1 = [1,2,545,676,64,2,24]
**output : [1, 2, 2, 24, 64, 545, 676]**

var array2 = ["v","a",545,676,64,2,"24"]
**output: ["a", "v", 2, "24", 64, 545, 676]**

वस्तुओं की एक सरणी के लिए:

function sortArrayOfObjects(arrayToSort, key) {
    function compareObjects(a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareObjects);
}

e.g. 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}]

**output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}]**

2

अपडेट करें! smartSortप्रो एडिटिव के लिए उत्तर के निचले भाग तक स्क्रॉल करें जो और भी अधिक मजेदार देता है! किसी भी चीज़ के
सरणियाँ !

इस फ़ंक्शन का मेरा व्यक्तिगत पसंदीदा रूप आरोही या अवरोही के लिए एक परम के लिए अनुमति देता है:

function intArraySort(c, a) {
    function d(a, b) { return b - a; }
    "string" == typeof a && a.toLowerCase();
    switch (a) {
        default: return c.sort(function(a, b) { return a - b; });
        case 1:
                case "d":
                case "dc":
                case "desc":
                return c.sort(d)
    }
};

उपयोग के रूप में सरल:

var ara = function getArray() {
        var a = Math.floor(Math.random()*50)+1, b = [];
        for (i=0;i<=a;i++) b.push(Math.floor(Math.random()*50)+1);
        return b;
    }();

//    Ascending
intArraySort(ara);
console.log(ara);

//    Descending
intArraySort(ara, 1);
console.log(ara);

//    Ascending
intArraySort(ara, 'a');
console.log(ara);

//    Descending
intArraySort(ara, 'dc');
console.log(ara);

//    Ascending
intArraySort(ara, 'asc');
console.log(ara);

jsFiddle


या कोड स्निपेट उदाहरण यहाँ!

function intArraySort(c, a) {
	function d(a, b) { return b - a }
	"string" == typeof a && a.toLowerCase();
	switch (a) {
		default: return c.sort(function(a, b) { return a - b });
		case 1:
		case "d":
		case "dc":
		case "desc":
		return c.sort(d)
	}
};

function tableExample() {
	var d = function() {
			var a = Math.floor(50 * Math.random()) + 1,
				b = [];
			for (i = 0; i <= a; i++) b.push(Math.floor(50 * Math.random()) + 1);
			return b
		},
		a = function(a) {
			var b = $("<tr/>"),
				c = $("<th/>").prependTo(b);
			$("<td/>", {
				text: intArraySort(d(), a).join(", ")
			}).appendTo(b);
			switch (a) {
				case 1:
				case "d":
				case "dc":
				case "desc":
					c.addClass("desc").text("Descending");
					break;
				default:
					c.addClass("asc").text("Ascending")
			}
			return b
		};
	return $("tbody").empty().append(a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1))
};

tableExample();
table { border-collapse: collapse; }
th, td { border: 1px solid; padding: .25em .5em; vertical-align: top; }
.asc { color: red; }
.desc { color: blue }
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table><tbody></tbody></table>


.smartSort ('asc' | 'desc')

अब एक और छँटाई विधि के साथ और भी मज़ेदार है जो कई मदों से भरा एक सरणी सॉर्ट करता है! वर्तमान में "साहचर्य" (उर्फ, स्ट्रिंग कुंजी) को कवर नहीं करता है, लेकिन यह हर प्रकार के मूल्य के बारे में कवर करता है! न केवल यह कई मानों को क्रमबद्ध करेगा ascयाdesc अनुसार , बल्कि यह मूल्यों के "समूहों" की निरंतर "स्थिति" को भी बनाए रखेगा। दूसरे शब्दों में; ints हमेशा पहले होते हैं, फिर तार आते हैं, फिर सरणियाँ (हाँ, मैं इसे बहुआयामी बना रहा हूँ!), फिर ऑब्जेक्ट्स (अनफ़िल्टर्ड, तत्व, दिनांक), और अंत में अपरिभाषित और अशक्त!

"क्यों?" तुम पूछो। क्यों नहीं!

अब 2 फ्लेवर में आता है! जिसमें से पहले नए ब्राउज़र की आवश्यकता है क्योंकि यह ऑब्जेक्ट Object.definePropertyमें विधि जोड़ने के लिए उपयोग करता है Array.protoype। यह प्राकृतिक उपयोग में आसानी के लिए अनुमति देता है , जैसे myArray.smartSort('a'):। यदि आपको पुराने ब्राउज़रों के लिए कार्यान्वित करने की आवश्यकता है, या आप मूल वस्तुओं को संशोधित करना पसंद नहीं करते हैं, तो केवल विधि संस्करण पर स्क्रॉल करें ।

/* begin */
/* KEY NOTE! Requires EcmaScript 5.1 (not compatible with older browsers) */
;;(function(){if(Object.defineProperty&&!Array.prototype.smartSort){var h=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a>b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("a");b instanceof Array&&b.smartSort("a");if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("a"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("a"),a.id==e[0]?1:-1;e=[a.tagName, b.tagName].smartSort("a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("a"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d"); return a[d].tagName==c[0]?1:-1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]>g[1]},k=function(a,b){if(null== a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("d");b instanceof Array&&b.smartSort("d");if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("d"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("d"),a.id==e[0]?-1:1;e=[a.tagName,b.tagName].smartSort("d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("d"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1;if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]};Object.defineProperty(Array.prototype,"smartSort",{value:function(){return arguments&& (!arguments.length||1==arguments.length&&/^a([sc]{2})?$|^d([esc]{3})?$/i.test(arguments[0]))?this.sort(!arguments.length||/^a([sc]{2})?$/i.test(arguments[0])?h:k):this.sort()}})}})();
/* end */

jsFiddle Array.prototype.smartSort ('asc | desc')


उपयोग सरल है! पहले कुछ क्रेजी अरेंजमेंट करें जैसे:

window.z = [ 'one', undefined, $('<span />'), 'two', null, 2, $('<div />', { id: 'Thing' }), $('<div />'), 4, $('<header />') ];
z.push(new Date('1/01/2011'));
z.push('three');
z.push(undefined);
z.push([ 'one', 'three', 'four' ]);
z.push([ 'one', 'three', 'five' ]);
z.push({ a: 'a', b: 'b' });
z.push({ name: 'bob', value: 'bill' });
z.push(new Date());
z.push({ john: 'jill', jack: 'june' });
z.push([ 'abc', 'def', [ 'abc', 'def', 'cba' ], [ 'cba', 'def', 'bca' ], 'cba' ]);
z.push([ 'cba', 'def', 'bca' ]);
z.push({ a: 'a', b: 'b', c: 'c' });
z.push({ a: 'a', b: 'b', c: 'd' });

तो बस इसे क्रमबद्ध करें!

z.smartSort('asc'); // Ascending
z.smartSort('desc'); // Descending

विधि केवल

पूर्ववर्ती के रूप में ही, केवल एक सरल विधि को छोड़कर!

/* begin */
/* KEY NOTE! Method `smartSort` is appended to native `window` for global use. If you'd prefer a more local scope, simple change `window.smartSort` to `var smartSort` and place inside your class/method */
window.smartSort=function(){if(arguments){var a,b,c;for(c in arguments)arguments[c]instanceof Array&&(a=arguments[c],void 0==b&&(b="a")),"string"==typeof arguments[c]&&(b=/^a([sc]{2})?$/i.test(arguments[c])?"a":"d");if(a instanceof Array)return a.sort("a"==b?smartSort.asc:smartSort.desc)}return this.sort()};smartSort.asc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a> b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.asc);b instanceof Array&&b.sort(smartSort.asc);if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c], b[c]],"a"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"a"),a.id==e[0]?1:-1;e=smartSort([a.tagName,b.tagName],"a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g), "a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"a"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"a");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1; if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==c[0]?1:-1}g=[a,b].sort();return g[0]>g[1]};smartSort.desc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)? 1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.desc);b instanceof Array&&b.sort(smartSort.desc);if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c],b[c]],"d"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]], b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"d"),a.id==e[0]?-1:1;e=smartSort([a.tagName,b.tagName],"d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g),"a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&& b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"d"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1; if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]}
/* end */

उपयोग:

z = smartSort(z, 'asc'); // Ascending
z = smartSort(z, 'desc'); // Descending

jsField Method smartSort (सरणी, "asc | desc")


2

इस कोड को आज़माएं:

HTML:

<div id="demo"></div>

जावास्क्रिप्ट कोड:

<script>
    (function(){
        var points = [40, 100, 1, 5, 25, 10];
        document.getElementById("demo").innerHTML = points;
        points.sort(function(a, b){return a-b});
        document.getElementById("demo").innerHTML = points;
    })();
</script>

2

इस कोड को नीचे की तरह आज़माएं

var a = [5, 17, 29, 48, 64, 21];
function sortA(arr) {
return arr.sort(function(a, b) {
return a - b;
})
;} 
alert(sortA(a));

क्या यह सच नहीं है?
user7125929

1
var numArray = [140000, 104, 99];
numArray = numArray.sort((a,b) => a-b);
alert(numArray)

4
StackOverflow में आपका स्वागत है। आपका उत्तर स्वीकृत उत्तर के समान है। क्या आप यह कहने के लिए अपने उत्तर में कोई स्पष्टीकरण जोड़ सकते हैं कि क्यों स्वीकार किए गए उत्तर पर इसे प्राथमिकता दी जानी चाहिए?
बस

1

जावास्क्रिप्ट में आवश्यक नहीं है, अगर आप सख्ती से -1, 0, या 1 ( PHP में स्पेसशिप ऑपरेटर कैसे काम करता है) के समान है, तो आप उपयोग कर सकते हैं ।sort() compareFunctionMath.sign()

compareFunctionनीचे सख्ती से रिटर्न -1, 0, या 1:

numArray.sort((a, b) => Math.sign(a - b));

नोट: Math.sign() Internet Explorer में समर्थित नहीं है।


0

यह ऐरे प्रोटोटाइप पर एक विधि के रूप में पहले से ही प्रस्तावित और स्वीकृत समाधान है:

Array.prototype.sortNumeric = function () {
    return this.sort((a, b) => a - b);
};
Array.prototype.sortNumericDesc = function () {
    return this.sort((a, b) => b - a);
};

0

जैसे-जैसे विधि ऐरे तत्वों को स्ट्रिंग में परिवर्तित करती है। तो, नीचे दिए गए तरीके भी सरणी तत्वों के साथ दशमलव संख्याओं के साथ ठीक काम करते हैं।

let productPrices = [10.33, 2.55, 1.06, 5.77];
console.log(productPrices.sort((a,b)=>a-b));

और आपको अपेक्षित परिणाम देता है।


0

सॉर्ट विधि को ओवरराइड करना।

Array.prototype.sortInt = function(){
    this.sort(function(a,b){return a-b});
}


numbers = [12,8,21,5,1,34];
numbers.sortInt()
//output -> [1,5,8,12,21,34]

0

डिफॉल्ट सॉर्ट फ़ंक्शन डिक्शनरी क्रम में क्रमबद्ध है:

var ar = [10000,3,200];
console.log(ar.sort());
//it will sort like :=> [10000, 200, 3]

उपरोक्त एक ऐसा मामला नहीं है जिसे हम संख्याओं के लिए चाहते हैं। इसलिए यदि आपके पास पूर्णांक हैं और डिफ़ॉल्ट प्रकार फ़ंक्शन काम नहीं कर रहा है (क्योंकि यह शब्दकोश क्रम में क्रमबद्ध है) तो आपको अपना स्वयं का फ़ंक्शन लागू करना होगा:

var ar = [10000,3,-09,200];
function customSortHelpForNumber(number1, number2){
     return number1-number2;
}
console.log(ar.sort(customSortHelpForNumber));
//it will sort like :=> [3, 200, 10000]

मुझे आशा है कि आपके मन में एक सवाल है कि यह कैसे काम करता है? यहां जब हम क्रमबद्ध तरीके से एक विधि प्रदान करते हैं, तो यह हर बार दो नंबर से गुजरता है और यदि संख्या वापस आती है

  • -या मान या 0, यह अपनी जगह पर पहला नंबर रखता है
  • + ve मूल्य यह जगह का आदान-प्रदान करता है।

सभी संख्याओं के लिए इसका अनुसरण करके यह पूर्णांक के सरणी को क्रमबद्ध करता है।

यदि आप ES6 का उपयोग कर रहे हैं तो एक तीर फ़ंक्शन लिखें:

console.log(ar.sort((num1,num2)=> num1-num2));
    //it will sort like :=> [3, 200, 10000]

-1

यहाँ बर्तन पुस्तकालय में मेरी तरह सरणी समारोह है:

sortArray: function(array) {
    array.sort(function(a, b) {
        return a > b;
    });
},

# Let's test a string array
var arr = ['bbc', 'chrome', 'aux', 'ext', 'dog'];
utils.sortArray(arr);
console.log(arr);
>>> ["aux", "bbc", "chrome", "dog", "ext", remove: function]

# Let's test a number array
var arr = [55, 22, 1425, 12, 78];
utils.sortArray(arr);
console.log(arr);
>>> [12, 22, 55, 78, 1425, remove: function]

3
यह सादा गलत है! सॉर्ट फ़ंक्शन को नकारात्मक, 0 या सकारात्मक संख्याओं को वापस करने की आवश्यकता है, न कि सही या गलत।
जेरपल्ली 20

जैसा कि @jperelli ने उल्लेख किया है, सॉर्ट फ़ंक्शन को एक नंबर की आवश्यकता है, न कि बूलियन, को वापस करने के लिए (और दिया जाता है कि 3 संभावित राज्य कैसे हैं, बराबर, ऊपर और नीचे, यह एक स्थिर क्रम होना आवश्यक है)। जैसा कि आपके उत्तर में कहा गया है, यह काम नहीं करता है। a-bइसके बजाय उपयोग किया जाना चाहिए। (आप फैंसी प्राप्त कर सकते हैं और एक कर सकते हैं Number(a>b)-0.5, हालांकि यह अभी भी एक स्थिर प्रकार नहीं है)।
ecc521
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.