Я определил следующее перечисление в TypeScript:

enum Color{
    Red, Green
}

Теперь в моей функции я получаю цвет в виде строки. Я пробовал следующий код:

var green= "Green";
var color : Color = <Color>green; // Error: can't convert string to enum

Как я могу преобразовать это значение в перечисление?

Перечисления в TypeScript 0.9 основаны на строках + числах. Вам не нужно утверждение типа для простых преобразований:

enum Color{
    Red, Green
}

// To String
 var green: string = Color[Color.Green];

// To Enum / number
var color : Color = Color[green];

Попробуйте онлайн

У меня есть документация об этом и других шаблонах Enum в моей книге OSS: https://basarat.gitbook.io/typescript/type-system/enums

Начиная с Typescript 2.1 строковые ключи в перечислениях строго типизированы. keyof typeofиспользуется для получения информации о доступных строковых ключах ( 1 ):

enum Color{
    Red, Green
}

let typedColor: Color = Color.Green;
let typedColorString: keyof typeof Color = "Green";

// Error "Black is not assignable ..." (indexing using Color["Black"] will return undefined runtime)
typedColorString = "Black";

// Error "Type 'string' is not assignable ..." (indexing works runtime)
let letColorString = "Red";
typedColorString = letColorString;

// Works fine
typedColorString = "Red";

// Works fine
const constColorString = "Red";
typedColorString = constColorString

// Works fine (thanks @SergeyT)
let letColorString = "Red";
typedColorString = letColorString as keyof typeof Color;

typedColor = Color[typedColorString];

https://www.typescriptlang.org/docs/handbook/advanced-types.html#index-types

Если вы уверены, что входная строка точно совпадает с Color enum, используйте:

const color: Color = (<any>Color)["Red"];

Если входная строка может не соответствовать Enum, используйте:

const mayBeColor: Color | undefined = (<any>Color)["WrongInput"];
if (mayBeColor !== undefined){
     // TypeScript will understand that mayBeColor is of type Color here
}

Игровая площадка

Если мы не приведем enumк <any>типу, тогда TypeScript покажет ошибку:

Элемент неявно имеет тип 'any', потому что индексное выражение не имеет типа 'number'.

Это означает, что по умолчанию тип TypeScript Enum работает с числовыми индексами, т.е. let c = Color[0]не с строковыми индексами, такими как let c = Color["string"]. Это известное ограничение команды Microsoft для более общих проблем строковых индексов объектов .

enum Color{
    Red, Green
}

// To String
 var green: string = Color[Color.Green];

// To Enum / number
var color : Color = Color[green as keyof typeof Color]; //Works with --noImplicitAny

Этот пример работает --noImplicitAnyв TypeScript

Источники:
https://github.com/Microsoft/TypeScript/issues/13775#issuecomment-276381229 https://www.typescriptlang.org/docs/handbook/advanced-types.html#index-types

Это замечание относится к basarat в ответ , а не оригинальный вопрос.

У меня была странная проблема в моем собственном проекте, когда компилятор выдавал ошибку, примерно эквивалентную «не может преобразовать строку в цвет», используя эквивалент этого кода:

var colorId = myOtherObject.colorId; // value "Green";
var color: Color = <Color>Color[colorId]; // TSC error here: Cannot convert string to Color.

Я обнаружил, что вывод типа компилятора запутался, и он подумал, что colorIdэто значение enum, а не ID. Чтобы решить эту проблему, мне пришлось привести идентификатор в виде строки:

var colorId = <string>myOtherObject.colorId; // Force string value here
var color: Color = Color[colorId]; // Fixes lookup here.

Я не уверен, что вызвало проблему, но я оставлю эту заметку здесь на случай, если кто-нибудь столкнется с той же проблемой, что и я.

Я получил это с помощью следующего кода.

var green= "Green";
var color : Color= <Color>Color[green];

Если вы предоставляете строковые значения для вашего перечисления, прямое приведение работает просто отлично.

