Convierta un entero en su equivalente de caracteres, donde 0 => a, 1 => b, etc.

Quiero convertir un entero en su carácter equivalente basado en el alfabeto. Por ejemplo:

0 => a
1 => b
2 => c
3 => d

etc. Podría construir una matriz y simplemente buscarla cuando la necesite, pero me pregunto si hay una función integrada para hacer esto por mí. Todos los ejemplos que he encontrado a través de Google están trabajando con valores ASCII y no con la posición de un personaje en el alfabeto.

Suponiendo que quiere letras minúsculas:

var chr = String.fromCharCode(97 + n); // where n is 0, 1, 2 ...

97 es el código ASCII para minúsculas 'a'. Si desea letras mayúsculas, reemplace 97 con 65 (mayúsculas 'A'). Tenga en cuenta que si n > 25saldrá del rango de letras.

Será más portátil en caso de extenderse a otros alfabetos:

char='abcdefghijklmnopqrstuvwxyz'[code]

o, para ser más compatible (con nuestro querido IE):

char='abcdefghijklmnopqrstuvwxyz'.charAt(code);

Si no le importa recuperar cadenas de caracteres múltiples, puede admitir índices positivos arbitrarios:

function idOf(i) {
    return (i >= 26 ? idOf((i / 26 >> 0) - 1) : '') +  'abcdefghijklmnopqrstuvwxyz'[i % 26 >> 0];
}

idOf(0) // a
idOf(1) // b
idOf(25) // z
idOf(26) // aa
idOf(27) // ab
idOf(701) // zz
idOf(702) // aaa
idOf(703) // aab

(No probado exhaustivamente para errores de precisión :)

Una respuesta simple sería (26 caracteres):

String.fromCharCode(97+n);

Si el espacio es precioso, puede hacer lo siguiente (20 caracteres):

(10+n).toString(36);

¡Piensa en lo que podrías hacer con todos esos bytes adicionales!

Cómo funciona esto es que convierte el número a base 36, por lo que tiene los siguientes caracteres:

0123456789abcdefghijklmnopqrstuvwxyz
^         ^
n        n+10

Al compensar por 10 los caracteres comienzan en alugar de0 .

Sin embargo, no estoy completamente seguro de qué tan rápido se compararían los dos ejemplos diferentes del lado del cliente.

String.fromCharCode (código1, código2, ..., códigoN) de Javascript toma un número infinito de argumentos y devuelve una cadena de letras cuyos valores ASCII correspondientes son código1, código2, ... códigoN. Como 97 es 'a' en ASCII, podemos ajustar su indexación agregando 97 a su índice.

function indexToChar(i) {
  return String.fromCharCode(i+97); //97 in ASCII is 'a', so i=0 returns 'a', 
                                    // i=1 returns 'b', etc
}

No me gustan todas las soluciones que usan números mágicos como 97o 36.

const A = 'A'.charCodeAt(0);

let numberToCharacter = number => String.fromCharCode(A + number);

let characterToNumber = character => character.charCodeAt(0) - A;

esto asume letras mayúsculas y comienza 'A' en 0.

Uso String.fromCharCode. Esto devuelve una cadena de un valor Unicode, que coincide con los primeros 128 caracteres de ASCII.

var a = String.fromCharCode(97);

Ahí tienes: (a-zA-Z)

function codeToChar( number ) {
  if ( number >= 0 && number <= 25 ) // a-z
    number = number + 97;
  else if ( number >= 26 && number <= 51 ) // A-Z
    number = number + (65-26);
  else
    return false; // range error
  return String.fromCharCode( number );
}

input: 0-51, o devolverá falso (error de rango);

O:

var codeToChar = function() {
  var abc = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
  return function( code ) {
    return abc[code];
  };
})();

devuelve indefinido en caso de error de rango. NOTA: la matriz se creará solo una vez y, debido al cierre, estará disponible para la nueva función codeToChar. Supongo que es aún más rápido que el primer método (es solo una búsqueda básicamente).

El único problema con la gran solución de @ mikemaccana es que utiliza el operador binario >> que es costoso, en cuanto a rendimiento. Sugiero esta modificación a su gran trabajo como una ligera mejora que sus colegas quizás puedan leer más fácilmente.

const getColumnName = (i) => {
     const previousLetters = (i >= 26 ? getColumnName(Math.floor(i / 26) -1 ) : '');
     const lastLetter = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[i % 26]; 
     return previousLetters + lastLetter;
}

O como una sola línea

const getColumnName = i => (i >= 26 ? getColumnName(Math.floor(i / 26) -1 ) : '') + 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[i % 26];

Ejemplo:

getColumnName(0); // "A"
getColumnName(1); // "B"
getColumnName(25); // "Z"
getColumnName(26); // "AA"
getColumnName(27); // "AB"
getColumnName(80085) // "DNLF"

Tratar

(n+10).toString(36)

chr = n=>(n+10).toString(36);

for(i=0; i<26; i++) console.log(`${i} => ${ chr(i) }`);

Suponiendo que quiere letras mayúsculas:

function numberToLetter(num){
        var alf={
            '0': 'A', '1': 'B', '2': 'C', '3': 'D', '4': 'E', '5': 'F', '6': 'G'
        };
        if(num.length== 1) return alf[num] || ' ';
        return num.split('').map(numberToLetter);
    }

Ejemplo:

numberToLetter ('023') es ["A", "C", "D"]

numberToLetter ('5') es "F"