Bunu yapmanın daha iyi bir yolu olmadığından eminim ama sormanın zarar vermeyeceğini düşündüm.

Yazmaktan yoruldum a='abcdefghijklmnopqrstuvwxyz' .

Harika diller var Range('a'..'z') veya benzer

JS ile mümkün olan en kısa sürede ne bulabiliriz?

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

sadece bir alfabeden daha uzundur - ancak bir yere batmamamı garanti ederim.

Ben az 50 karakterden az üretmek için kötü bir bit-Shifty yolu umut ediyorum.

Etrafı karıştırdım i=97;Array(26).map(x=>String.fromChar....i++

fakat katıldığım zamanlar her zaman çok daha uzundu, sonra kullanılabilirliği için diziyi (26) böldüm.

Düzenleme: Ben aşağı aldım

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

60 bayt

String.fromCharCode Alternatif

... sadece küçük harfli bir alfabeden memnunsanız.

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

Not: Bu tekniklerin tümü, değişkene alfabe dizesini atar a.

% 99 eminim ki bunu JavaScript'te başarmanın en kısa yolunun gerçekten:

a="abcdefghijklmnopqrstuvwxyz" // 30 bytes

Ancak başka ilginç yöntemler de var. Dize sıkıştırmasını kullanabilirsiniz:

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

Sıkıştırılmış dize alabilirsiniz atob`abcdefghijklmnopqrstuvwx`. 'yz'Sonuç sadece 27 byte durumdayken, tüm dizeyi sıkıştırmak eğer, bunun nedeni olarak öne dönecek elle eklenmesi gerekir abcdefghijklmnopqrstuvwxyw==.

Programlı olarak yapmanın en kısa yolunun da önerdiğiniz yöntem olduğuna inanıyorum:

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

İsterseniz bunu ES6 özellikleriyle ( şablon dizeleri`` , yayma operatörü... ) yapabilirsiniz:

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

Bir değişken yerine bunun yerine daha iyisini yapabilirsiniz .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='')

Veya başka bir bayt kısa olan dizi kavramalara sahip ES7 :

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

Değişkeni önceden oluşturmak, başka bir bayttan tasarruf sağlar:

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

Ayrıca, String.fromCharCodebirden fazla argüman kabul eder ve otomatik olarak onlara katılır. Böylece her ES6 sürümünü 57 byte'a indirebiliriz:

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

Ve ES7’den 55’e:

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

Golf sahaları hakkında daha fazla bilgi edinmek istiyorsanız, bu ipuçlarını inceleyin . ES7'nin dizi anlamalarıyla ilgili bir tane de var .

EDIT: edc65'in işaret ettiği gibi, bunların çoğu kullanım i.toString(36)yerine kısalır 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

Bunun fonksiyon dönüş değeri olarak adlandırılabilecek en kısa yol olduğuna inanıyorum:

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

Bir işlevden elle döndürmekten üç bayt daha kısadır:

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

Tabii ki, x=>"abcdefghijklmnopqrstuvwxyz"hala her şeyi atar.

İşte başka bir yaklaşım, 51 byte ES6 ifadesi:

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

Tabii ki büyük harf 50 bayt.

Daha önce öğrendiğim bir hile kullanarak 36 byte (bu yazıdan: /codegolf//a/176496/64538 ):

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

window.name varsayılan olarak boş bir dizedir.

Elbette, bu daha uzun bir değişken ismi kullandığı için 38 baytlık çözümden daha az pratiktir.

Global kapsamda neyin tanımlanıp neyin tanımlanmadığını kullanmak

Nesne özelliklerinin dizi eşleştirmesi için 39 bayt a-z

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

Sıralanmamış için 48 bayt Set

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

Bir sıralama için 55 bayt Set

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

Sıralanmış bir dize için 67 bayt

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