enum Color {
  Green = "Green",
  Red = "Red"
}

const color = "Green";
const colorEnum = color as Color;

Учитывая, что вы используете машинопись, многие из приведенных выше решений могут не работать или слишком сложны.

Ситуация : строки не совпадают со значениями перечисления (регистр отличается)

enum Color {
  Green = "green",
  Red = "red"
}

Просто используйте:

const color = "green" as Color

Я также столкнулся с той же ошибкой компилятора. Просто небольшая вариация подхода Sly_cardinal.

var color: Color = Color[<string>colorId];

Если компилятор TypeScript знает, что тип переменной - строка, это работает:

let colorName : string = "Green";
let color : Color = Color[colorName];

В противном случае вы должны явно преобразовать его в строку (чтобы избежать предупреждений компилятора):

let colorName : any = "Green";
let color : Color = Color["" + colorName];

Во время выполнения оба решения будут работать.

В этом вопросе много смешанной информации, поэтому давайте рассмотрим всю реализацию TypeScript 2.x + в Руководстве Ника по использованию Enums в моделях с TypeScript .

Это руководство предназначено для: людей, которые создают код на стороне клиента, который принимает набор известных строк с сервера, который будет удобно моделироваться как Enum на стороне клиента.

Определить перечисление

Давайте начнем с перечисления. Это должно выглядеть примерно так:

export enum IssueType {
  REPS = 'REPS',
  FETCH = 'FETCH',
  ACTION = 'ACTION',
  UNKNOWN = 'UNKNOWN',
}

Здесь следует отметить две вещи:

1. Мы явно объявляем их как регистры перечисления со строковыми данными, что позволяет нам создавать их с помощью строк, а не некоторых других не связанных чисел.

2. Мы добавили опцию , которая может или не может существовать на нашей модели сервера: UNKNOWN. Это может быть обработано так, как undefinedвы предпочитаете, но я бы хотел по возможности избегать | undefinedтипов, чтобы упростить обработку.

Самое замечательное в UNKNOWNслучае с кейсом состоит в том, что вы можете быть действительно очевидны в коде и делать стили для неизвестных перечисляемых случаев ярко-красными и мигающими, чтобы вы знали, что вы что-то неправильно обрабатываете.

Разобрать перечисление

Возможно, вы используете это перечисление, встроенное в другую модель, или все в одиночку, но вам придется проанализировать перечисление со строковым типом y из JSON или XML (ха) в свой строго типизированный аналог. При встраивании в другую модель этот синтаксический анализатор живет в конструкторе класса.

parseIssueType(typeString: string): IssueType {
  const type = IssueType[typeString];
  if (type === undefined) {
    return IssueType.UNKNOWN;
  }

  return type;
}

Если перечисление правильно проанализировано, оно в конечном итоге будет иметь правильный тип. В противном случае это будет, undefinedи вы можете перехватить его и вернуть ваше UNKNOWNдело. Если вы предпочитаете использовать в undefinedкачестве неизвестного случая, вы можете просто вернуть любой результат из попытки разбора enum.

Оттуда, это только вопрос использования функции анализа и использования вашей новой строго типизированной переменной.

const strongIssueType: IssueType = parseIssueType('ACTION');
// IssueType.ACTION
const wrongIssueType: IssueType = parseIssueType('UNEXPECTED');
// IssueType.UNKNOWN

Я искал ответ, который можно получить enumот a string, но в моем случае значения перечислений имели разные строковые значения. У OP был простой enum для Color, но у меня было что-то другое:

enum Gender {
  Male = 'Male',
  Female = 'Female',
  Other = 'Other',
  CantTell = "Can't tell"
}

Когда вы пытаетесь разрешить Gender.CantTellс помощью "Can't tell"строки, он возвращается undefinedс исходным ответом.

Другой ответ

По сути, я придумал другой ответ, вдохновленный этим ответом :

export const stringToEnumValue = <ET, T>(enumObj: ET, str: string): T =>
  (enumObj as any)[Object.keys(enumObj).filter(k => (enumObj as any)[k] === str)[0]];

