[Question]
  [
I'm pretty sure there's not a better way to do this but figured it couldn't hurt to ask.
I'm tired of typing out `a='abcdefghijklmnopqrstuvwxyz'`.
Cool languages have `Range('a'..'z')` or similar
What can we come up with with JS that's as short as possible??
```
for(i=97,a='';i<123;){a+=String.fromCharCode(i++)}
```
is longer than just the alphabet - but guarantees I don't screw up somewhere.
I'm hoping there's a nasty bit-shifty way to produce a-z in less than 50 characters.
I messed around with `i=97;Array(26).map(x=>String.fromChar....i++`
but it was always way longer by the time I joined then split the array(26) to be useable
---
Edit: I've gotten it down to 
```
[...Array(26)].reduce(a=>a+String.fromCharCode(i++),'',i=97)
```
60 bytes
  
[Answer]
# Alternative to String.fromCharCode
... if you are happy with a lowercase only alphabet.
```
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
```
[Answer]
**Note:** All of these techniques assign the alphabet string to variable `a`.
---
I am 99% certain that the shortest way to achieve this in JavaScript is indeed:
```
a="abcdefghijklmnopqrstuvwxyz" // 30 bytes
```
But there are several other interesting methods. You can use string compression: 
```
a=btoa`i¬∑?y√∏!?9%?z)¬™¬ª-¬∫√º1`+'yz' // 31 bytes; each ? represents an unprintable
```
You can get the compressed string from `atob`abcdefghijklmnopqrstuvwx``. The `'yz'` must be added manually because if you compress the whole string, while the result is only 27 bytes, it will turn out as `abcdefghijklmnopqrstuvwxyw==`.
I believe the shortest way to do it programmatically is also the method you suggested:
```
for(i=97,a='';i<123;)a+=String.fromCharCode(i++) // 48 bytes
```
You can do it with ES6 features ([template strings ````](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings), [spread operator `...`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator)) if you want:
```
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
```
You can do one better with a variable instead of `.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='')
```
Or ES7 with [array comprehensions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Array_comprehensions), which is another byte shorter:
```
a=[for(_ of Array(i=26))String.fromCharCode(++i+70)].join`` // 59 bytes
```
Creating the variable beforehand saves yet another byte:
```
a='',[for(_ of Array(i=26))a+=String.fromCharCode(++i+70)] // 58 bytes
```
Also, `String.fromCharCode` accepts multiple arguments and will automatically join them. So we can golf each ES6 version down to 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))
```
And the ES7 one down to 55:
```
a=String.fromCharCode(...[for(_ of Array(i=26))++i+70]) // 55 bytes
```
If you'd like to learn more about golfing ranges, check out [this set of tips](https://codegolf.stackexchange.com/a/61505/42545). There's also one about [ES7's array comprehensions](https://codegolf.stackexchange.com/a/61489/42545).
**EDIT:** As edc65 has pointed out, most of these become shorter using `i.toString(36)` instead of `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
```
I believe this one is the shortest possible that can be called as a function return value:
```
eval("for(i=9,a='';++i<36;)a+=i.toString(36)") // 46 bytes
```
It's three bytes shorter than manually returning it from a function:
```
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
```
Of course, `x=>"abcdefghijklmnopqrstuvwxyz"` still beats everything else.
[Answer]
Here's another approach, a 51 byte ES6 expression:
```
String.fromCharCode(...Array(123).keys()).slice(97)
```
50 bytes in upper case of course.
[Answer]
```
(36n**26n*351n/1225n-1n).toString(36)
```
37 bytes, as an expression. Uses the same base-36 method as many others, but further, obtaining all the letters from a single number. Requires BigInt support.
[Answer]
36 bytes, using a trick I just learned about (from this post: <https://codegolf.stackexchange.com/a/176496/64538>):
```
for(i=9;++i<36;)name+=i.toString(36)
```
`window.name` is an empty string by default.
Of course, this is even less practical than the 38-byte solution since it uses a longer variable name.
[Answer]
Using what may or may not be defined at global scope
39 bytes for object properties to array matching `a-z`
```
a=`${Object.keys(top)}`.match(/[a-z]/g)
```
48 bytes for an unsorted `Set`
```
a=new Set(`${Object.keys(top)}`.match(/[a-z]/g))
```
55 bytes for a sorted `Set`
```
a=new Set(`${Object.keys(top)}`.match(/[a-z]/g).sort())
```
67 bytes for a sorted string
```
a=[...new Set(`${Object.keys(top)}`.match(/[a-z]/g).sort())].join``
```
[Answer]
I like this answer from above, but just throwing this small addition out there:
```
const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
```
The other answers are great but consider this example:
```
const excelSheet = sheet('whatever.csv')
const headers = excelSheet.meta.headers // ['First Name', 'Last Name']
headers.map((header, i) => {
    console.log(`${header} is column ${alphabet[i]}`)
})
// First Name is column A
// Last Name is column B
```
It's more usable and readable for beginner/intermediate JavaScript developers. But this **is** code golf so I understand if this gets downvoted.
]