How to use destructuring assignment to define enumerations in ES6?

Question

You can use destructuring assignment to define enumerations in ES6 as follows:

var [red, green, blue] = [0, 1, 2];

Instead, I'd like the right hand side of the destructuring assignment to be dynamic. For example:

var MAX_ENUM_SIZE = 32;
var ENUM = new Array(MAX_ENUM_SIZE);
for (var i = 0; i < MAX_ENUM_SIZE; i++) ENUM[i] = i;

var [red, green, blue] = ENUM;

Unfortunately, this seems like a hack. What if I want a bigger enumeration in the future? Hence, I was thinking of using destructuring assignment with an iterator as follows:

var [red, green, blue] = enumeration(/* I don't want to specify size */);

However, I don't think it's possible to use destructuring assignment with iterators ^{[citation needed]} . Is there any way to accomplish this goal?

Answer 1

Use a generator

 function* enumerator() { let i = 0; while (true) yield i++; }; let [red,green,blue] = enumerator(); console.log(red, green, blue); // 0 1 2 let [a,b,c,d,e] = enumerator(); console.log(a,b,c,d,e); // 0 1 2 3 4 

The generator is flexible making this pretty neat for implementing different types of enums – for example, these cute bitmask enums

 function* bitmask() { let i = 0; while (i < 32) yield 1 << i++; throw Error("bitmask enumerator exceeds 32 bits"); } let [R,W,X] = bitmask(); const read = p => (p & R) !== 0; const write = p => (p & W) !== 0; const exec = p => (p & X) !== 0; { let p = R | W; // read and write only console.log("can read?", read(p)); // true console.log("can write?", write(p)); // true console.log("can exec?", exec(p)); // false } { let p = R | X; // read and execute only console.log("can read?", read(p)); // true console.log("can write?", write(p)); // false console.log("can exec?", exec(p)); // true } 

Answer 2

Note, each of the below prospective approaches could probably be improved.

The variables appear to be global at Question. You can create an array of strings referencing the variable which should be created, define the variable from the element of the array

 // not technically destructuring, though achieves same result; // that is, setting variables globally for (var prop of (props = ["a", "b", "c", "d"])) { // set identifier globally self[prop] = props.indexOf(prop); // set a value for each `prop` } // delete `prop`, `props` prop = props = void 0; console.log(a, b, c, d); 

Other approaches

using object destructuring

 var { red, blue, green } = (function(data, props) { for (var prop of Object.keys(props)) { data[props[prop]] = props.indexOf(props[prop]); // or some other value }; return data }({}, ["red", "blue", "green"])); console.log(red, blue, green); 

using a list of variables to be

 var props = ["red", "blue", "green"]; // list of variables to be var [red, blue, green] = props.map((v, k) => k); console.log(red, blue, green, "window[\\"red\\"]:", window[props[0]]);