typescript - What is the best way to manage static keys? (TS)

Question

In my app I have always the issue to use some keys which are predefined and won't change at all - i.e. they are hardcoded. And I have no real clue which of the options are the best.

Currently I have:

export class PermissionKeys {
  public static readonly MYKEY_NOT_ALL_SPECIFIED = 'MYKEY_NOT_ALL_SPECIFIED';
}

as well as

export enum MyKey {
  MYKEY_NOT_ALL_SPECIFIED = <any>'MYKEY_NOT_ALL_SPECIFIED',
}

and in the final code I want to compare something like this.checkKey=MYKEY_NOT_ALL_SPECIFIED. With the enum I need to append always the .toString(). With the readonly strings I need to specify the name and the content (which remains always exactly the same).

Anybody have better ideas to manage hardcoded keys?

Answer 1

Without more information on your use case, I'm not sure what's the best way for you to go. You can use string enums:

export enum MyKey {
  MYKEY_NOT_ALL_SPECIFIED = 'MYKEY_NOT_ALL_SPECIFIED', // no <any>
  OTHERKEY = 'OTHERKEY',
  ETC = 'ETC'
}

class Something {
  checkKey: MyKey;
  someMethod() {
    if (this.checkKey === MyKey.MYKEY_NOT_ALL_SPECIFIED) {
      // do something
    } 
  }
}

Or, if you don't want to repeat yourself and know that the values and keys will always be equal, you can just use a constant plain object:

function sameValuesAsKeys<K extends string>(...values: K[]): {readonly [P in K]: P} {
  const ret = {} as {[P in K]: P}
  values.forEach(k => ret[k] = k);
  return ret;
}

export const MyKey = sameValuesAsKeys('MYKEY_NOT_ALL_SPECIFIED', "OTHERKEY", "ETC");
type MyKey = keyof typeof MyKey;

// still works
class Something {
  checkKey: MyKey;
  someMethod() {
    if (this.checkKey === MyKey.MYKEY_NOT_ALL_SPECIFIED) {
      // do something
    } 
  }
}

Does that answer your question? If not, please be more specific about your use case... show some code where you can't get the key you want or where you feel like you're repeating yourself, and I'll update the answer.

Hope that helps; good luck!

---

Update 1

Explaining the signature of

function sameValuesAsKeys<K extends string>(...values: K[]): {readonly [P in K]: P}

The type parameter K is some string or union of strings, and the parameter values is an array of that type of string. If I call sameValuesAsKeys("dog","cat"), TypeScript infers K to be "dog"|"cat". The return type of sameValuesAsKeys() is {readonly [P in K]: P} which is a mapped type meaning roughly "an object where each property is readonly and where the value is the same as the key". So if I call sameValuesAsKeys("dog","cat"), the return value is of type {readonly dog: "dog"; readonly cat: "cat"}.