如何使用javascript计算下一个修订号

我的应用程序中有一个修订号属性，它只是一个字符串。我需要传入当前值并计算下一个有效值并返回该值

以下是有效的进展：

.A
.B
.C
0
0.A
0.B
1
1.A
etc

忘记在别处控制的整数吧。这只处理那些有周期的。 这些限制包括：

• 第一个组件始终是一个数字（或无）
• 然后是一段时间
• 然后是一个字母，不包括I和O（因为它们类似于1和0），一旦你到达Z，它应该转到AA，AB，AC，…，ZZ

所以

任何帮助都将不胜感激

以下是我所拥有的-我只是不知道如何“增加”字母部分：

function calcNextRev(currentRev)
{
var revParts = currentRev.split(".");
var majorRev = revParts[0];
var currentMinorRev = revParts[1];

???

return majorRev + "." + newMinorRev;
}

试试这个：

变量alfab=['A'，'B'，'C'，'D'，'E'，'F'，'G'，'H'，'J'，'K'，'L'，'M'，'N'，'p'，'Q'，'R'，'S'，'T'，'U'，'V'，'W'，'Y'，'Z']； var currentRev='0.AZ'； var结果

function calcNextRev(currentRev) {
var newMinorRev;
var revParts = currentRev.split(".");
var majorRev = revParts[0];
var currentMinorRev = revParts[1];
//Case string is 1 letter long
if (currentMinorRev.length == 1) {
    for (i = 0; i < alfab.length; i++) {
        if (currentMinorRev == alfab[i]) {
            if (i == alfab.length - 1) {
                newMinorRev = alfab[0] + alfab[0];
            } else {
                var ii = i + 1;
                newMinorRev = alfab[ii];
            }
        }
    }
}
//Case string is more than one letter long
if (currentMinorRev.length > 1) {
    var currentMinorRev2 = currentMinorRev.split("");
    var l = currentMinorRev2.length - 1;
    for (o = 0; o < alfab.length; o++) {
        if (currentMinorRev2[l] == alfab[o] && o == alfab.length - 1) 
        {
            var currentalias = currentMinorRev2;
            currentalias[l] = alfab[0];
            currentalias.push(alfab[0]);
            newMinorRev = currentalias.join('');
        } 
        if (currentMinorRev2[l] == alfab[o] && o != alfab.length - 1) 
        {
            var xo = o + 1;
            var currentalias = currentMinorRev2;
            currentalias[l] = alfab[xo];
            newMinorRev = currentalias.join('');
            o++;

        }
    }
};
result = majorRev + "." + newMinorRev;
return result;
}

alert(calcNextRev(currentRev));

