क्रमबद्ध सरणी (प्राकृतिक क्रमबद्ध)

Question

मान लीजिए मैं एक सरणी

var arr = [1,5,"ahsldk",10,55,3,2,7,8,1,2,75,"abc","huds"]; 

और मैं इसे छँटाई की कोशिश की है, मैं कुछ की तरह मिलता है ...

[1, 1, 10, 2, 2, 3, 5, 55, 7, 75, 8, "abc", "ahsldk", "huds"] 

नोटिस 10 से पहले है 2, मैं कैसे हो सकता है कुछ अधिक

[1,1,2,2,3,5 ..., "abc", "ahs...",...] 

Answer 1

mrhoo द्वारा

http://snipplr.com/view/36012/javascript-natural-sort/ से की तरह:

0,123,

Array.prototype.naturalSort= function(){ 
    var a, b, a1, b1, rx=/(\d+)|(\D+)/g, rd=/\d+/; 
    return this.sort(function(as, bs){ 
     a= String(as).toLowerCase().match(rx); 
     b= String(bs).toLowerCase().match(rx); 
     while(a.length && b.length){ 
      a1= a.shift(); 
      b1= b.shift(); 
      if(rd.test(a1) || rd.test(b1)){ 
       if(!rd.test(a1)) return 1; 
       if(!rd.test(b1)) return -1; 
       if(a1!= b1) return a1-b1; 
      } 
      else if(a1!= b1) return a1> b1? 1: -1; 
     } 
     return a.length- b.length; 
    }); 
} 

या, Alphanum से: Javascript Natural Sorting Algorithm by Brian Huisman:

Array.prototype.alphanumSort = function(caseInsensitive) { 
    for (var z = 0, t; t = this[z]; z++) { 
    this[z] = []; 
    var x = 0, y = -1, n = 0, i, j; 

    while (i = (j = t.charAt(x++)).charCodeAt(0)) { 
     var m = (i == 46 || (i >=48 && i <= 57)); 
     if (m !== n) { 
     this[z][++y] = ""; 
     n = m; 
     } 
     this[z][y] += j; 
    } 
    } 

    this.sort(function(a, b) { 
    for (var x = 0, aa, bb; (aa = a[x]) && (bb = b[x]); x++) { 
     if (caseInsensitive) { 
     aa = aa.toLowerCase(); 
     bb = bb.toLowerCase(); 
     } 
     if (aa !== bb) { 
     var c = Number(aa), d = Number(bb); 
     if (c == aa && d == bb) { 
      return c - d; 
     } else return (aa > bb) ? 1 : -1; 
     } 
    } 
    return a.length - b.length; 
    }); 

    for (var z = 0; z < this.length; z++) 
    this[z] = this[z].join(""); 
} 

Answer 2

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

Answer 3

आप केवल वर्णमाला है और पूर्णांक आइटम, आप सरल कोड के साथ छड़ी कर सकते हैं:

var arr = [1,5,"ahsldk",10,55,3,2,7,8,1,2,75,"abc","huds"]; 
arr.sort(function(a, b) 
{ 
    if (a == b) 
     return 0; 

    var n1 = parseInt(a, 10); 
    var n2 = parseInt(b, 10); 
    if (isNaN(n1) && isNaN(n2)) { 
     //both alphabetical 
     return (a > b) ? 1 : 0; 
    } 
    else if (!isNaN(n1) && !isNaN(n2)) { 
     //both integers 
     return (n1 > n2) ? 1 : 0; 
    } 
    else if (isNaN(n1) && !isNaN(n2)) { 
     //a alphabetical and b is integer 
     return 1; 
    } 

    //a integer and b is alphabetical 
    return 0; 
}); 

कार्य उदाहरण: http://jsfiddle.net/25X2e/

Answer 4

लघु और मिठाई, मूल प्रश्न प्रति:

var arr = [1,5,"ahsldk",10,55,3,2,7,8,1,2,75,"abc","huds"]; 
arr.sort(function(a,b){ 
    var a1=typeof a, b1=typeof b; 
    return a1<b1 ? -1 : a1>b1 ? 1 : a<b ? -1 : a>b ? 1 : 0; 
}); 
// [1, 1, 2, 2, 3, 5, 7, 8, 10, 55, 75, "abc", "ahsldk", "huds"] 

(टाइप करके पहले क्रमबद्ध करें, फिर मूल्य के अनुसार।)

---

