Getting the enum key with the value string (reverse mapping) in TypeScript

If you have a string (or any other value) that you know is a valid enum value, you can just tell the compiler to treat the value as an enum.

NOTE: This is only works if you know that your value is valid for the enum.

enum Fruit {
    Apple = 'apple',
    Bananna = 'bananna'
}

const str: string = 'apple';

const fruit: Fruit = str as Fruit;

if (fruit === Fruit.Apple)
    console.log("It's an apple");

if (fruit === Fruit.Bananna)
    console.log("It's a bananna");

Output: It's an apple

You can easily create a map that allows you to get the key from the value without creating a special function for it.

export enum ApiMessage {
    logged_ok = 'Logged OK',
    register_ok = 'Register OK'
}

export type ApiMessageKey = keyof typeof ApiMessage;

export const API_MESSAGE_KEYS = new Map<ApiMessage, ApiMessageKey>(
    Object.entries(ApiMessage).map(([key, value]:[ApiMessageKey, ApiMessage]) => [value, key])
)

API_MESSAGE_KEYS.get(ApiMessage.logged_ok); // 'logged_ok'

You can now get the traits and their keys of enums within types in TypeScript🎉🎉

 enum ApiMessage {
    logged_ok = 'Logged OK',
    register_ok = 'Register OK'
}

// "logged_ok" | "register_ok"
type ApiMessageTraits = keyof typeof ApiMessage;

// "Logged OK" | "Register OK"
type MessageContents = `${ApiMessage}`;

Sadly, this relies on casting the keys of the enumerables into a string, so you can't have any other type of keys except for a string.

Edit: Simplified second method greatly by using template literals w/ TypeScript >=4.1.

Edit: You can also now get the values of enums with numerical values via the new string number parsing in extends clauses:

 enum ApiMessage {
    logged_ok = 1,
    register_ok = 2,
}

// "logged_ok" | "register_ok"
type ApiMessageTraits = keyof typeof ApiMessage;

// 1 | 2
type MessageContents = `${ApiMessage}` extends `${infer N extends number}` ? N : never;

Simplified version

The enum produces an object with key-value pairs.
All you really need to do is find the right entry, if any.

So, given example

enum ApiMessages {
  Ok = 'OK',
  Forbidden = 'No access for you',
}

const example = ApiMessages.Forbidden;

find the enum entry

const match = Object.entries(ApiMessages).find(([key, value]) => value === example);

select the key

if (match) {
  const [key] = match;
  console.log(`'${example}' matched key '${key}'.`);
}

// output: 'No access for you' matched key 'Forbidden'.

that's it.

Find a working example here.

You can use .findKey from lodash here for a one line solution:

import { findKey } from 'lodash';

enum SomeType {
  FOO = 'bar',
  BAZ = 'qux'
}

const example = findKey(SomeType, (o) => o === 'bar');
console.log(example);

Returns 'FOO'

I was sent the enum code from an API so needed a quick way to get the description...

Easy to do in js but not so easy in Typescript!

Uses Soren's method as a base

export function getEnumKeyByEnumValue<T extends { [index: string]: string }>(
  myEnum: T,
  enumValue: string
): keyof T | null {
  let longDesc: string = 'No Match';

  Object.keys(myEnum).forEach((key) => {
    if (key == enumValue) longDesc = myEnum[key];
  });

  return longDesc;
}

getEnumKeyByEnumValue(BenefitType, appeal.benefit)

As an addition to @Søren's answer to go all the way with type safety, you could do something like this:

const getEnumKey = <T extends {}>(theEnum: T, keyValue:T[keyof T]) =>
  (Object.keys(theEnum) as (keyof T)[]).
  find((k ) => theEnum[k] === keyValue) as keyof T || null ;

That way you also get (some) type safety and IDE intellisense ect.:

Using lodash you could try:

_.keys(ApiMessages)[_.toArray(ApiMessages).indexOf(ApiMessages.logged_ok)]

Should give you back 'logged_ok'