Вы можете легко создать функцию, которая сделает это за вас, если вам это очень нужно.

function genCharArray(charA, charZ) {
    var a = [], i = charA.charCodeAt(0), j = charZ.charCodeAt(0);
    for (; i <= j; ++i) {
        a.push(String.fromCharCode(i));
    }
    return a;
}
console.log(genCharArray('a', 'z')); // ["a", ..., "z"]

Лично я считаю лучшим:

alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');

Кратко, эффективно, разборчиво и просто!

РЕДАКТИРОВАТЬ: я решил, что, поскольку мой ответ получает достаточно внимания, добавить функциональность для выбора определенных диапазонов букв.

function to_a(c1 = 'a', c2 = 'z') {
    a = 'abcdefghijklmnopqrstuvwxyz'.split('');
    return (a.slice(a.indexOf(c1), a.indexOf(c2) + 1)); 
}

console.log(to_a('b', 'h'));

Краткая версия ES6:

const alphabet = [...'abcdefghijklmnopqrstuvwxyz'];
console.log(alphabet);

new Array( 26 ).fill( 1 ).map( ( _, i ) => String.fromCharCode( 65 + i ) );

Используйте 97 вместо 65, чтобы получить строчные буквы.

Если кто-то пришел сюда в поисках чего-то, что можно жестко закодировать, вот вам:

["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"]

Используя оператор распространения ES6, вы можете сделать что-то вроде этого:

let alphabet = [...Array(26).keys()].map(i => String.fromCharCode(i + 97));

Я видел ответ, который мне понравился выше, который был жестко закодированным списком английских алфавитов, но он был только в нижнем регистре, и мне тоже нужен был верхний регистр, поэтому я решил изменить его на случай, если он понадобится кому-то еще:

const lowerAlph = ["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 upperCaseAlp = ["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"];

Многие из этих ответов либо используют массив символов, либо String.fromCharCode, я предлагаю немного другой метод, который использует буквы в base36:

[...Array(26)].map((e,i)=>(i+10).toString(36))

Преимуществом этого является чисто кодовый гольф, он использует меньше символов, чем другие.

в случае, если вам нужен жестко закодированный array алфавита, но с меньшим набором текста. альтернативное решение того, что упомянуто выше.

var arr = "abcdefghijklmnopqrstuvwxyz".split("");

выведет такой массив

/* ["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"] */

Пытаться

[...Array(26)].map((x,i)=>String.fromCharCode(i + 97))

let alphabet = [...Array(26)].map((x,i)=>String.fromCharCode(i + 97));

console.log(alphabet);

Обновлять

Как вы заметили в комментариях, эта идея уже использовалась в этом ответе (я пропустил это) - но этот ответ короче, так что относитесь это как улучшение размера этого старого ответа

Магия

[...8337503854730415241050377135811259267835n.toString(36)]

// chrome & firefox
let a1 = [...8337503854730415241050377135811259267835n.toString(36)];

console.log(a1);


// version working on all browsers (without using BigInt)
let a2 = [...[37713647386641440,2196679683172530,53605115].map(x=>x.toString(36)).join``];  

console.log(a2);

Чтобы добавить в решение @Sherwin Ablaña Dapito (мне нравятся подсказки в ответах)

• 65 — начало верхнего алфавита, 26 — количество символов в алфавите.
• Метод fill() изменяет все элементы массива на статическое значение (1) на месте.
• map() применяется к каждому элементу, создает новый массив и имеет функцию в качестве аргумента.
• =› выражение стрелочной функции, может быть записано как function (i){ return i+ 65;}
• _ на карте: игнорировать параметр (значение-заполнитель, здесь нет значения) и использовать second = index
• String.fromcharcode говорит само за себя

new Array( 26 ).fill( 1 ).map( ( _, i ) => String.fromCharCode( 65 + i ) );

Вот быстрый однострочный

Никаких зависимостей!

Array.from(Array(26)).map((e, i) => i + 65).map((x) => String.fromCharCode(x));

console.log(Array.from(Array(26)).map((e, i) => i + 65).map((x) => String.fromCharCode(x)));

Использование синтаксиса JavaScript Array.from позволяет создать массив и выполнить функцию отображения для каждого из элементов массива. Создайте новый массив длиной 26 и для каждого элемента установите значение, равное строке, полученной из символьного кода индекса текущего элемента плюс магическое число ascii.

const alphabet = Array.from(Array(26), (e, i) => String.fromCharCode(i + 97));

Опять же, 97 можно поменять местами с 65 для прописного алфавита.

Массив также может быть инициализирован значениями с использованием метода ключей объекта, а не с использованием индекса карты.

const alphabet = Array.from(Array(26).keys(), i => String.fromCharCode(i + 97));

const ALPHA = Array.from({ length: 26 }, (_, i) => String.fromCharCode('a'.charCodeAt(0) + i)); // ['a', 'b', ...'z']

Я считаю, что приведенный выше код более идиоматичен. Достаточно короткий, чтобы быть встроенным кодом. Вам не нужно запоминать charCode вашей начальной буквы и настраиваться для извлечения подмножеств алфавита, просто контролируя длину и начальную букву, например

Array.from({ length: 3 }, (_, i) => String.fromCharCode('x'.charCodeAt(0) + i)) // ['x', 'y', 'z]

Создать список символов с помощью одной строки

const charList = (a,z,d=1)=>(a=a.charCodeAt(),z=z.charCodeAt(),[...Array(Math.floor((z-a)/d)+1)].map((_,i)=>String.fromCharCode(a+i*d)));

console.log("from A to G", charList('A', 'G'));
console.log("from A to Z with step/delta of 2", charList('A', 'Z', 2));
console.log("reverse order from Z to P", charList('Z', 'P', -1));
console.log("from 0 to 5", charList('0', '5', 1));
console.log("from 9 to 5", charList('9', '5', -1));
console.log("from 0 to 8 with step 2", charList('0', '8', 2));
console.log("from α to ω", charList('α', 'ω'));
console.log("Hindi characters from क to ह", charList('क', 'ह'));
console.log("Russian characters from А to Я", charList('А', 'Я'));

const charList = (p: string, q: string, d = 1) => {
  const a = p.charCodeAt(0),
    z = q.charCodeAt(0);
  return [...Array(Math.floor((z - a) / d) + 1)].map((_, i) =>
    String.fromCharCode(a + i * d)
  );
};

Просто для удовольствия, вы можете определить геттер для прототипа массива:

Object.defineProperty(Array.prototype, 'to_a', {
  get: function () {
    const start = this[0].charCodeAt(0);
    const end = this[1].charCodeAt(0);
    return Array.from(Array(end - start + 1).keys()).map(n => String.fromCharCode(start + n));
  }
});

Что позволяет сделать что-то вроде:

['a', 'z'].to_a; // [ "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", ..., "z" ]

Попробуй это

let name = ''

for(let i=0; i<26; i++){
  name+=(i+10).toString(36)
}

console.log(name.split(''))

Ни Javascript, ни Jquery ничего подобного не предоставляют. Вы должны создать свой собственный массив.

Вы можете попробовать так:

var alpha = ["a","b","c",....];

или лучше попробуй так:

var index = 97;
$("#parent .number").each(function(i) {
    $(this).html(String.fromCharCode(index++));
});

ДЕМО