Quelle méthode peut être utilisée pour incrémenter des lettres?


98

Est-ce que quelqu'un connaît une bibliothèque Javascript (par exemple, soulignement, jQuery, MooTools, etc.) qui offre une méthode pour incrémenter une lettre?

J'aimerais pouvoir faire quelque chose comme:

"a"++; // would return "b"

Je ne suis pas sûr que la syntaxe que vous recherchez soit possible, mais l'opération est possible via des méthodes.
anson le

Quelle est l'application?
valentinas

Réponses:


177

Solution simple et directe

function nextChar(c) {
    return String.fromCharCode(c.charCodeAt(0) + 1);
}
nextChar('a');

Comme d'autres l'ont noté, l'inconvénient est qu'il peut ne pas gérer les cas comme la lettre «z» comme prévu. Mais cela dépend de ce que vous en voulez. La solution ci-dessus renverra '{' pour le caractère après 'z', et c'est le caractère après 'z' en ASCII, donc cela pourrait être le résultat que vous recherchez en fonction de votre cas d'utilisation.


Générateur de cordes unique

(Mis à jour le 09/05/2019)

Étant donné que cette réponse a reçu autant de visibilité, j'ai décidé de l'élargir un peu au-delà de la portée de la question initiale pour potentiellement aider les personnes qui trébuchent sur cela de Google.

Je trouve que ce que je veux souvent, c'est quelque chose qui générera des chaînes séquentielles et uniques dans un certain jeu de caractères (par exemple, n'utiliser que des lettres), j'ai donc mis à jour cette réponse pour inclure une classe qui le fera ici:

class StringIdGenerator {
  constructor(chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ') {
    this._chars = chars;
    this._nextId = [0];
  }

  next() {
    const r = [];
    for (const char of this._nextId) {
      r.unshift(this._chars[char]);
    }
    this._increment();
    return r.join('');
  }

  _increment() {
    for (let i = 0; i < this._nextId.length; i++) {
      const val = ++this._nextId[i];
      if (val >= this._chars.length) {
        this._nextId[i] = 0;
      } else {
        return;
      }
    }
    this._nextId.push(0);
  }

  *[Symbol.iterator]() {
    while (true) {
      yield this.next();
    }
  }
}

Usage:

const ids = new StringIdGenerator();

ids.next(); // 'a'
ids.next(); // 'b'
ids.next(); // 'c'

// ...
ids.next(); // 'z'
ids.next(); // 'A'
ids.next(); // 'B'

// ...
ids.next(); // 'Z'
ids.next(); // 'aa'
ids.next(); // 'ab'
ids.next(); // 'ac'

Solution simple, mais ne gère pas l'occurrence de «z» ou «Z».
Trent

3
sorte de buzzkill qu'il ira dans des caractères spéciaux comme /
Daniel Thompson

Exactement ce que je recherchais alors que j'essayais de sélectionner des caractères Unicode non affichés dans une police IBM Code Page 437 de la vieille école. Vous venez littéralement de m'économiser des heures de saisie de caractères.
LeftOnTheMoon

1
Daniel Thompson cette solution fournit plus que suffisamment d'informations, vous pouvez gérer vous-même les cas d'angle. Après tout, c'est un site Web «d'entraide», pas mon travail pour un site Web gratuit.
Bojidar Stanchev

Il m'a fallu un certain temps pour comprendre comment faire du personnage de départ un argument. J'ai fini par utiliser ._nextId = [chars.split (''). FindIndex (x => x == start)]; Ou commencez + 1 si vous voulez qu'il commence 1 de plus que ce que vous avez passé.
JohnDavid

49

Un javascript simple devrait faire l'affaire:

String.fromCharCode('A'.charCodeAt() + 1) // Returns B

1
Pure Charm, toute suggestion pour éviter les espaces blancs et les caractères spéciaux. coderByte a une question à ce sujet
sg28

22

Et si la lettre donnée est z? Voici une meilleure solution. Il va A, B, C ... X, Y, Z, AA, AB, ... etc. Fondamentalement, il incrémente les lettres comme les ID de colonne d'une feuille de calcul Excel.

