Comment utiliser javascript pour calculer le numéro de révision suivant

Question

J'ai un attribut de numéro de révision dans mon application et il s'agit simplement d'une chaîne. J'ai besoin de passer la valeur actuelle et de calculer la prochaine valeur valide et de la retourner.

Voici la progression valide:

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

Oublier les nombres entiers, qui est contrôlée ailleurs. Cela ne concerne que ceux qui ont des périodes. Les restrictions sont les suivantes:

• Le premier composant est toujours un numéro (ou rien)
• Puis une période
• Puis une lettre, à l'exclusion I et O (car ils ressemblent à 1 et 0) et une fois que vous portée Z devrait aller à AA, AB, AC, ..., ZZ

Alors

If I pass in .A it should return .B 
If I pass in 1.H it should pass back 1.J 
If I pass in 1.Z it should pass back 1.AA 

Toute aide être apprécié.

Voici ce que j'ai - je ne sais pas comment "incrément" la partie de la lettre:

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

??? 

return majorRev + "." + newMinorRev; 
} 

Answer 1

Essayez ceci:

(demo here)

var 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 résultat;

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)); 

Answer 2

Essentiellement ce que vous faites est compter, bien que dans la base 24, et en utilisant comme chiffres ABCDEFGHJKLMNPQRSTUVWXYZ au lieu de la « normale » ABCDEFGHIJKLMNO. Nous utiliserons donc la capacité peu connue de JavaScript pour gérer les numéros autres que ceux de base 10, sous la forme parseInt(value,base) et value.toString(base).

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; 
} 

Cela vous donne également des numéros de version de trois lettres et plus "gratuitement"; "ZZ" ira à "AAA". En outre, il vous permet de sauter facilement n'importe quel nombre de versions avant ou arrière.

Pour gérer le premier numéro de version numérique:

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