JavaScript的列進行排序

Question

什麼是排序的最好方式，如果列值是：

之前排序：

CANCELLED, 
v06.*, 
INDEPENDENT, 
v06.00, 
v06.00.01, 
v06.01, 
v06.02, 
v06.00.xx, 
v06.03, 
v06.04, 
ON HOLD, 
v06.06, 
v06.05, 
v06.05.01, 
v06.04.01, 
v06.05.02, 
v06.07, 
v07.00, 

排序後：提前

CANCELLED, 
    INDEPENDENT, 
    ON HOLD, 
    v06.*, 
    v06.00, 
    v06.00.01, 
    v06.00.xx, 
    v06.01, 
    v06.02, 
    v06.03, 
    v06.04, 
    v06.04.01, 
    v06.05, 
    v06.05.01, 
    v06.05.02, 
    v06.06, 
    v06.07, 
    v07.00 

感謝， 約瑟夫

Answer 1

假設您的「列值」在Array中，請使用Array.sort用自定義compareFunction定義您想要的順序。

var columnValues = [ 
    "CANCELLED", "v06.*", "INDEPENDENT", "v06.00", "v06.00.01", 
    "v06.01", "v06.02", "v06.00.xx", "v06.03", "v06.04", "ON HOLD", 
    "v06.06", "v06.05", "v06.05.01", "v06.04.01", "v06.05.02", 
    "v06.07", "v07.00" ]; 
columnValues.sort(function(a, b) { 
    if (a is less than b by some ordering criterion) 
     return -1; 
    if (a is greater than b by the ordering criterion) 
     return 1; 
    // a must be equal to b 
    return 0; 
}); 

編輯這裏有一個囉嗦compareFunction，似乎你想要做什麼，至少在這個例子中你給：

function(a, b) { 
    if (a==b) { 
     return 0; 
    } 
    if (a.length && a[0]=='v' && b.length && b[0]=='v') { 
     // Both strings are version strings. 
     // Do special case version matching. 
     var aParts = a.substring(1).split('.'), 
      bParts = b.substring(1).split('.'), 
      l = Math.max(a.length, b.length), 
      i = 0; 
     for (;i<l;i++) { 
      var aPart = aParts[i], 
       bPart = bParts[i]; 
      if (aPart == '*' && bPart != '*') { 
       return -1; 
      } 
      if (bPart == '*' && aPart != '*') { 
       return 1; 
      } 
      if (aPart == 'xx' && bPart != 'xx') { 
       return 1; 
      } 
      if (bPart == 'xx' && aPart != 'xx') { 
       return -1; 
      } 
      var aNum = parseInt(aPart,10), 
       bNum = parseInt(bPart,10); 
      if (aNum < bNum) { 
       return -1; 
      } 
      if (aNum > bNum) { 
       return 1; 
      } 
      // Same so far, try next part 
     } 
     // One must be longer than the other. 
     return (aParts.length < bParts.length) ? -1 : 1 
    } 
    // Simple alphabetic comparison 
    if (a < b) 
     return -1; 
    if (a > b) 
     return 1; 
} 

演示：http://jsfiddle.net/daybarr/h6nmg/

Answer 2

首先排序它按字母順序升序（按'默認'排序 - 或sort()而不傳遞函數），然後按數字排序。不過，我敢肯定有一個更好的方法：

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

var arr = [ 
    "v07.00", "CANCELLED", "v06.*", "v06.04.01", "INDEPENDENT", "v06.00", "v06.00.01", 
    "v06.01", "v06.02", "v06.00.xx", "v06.03", "v06.04", "ON HOLD", 
    "v06.06", "v06.05", "v06.05.01", "v06.05.02", 
    "v06.07", 
]; 
alert(arr.sort().sort(sortNumber).join("\n")); 

演示：http://jsfiddle.net/karim79/rY8Du/1/

Answer 3

一旦你列到一個數組，你可以使用任何自然排序方法， 但你需要寫一些額外的行，按照你想要的方式對'*'進行排序。

這裏是一個樣品 -

function natSort(as, bs){ 
    var a, b, a1, b1, i= 0, L, rx= /(\d+)|(\D+)/g, rd= /\d/; 
    if(isFinite(as) && isFinite(bs)) 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.replace('*','0'); // or possibly sort any non alpha nums first: 
    b=b.replace('*','0'); // replace(/[^\w\.]/g,'0'); 

    a= a.match(rx); 
    b= b.match(rx); 
    L= a.length> b.length? b.length: a.length; 
    while(i < L){ 
     a1= a[i]; 
     b1= b[i++]; 
     if(a1!== b1){ 
      if(isFinite(a1) && isFinite(b1)){ 
       if(a1.charAt(0)=== "0") a1= "." + a1; 
       if(b1.charAt(0)=== "0") b1= "." + b1; 
       return a1 - b1; 
      } 
      else return a1> b1? 1: -1; 
     } 
    } 
    return a.length - b.length; 
} 

var v= "v06.05,ON HOLD,v07.00,INDEPENDENT,v06.07,v06.03,v06.*,v06.05.02,v06.05.01,"+ 
"v06.00.xx,v06.00,CANCELLED,v06.02,v06.04,v06.00.01,v06.06,v06.01,v06.04.01"; 
v=v.split(/, */); 

'before sort:\n'+v.join(',\n')+'\n\nafter sort:\n'+ v.sort(natSort).join(',\n') 


/* returned value: 
before sort: 
v06.05, 
ON HOLD, 
v07.00, 
INDEPENDENT, 
v06.07, 
v06.03, 
v06.*, 
v06.05.02, 
v06.05.01, 
v06.00.xx, 
v06.00, 
CANCELLED, 
v06.02, 
v06.04, 
v06.00.01, 
v06.06, 
v06.01, 
v06.04.01 

after sort: 
CANCELLED, 
INDEPENDENT, 
ON HOLD, 
v06.*, 
v06.00, 
v06.00.01, 
v06.00.xx, 
v06.01, 
v06.02, 
v06.03, 
v06.04, 
v06.04.01, 
v06.05, 
v06.05.01, 
v06.05.02, 
v06.06, 
v06.07, 
v07.00 
*/