IE8 में जावास्क्रिप्ट: अल्फान्यूमेरिक प्रॉपर्टी द्वारा ऑब्जेक्ट्स की सरणी को सॉर्ट करने के लिए कैसे करें

Question

मुझे जावास्क्रिप्ट ऑब्जेक्ट्स की एक सरणी मिली है जिसे मैं एक ऐसी संपत्ति द्वारा पार-संगत रूप से सॉर्ट करना चाहता हूं जो हमेशा एक वैकल्पिक एकल अक्षर के साथ एक सकारात्मक पूर्णांक होता है समाप्त। मैं एक समाधान है कि कम से कम में काम करता है के लिए देख रहा हूँ Firefox 3 और Internet Explorer 8 निकटतम मैं इस तरह के एक प्रकार का कार्य करने के लिए आए हैं निम्नलिखित है:

var arrayOfObjects = [{id: '1A', name: 'bar', size: 'big'}, {id: '1C', name: 'bar', size: 'small'}, {id: '1', name: 'foo', size: 'big'}, {id: '1F', name: 'bar', size: 'big'}, {id: '1E', name: 'bar', size: 'big'}, {id: '1B', name: 'bar', size: 'small'}, {id: '1D', name: 'bar', size: 'big'}, {id: '1G', name: 'foo', size: 'small'}, {id: '3', name: 'foo', size: 'small'}, {id: '23', name: 'foo', size: 'small'}, {id: '2', name: 'foo', size: 'small'}, {id: '1010', name: 'foo', size: 'small'}, {id: '23C', name: 'foo', size: 'small'}, {id: '15', name: 'foo', size: 'small'}] 

arrayOfObjects.sort(function(a, b){ 
    return (a.id < b.id ? -1 : a.id == b.id ? 0 : 1); 
}); 

के बाद तो हल कर जा रहा है, arrayOfObjects प्रिंट देता है :

1, foo, बड़े
1010, foo, छोटे
15, foo, छोटे
1 ए, बार, बड़ा
1 बी, बार, छोटे
1C, बार छोटे
-1 डी, बार, बड़ा
1E, बार, बड़ा
1F, बार, बड़ा
1G, foo, छोटे
2, foo, छोटे
23, foo, छोटे
23 सी, foo, छोटे
3, foo , छोटे

हालांकि, मैं क्रम में नीचे प्रिंट करने की arrayOfObjects चाहते हैं:

1, foo, बड़े
1 ए, बार, बड़ा
1 बी , बार, छोटे
1C, बार, छोटे
-1 डी, बार, बड़ा
1E, बार, बड़ा
1F, बार, बड़े
1G, foo, छोटे
2, foo छोटे
3, foo, छोटे
15, foo, छोटे
23, foo, छोटे
23 सी, foo, छोटे
1010, foo, छोटे

यह देखते हुए कि, मैं कैसे अब ठीक कर सकता है ओवी फ़ंक्शन ताकि वस्तुओं को प्राथमिक कुंजी के रूप में क्रमबद्ध किया जा सके और द्वितीयक कुंजी के रूप में अक्षर? किसी भी सहायता के लिए अग्रिम रूप से धन्यवाद।

Answer 1

arrayOfObjects.sort((function() { 
    var splitter = /^(\d+)([A-Z]*)/; 
    return function(a, b) { 
    a = a.id.match(splitter); b = b.id.match(splitter); 
    var anum = parseInt(a[1], 10), bnum = parseInt(b[1], 10); 
    if (anum === bnum) 
     return a[2] < b[2] ? -1 : a[2] > b[2] ? 1 : 0; 
    return anum - bnum; 
    } 
})()); 

विचार कुंजी को संख्यात्मक और स्ट्रिंग भागों में विभाजित करना है।

arrayOfObjects.sort(function(a, b) { 
    var splitter = /^(\d+)([A-Z]*)/; 
    a = a.id.match(splitter); b = b.id.match(splitter); 
    var anum = parseInt(a[1], 10), bnum = parseInt(b[1], 10); 
    if (anum === bnum) 
    return a[2] < b[2] ? -1 : a[2] > b[2] ? 1 : 0; 
    return anum - bnum;  
}); 

एक छोटे से:

संपादित

संपादित फिर @Ryan Tenney बुद्धिमानी से पता चलता है कि गुमनाम बाहरी समारोह वास्तव में आवश्यक नहीं है (उफ़ "मैच" पीछे की ओर फोन मिल गया) सरल होते हैं।

Answer 2

आप digits-

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

यदि अंक मेल नहीं खाते हैं, तो अन्य कोर्स से संख्याओं को घटाकर संख्याओं को घटाएं।

var rx=/^(\d+)(\D?)$/; 

    arrayOfObjects.sort(function(a, b){ 
     var id_a= a.id.match(rx), id_b= b.id.match(rx); 
     if(id_a[1]== id_b[1]){ 
      if(id_a[2]=== id_b[2]) return 0; 
      else{ 
       if(!id_a[2]) return -1; 
       if(!id_b[2]) return 1; 
       return id_a[2]> id_b[2]? 1: -1; 
      } 
     } 
     return id_a[1]-id_b[1]; 
    }); 

Answer 3

यहाँ समारोह की तुलना कर रहा है, थोड़ा और वर्बोज़ कोड और सार्थक चर नाम के साथ:

/** 
* Sort array ba numerical & alphabetical order ["1a", "2z", "2a", 99, 100] 
*/ 
function compare(a, b) { 

    var re = /(\d+)([^ ]?)/, numA, numB, charA, charB, 
     aMatches = re.exec(a), 
     bMatches = re.exec(b) ; 

    numA = aMatches[1] ? aMatches[1] : ''; //get the number part 
    charA = aMatches[2] ? aMatches[2] : ''; //get the char part 

    numB = bMatches[1] ? bMatches[1] : ''; 
    charB = bMatches[2] ? bMatches[2] : ''; 

    if (charA || charB){ //if one or both of the compare candidates have letter 
     if (numA==numB){ //only if number parts are equal 
      return charA.localeCompare(charB); // we compare letters 
     } 
    } 

    return numA - numB; // otherwise just compare numbers 
}