Je suis sûr qu'il n'y a pas de meilleure façon de le faire, mais je me suis dit que ça ne pouvait pas faire de mal de demander.

J'en ai assez de taper a='abcdefghijklmnopqrstuvwxyz'.

Les langues cool ont Range('a'..'z')ou similaire

Que pouvons-nous proposer avec JS aussi court que possible ??

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

est plus long que l'alphabet, mais garantit que je ne foirerai pas quelque part.

J'espère qu'il existe un moyen désagréable de produire un az en moins de 50 caractères.

Je déconne avec i=97;Array(26).map(x=>String.fromChar....i++

mais c'était toujours bien plus long au moment où j'ai rejoint puis divisé le tableau (26) pour être utilisable

Edit: je suis descendu à

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

60 octets

Alternative à String.fromCharCode

... si vous êtes satisfait d'un alphabet en minuscules uniquement.

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

Remarque: Toutes ces techniques affectent la chaîne alphabétique à une variable a.

Je suis certain à 99% que le moyen le plus court d'y parvenir en JavaScript est en effet:

a="abcdefghijklmnopqrstuvwxyz" // 30 bytes

Mais il existe plusieurs autres méthodes intéressantes. Vous pouvez utiliser la compression de chaînes:

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

Vous pouvez obtenir la chaîne compressée à partir de atob`abcdefghijklmnopqrstuvwx`. Le 'yz'doit être ajouté manuellement car si vous compressez la chaîne entière, alors que le résultat n'est que de 27 octets, il se transformera en abcdefghijklmnopqrstuvwxyw==.

Je pense que le moyen le plus court de le faire par programme est également la méthode que vous avez suggérée:

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

Vous pouvez le faire avec les fonctionnalités ES6 ( chaînes de modèle`` , opérateur de propagation... ) si vous voulez:

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

Vous pouvez faire mieux avec une variable au lieu 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='')

Ou ES7 avec des compréhensions de tableau , qui est un autre octet plus court:

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

La création de la variable au préalable enregistre encore un autre octet:

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

En outre, String.fromCharCodeaccepte plusieurs arguments et les rejoindront automatiquement. Nous pouvons donc jouer à chaque version ES6 jusqu'à 57 octets:

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

Et l'ES7 jusqu'à 55:

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

Si vous souhaitez en savoir plus sur les parcours de golf, consultez cet ensemble de conseils . Il y a aussi un sur les compréhensions de tableau d'ES7 .

EDIT: Comme l'a souligné edc65, la plupart d'entre eux deviennent plus courts en utilisant i.toString(36)au lieu 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

Je crois que celui-ci est le plus court possible qui puisse être appelé comme valeur de retour de fonction:

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

Il est trois octets plus court que le renvoyer manuellement à partir d'une fonction:

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

Bien sûr, x=>"abcdefghijklmnopqrstuvwxyz"bat toujours tout le reste.

Voici une autre approche, une expression ES6 de 51 octets:

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

50 octets en majuscule bien sûr.

36 octets, en utilisant une astuce que je viens d'apprendre (à partir de ce post: /codegolf//a/176496/64538 ):

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

window.name est une chaîne vide par défaut.

Bien sûr, cela est encore moins pratique que la solution à 38 octets car elle utilise un nom de variable plus long.

Utilisation de ce qui peut ou non être défini à l'échelle mondiale

39 octets pour les propriétés des objets et la correspondance des tableaux a-z

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

48 octets pour un non trié Set

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

55 octets pour un trié Set

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

67 octets pour une chaîne triée

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