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"
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"
Réponses:
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.
(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'
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>
if (same(u,'Z')){
en if (u == 'Z'){
et cela fonctionne parfaitement, merci!
same(str,char)
n'a pas été collée là-dedans? Je ne sais pas.
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!
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 ...
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
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));
}
Comment l'utiliser:
charLoop("A", "K", function(char) {
//char is one letter of the sequence
});
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/
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'
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"));
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);
}
};
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('')
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.
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;
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();