Ноты

• Беру первый результат из filter, если предположить , что клиент проходит действительную строку из перечисления. Если это не так, undefinedбудут возвращены.
• Мы приведем enumObjк any, потому что с TypeScript 3.0+ (в настоящее время используется TypeScript 3.5), enumObjразрешается как unknown.

Пример использования

const cantTellStr = "Can't tell";

const cantTellEnumValue = stringToEnumValue<typeof Gender, Gender>(Gender, cantTellStr);
console.log(cantTellEnumValue); // Can't tell

Примечание: и, как кто-то указал в комментарии, я также хотел использовать noImplicitAny.

Обновленная версия

Нет приведения anyи правильного набора текста.

export const stringToEnumValue = <T, K extends keyof T>(enumObj: T, value: string): T[keyof T] | undefined =>
  enumObj[Object.keys(enumObj).filter((k) => enumObj[k as K].toString() === value)[0] as keyof typeof enumObj];

Кроме того, обновленная версия имеет более простой способ вызова и более читабельна:

stringToEnumValue(Gender, "Can't tell");

Мне нужно было знать, как перебирать значения перечислений (тестировал множество перестановок нескольких перечислений), и я обнаружил, что это хорошо работает:

export enum Environment {
    Prod = "http://asdf.com",
    Stage = "http://asdf1234.com",
    Test = "http://asdfasdf.example.com"
}

Object.keys(Environment).forEach((environmentKeyValue) => {
    const env = Environment[environmentKeyValue as keyof typeof Environment]
    // env is now equivalent to Environment.Prod, Environment.Stage, or Environment.Test
}

Источник: https://blog.mikeski.net/development/javascript/typescript-enums-to-from-string/

Enum

enum MyEnum {
    First,
    Second,
    Three
}

Пример использования

const parsed = Parser.parseEnum('FiRsT', MyEnum);
// parsed = MyEnum.First 

const parsedInvalid= Parser.parseEnum('other', MyEnum);
// parsedInvalid = undefined

Игнорировать регистрозависимый анализ

class Parser {
    public static parseEnum<T>(value: string, enumType: T): T[keyof T] | undefined {
        if (!value) {
            return undefined;
        }

        for (const property in enumType) {
            const enumMember = enumType[property];
            if (typeof enumMember === 'string') {
                if (enumMember.toUpperCase() === value.toUpperCase()) {
                    const key = enumMember as string as keyof typeof enumType;
                    return enumType[key];
                }
            }
        }
        return undefined;
    }
}

Перечисления, созданные так, как вы это сделали, скомпилированы в объект, в котором хранятся как прямые, так (name -> value)и обратные (value -> name)отображения. Как мы можем наблюдать из этого скриншота Chrome Devtools:

Вот пример того, как работает двойное сопоставление и как приводить от одного к другому:

enum Color{
    Red, Green
}
// To Number
var greenNr: number = Color['Green'];
console.log(greenNr); // logs 1

// To String
var greenString: string = Color[Color['Green']];  // or Color[Color[1]
console.log(greenString); // logs Green

// In your example

// recieve as Color.green instead of the string green
var green: string = Color[Color.Green];  

// obtain the enum number value which corresponds to the Color.green property
var color: Color = (<any>Color)[green];  

console.log(color); // logs 1

Попробуй это

var color: Color = (Цвет как любой) ["Зеленый];

Это прекрасно работает для версии 3.5.3

Если вы используете пространства имен для расширения функциональности вашего перечисления, вы также можете сделать что-то вроде

    enum Color {
        Red, Green
    }

    export namespace Color {
      export function getInstance(color: string) : Color {
        if(color == 'Red') {
          return Color.Red;
        } else if (color == 'Green') {
          return Color.Green;
        }
      }
    }

и использовать это так

  Color.getInstance('Red');

другой вариант может быть

const green= "Green";

const color : Color = Color[green] as Color;