const sortAlphaNum = (a, b) => a.localeCompare(b,  en , { numeric: true })

使用:

const sortAlphaNum = (a, b) => a.localeCompare(b,  en , { numeric: true })
console.log([ A1 ,  A10 ,  A11 ,  A12 ,  A2 ,  A3 ,  A4 ,  B10 ,  B2 ,  F1 ,  F12 ,  F3 ].sort(sortAlphaNum))

Gives:

[A1”、“A2”、“A3”、“A4”、“A10”、“A11”、“A12”、“B2”、“B10”、“F1”、“F3”、“F12”>

你可能不得不将<条码>在上的论据更改到你的地方,或从方案上确定,但这一工程是用来修饰的。

localeCompare 得到IE11、Acre、Edpa、Emge、Embra和So10的支持。

我的情况类似,但是,甲型数字和复数混合在一起;数字,需要先分所有数字,然后是字母数字。

A10
1
5
A9
2
B3
A2

需要成为:

1
2
5
A2
A9
A10
B3

我能够使用所供应的算法和黑板,以达到这一目的:

var reA = /[^a-zA-Z]/g;
var reN = /[^0-9]/g;
function sortAlphaNum(a,b) {
    var AInt = parseInt(a, 10);
    var BInt = parseInt(b, 10);

    if(isNaN(AInt) && isNaN(BInt)){
        var aA = a.replace(reA, "");
        var bA = b.replace(reA, "");
        if(aA === bA) {
            var aN = parseInt(a.replace(reN, ""), 10);
            var bN = parseInt(b.replace(reN, ""), 10);
            return aN === bN ? 0 : aN > bN ? 1 : -1;
        } else {
            return aA > bA ? 1 : -1;
        }
    }else if(isNaN(AInt)){//A is not an Int
        return 1;//to make alphanumeric sort first return -1 here
    }else if(isNaN(BInt)){//B is not an Int
        return -1;//to make alphanumeric sort first return 1 here
    }else{
        return AInt > BInt ? 1 : -1;
    }
}
var newlist = ["A1", 1, "A10", "A11", "A12", 5, 3, 10, 2, "A2", "A3", "A4", "B10", "B2", "F1", "F12", "F3"].sort(sortAlphaNum);

您可使用https://developer.mozilla.org/en-US/docs/Web/Java/Reference/Global_Objects/Collator”rel=“noretinger”>Intl.Collator<>/code。

let arr = ["A1", "A10", "A11", "A12", "A2", "A3", "A4", "B10", "B2", "F1", "F12", "F3"]

let op = arr.sort(new Intl.Collator( en ,{numeric:true, sensitivity: accent }).compare)

console.log(op)

<代码>arr.sort([功能])

职能比较(选择)。 具体说明了哪类命令。 如果遗漏,则根据每个要素的细微转换,按照统法协会代码点值对阵列进行分类。 - MDN

Adding to the accepted answer from epascarello, since I cannot comment on it. I m still a noob here. When one of the strinngs doesn t have a number the original answer will not work. For example A and A10 will not be sorted in that order. Hence you might wamnt to jump back to normal sort in that case.

var reA = /[^a-zA-Z]/g;
var reN = /[^0-9]/g;
function sortAlphaNum(a,b) {
    var aA = a.replace(reA, "");
    var bA = b.replace(reA, "");
    if(aA === bA) {
      var aN = parseInt(a.replace(reN, ""), 10);
      var bN = parseInt(b.replace(reN, ""), 10);
      if(isNaN(bN) || isNaN(bN)){
        return  a > b ? 1 : -1;
      }
      return aN === bN ? 0 : aN > bN ? 1 : -1;
    } else {
     return aA > bA ? 1 : -1;
    }
 }
 ["A1", "A10", "A11", "A12", "A2", "A3", "A4", "B10", "B2", "F1", "F12","F3"].sort(sortAlphaNum);`

Only problem with the above given solution was that the logic failed when numeric data was same & alphabets varied e.g. 28AB, 28PQR, 28HBC. Here is the modified code.

var reA = /[^a-zA-Z]/g;
    var reN = /[^0-9]/g;
    var AInt = parseInt(a, 10);
    var BInt = parseInt(b, 10);
    if(isNaN(AInt) && isNaN(BInt)){
        var aA = a.replace(reA, "");
        var bA = b.replace(reA, "");
        if(aA === bA) {
            var aN = parseInt(a.replace(reN, ""), 10);
            var bN = parseInt(b.replace(reN, ""), 10);
            alert("in if "+aN+" : "+bN);
            return aN === bN ? 0 : aN > bN ? 1 : -1;
        } else {
            return aA > bA ? 1 : -1;
        }
    }else if(isNaN(AInt)){//A is not an Int
        return 1;//to make alphanumeric sort first return 1 here
    }else if(isNaN(BInt)){//B is not an Int
        return -1;//to make alphanumeric sort first return -1 here
    }else if(AInt == BInt) {
        var aA = a.replace(reA, "");
        var bA = b.replace(reA, "");
        return aA > bA ? 1 : -1;
    }
    else {
        return AInt > BInt ? 1 : -1;
    }

此处为ES6型字母升级至本回答。

export function SortAlphaNum(a: string, b: string) {
    const reA = /[^a-zA-Z]/g;
    const reN = /[^0-9]/g;
    const aA = a.replace(reA, "");
    const bA = b.replace(reA, "");
    if (aA === bA) {
      const aN = parseInt(a.replace(reN, ""), 10);
      const bN = parseInt(b.replace(reN, ""), 10);
      return aN === bN ? 0 : aN > bN ? 1 : -1;
    } else {
      return aA > bA ? 1 : -1;
    }
}

Well, just in case someone s looking for a cleaner approach using localeCompare

arr.sort((a, b) => a.localeCompare(b, undefined,{ numeric: true }))

我解决了上述问题,其文字如下。

arrVals.sort(function(a, b){
    //return b.text - a.text;
    var AInt = parseInt(a.text, 10);
    var BInt = parseInt(b.text, 10);

    if ($.isNumeric(a.text) == false && $.isNumeric(b.text) == false) {
        var aA = a.text
        var bA = b.text;
        return aA > bA ? 1 : -1;
    } else if ($.isNumeric(a.text) == false) {  // A is not an Int
        return 1;    // to make alphanumeric sort first return -1 here
    } else if ($.isNumeric(b.text) == false) {  // B is not an Int
        return -1;   // to make alphanumeric sort first return 1 here
    } else {
        return AInt < BInt ? 1 : -1;
    }
});

这对一大批混杂的阵列做了罚款。

谢谢。

alphaNumericCompare(a, b) {

    let ax = [], bx = [];

    a.replace(/(d+)|(D+)/g, function (_, $1, $2) { ax.push([$1 || Infinity, $2 ||   ]) });
    b.replace(/(d+)|(D+)/g, function (_, $1, $2) { bx.push([$1 || Infinity, $2 ||   ]) });

    while (ax.length && bx.length) {
       let an = ax.shift();
       let bn = bx.shift();
       let nn = (an[0] - bn[0]) || an[1].localeCompare(bn[1]);
       if (nn) {
         return nn;
       }
     }
     return ax.length - bx.length;
}

这对我来说是可行的,它只是一个更细微的契约。

const reg = /[0-9]+/g;

array.sort((a, b) => {
     let v0 = a.replace(reg, v => v.padStart(10,  0 ));
     let v1 = b.replace(reg, v => v.padStart(10,  0 ));
     return v0.localeCompare(v1);
});

此处的版本(根据@SunnyPenguin &@Code Maniac的答复)作为图书馆功能。 更新和复制可变名称;评论意见为明确性增添了内容。

// Sorts strings with numbers by keeping the numbers in ascending order
export const sortAlphaNum: Function = (a: string, b: string, locale: string): number => {
  const letters: RegExp = /[^a-zA-Z]/g;
  const lettersOfA: string = a.replace(letters,   );
  const lettersOfB: string = b.replace(letters,   );

  if (lettersOfA === lettersOfB) {
    const numbers: RegExp = /[^0-9]/g;
    const numbersOfA: number = parseInt(a.replace(numbers,   ), 10);
    const numbersOfB: number = parseInt(b.replace(numbers,   ), 10);

    if (isNaN(numbersOfA) || isNaN(numbersOfB)) {
      // One is not a number - comparing letters only
      return new Intl.Collator(locale, { sensitivity:  accent  }).compare(a, b);
    }
    // Both have numbers - compare the numerical parts
    return numbersOfA === numbersOfB ? 0 : numbersOfA > numbersOfB ? 1 : -1;
  } else {
    // Letter parts are different - comparing letters only
    return new Intl.Collator(locale, { sensitivity:  accent  }).compare(lettersOfA, lettersOfB);
  }
};