Jaka jest metoda, której można użyć do zwiększania liczby liter?

99

Czy ktoś zna bibliotekę Javascript (np. Podkreślenia, jQuery, MooTools itp.), Która oferuje metodę inkrementacji litery?

Chciałbym móc zrobić coś takiego:

"a"++; // would return "b"
andyzinsser
źródło
Nie jestem pewien, czy składnia , której szukasz, jest możliwa, ale operacja jest możliwa za pomocą metod.
anson
Jaka jest aplikacja?
walentynki

Odpowiedzi:

179

Proste, bezpośrednie rozwiązanie

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

Jak zauważyli inni, wadą jest to, że może nie obsługiwać przypadków takich jak litera „z” zgodnie z oczekiwaniami. Ale to zależy od tego, czego od tego chcesz. Powyższe rozwiązanie zwróci „{” dla znaku po „z”, a to jest znak po „z” w ASCII, więc może to być wynik, którego szukasz, w zależności od tego, jaki jest twój przypadek użycia.


Unikalny generator ciągów

(Zaktualizowano 2019/05/09)

Ponieważ ta odpowiedź zyskała tak dużą widoczność, postanowiłem rozszerzyć ją nieco poza zakres pierwotnego pytania, aby potencjalnie pomóc ludziom, którzy natkną się na to z Google.

Uważam, że często potrzebuję czegoś, co wygeneruje sekwencyjne, unikalne ciągi w określonym zestawie znaków (na przykład przy użyciu tylko liter), więc zaktualizowałem tę odpowiedź, aby uwzględnić klasę, która zrobi to tutaj:

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

Stosowanie:

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'
Nathan Wall
źródło
Proste rozwiązanie, ale nie obsługuje wystąpienia „z” ani „Z”.
Trent
3
rodzaj buzzkill, który przejdzie do znaków specjalnych, takich jak /
Daniel Thompson
Dokładnie to, czego szukałem, próbując przejść i wybrać niewyświetlające się znaki Unicode do starej czcionki IBM Code Page 437. Dosłownie zaoszczędziłeś mi wiele godzin pisania znaków.
LeftOnTheMoon
1
Daniel Thompson to rozwiązanie zapewnia więcej niż wystarczającą ilość informacji, możesz samodzielnie zająć się przypadkami narożnymi. W końcu jest to strona "pomagająca sobie nawzajem", nie wykonuję mojej pracy za darmo.
Bojidar Stanchev
Zajęło mi trochę czasu, zanim wymyśliłem, jak sprawić, by znak początkowy był argumentem. Skończyło się na użyciu ._nextId = [chars.split (''). FindIndex (x => x == start)]; Lub zacznij + 1, jeśli chcesz, aby zaczął się o 1 więcej niż to, co przekazałeś.
JohnDavid
49

Zwykły javascript powinien załatwić sprawę:

String.fromCharCode('A'.charCodeAt() + 1) // Returns B
Zar
źródło
1
Czysty urok, wszelkie sugestie dotyczące unikania białych znaków i znaków specjalnych. coderByte ma pytanie na ten temat
sg28
22

A co jeśli dana litera to z? Oto lepsze rozwiązanie. Idzie A, B, C ... X, Y, Z, AA, AB, ... itd. Zasadniczo zwiększa litery, tak jak ID kolumn w arkuszu kalkulacyjnym Excel.

nextChar ('yz'); // zwraca „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>

Ronnie Royston
źródło
Zmieniono if (same(u,'Z')){na if (u == 'Z'){i działa idealnie, dzięki!
Sean Kendle
Cieszę się, że zadziałało i dzięki za informację zwrotną. Może ten początkowy błąd polegał na tym, że bcs funkcja zatytułowana same(str,char)nie została tam wklejona? Nie wiem.
Ronnie Royston
Tak musi być, same()jest to oczywiście funkcja niestandardowa. No cóż, ==działa i gdybym chciał być bardzo pewny, przydałbym się ===, ale przetestowałem to i jest w porządku. Dzięki jeszcze raz!
Sean Kendle,
jeśli wpiszesz zz, otrzymasz potrójne A, czy to błąd w kodzie?
Amr Ashraf
1
nie sądzę? co następuje po zz? aaa prawda? Nie mam zainstalowanego programu Excel na tym komputerze (aby sprawdzić dwukrotnie), ale wydaje mi się to właściwe.
Ronnie Royston,
5

Jeden możliwy sposób mógłby być taki, jak zdefiniowano poniżej

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 ...
Sandeep Singh
źródło
4

Możesz tego spróbować

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

Najpierw przekonwertuj go na liczbę Ascii .. Zwiększ ją .. a następnie przekonwertuj z Ascii na znak ..

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

Sprawdź FIDDLE

Sushanth -
źródło
1
Hmm. Potrzebuje więcej jQuery.
Jasper
4

Musiałem wielokrotnie używać sekwencji liter, więc utworzyłem tę funkcję w oparciu o to pytanie SO. Mam nadzieję, że to pomoże innym.

function charLoop(from, to, callback)
{
    var i = from.charCodeAt(0);
    var to = to.charCodeAt(0);
    for(;i<=to;i++) callback(String.fromCharCode(i));
}
  • od - litera początkowa
  • do - ostatnia litera
  • callback (letter) - funkcja do wykonania dla każdej litery w sekwencji

Jak tego użyć:

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

Zobacz to działające demo

letiagoalves
źródło
3

Dodając wszystkie te odpowiedzi:

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

Przykład: http://jsfiddle.net/pitaj/3F5Qt/

PitaJ
źródło
2

Ten działa dobrze:

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'
NikK
źródło
1

Rozwiązanie tylko dla śmiechu

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

dean schmid
źródło
0

To jest naprawdę stare. Ale potrzebowałem tej funkcjonalności i żadne z rozwiązań nie jest optymalne dla mojego przypadku użycia. Chciałem wygenerować a, b, c ... z, aa, ab ... zz, aaa .... Ta prosta rekurencja spełnia swoje zadanie.

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);
}
};
mrtyormaa
źródło
0

Utwórz funkcję z {a: 'b', b: 'c', etc} w zamknięciu: -

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

stosowanie:-

nextChar('a')

Dodawanie wielkich liter i cyfr: -

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

ps W niektórych wersjach JavaScript możesz użyć [...chars]zamiastchars.split('')

Quentin 2
źródło
0

Oto odmiana algorytmu rot13, który przesłałem na https://stackoverflow.com/a/28490254/881441 :

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

Kod wejściowy na dole i wyszukany kodek znajdują się na górze (tj. Kod wyjściowy jest taki sam jak kod wejściowy, ale przesunięty o 1). Funkcja zmienia tylko litery, tzn. Jeśli zostanie przekazany jakikolwiek inny znak, pozostanie on niezmieniony przez ten kodek.

Stephen Quan
źródło
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;
LokeshKumar
źródło
1
Możesz chcieć wyjaśnić, co dokładnie zrobiłeś tutaj i jak to pomaga, zamiast po prostu mieć blok kodu, dzięki! - Może jakieś pomocne elementy w kodzie?
Mark Davies
String.fromCharCode () zwraca kod znaku litery.
LokeshKumar
0

Na podstawie zwiększania i zmniejszania odpowiedzi @Nathan na ścianie

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

Stosowanie

const ids = new StringIdGenerator();

ids.next(); 
ids.prev();
Gowtham Sooryaraj
źródło