功能calcNextRev（当前版本）{
var newMinorRev；
var revParts=当前版本拆分（“.”）；
var majorRev=revParts[0]；
var currentMinorRev=revParts[1]；
//大小写字符串的长度为1个字母
如果（currentMinorRev.length==1）{
对于（i=0；i1）{
var currentMinorRev2=currentMinorRev.split（“”）；
var l=CurrentMinorRef2.length-1；
对于（o=0；o

试试这个：

变量alfab=['A'，'B'，'C'，'D'，'E'，'F'，'G'，'H'，'J'，'K'，'L'，'M'，'N'，'p'，'Q'，'R'，'S'，'T'，'U'，'V'，'W'，'Y'，'Z']； var currentRev='0.AZ'； var结果

function calcNextRev(currentRev) {
var newMinorRev;
var revParts = currentRev.split(".");
var majorRev = revParts[0];
var currentMinorRev = revParts[1];
//Case string is 1 letter long
if (currentMinorRev.length == 1) {
    for (i = 0; i < alfab.length; i++) {
        if (currentMinorRev == alfab[i]) {
            if (i == alfab.length - 1) {
                newMinorRev = alfab[0] + alfab[0];
            } else {
                var ii = i + 1;
                newMinorRev = alfab[ii];
            }
        }
    }
}
//Case string is more than one letter long
if (currentMinorRev.length > 1) {
    var currentMinorRev2 = currentMinorRev.split("");
    var l = currentMinorRev2.length - 1;
    for (o = 0; o < alfab.length; o++) {
        if (currentMinorRev2[l] == alfab[o] && o == alfab.length - 1) 
        {
            var currentalias = currentMinorRev2;
            currentalias[l] = alfab[0];
            currentalias.push(alfab[0]);
            newMinorRev = currentalias.join('');
        } 
        if (currentMinorRev2[l] == alfab[o] && o != alfab.length - 1) 
        {
            var xo = o + 1;
            var currentalias = currentMinorRev2;
            currentalias[l] = alfab[xo];
            newMinorRev = currentalias.join('');
            o++;

        }
    }
};
result = majorRev + "." + newMinorRev;
return result;
}

alert(calcNextRev(currentRev));

功能calcNextRev（当前版本）{
var newMinorRev；
var revParts=当前版本拆分（“.”）；
var majorRev=revParts[0]；
var currentMinorRev=revParts[1]；
//大小写字符串的长度为1个字母
如果（currentMinorRev.length==1）{
对于（i=0；i1）{
var currentMinorRev2=currentMinorRev.split（“”）；
var l=CurrentMinorRef2.length-1；
对于（o=0；o

基本上，您所做的是计数，尽管是以24为基数，并将其用作数字

而不是“正常”
0123456789ABCDEFGHIJKLMNO
。因此，我们将使用JavaScript鲜为人知的处理非十进制数字的能力，形式为
parseInt（value，base）
和
value.toString（base）

基本上，您所做的是计数，尽管以24为基数，并将其用作数字
ABCDEFGHJKLMNPQRSTUVWXYZ
，而不是“正常”
0123456789ABCDEFGHIJKLMNO
。因此，我们将使用JavaScript鲜为人知的处理非十进制数字的能力，形式为
parseInt（value，base）
和
value.toString（base）

所以，需求是明确的，到目前为止您尝试了什么？您写了“1.Z它应该传回1.AA”或2.A？当2.x出现时，您可以像比较数字一样比较字符串。例如
'b'>'a'
返回
true
。然后你可以使用.1.Z->1.AA“递增”一个字母，然后只递增第二个字母，如果需要的话一直递增到1.ZZ（不太可能）。所以，要求很清楚，你到目前为止做了哪些尝试？你写了“1.Z它应该传回1.AA”或2.a？当2.x出现时，您可以像比较数字一样比较字符串。例如
'b'>'a'
返回
true
。然后，你可以使用.1.Z->1.AA“递增”一个字母，然后只递增第二个字母，如果需要的话，一直递增到1.ZZ（不太可能），看起来是这样的。Z转到.ZA，但它应该转到。AA此外，主要的修订不应该递增-已经有一个完全独立的函数在做了that@trueimage，这就是你想要的吗？@trueimage，很高兴听到。您可以单击以接受最有效的答案。@trueimage，好的，我可能误解了。这里有一个版本可以工作到。ZZ，如果你想它更长的时间，我可以修复，现在对我来说太晚了。它看起来像是.Z转到.ZA，但它应该转到.aa。而且，主要的修订不应该增加-已经有一个完全独立的函数在做了that@trueimage是这样吗
var letters = "ABCDEFGHJKLMNPQRSTUVWXYZ".split(""), 
    base24_to_letters_map = {}, 
    letters_to_base24_map = {};

// Build maps from base 24 digits to desired range of letters and vice versa
for (var i=0; i<24; i++) {
    base24_to_letters_map[i.toString(24)] = letters[i];
    letters_to_base24_map[letters[i]] = i.toString(24).toUpperCase();
}

// Convert each digit in "val" based on "map"
function convert (val, map) {
    return val.replace(/[0-9A-Z]/g, function(chr) { return map[chr]; });
}

function increment (version) {
    var base24, number;

    base24 = convert (version, letters_to_base24_map);  // convert "BJ" to "1A"
    number = parseInt (base24, 24);                     // convert "1A" to 34
    number++;                                           // increment
    base24 = number.toString (24);                      // convert 35 to "1B"
    version = convert (base24, base24_to_letters_map);  // convert 1B to BK

    return version;
}

full_version.replace(/[A-Z][A-Z]?/, function (letter_portion) {
    return increment (letter_portion);
});