Sono abbastanza sicuro che non ci sia un modo migliore per farlo, ma ho pensato che non poteva far male chiedere.

Sono stanco di scrivere a macchina a='abcdefghijklmnopqrstuvwxyz'.

Lingue fantastiche hanno Range('a'..'z')o simili

Cosa possiamo inventare con JS che è il più corto possibile ??

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

è più lungo dell'alfabeto, ma garantisce che non sbaglio da qualche parte.

Spero che ci sia un modo brutto per creare az in meno di 50 caratteri.

Ho fatto un casino i=97;Array(26).map(x=>String.fromChar....i++

ma quando mi sono unito è sempre stato molto più lungo, quindi dividere l'array (26) per essere utilizzabile

Modifica: ho capito

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

60 byte

Alternativa a String.fromCharCode

... se sei soddisfatto di un solo alfabeto minuscolo.

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

Nota: tutte queste tecniche assegnano la stringa alfabetica alla variabile a.

Sono sicuro al 99% che il modo più breve per raggiungere questo obiettivo in JavaScript è effettivamente:

a="abcdefghijklmnopqrstuvwxyz" // 30 bytes

Ma ci sono molti altri metodi interessanti. Puoi usare la compressione delle stringhe:

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

È possibile ottenere la stringa compressa da atob`abcdefghijklmnopqrstuvwx`. La 'yz'deve aggiungere manualmente perché se si comprime l'intera stringa, mentre il risultato è solo 27 byte, si rivelerà come abcdefghijklmnopqrstuvwxyw==.

Credo che il modo più breve per farlo a livello di codice sia anche il metodo che hai suggerito:

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

Puoi farlo con le funzionalità ES6 ( stringhe di modelli`` , operatore di diffusione... ) se vuoi:

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

Puoi fare di meglio con una variabile anziché .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='')

O ES7 con comprensione dell'array , che è un altro byte più breve:

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

La creazione anticipata della variabile salva un altro byte:

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

Inoltre, String.fromCharCodeaccetta più argomenti e li unirà automaticamente. Quindi possiamo golf ogni versione ES6 fino a 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))

E quello ES7 fino a 55:

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

Se vuoi saperne di più sui campi da golf, dai un'occhiata a questo set di suggerimenti . Ce n'è anche uno sulle comprensioni dell'array di ES7 .

EDIT: come ha sottolineato edc65, la maggior parte di questi si accorciano usando i.toString(36)invece di 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

Credo che questo sia il più breve possibile che può essere chiamato come valore di ritorno di una funzione:

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

È tre byte più breve rispetto alla restituzione manuale da una funzione:

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

Certo, x=>"abcdefghijklmnopqrstuvwxyz"batte ancora tutto il resto.

Ecco un altro approccio, un'espressione ES6 a 51 byte:

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

50 byte ovviamente in maiuscolo.

36 byte, usando un trucco di cui ho appena appreso (da questo post: /codegolf//a/176496/64538 ):

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

window.name è una stringa vuota per impostazione predefinita.

Naturalmente, questo è ancora meno pratico della soluzione a 38 byte poiché utilizza un nome di variabile più lungo.

Utilizzando ciò che può o non può essere definito nell'ambito globale

39 byte per le proprietà degli oggetti per la corrispondenza dell'array a-z

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

48 byte per un non ordinato Set

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

55 byte per un ordinato Set

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

67 byte per una stringa ordinata

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