Saya cukup yakin tidak ada cara yang lebih baik untuk melakukan ini tetapi saya pikir tidak ada salahnya untuk bertanya.

Saya lelah mengetik a='abcdefghijklmnopqrstuvwxyz' .

Bahasa keren miliki Range('a'..'z') atau serupa

Apa yang bisa kita dapatkan dengan JS yang sesingkat mungkin ??

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

lebih panjang dari sekedar alfabet - tetapi menjamin saya tidak mengacau di suatu tempat.

Saya berharap ada cara yang agak licik untuk menghasilkan az dalam kurang dari 50 karakter.

Saya mengacau i=97;Array(26).map(x=>String.fromChar....i++

tapi itu selalu jauh lebih lama pada saat saya bergabung kemudian membagi array (26) agar bisa digunakan

Sunting: Saya sudah turun ke

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

60 byte

Alternatif untuk String.fromCharCode

... jika Anda senang dengan huruf kecil saja.

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

Catatan: Semua teknik ini menetapkan string alfabet ke variabel a.

Saya yakin 99% bahwa cara terpendek untuk mencapai ini dalam JavaScript adalah:

a="abcdefghijklmnopqrstuvwxyz" // 30 bytes

Tetapi ada beberapa metode menarik lainnya. Anda dapat menggunakan kompresi string:

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

Anda bisa mendapatkan string terkompresi dari atob`abcdefghijklmnopqrstuvwx`. The 'yz'harus ditambahkan secara manual karena jika Anda kompres seluruh string, sedangkan hasilnya adalah hanya 27 byte, itu akan berubah sebagai abcdefghijklmnopqrstuvwxyw==.

Saya percaya cara terpendek untuk melakukannya secara terprogram juga metode yang Anda sarankan:

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

Anda dapat melakukannya dengan fitur ES6 ( string template`` , spread operator... ) jika Anda ingin:

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

Anda bisa melakukan yang lebih baik dengan variabel alih-alih .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='')

Atau ES7 dengan pemahaman array , yang merupakan byte lain yang lebih pendek:

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

Membuat variabel sebelumnya menyimpan byte lain:

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

Juga, String.fromCharCodemenerima beberapa argumen dan secara otomatis akan bergabung dengannya. Jadi kita bisa melakukan golf setiap versi ES6 hingga 57 byte:

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

Dan ES7 satu ke 55:

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

Jika Anda ingin mempelajari lebih lanjut tentang rentang golf, lihat serangkaian kiat ini . Ada juga satu tentang pemahaman array ES7 .

EDIT: Seperti yang ditunjukkan oleh edc65, sebagian besar ini menjadi lebih pendek i.toString(36)daripada menggunakan 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

Saya percaya ini adalah yang sesingkat mungkin yang dapat disebut sebagai nilai fungsi pengembalian:

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

Ini tiga byte lebih pendek daripada secara manual mengembalikannya dari suatu fungsi:

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

Tentu saja, x=>"abcdefghijklmnopqrstuvwxyz"masih mengalahkan yang lainnya.

Berikut pendekatan lain, ekspresi ES6 51 byte:

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

50 byte dalam huruf besar tentu saja.

36 byte, menggunakan trik yang baru saya pelajari (dari posting ini: /codegolf//a/176496/64538 ):

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

window.name adalah string kosong secara default.

Tentu saja, ini bahkan kurang praktis daripada solusi 38-byte karena menggunakan nama variabel yang lebih panjang.

Menggunakan apa yang mungkin atau tidak dapat didefinisikan pada lingkup global

39 byte untuk properti objek ke pencocokan array a-z

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

48 byte untuk yang tidak disortir Set

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

55 byte untuk diurutkan Set

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

67 byte untuk string yang diurutkan

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