एक विधि क्या है जिसका उपयोग अक्षरों को बढ़ाने के लिए किया जा सकता है?

Question

क्या कोई जावास्क्रिप्ट लाइब्रेरी (जैसे अंडरस्कोर, jQuery, MooTools, आदि) के बारे में जानता है जो एक पत्र को बढ़ाने का एक तरीका प्रदान करता है?

मैं ऐसा कुछ करने में सक्षम होना चाहता हूं:

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

Comments

मुझे यकीन नहीं है कि आप जिस वाक्यविन्यास की तलाश कर रहे हैं वह संभव है, लेकिन विधियों के माध्यम से ऑपरेशन संभव है।

— anson

आवेदन क्या है?

— वैलेंटाइनस

Answer 1

सरल, प्रत्यक्ष समाधान

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'

Comments

सरल समाधान, लेकिन 'z' या 'Z' की घटना को नहीं संभालता है।

— ट्रेंट

इस तरह के बज़किल की तरह यह विशेष पात्रों में जाएगा जैसे /

— डैनियल थॉम्पसन

बिल्कुल वैसा ही जैसा मैं देख रहा था कि मैं एक पुराने स्कूल के आईबीएम कोड पेज 437 फॉन्ट में नॉन-डिस्प्लेिंग यूनिकोड कैरेक्टर्स को देख रहा था। तुम सचमुच चरित्र टाइपिंग के घंटे मुझे बचा लिया।

— LeftOnTheMoon

डैनियल थॉम्पसन यह समाधान पर्याप्त जानकारी प्रदान करता है, आप स्वयं कोनों के मामलों को संभाल सकते हैं। आखिरकार, यह एक "मदद-प्रत्येक-अन्य" वेबसाइट है, मुफ्त वेबसाइट के लिए मेरा काम नहीं है।

— बोजिदर स्टेंचव

आरंभिक चरित्र को एक तर्क बनाने के तरीके का पता लगाने के लिए मुझे कुछ समय लगा। मैंने उपयोग किया ।_nextId = [chars.split ('')। findIndex (x => x == start)]; या + 1 शुरू करें यदि आप चाहते हैं कि आप जो भी पास करते हैं उससे 1 अधिक शुरू करें।

— जॉनडविड

Answer 2

सादे जावास्क्रिप्ट को चाल करना चाहिए:

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

Comments

शुद्ध आकर्षण, सफेद रिक्त स्थान और विशेष पात्रों से बचने पर कोई सुझाव। coderByte का इस पर एक प्रश्न है

— sg28

Answer 3

क्या होगा यदि दिया गया अक्षर z है? यहाँ एक बेहतर समाधान है। यह ए, बी, सी ... एक्स, वाई, जेड, एए, एबी, ... आदि जाता है। मूल रूप से यह एक एक्सेल स्प्रेडशीट के कॉलम आईडी की तरह अक्षर बढ़ाता है।

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>

Comments

बदल गया if (same(u,'Z')){है if (u == 'Z'){और यह पूरी तरह से काम करता है, धन्यवाद!

— सीन केंडल

खुशी है कि यह काम किया और प्रतिक्रिया के लिए धन्यवाद। हो सकता है कि प्रारंभिक त्रुटि वहाँ bcs समारोह शीर्षक same(str,char)था वहाँ में चिपकाया नहीं गया था? मुझे नही पता।

— रॉनी रोयस्टोन

मामला होना चाहिए, same()स्पष्ट रूप से एक कस्टम फ़ंक्शन है। ओह ठीक है, ==काम करता है, और अगर मैं सुपर सुनिश्चित होना चाहता था, तो मैं उपयोग कर सकता था ===, लेकिन मैंने इसका परीक्षण किया है, और यह ठीक है। एक बार फिर धन्यवाद!

— शॉन केंडल

अगर आप zz टाइप करते हैं तो आपको ट्रिपल ए मिलेगा यह कोड में एक बग है ??

— अमर अशरफ

मुझे ऐसा नहीं लगता? zz के बाद क्या आता है? आआ सही? मेरे पास इस मशीन पर (डबल चेक करने के लिए) एक्सेल स्थापित नहीं है, लेकिन यह मेरे लिए सही लगता है।

— रॉनी रोयस्टन

Answer 4

एक संभावित तरीका नीचे परिभाषित किया जा सकता है

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 ...

Answer 5

आप यह कोशिश कर सकते हैं

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 की जाँच करें

Comments

हम्म। अधिक jQuery की जरूरत है।

— जैस्पर

Answer 6

मुझे कई बार अक्षरों के अनुक्रमों का उपयोग करने की आवश्यकता थी और इसलिए मैंने इस SO प्रश्न के आधार पर यह फ़ंक्शन बनाया। मुझे उम्मीद है कि यह दूसरों की मदद कर सकता है।

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

• से - पत्र शुरू करें
• से - अंतिम अक्षर
• कॉलबैक (अक्षर) - अनुक्रम में प्रत्येक अक्षर के लिए निष्पादित करने के लिए फ़ंक्शन

इसे कैसे उपयोग करे:

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

इस कार्यशील डेमो को देखें

Answer 7

इन सभी उत्तरों को जोड़ना:

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

Answer 8

यह अच्छी तरह से काम करता है:

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'

Answer 9

हंसी के समाधान के लिए बस

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

Answer 10

यह वास्तव में पुराना है। लेकिन मुझे इस कार्यक्षमता की आवश्यकता थी और मेरे उपयोग के मामले में कोई भी समाधान इष्टतम नहीं है। मैं 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);
}
};

Answer 11

एक बंद में {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 जावास्क्रिप्ट के कुछ संस्करणों में, आप [...chars]इसके बजाय उपयोग कर सकते हैंchars.split('')

Comments

nb stackoverflow.com/questions/10758913/…

— क्वेंटिन 2

Answer 12

यहाँ मैं https://stackoverflow.com/a/28490254/881441 पर सबमिट किए गए रोट 13 अल्गोरिथम की भिन्नता है :

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

नीचे में इनपुट कोड और देखा हुआ कोडक शीर्ष पर है (यानी आउटपुट कोड इनपुट कोड के समान है लेकिन 1 से स्थानांतरित कर दिया गया है)। फ़ंक्शन केवल अक्षरों को बदलता है, अर्थात यदि कोई अन्य वर्ण पास किया जाता है, तो यह इस कोडेक द्वारा अपरिवर्तित होगा।

Answer 13

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;

Comments

आप यह समझाना चाहते हैं कि आपने वास्तव में यहाँ क्या किया है और यह कोड के ब्लॉक होने के बजाय कैसे मदद करता है, धन्यवाद! - शायद कोड में कुछ सहायक cmoments?

— मार्क डेविस

String.fromCharCode () यह पत्र का चार कोड लौटाता है।

— लोकेशकुमार

Answer 14

@ नातान दीवार उत्तर वेतन वृद्धि और गिरावट के आधार पर

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