可用于递增字母的方法是什么？

98

是否有人知道提供增量字母的方法的Javascript库（例如，下划线，jQuery，MooTools等）？

我希望能够执行以下操作：

"a"++; // would return "b"
javascript  increment  alphabetical 
— Andyzinsser
source
我不确定您要查找的语法是否可行，但是可以通过方法进行操作。
— anson 2012年
有什么用途？
— valentinas 2012年

Answers:

177

简单直接的解决方案

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

正如其他人指出的那样，缺点是它可能无法按预期处理字母“ z”之类的情况。但这取决于您想要什么。上面的解决方案将为'z'之后的字符返回'{'，这是ASCII中'z'之后的字符，因此这可能是您要寻找的结果，具体取决于您的用例。

唯一的字符串生成器

（更新2019/05/09）

由于此答案获得了广泛的关注，因此我决定将其扩展到超出原始问题的范围，以潜在地帮助那些在Google上绊脚石的人们。

我发现我经常想要的是可以在某个字符集（例如仅使用字母）中生成顺序的，唯一的字符串的东西，因此我更新了此答案，以包括一个可以在此处执行此操作的类：

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

用法：

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'
— 内森·沃尔
source
简单的解决方案，但不处理“ z”或“ Z”的出现。
— 特伦特
3
一种嗡嗡声，它会变成特殊字符，例如/
— Daniel Thompson
正是我在尝试通过将不显示的unicode字符选择为老式的IBM Code Page 437字体时所需要的。您实际上只是为我节省了几个小时的字符输入时间。
— LeftOnTheMoon
1
Daniel Thompson此解决方案提供了足够多的信息，您可以自己处理极端情况。毕竟，这是一个“互相帮助”的网站，而不是免费网站。
— Bojidar Stanchev
花了我一段时间来弄清楚如何使起始字符成为参数。我最终使用._nextId = [chars.split（''）。findIndex（x => x == start）]; 或启动+ 1，如果你希望它开始比你通过什么1以上。
— JohnDavid
49

普通的javascript应该可以解决问题：

String.fromCharCode('A'.charCodeAt() + 1) // Returns B
— 扎尔
source
1
纯净的魅力，关于避免空格和特殊字符的任何建议。coderByte对此有疑问
— sg28 '18
22

如果给定字母是z怎么办？这是一个更好的解决方案。它的行号为A，B，C ... X，Y，Z，AA，AB等。基本上，它会递增字母，如Excel电子表格的列ID。

nextChar（'yz'）; //返回“ 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>
展开摘要

— 罗尼·罗斯顿
source
更改if (same(u,'Z')){为if (u == 'Z'){，并且效果很好，谢谢！
— 肖恩·肯德尔
很高兴它的工作，并感谢您的反馈。可能是最初的错误存在same(str,char)于此吗？bcs标题函数没有粘贴在那里？我不知道。
— 罗尼·罗斯顿
一定要这样，same()显然是自定义功能。哦，==行得通，而且，如果我想超级确定，我可以使用===，但是我已经对其进行了测试，这很好。再次感谢！
— 肖恩·肯德尔
如果您输入zz，您将得到三元组A，这是代码中的错误吗？
— 阿姆·阿什拉夫
1
我不这么认为吗？zz之后会发生什么？aaa对吗？我没有在这台机器上安装excel（要仔细检查），但听起来对我来说是正确的。
— 罗尼·罗伊斯顿
5

一种可能的方式如下所示

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）
source
4

你可以试试这个 

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

首先将其转换为Ascii数字..递增它..然后从Ascii转换为char ..

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

检查FIDDLE

— 苏珊斯-
source
1
嗯 需要更多的jQuery。
— 贾斯珀
4

我需要多次使用字母序列，因此我根据这个SO问题进行了此功能。我希望这可以帮助其他人。

function charLoop(from, to, callback)
{
    var i = from.charCodeAt(0);
    var to = to.charCodeAt(0);
    for(;i<=to;i++) callback(String.fromCharCode(i));
}
  • 从-起始字母
  • 到-最后一封信
  • callback（letter）-为序列中的每个字母执行的函数

如何使用它：

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

观看此工作演示

— 刺槐
source
3

加上所有这些答案：

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

示例：http：//jsfiddle.net/pitaj/3F5Qt/

— 皮塔
source
2

这个很好用：

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'
— 尼克
source
1

一个只为笑的解决方案 

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"));
展开摘要

— 迪安·施密德
source
0

这真的很旧。但是我需要此功能，而且所有解决方案都不适合我的用例。我想生成a，b，c ... z，aa，ab ... zz，aaa...。这个简单的递归就可以了。

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);
}
};
— 莫尔蒂玛
source
0

在闭包中使用{a：'b'，b：'c'等等}创建函数：

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

用法：-

nextChar('a')

添加大写和数字：-

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

ps在某些版本的Javascript中，您可以使用[...chars]代替chars.split('')

— 昆汀2
source
— 昆廷- 2
0

这是我在https://stackoverflow.com/a/28490254/881441上提交的rot13算法的一种变体：

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

输入代码位于底部，查找的编解码器位于顶部（即，输出代码与输入代码相同，但移位了1）。该函数仅更改字母，即，如果传入任何其他字符，则此编解码器将保持不变。

— 泉泉
source
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）
source
1
您可能想解释一下您在这里所做的确切工作以及它如何提供帮助，而不是仅仅提供一些代码，谢谢！-也许代码中有帮助吗？
— Mark Davies
String.fromCharCode（）返回字母的字符代码。
— LokeshKumar
0

基于@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;
  }
    
}

用法

const ids = new StringIdGenerator();

ids.next(); 
ids.prev();
— 哥谭·索亚拉拉吉
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.