Ich bin mir ziemlich sicher, dass es keinen besseren Weg gibt, aber ich dachte, es könnte nicht schaden, danach zu fragen.

Ich bin es leid zu tippen a='abcdefghijklmnopqrstuvwxyz'.

Coole Sprachen haben Range('a'..'z')oder ähnliches

Was können wir mit JS anfangen, das so kurz wie möglich ist?

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

ist länger als nur das Alphabet - aber garantiert vermassle ich es nicht irgendwo.

Ich hoffe, es gibt eine unangenehme Art, Az in weniger als 50 Zeichen zu erzeugen.

Ich habe rumgespielt i=97;Array(26).map(x=>String.fromChar....i++

Aber es dauerte immer viel länger, bis ich mich anschloss und das Array (26) aufteilte, um nutzbar zu sein

Edit: Ich habe es geschafft

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

60 Bytes

Alternative zu String.fromCharCode

... wenn Sie nur mit Kleinbuchstaben zufrieden sind.

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

Hinweis: Alle diese Techniken weisen der Variablen die alphabetische Zeichenfolge zu a.

Ich bin zu 99% sicher, dass der kürzeste Weg, dies in JavaScript zu erreichen, tatsächlich ist:

a="abcdefghijklmnopqrstuvwxyz" // 30 bytes

Es gibt aber noch einige andere interessante Methoden. Sie können die Zeichenfolgenkomprimierung verwenden:

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

Sie können die komprimierte Zeichenfolge von abrufen atob`abcdefghijklmnopqrstuvwx`. Das 'yz'muss manuell hinzugefügt werden, da wenn Sie die gesamte Zeichenfolge komprimieren, das Ergebnis jedoch nur 27 Byte beträgt, es sich als ergibt abcdefghijklmnopqrstuvwxyw==.

Ich glaube, der kürzeste Weg, dies programmatisch zu tun, ist auch die von Ihnen vorgeschlagene Methode:

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

Sie können dies mit ES6-Funktionen ( Vorlagenzeichenfolgen`` , Spread-Operator... ) tun , wenn Sie Folgendes möchten:

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

Sie können mit einer Variablen besser vorgehen als mit .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='')

Oder ES7 mit Array-Verständnis , das ein weiteres Byte kürzer ist:

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

Durch vorheriges Erstellen der Variablen wird ein weiteres Byte gespeichert:

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

Auch String.fromCharCodeakzeptiert mehrere Argumente und wird automatisch join them. So können wir jede ES6-Version auf 57 Bytes reduzieren:

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

Und die ES7 bis 55:

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

Wenn Sie mehr über Golfplätze erfahren möchten, lesen Sie diese Tipps . Es gibt auch eine Erklärung zum Array-Verständnis von ES7 .

EDIT: Wie edc65 herausgestellt hat, werden die meisten davon kürzer mit i.toString(36)anstelle von 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

Ich glaube, dieses ist das kürzeste, das als Funktionsrückgabewert aufgerufen werden kann:

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

Es ist drei Bytes kürzer als das manuelle Zurückgeben von einer Funktion:

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

Natürlich x=>"abcdefghijklmnopqrstuvwxyz"schlägt noch alles andere.

Hier ist ein weiterer Ansatz, ein 51-Byte-ES6-Ausdruck:

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

Natürlich 50 Bytes in Großbuchstaben.

36 Bytes mit einem Trick, über den ich gerade erfahren habe (aus diesem Beitrag: /codegolf//a/176496/64538 ):

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

window.name ist standardmäßig eine leere Zeichenfolge.

Dies ist natürlich noch weniger praktisch als die 38-Byte-Lösung, da ein längerer Variablenname verwendet wird.

Verwendung dessen, was im globalen Bereich definiert sein kann oder nicht

39 Bytes für Objekteigenschaften für den Array-Abgleich a-z

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

48 Bytes für eine unsortierte Set

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

55 Bytes für eine sortierte Set

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

67 Bytes für eine sortierte Zeichenfolge

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