nextChar ('yz'); // renvoie "ZA"

    function nextChar(c) {
        var u = c.toUpperCase();
        if (same(u,'Z')){
            var txt = '';
            var i = u.length;
            while (i--) {
                txt += 'A';
            }
            return (txt+'A');
        } else {
            var p = "";
            var q = "";
            if(u.length > 1){
                p = u.substring(0, u.length - 1);
                q = String.fromCharCode(p.slice(-1).charCodeAt(0));
            }
            var l = u.slice(-1).charCodeAt(0);
            var z = nextLetter(l);
            if(z==='A'){
                return p.slice(0,-1) + nextLetter(q.slice(-1).charCodeAt(0)) + z;
            } else {
                return p + z;
            }
        }
    }
    
    function nextLetter(l){
        if(l<90){
            return String.fromCharCode(l + 1);
        }
        else{
            return 'A';
        }
    }
    
    function same(str,char){
        var i = str.length;
        while (i--) {
            if (str[i]!==char){
                return false;
            }
        }
        return true;
    }

// below is simply for the html sample interface and is unrelated to the javascript solution

var btn = document.getElementById('btn');
var entry = document.getElementById('entry');
var node = document.createElement("div");
node.id = "node";

btn.addEventListener("click", function(){
  node.innerHTML = '';
  var textnode = document.createTextNode(nextChar(entry.value));
  node.appendChild(textnode);
  document.body.appendChild(node);
});
<input id="entry" type="text"></input>
<button id="btn">enter</button>