एक और अधिक-पूर्ण विशेषताओं प्राकृतिक प्रकार:

var items = ['a1c', 'a01', 'a1', 'a13', 'a1a', 'a1b', 'a3b1', 'a1b0', 
 
      'a1b3', 'a1b1', 'dogs', 'cats', 'hogs', 'a2', '2', '20', 
 
      1, 13, 1.1, 1.13, '1.2', 'a']; 
 
    
 
console.log(naturalSort(items)) 
 
    
 
function naturalSort(ary, fullNumbers) { 
 
    var re = fullNumbers ? /[\d\.\-]+|\D+/g : /\d+|\D+/g; 
 

 
    // Perform a Schwartzian transform, breaking each entry into pieces first 
 
    for (var i=ary.length;i--;) 
 
    ary[i] = [ary[i]].concat((ary[i]+"").match(re).map(function(s){ 
 
     return isNaN(s) ? [s,false,s] : [s*1,true,s]; 
 
    })); 
 

 
    // Perform a cascading sort down the pieces 
 
    ary.sort(function(a,b){ 
 
    var al = a.length, bl=b.length, e=al>bl?al:bl; 
 
    for (var i=1;i<e;++i) { 
 
     // Sort "a" before "a1" 
 
     if (i>=al) return -1; else if (i>=bl) return 1; 
 
     else if (a[i][0]!==b[i][0]) 
 
     return (a[i][1]&&b[i][1]) ?  // Are we comparing numbers? 
 
       (a[i][0]-b[i][0]) :   // Then diff them. 
 
       (a[i][2]<b[i][2]) ? -1 : 1; // Otherwise, lexicographic sort 
 
    } 
 
    return 0; 
 
    }); 
 

 
    // Restore the original values into the array 
 
    for (var i=ary.length;i--;) ary[i] = ary[i][0]; 
 
    return ary; 
 
}

naturalSort के साथ, दूसरा पैरामीटर के रूप में true पारित यदि आप "1.2" से पहले क्रमबद्ध करना चाहते हैं "1.13"।

Answer 5

// अधिकांश प्राकृतिक प्रकार छँटाई स्ट्रिंग्स के लिए कर रहे हैं,

तो 'करें 2' 'file10' से पहले सॉर्ट की गई है।

आप वास्तविक संख्या आप सरणी के सामने करने के लिए उन्हें सुलझाने के लिए की जरूरत है मिश्रण रहे हैं, तो

क्योंकि ऋणात्मक संख्याओं और हाइफ़न से अलग कर दिया अंक व्याख्या करने के लिए एक दर्द कर रहे हैं।

अग्रणी शून्यों के साथ स्ट्रिंग सावधान रहना आवश्यक है, इसलिए 'part002' 'part010' से पहले सॉर्ट होगा।

function natSort=function(as, bs){ 
    var a, b, a1, b1, 
    rx= /(\d+)|(\D+)/g, rd= /\d/, rz=/^0/; 
    if(typeof as=='number' || typeof bs=='number'){ 
     if(isNaN(as))return 1; 
     if(isNaN(bs))return -1; 
     return as-bs; 
    } 
    a= String(as).toLowerCase(); 
    b= String(bs).toLowerCase(); 
    if(a=== b) return 0; 
    if(!(rd.test(a) && rd.test(b))) return a> b? 1: -1; 
    a= a.match(rx); 
    b= b.match(rx); 
    while(a.length && b.length){ 
     a1= a.shift(); 
     b1= b.shift(); 
     if(a1!== b1){ 
      if(rd.test(a1) && rd.test(b1)){ 
       return a1.replace(rz,'.0')- b1.replace(rz,'.0'); 
      } 
      else return a1> b1? 1: -1; 
     } 
    } 
    return a.length - b.length; 
} 

array.sort (natSort)

Answer 6

यह एक परिष्कृत है।

var arr = [1,5,"ahsldk",10,55,3,2,7,8,1,2,75,"56","abc","huds"]; 
    arr.sort(
       function (a,b){ 
        if (isNaN(a)&&isNaN(b)) return a<b?-1:a==b?0:1;//both are string 
        else if (isNaN(a)) return 1;//only a is a string 
        else if (isNaN(b)) return -1;//only b is a string 
        else return a-b;//both are num 
       } 
    ); 

परिणाम: 1 | 1 | 2 | 2 | 3 | 5 | 7 | 8 | 10 | 55 | 56 | 75 | एबीसी | ahsldk | HUDs |