Я почти уверен, что нет лучшего способа сделать это, но подумал, что не мешало бы спросить.

Я устал печатать a='abcdefghijklmnopqrstuvwxyz'.

Крутые языки имеют Range('a'..'z')или похожие

Что мы можем придумать с JS, который как можно короче ??

for(i=97,a='';i<123;){a+=String.fromCharCode(i++)}

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

Я надеюсь, что есть отвратительный, немного изменчивый способ создания азбуки длиной менее 50 символов.

Я возился с i=97;Array(26).map(x=>String.fromChar....i++

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

Редактировать: я получил это до

[...Array(26)].reduce(a=>a+String.fromCharCode(i++),'',i=97)

60 байт

Альтернатива String.fromCharCode

... если вас устраивает только строчный алфавит.

for(i=9,a='';++i<36;)a+=i.toString(36) // 38, cannot be used in an expression
[...Array(26)].map(_=>(++i).toString(36),i=9).join`` // 52 directly returnig the string desired
[...Array(26)].map(_=>a+=(++i).toString(36),a='',i=9) // 53 assign to a variable
(i=9,[for(_ of Array(26))(++i).toString(36)].join``) // 52 ES7 direct return
i=9,a='',[for(_ of Array(26))a+=(++i).toString(36)] // 51 ES7 assign to a variable

Примечание. Все эти методы назначают строку алфавита переменной a.

Я на 99% уверен, что самый короткий способ достичь этого в JavaScript действительно:

a="abcdefghijklmnopqrstuvwxyz" // 30 bytes

Но есть несколько других интересных методов. Вы можете использовать сжатие строк:

a=btoa`i·?yø!?9%?z)ª»-ºü1`+'yz' // 31 bytes; each ? represents an unprintable

Вы можете получить сжатую строку из atob`abcdefghijklmnopqrstuvwx`. 'yz'Должны быть добавлены вручную , потому что если сжать всю строку, а результат всего 27 байт, то получится , как abcdefghijklmnopqrstuvwxyw==.

Я считаю, что самый короткий способ сделать это программно - это также метод, который вы предложили:

for(i=97,a='';i<123;)a+=String.fromCharCode(i++) // 48 bytes

Вы можете сделать это с помощью функций ES6 ( строки шаблона`` , оператор распространения... ), если хотите:

a=[...Array(26)].map(_=>String.fromCharCode(i++),i=97).join`` // 61 bytes
a=[...Array(26)].map((_,i)=>String.fromCharCode(i+97)).join`` // also 61 bytes
a=[...Array(i=26)].map(_=>String.fromCharCode(++i+70)).join`` // again, 61 bytes

Вы можете сделать лучше с переменной вместо .join``:

[...Array(26)].map(_=>a+=String.fromCharCode(i++),i=97,a='') // all 60 bytes
[...Array(26)].map((_,i)=>a+=String.fromCharCode(i+97),a='')
[...Array(i=26)].map(_=>a+=String.fromCharCode(++i+70),a='')

Или ES7 с массивами , что на другой байт короче:

a=[for(_ of Array(i=26))String.fromCharCode(++i+70)].join`` // 59 bytes

Предварительное создание переменной сохраняет еще один байт:

a='',[for(_ of Array(i=26))a+=String.fromCharCode(++i+70)] // 58 bytes

Кроме того, String.fromCharCodeпринимает несколько аргументов и автоматически присоединится к ним. Таким образом, мы можем сыграть в гольф каждую версию ES6 до 57 байт:

a=String.fromCharCode(...[...Array(26)].map(_=>i++,i=97)) // all 57 bytes
a=String.fromCharCode(...[...Array(26)].map((_,i)=>i+97))
a=String.fromCharCode(...[...Array(i=26)].map(_=>++i+70))

И ES7 один до 55:

a=String.fromCharCode(...[for(_ of Array(i=26))++i+70]) // 55 bytes

Если вы хотите узнать больше о полях для гольфа, ознакомьтесь с этим набором советов . Есть также один из понимания массивов ES7 .

РЕДАКТИРОВАТЬ: Как указало edc65, большинство из них становятся короче, используя i.toString(36)вместо String.fromCharCode(i):

for(i=9,a='';++i<36;)a+=i.toString(36) // 38 bytes
a=[...Array(26)].map(_=>(++i).toString(36),i=9).join`` // 54 bytes
[...Array(26)].map(_=>a+=(++i).toString(36),i=9,a='') // 53 bytes
i=9,a=[for(_ of Array(26))(++i).toString(36)].join`` // 52 bytes
i=9,a='',[for(_ of Array(26))a+=(++i).toString(36)] // 51 bytes

Я считаю, что это самое короткое из возможных значений, которое можно вызвать как возвращаемое значение функции:

eval("for(i=9,a='';++i<36;)a+=i.toString(36)") // 46 bytes

Это на три байта короче, чем возвращение вручную из функции:

x=>eval("for(i=9,a='';++i<36;)a+=i.toString(36)") // 49 bytes
x=>{for(i=9,a='';++i<36;)a+=i.toString(36);return a} // 52 bytes

Конечно, x=>"abcdefghijklmnopqrstuvwxyz"все еще бьет все остальное.

Вот еще один подход, 51-байтовое выражение ES6:

String.fromCharCode(...Array(123).keys()).slice(97)

50 байтов в верхнем регистре, конечно.

36 байт, используя трюк, о котором я только что узнал (из этого поста: /codegolf//a/176496/64538 ):

for(i=9;++i<36;)name+=i.toString(36)

window.name пустая строка по умолчанию.

Конечно, это даже менее практично, чем 38-байтовое решение, поскольку оно использует более длинное имя переменной.

Использование того, что может или не может быть определено в глобальном масштабе

39 байтов для свойств объекта для сопоставления массива a-z

a=`${Object.keys(top)}`.match(/[a-z]/g)

48 байтов для несортированного Set

a=new Set(`${Object.keys(top)}`.match(/[a-z]/g))

55 байт для отсортированного Set

a=new Set(`${Object.keys(top)}`.match(/[a-z]/g).sort())

67 байт для отсортированной строки

a=[...new Set(`${Object.keys(top)}`.match(/[a-z]/g).sort())].join``