Changé if (same(u,'Z')){en if (u == 'Z'){et cela fonctionne parfaitement, merci!
Sean Kendle

Heureux que cela ait fonctionné et merci pour les commentaires. Peut-être que cette erreur initiale est-ce que la fonction intitulée same(str,char)n'a pas été collée là-dedans? Je ne sais pas.
Ronnie Royston

Ça doit être le cas, same()c'est clairement une fonction personnalisée. Eh bien, ==ça marche, et si je voulais être super sûr, je pourrais l'utiliser ===, mais je l'ai testé, et c'est bien. Merci encore!
Sean Kendle

si vous tapez zz vous obtiendrez un triple A est-ce un bug dans le code ??
Amr Ashraf

1
je ne pense pas? qu'est-ce qui vient après zz? aaa non? Je n'ai pas installé Excel sur cette machine (à vérifier) ​​mais cela me semble correct.
Ronnie Royston

5

Un moyen possible pourrait être tel que défini ci-dessous

function incrementString(value) {
  let carry = 1;
  let res = '';

  for (let i = value.length - 1; i >= 0; i--) {
    let char = value.toUpperCase().charCodeAt(i);

    char += carry;

    if (char > 90) {
      char = 65;
      carry = 1;
    } else {
      carry = 0;
    }

    res = String.fromCharCode(char) + res;

    if (!carry) {
      res = value.substring(0, i) + res;
      break;
    }
  }

  if (carry) {
    res = 'A' + res;
  }

  return res;
}

console.info(incrementString('AAA')); // will print AAB
console.info(incrementString('AZA')); // will print AZB
console.info(incrementString('AZ')); // will print BA
console.info(incrementString('AZZ')); // will print BAA
console.info(incrementString('ABZZ')); // will print ACAA
console.info(incrementString('BA')); // will print BB
console.info(incrementString('BAB')); // will print BAC

// ... and so on ...


4

Vous pouvez essayer ceci

console.log( 'a'.charCodeAt​(0))​

Convertissez-le d'abord en nombre Ascii .. Incrémentez-le .. puis convertissez-le d'Ascii en caractère.

var nex = 'a'.charCodeAt(0);
console.log(nex)
$('#btn1').on('click', function() {
   var curr = String.fromCharCode(nex++)
   console.log(curr)
});

Vérifiez FIDDLE


1
Hmm. Besoin de plus de jQuery.
Jasper

4

J'avais besoin d'utiliser des séquences de lettres plusieurs fois et j'ai donc créé cette fonction sur la base de cette question SO. J'espère que cela peut aider les autres.

function charLoop(from, to, callback)
{
    var i = from.charCodeAt(0);
    var to = to.charCodeAt(0);
    for(;i<=to;i++) callback(String.fromCharCode(i));
}
  • de - lettre de départ
  • à - dernière lettre
  • callback (letter) - fonction à exécuter pour chaque lettre de la séquence

Comment l'utiliser:

charLoop("A", "K", function(char) {
    //char is one letter of the sequence
});

Voir cette démo fonctionnelle


3

En ajoutant toutes ces réponses:

// first code on page
String.prototype.nextChar = function(i) {
    var n = i | 1;
    return String.fromCharCode(this.charCodeAt(0) + n);
}

String.prototype.prevChar = function(i) {
    var n = i | 1;
    return String.fromCharCode(this.charCodeAt(0) - n);
}

Exemple: http://jsfiddle.net/pitaj/3F5Qt/


2

Celui-ci fonctionne bien:

var nextLetter = letter => {
    let charCode = letter.charCodeAt(0);
    let isCapital = letter == letter.toUpperCase();

    if (isCapital == true) {
        return String.fromCharCode((charCode - 64) % 26 + 65)
    } else {
        return String.fromCharCode((charCode - 96) % 26 + 97)
    }
}

EXAMPLES

nextLetter("a"); // returns 'b'
nextLetter("z"); // returns 'a'
nextLetter("A"); // returns 'B'
nextLetter("Z"); // returns 'A'

1

Une solution juste pour rire

function nextLetter(str) {
  const Alphabet = [
    // lower case alphabet
    "a", "b", "c",
    "d", "e", "f",
    "g", "h", "i",
    "j", "k", "l",
    "m", "n", "o",
    "p", "q", "r",
    "s", "t", "u",
    "v", "w", "x",
    "y", "z",
    // upper case alphabet
    "A", "B", "C",
    "D", "E", "F",
    "G", "H", "I",
    "J", "K", "L",
    "M", "N", "O",
    "P", "Q", "R",
    "S", "T", "U",
    "V", "W", "X",
    "Y", "Z"
  ];

  const LetterArray = str.split("").map(letter => {
    if (Alphabet.includes(letter) === true) {
      return Alphabet[Alphabet.indexOf(letter) + 1];
    } else {
      return " ";
    }
  });

  const Assemble = () => LetterArray.join("").trim();
  return Assemble();
}


console.log(nextLetter("hello*3"));


0

C'est vraiment vieux. Mais j'avais besoin de cette fonctionnalité et aucune des solutions n'est optimale pour mon cas d'utilisation. Je voulais générer a, b, c ... z, aa, ab ... zz, aaa .... Cette simple récursivité fait le travail.

function nextChar(str) {
if (str.length == 0) {
    return 'a';
}
var charA = str.split('');
if (charA[charA.length - 1] === 'z') {
    return nextID(str.substring(0, charA.length - 1)) + 'a';
} else {
    return str.substring(0, charA.length - 1) +
        String.fromCharCode(charA[charA.length - 1].charCodeAt(0) + 1);
}
};

0

Créer une fonction avec {a: 'b', b: 'c', etc} dans une fermeture: -

let nextChar = (s => (
    "abcdefghijklmopqrstuvwxyza".split('')
    .reduce((a,b)=> (s[a]=b, b)), // make the lookup
c=> s[c] // the function returned
))({}); // parameter s, starts empty

usage:-

nextChar('a')

Ajout de majuscules et de chiffres: -

let nextCh = (
    (alphabeta, s) => (
        [alphabeta, alphabeta.toUpperCase(), "01234567890"]
            .forEach(chars => chars.split('')
               .reduce((a,b) => (s[a]=b, b))), 
        c=> s[c] 
    )
)("abcdefghijklmopqrstuvwxyza", {});

ps Dans certaines versions de Javascript, vous pouvez utiliser à la [...chars]place dechars.split('')



0

Voici une variante de l'algorithme rot13 que j'ai soumis sur https://stackoverflow.com/a/28490254/881441 :

function rot1(s) {
  return s.replace(/[A-Z]/gi, c =>
    "BCDEFGHIJKLMNOPQRSTUVWXYZAbcdefghijklmnopqrstuvwxyza"[
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".indexOf(c) ] )
}

Le code d'entrée en bas et le codec recherché sont en haut (c'est-à-dire que le code de sortie est le même que le code d'entrée mais décalé de 1). La fonction ne change que les lettres, c'est-à-dire que si un autre caractère est passé, il sera inchangé par ce codec.


0

function charLoop(from, to, callback) {
    var i = from.charCodeAt(0);
    var to = to.charCodeAt(0);
    for (; i <= to; i++) {
        callback(String.fromCharCode(i));
    }
}

var sequence = "";
charLoop("A", "Z", function (char) {
    sequence += char + " ";
});

sequence = sequence.trim();
sequence = sequence.split(" ");

var resseq = sequence;
var res = "";
var prevlet = "";
var nextlet = "";

for (b = 0; b < resseq.length; b++) {
    if (prevlet != "") {
        prevlet = resseq[b];
    }

    for (a = 0; a < sequence.length; a++) {
        for (j = 1; j < 100; j++) {
            if (prevlet == "") {
                prevlet = sequence[a];
                nextlet = sequence[a + 1];
                res += sequence[a] + sequence[a] + 0 + j + " ";
            }
            else {

                if (j < 10) {
                    res += prevlet + sequence[a] + 0 + j + " ";
                }
                else {
                    res += prevlet + sequence[a] + j + " ";
                }
            }
        }
    }
}

document.body.innerHTML = res;

1
Vous voudrez peut-être expliquer ce que vous avez fait exactement ici et comment cela aide plutôt que d'avoir simplement un bloc de code, merci! - Peut-être quelques moments utiles dans le code?
Mark Davies le

String.fromCharCode () il renvoie le code char de la lettre.
LokeshKumar le

0

Basé sur l'incrémentation et la diminution de réponse du mur @Nathan

// Albhabet auto increment and decrement
class StringIdGenerator {
    constructor(chars = '') {
      this._chars = chars;
    }

  next() {
    var u = this._chars.toUpperCase();
    if (this._same(u,'Z')){
        var txt = '';
        var i = u.length;
        while (i--) {
            txt += 'A';
        }
        this._chars = txt+'A';
        return (txt+'A');
    } else {
      var p = "";
      var q = "";
      if(u.length > 1){
          p = u.substring(0, u.length - 1);
          q = String.fromCharCode(p.slice(-1).charCodeAt(0));
      }
      var l = u.slice(-1).charCodeAt(0);
      var z = this._nextLetter(l);
      if(z==='A'){
        this._chars = p.slice(0,-1) + this._nextLetter(q.slice(-1).charCodeAt(0)) + z;
          return p.slice(0,-1) + this._nextLetter(q.slice(-1).charCodeAt(0)) + z;
      } else {
        this._chars = p+z;
          return p + z;
      }
    }
  }

  prev() {
    var u = this._chars.toUpperCase();
    console.log("u "+u)
    var l = u.slice(-1).charCodeAt(0);
    var z = this._nextLetter(l);
    var rl = u.slice(1)
    var y = (rl == "A") ? "Z" :this._prevLetter(rl.charCodeAt(0))
      var txt = '';
      var i = u.length;
      var j = this._chars
      var change = false
      while (i--) {
        if(change){
          if (u[u.length-1] == "A"){
            txt += this._prevLetter(u[i].charCodeAt(0))
          }else{
            txt += u[i]
          }
          
        }else{
          if (u[u.length-1] == "A"){
            txt += this._prevLetter(u[i].charCodeAt(0))
            change = true
          }else{
            change = true
            txt += this._prevLetter(u[i].charCodeAt(0))
          }
        }
      }
      if(u == "A" && txt == "Z"){
        this._chars = ''
      }else{
        this._chars = this._reverseString(txt);
      }
      console.log(this._chars)
      return (j);
  }
  _reverseString(str) {
      return str.split("").reverse().join("");
  }
  _nextLetter(l){
      if(l<90){
          return String.fromCharCode(l + 1);
      }
      else{
          return 'A';
      }
  }

  _prevLetter(l){
    if(l<=90){
      if(l == 65) l = 91
        return String.fromCharCode(l-1);
    }
    else{
        return 'A';
    }
  }
  _same(str,char){
      var i = str.length;
      while (i--) {
          if (str[i]!==char){
              return false;
          }
      }
      return true;
  }
    
}

Usage

const ids = new StringIdGenerator();

ids.next(); 
ids.prev();
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.