Estoy bastante seguro de que no hay una mejor manera de hacer esto, pero pensé que no podía hacer daño preguntar.

Estoy cansado de escribir a='abcdefghijklmnopqrstuvwxyz'.

Los idiomas geniales tienen Range('a'..'z')o similares

¿Qué se nos ocurre con JS que sea lo más corto posible?

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

es más largo que el alfabeto, pero garantiza que no me equivoque en ningún lado.

Espero que haya una manera desagradable de producir az en menos de 50 caracteres.

Me metí con i=97;Array(26).map(x=>String.fromChar....i++

pero siempre fue mucho más largo para cuando me uní y luego dividí la matriz (26) para poder usarla

Editar: lo he reducido a

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

60 bytes

Alternativa a String.fromCharCode

... si está satisfecho con un alfabeto en minúsculas solamente.

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: Todas estas técnicas asignan la cadena del alfabeto a la variable a.

Estoy 99% seguro de que la forma más corta de lograr esto en JavaScript es:

a="abcdefghijklmnopqrstuvwxyz" // 30 bytes

Pero hay varios otros métodos interesantes. Puede usar la compresión de cadena:

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

Puede obtener la cadena comprimida de atob`abcdefghijklmnopqrstuvwx`. La 'yz'hay que añadir manualmente porque si comprime toda la cadena, mientras que el resultado es sólo 27 bytes, que va a salir como abcdefghijklmnopqrstuvwxyw==.

Creo que la forma más corta de hacerlo mediante programación es también el método que sugirió:

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

Puede hacerlo con las funciones de ES6 ( cadenas de plantillas`` , operador de propagación... ) si desea:

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

Puede hacerlo mejor con una variable en lugar de .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 comprensiones de matriz , que es otro byte más corto:

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

Crear la variable de antemano guarda otro byte:

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

Además, String.fromCharCodeacepta múltiples argumentos y los unirá automáticamente. Entonces podemos jugar golf cada versión de ES6 hasta 57 bytes:

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

Y el ES7 uno hasta 55:

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

Si desea obtener más información sobre los campos de golf, consulte este conjunto de consejos . También hay uno sobre las comprensiones de matriz de ES7 .

EDITAR: como ha señalado edc65, la mayoría de estos se acortan usando en i.toString(36)lugar de 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

Creo que este es el más corto posible que se puede llamar como un valor de retorno de función:

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

Es tres bytes más corto que devolverlo manualmente desde una función:

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

Por supuesto, x=>"abcdefghijklmnopqrstuvwxyz"aún supera todo lo demás.

Aquí hay otro enfoque, una expresión ES6 de 51 bytes:

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

50 bytes en mayúscula, por supuesto.

36 bytes, usando un truco que acabo de aprender (de esta publicación: /codegolf//a/176496/64538 ):

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

window.name es una cadena vacía por defecto.

Por supuesto, esto es incluso menos práctico que la solución de 38 bytes, ya que utiliza un nombre de variable más largo.

Usar lo que puede o no definirse a nivel global

39 bytes para las propiedades del objeto para la coincidencia de matrices a-z

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

48 bytes para un sin clasificar Set

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

55 bytes para un ordenado Set

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

67 bytes para una cadena ordenada

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