Styjun

How can I shorten this monster block? (Non-Array solution)

setFooTypeFlag(flag: string) 
 switch (flag) 
 case 'a':
 this.fooType.a = true; 
 this.fooType.b = false;
 this.fooType.c = false;
 this.fooType.d = false;
 break;
 case 'b'
 this.fooType.a = false;
 this.fooType.b = true;
 this.fooType.c = false;
 this.fooType.d = false;
 break;
 case 'c':
 this.fooType.a = false;
 this.fooType.b = false;
 this.fooType.c = true;
 this.fooType.d = false;
 break;
 case 'd':
 this.fooType.a = false;
 this.fooType.b = false;
 this.fooType.c = false;
 this.fooType.d = true;
 break;
 

Is it short enough for you? :)

Basically, iterate on each key and just set everything to flag === key :)

setFooTypeFlag(flag: string) 
 Object.keys(this.fooType).forEach(key => 
 this.fooType[key] = flag === key;
 );

If at the beginning, this has no keys yet, please refer to the answer of Jack.

Use a dynamic property name. This will work for any amount of possibilities, and it doesn't require you to initialise them all beforehand:

setFooTypeFlag(flag: string) 
 var chars = ["a", "b", "c", "d"];
 for (var i = 0; i < chars.length; i++) 
 this.fooType[chars[i]] = chars[i] == flag;
 

enum fooTypes 
 "a" = "a",
 "b" = "b",
 "c" = "c",
 "d" = "d"


interface IFooFlags 
 [key: string]: boolean;


const defaultFooTypes = new Map<fooTypes, boolean>([
 [fooTypes.a, true],
 [fooTypes.b, true],
 [fooTypes.c, true],
 [fooTypes.d, true]
]);

const fooTypesMappings = new Map<fooTypes, boolean[]>([
 [fooTypes.a, [true, false, false, false]],
 [fooTypes.b, [false, true, false, false]],
 [fooTypes.c, [false, false, true, false]],
 [fooTypes.d, [false, false, false, true]]
]);

class MyClass 
 private mappings = fooTypesMappings;
 private fooTypes = defaultFooTypes;

 private setFooTypes(values: boolean[]): void 
 [...this.fooTypes.keys()].forEach((key, index) =>
 this.fooTypes.set(key, values[index])
 );
 

 // In modern engines you can return:
 // Object.fromEntries(this.fooTypes)
 public getFooTypes(): IFooFlags 
 return [...this.fooTypes].reduce(
 (obj, 0: key, 1: val ) => ( ...obj, [key]: val ),
 
 );
 

 public setFooTypeFlag(flag: fooTypes): void 
 const flagTypes = this.mappings.get(flag);
 if (!flagTypes) 
 throw new Error("Invalid flag type");
 
 this.setFooTypes(flagTypes);
 


const fooLover = new MyClass();
fooLover.setFooTypeFlag(fooTypes.d);
alert(JSON.stringify(fooLover.getFooTypes()));

Here is a demo of it

I also got inspired by the answer from @jack-bashford:

class MyClass 
 private flags = [...Array(26)].map((_, i) => (i + 10).toString(36));
 private minObjectKeys = 4;

 public buildBaseObject(flag: string): any 
 return this.getFlagPortion(flag).reduce(
 (obj, key) => ( ...obj, [key]: key === flag ),
 
 );
 

 private getFlagPortion(flag: string): string[] 
 const sliceEndPositon = this.getSliceEndPosition(flag);
 return this.flags.slice(0, sliceEndPositon);
 

 private getSliceEndPosition(flag: string): number 
 const flagPosition = this.flags.indexOf(flag) + 1;
 return flagPosition < this.minObjectKeys
 ? this.minObjectKeys
 : flagPosition;
 


const fooLover = new MyClass();
alert(JSON.stringify(fooLover.buildBaseObject("d")));

Here is the demo