Tạo một enum với các giá trị chuỗi

Mã sau có thể được sử dụng để tạo một enumTypeScript:

enum e {
    hello = 1,
    world = 2
};

Và các giá trị có thể được truy cập bởi:

e.hello;
e.world;

Làm cách nào để tạo một enumgiá trị chuỗi?

enum e {
    hello = "hello", // error: cannot convert string to e
    world = "world"  // error 
};

TypeScript 2.4

Bây giờ có enums chuỗi để mã của bạn chỉ hoạt động:

enum E {
    hello = "hello",
    world = "world"
};

🌹

TypeScript 1.8

Vì TypeScript 1.8, bạn có thể sử dụng các kiểu chữ theo chuỗi để cung cấp trải nghiệm đáng tin cậy và an toàn cho các giá trị chuỗi được đặt tên (một phần là các enum được sử dụng cho).

type Options = "hello" | "world";
var foo: Options;
foo = "hello"; // Okay 
foo = "asdf"; // Error!

Thêm: https://www.typescriptlang.org/docs/handbook/advified-types.html#opes-literal-types

Hỗ trợ di sản

Enums trong TypeScript là dựa trên số.

Bạn có thể sử dụng một lớp với các thành viên tĩnh mặc dù:

class E
{
    static hello = "hello";
    static world = "world"; 
}

Bạn cũng có thể đi đơn giản:

var E = {
    hello: "hello",
    world: "world"
}

Cập nhật: Dựa trên yêu cầu để có thể làm một cái gì đó như var test:E = E.hello;sau thỏa mãn điều này:

class E
{
    // boilerplate 
    constructor(public value:string){    
    }

    toString(){
        return this.value;
    }

    // values 
    static hello = new E("hello");
    static world = new E("world");
}

// Sample usage: 
var first:E = E.hello;
var second:E = E.world;
var third:E = E.hello;

console.log("First value is: "+ first);
console.log(first===third); 

Trong phiên bản mới nhất (1.0RC) của TypeScript, bạn có thể sử dụng các enum như thế này:

enum States {
    New,
    Active,
    Disabled
} 

// this will show message '0' which is number representation of enum member
alert(States.Active); 

// this will show message 'Disabled' as string representation of enum member
alert(States[States.Disabled]);

Cập nhật 1

Để lấy giá trị số của thành viên enum từ giá trị chuỗi, bạn có thể sử dụng:

var str = "Active";
// this will show message '1'
alert(States[str]);

Cập nhật 2

Trong TypeScript 2.4 mới nhất, đã có các enums chuỗi được giới thiệu, như thế này:

enum ActionType {
    AddUser = "ADD_USER",
    DeleteUser = "DELETE_USER",
    RenameUser = "RENAME_USER",

    // Aliases
    RemoveUser = DeleteUser,
}

Để biết thêm thông tin về TypeScript 2.4, hãy đọc blog trên MSDN .

TypeScript 2.4+

Bây giờ bạn có thể gán giá trị chuỗi trực tiếp cho các thành viên enum:

enum Season {
    Winter = "winter",
    Spring = "spring",
    Summer = "summer",
    Fall = "fall"
}

Xem # 15486 để biết thêm thông tin.

TypeScript 1.8+

Trong TypeScript 1.8+, bạn có thể tạo một kiểu chuỗi ký tự để xác định loại và một đối tượng có cùng tên cho danh sách các giá trị. Nó bắt chước một hành vi dự kiến ​​của một chuỗi enum.

Đây là một ví dụ:

type MyStringEnum = "member1" | "member2";

const MyStringEnum = {
    Member1: "member1" as MyStringEnum,
    Member2: "member2" as MyStringEnum
};

Mà sẽ hoạt động như một chuỗi enum:

// implicit typing example
let myVariable = MyStringEnum.Member1; // ok
myVariable = "member2";                // ok
myVariable = "some other value";       // error, desired

// explict typing example
let myExplicitlyTypedVariable: MyStringEnum;
myExplicitlyTypedVariable = MyStringEnum.Member1; // ok
myExplicitlyTypedVariable = "member2";            // ok
myExplicitlyTypedVariable = "some other value";   // error, desired

Hãy chắc chắn để nhập tất cả các chuỗi trong đối tượng! Nếu bạn không thì trong ví dụ đầu tiên ở trên, biến sẽ không được nhập vào MyStringEnum.

Trong TypeScript 0.9.0.1, mặc dù xảy ra lỗi trình biên dịch, trình biên dịch vẫn có thể biên dịch tệp ts thành tệp js. Mã này hoạt động như chúng tôi mong đợi và Visual Studio 2012 có thể hỗ trợ hoàn thành mã tự động.

Cập nhật:

Theo cú pháp, TypeScript không cho phép chúng ta tạo một enum với các giá trị chuỗi, nhưng chúng ta có thể hack trình biên dịch: p

enum Link
{
    LEARN   =   <any>'/Tutorial',
    PLAY    =   <any>'/Playground',
    GET_IT  =   <any>'/#Download',
    RUN_IT  =   <any>'/Samples',
    JOIN_IN =   <any>'/#Community'
}

alert('Link.LEARN:    '                     + Link.LEARN);
alert('Link.PLAY:    '                      + Link.PLAY);
alert('Link.GET_IT:    '                    + Link.GET_IT);
alert('Link[\'/Samples\']:    Link.'        + Link['/Samples']);
alert('Link[\'/#Community\']    Link.'      + Link['/#Community']);

Sân chơi

TypeScript 2.1 +

Các loại tra cứu , được giới thiệu trong TypeScript 2.1 cho phép một mẫu khác để mô phỏng các enum chuỗi:

// String enums in TypeScript 2.1
const EntityType = {
    Foo: 'Foo' as 'Foo',
    Bar: 'Bar' as 'Bar'
};

function doIt(entity: keyof typeof EntityType) {
    // ...
}

EntityType.Foo          // 'Foo'
doIt(EntityType.Foo);   // 👍
doIt(EntityType.Bar);   // 👍
doIt('Foo');            // 👍
doIt('Bad');            // 🙁 

TypeScript 2.4 +

Với phiên bản 2.4, TypeScript đã giới thiệu hỗ trợ riêng cho enum chuỗi, vì vậy không cần giải pháp ở trên. Từ các tài liệu TS:

enum Colors {
  Red = "RED",
  Green = "GREEN",
  Blue = "BLUE",
}

Tại sao không chỉ sử dụng cách truy cập tự nhiên của chuỗi enum.

enum e {
  WHY,
  NOT,
  USE,
  NATIVE
}

e[e.WHY] // this returns string 'WHY'

Bạn có thể sử dụng enums chuỗi trong TypeScript mới nhất:

enum e
{
    hello = <any>"hello",
    world = <any>"world"
};

Nguồn: https://blog.rsuter.com/how-to-im vây-an-enum-with-String-value-in-typepes /

CẬP NHẬT - 2016

Một cách mạnh mẽ hơn để tạo ra một chuỗi các chuỗi mà tôi sử dụng cho React ngày nay là như thế này:

export class Messages
{
    static CouldNotValidateRequest: string = 'There was an error validating the request';
    static PasswordMustNotBeBlank: string = 'Password must not be blank';   
}

import {Messages as msg} from '../core/messages';
console.log(msg.PasswordMustNotBeBlank);

Đây là một giải pháp khá sạch sẽ cho phép kế thừa, sử dụng TypeScript 2.0. Tôi đã không thử điều này trên một phiên bản trước đó.

Tiền thưởng: giá trị có thể là bất kỳ loại nào !

export class Enum<T> {
  public constructor(public readonly value: T) {}
  public toString() {
    return this.value.toString();
  }
}

export class PrimaryColor extends Enum<string> {
  public static readonly Red = new Enum('#FF0000');
  public static readonly Green = new Enum('#00FF00');
  public static readonly Blue = new Enum('#0000FF');
}

export class Color extends PrimaryColor {
  public static readonly White = new Enum('#FFFFFF');
  public static readonly Black = new Enum('#000000');
}

// Usage:

console.log(PrimaryColor.Red);
// Output: Enum { value: '#FF0000' }
console.log(Color.Red); // inherited!
// Output: Enum { value: '#FF0000' }
console.log(Color.Red.value); // we have to call .value to get the value.
// Output: #FF0000
console.log(Color.Red.toString()); // toString() works too.
// Output: #FF0000

class Thing {
  color: Color;
}

let thing: Thing = {
  color: Color.Red,
};

switch (thing.color) {
  case Color.Red: // ...
  case Color.White: // ...
}

Một cách khó khăn để làm điều này là: -

CallStatus.ts

enum Status
{
    PENDING_SCHEDULING,
    SCHEDULED,
    CANCELLED,
    COMPLETED,
    IN_PROGRESS,
    FAILED,
    POSTPONED
}

export = Status

Công dụng

static getEnumString(enum:any, key:any):string
{
    return enum[enum[key]];
}

Cách sử dụng

Utils.getEnumString(Status, Status.COMPLETED); // = "COMPLETED"

Điều này làm việc cho tôi:

class MyClass {
    static MyEnum: { Value1; Value2; Value3; }
    = {
        Value1: "Value1",
        Value2: "Value2",
        Value3: "Value3"
    };
}

hoặc là

module MyModule {
    export var MyEnum: { Value1; Value2; Value3; }
    = {
        Value1: "Value1",
        Value2: "Value2",
        Value3: "Value3"
    };
}

số 8)

Cập nhật: Ngay sau khi đăng bài này, tôi đã phát hiện ra một cách khác, nhưng quên đăng một bản cập nhật (tuy nhiên, ai đó đã đề cập ở trên):

enum MyEnum {
    value1 = <any>"value1 ", 
    value2 = <any>"value2 ", 
    value3 = <any>"value3 " 
}

Tôi chỉ cần khai báo một giao diện và sử dụng một biến loại đó truy cập enum. Giữ giao diện và enum đồng bộ thực sự dễ dàng, vì TypeScript phàn nàn nếu có gì đó thay đổi trong enum, như vậy.

lỗi TS2345: Đối số của loại 'typeof EAbFlagEnum' không thể gán cho tham số của loại 'IAbFlagEnum'. Thuộc tính 'Di chuyển' bị thiếu trong loại 'loại EAbFlagEnum'.

Ưu điểm của phương pháp này là không yêu cầu truyền kiểu để sử dụng enum (giao diện) trong các tình huống khác nhau và do đó, nhiều loại tình huống hơn được hỗ trợ, chẳng hạn như chuyển đổi / trường hợp.

// Declare a TypeScript enum using unique string 
//  (per hack mentioned by zjc0816)

enum EAbFlagEnum {
  None      = <any> "none",
  Select    = <any> "sel",
  Move      = <any> "mov",
  Edit      = <any> "edit",
  Sort      = <any> "sort",
  Clone     = <any> "clone"
}

// Create an interface that shadows the enum
//   and asserts that members are a type of any

interface IAbFlagEnum {
    None:   any;
    Select: any;
    Move:   any;
    Edit:   any;
    Sort:   any;
    Clone:  any;
}

// Export a variable of type interface that points to the enum

export var AbFlagEnum: IAbFlagEnum = EAbFlagEnum;

Sử dụng biến, thay vì enum, tạo ra kết quả mong muốn.

var strVal: string = AbFlagEnum.Edit;

switch (strVal) {
  case AbFlagEnum.Edit:
    break;
  case AbFlagEnum.Move:
    break;
  case AbFlagEnum.Clone
}

Cờ là một điều cần thiết khác đối với tôi, vì vậy tôi đã tạo ra một mô-đun NPM thêm vào ví dụ này và bao gồm các bài kiểm tra.

https://github.com/djabraham/ts-enum-tools

CẬP NHẬT: TypeScript 3.4

Bạn chỉ có thể sử dụng as const:

const AwesomeType = {
   Foo: "foo",
   Bar: "bar"
} as const;

TypeScript 2.1

Điều này cũng có thể được thực hiện theo cách này. Hy vọng nó sẽ giúp được ai đó.

const AwesomeType = {
    Foo: "foo" as "foo",
    Bar: "bar" as "bar"
};

type AwesomeType = (typeof AwesomeType)[keyof typeof AwesomeType];

console.log(AwesomeType.Bar); // returns bar
console.log(AwesomeType.Foo); // returns foo

function doSth(awesometype: AwesomeType) {
    console.log(awesometype);
}

doSth("foo") // return foo
doSth("bar") // returns bar
doSth(AwesomeType.Bar) // returns bar
doSth(AwesomeType.Foo) // returns foo
doSth('error') // does not compile

Với các trình biến đổi tùy chỉnh ( https://github.com/Microsoft/TypeScript/pull/13940 ) có sẵn trong typcript @ next, bạn có thể tạo đối tượng giống như enum với các giá trị chuỗi từ các kiểu chuỗi ký tự.

Xin vui lòng nhìn vào gói npm của tôi, ts-biến-liệt kê .

Ví dụ sử dụng:

// The signature of `enumerate` here is `function enumerate<T extends string>(): { [K in T]: K };`
import { enumerate } from 'ts-transformer-enumerate';

type Colors = 'green' | 'yellow' | 'red';
const Colors = enumerate<Colors>();

console.log(Colors.green); // 'green'
console.log(Colors.yellow); // 'yellow'
console.log(Colors.red); // 'red'

TypeScript <2.4

/** Utility function to create a K:V from a list of strings */
function strEnum<T extends string>(o: Array<T>): {[K in T]: K} {
  return o.reduce((res, key) => {
    res[key] = key;
    return res;
  }, Object.create(null));
}

/**
  * Sample create a string enum
  */

/** Create a K:V */
const Direction = strEnum([
  'North',
  'South',
  'East',
  'West'
])
/** Create a Type */
type Direction = keyof typeof Direction;

/** 
  * Sample using a string enum
  */
let sample: Direction;

sample = Direction.North; // Okay
sample = 'North'; // Okay
sample = 'AnythingElse'; // ERROR!

từ https://basarat.gitbooks.io/typescript/docs/types/literal-types.html

Đến liên kết nguồn, bạn có thể tìm thấy nhiều cách dễ dàng hơn để thực hiện kiểu chuỗi ký tự

Có rất nhiều câu trả lời, nhưng tôi không thấy bất kỳ giải pháp hoàn chỉnh nào. Vấn đề với câu trả lời được chấp nhận, cũng như enum { this, one }, là nó phân tán giá trị chuỗi bạn đang sử dụng thông qua nhiều tệp. Tôi cũng không thực sự thích "cập nhật", nó phức tạp và cũng không tận dụng các loại. Tôi nghĩ câu trả lời của Michael Bromley là đúng nhất, nhưng giao diện của nó hơi rắc rối và có thể làm với một loại.

Tôi đang sử dụng TypeScript 2.0. * Đây là những gì tôi sẽ làm

export type Greeting = "hello" | "world";
export const Greeting : { hello: Greeting , world: Greeting } = {
    hello: "hello",
    world: "world"
};

let greet: Greeting = Greeting.hello

Nó cũng có thông tin loại / di chuột qua đẹp hơn nhiều khi sử dụng IDE hữu ích. Hạn chế là bạn phải viết các chuỗi hai lần, nhưng ít nhất nó chỉ ở hai nơi.

Câu trả lời của @ basarat thật tuyệt. Ở đây được đơn giản hóa nhưng một ví dụ mở rộng một chút bạn có thể sử dụng:

export type TMyEnumType = 'value1'|'value2';

export class MyEnumType {
    static VALUE1: TMyEnumType = 'value1';
    static VALUE2: TMyEnumType = 'value2';
}

console.log(MyEnumType.VALUE1); // 'value1'

const variable = MyEnumType.VALUE2; // it has the string value 'value2'

switch (variable) {
    case MyEnumType.VALUE1:
        // code...

    case MyEnumType.VALUE2:
        // code...
}

Đã đối mặt với vấn đề này gần đây với TypeScript 1.0.1 và đã giải quyết theo cách này:

enum IEvents {
        /** A click on a product or product link for one or more products. */
        CLICK,
        /** A view of product details. */
        DETAIL,
        /** Adding one or more products to a shopping cart. */
        ADD,
        /** Remove one or more products from a shopping cart. */
        REMOVE,
        /** Initiating the checkout process for one or more products. */
        CHECKOUT,
        /** Sending the option value for a given checkout step. */
        CHECKOUT_OPTION,
        /** The sale of one or more products. */
        PURCHASE,
        /** The refund of one or more products. */
        REFUND,
        /** A click on an internal promotion. */
        PROMO_CLICK
}

var Events = [
        'click',
        'detail',
        'add',
        'remove',
        'checkout',
        'checkout_option',
        'purchase',
        'refund',
        'promo_click'
];

function stuff(event: IEvents):boolean {
        // event can now be only IEvents constants
        Events[event]; // event is actually a number that matches the index of the array
}
// stuff('click') won't work, it needs to be called using stuff(IEvents.CLICK)

Tôi nghĩ bạn nên thử với điều này, trong trường hợp này giá trị của biến sẽ không thay đổi và nó hoạt động khá giống như enum, sử dụng như một lớp cũng có nhược điểm duy nhất là do nhầm lẫn bạn có thể thay đổi giá trị của biến tĩnh và đó là những gì chúng tôi không muốn trong enums.

namespace portal {

export namespace storageNames {

    export const appRegistration = 'appRegistration';
    export const accessToken = 'access_token';

  }
}

export enum PaymentType {
                Cash = 1,
                Credit = 2
            }
var paymentType = PaymentType[PaymentType.Cash];

//to access the enum with its string value you can convert it to object 
//then you can convert enum to object with proberty 
//for Example :

enum days { "one" =3, "tow", "Three" }

let _days: any = days;

if (_days.one == days.one)
{ 
    alert(_days.one + ' | ' + _days[4]);
}

Little js-hacky nhưng hoạt động: e[String(e.hello)]

Nếu những gì bạn muốn chủ yếu là gỡ lỗi dễ dàng (với kiểm tra khá kiểu) và không cần chỉ định các giá trị đặc biệt cho enum, thì đây là việc tôi đang làm:

export type Enum = { [index: number]: string } & { [key: string]: number } | Object;

/**
 * inplace update
 * */
export function enum_only_string<E extends Enum>(e: E) {
  Object.keys(e)
    .filter(i => Number.isFinite(+i))
    .forEach(i => {
      const s = e[i];
      e[s] = s;
      delete e[i];
    });
}

enum AuthType {
  phone, email, sms, password
}
enum_only_string(AuthType);

Nếu bạn muốn hỗ trợ lưu trữ mã / dữ liệu cũ, bạn có thể giữ các phím số.

Bằng cách này, bạn có thể tránh gõ các giá trị hai lần.

Enum rất, rất, rất đơn giản với chuỗi (TypeScript 2.4)

import * from '../mylib'

export enum MESSAGES {
    ERROR_CHART_UNKNOWN,
    ERROR_2
}

export class Messages {
    public static get(id : MESSAGES){
        let message = ""
        switch (id) {
            case MESSAGES.ERROR_CHART_UNKNOWN :
                message = "The chart does not exist."
                break;
            case MESSAGES.ERROR_2 :
                message = "example."
                break;
        }
        return message
    }
}

function log(messageName:MESSAGES){
    console.log(Messages.get(messageName))
}

Tôi đã thử trong TypeScript 1.5 như bên dưới và nó hoạt động với tôi

module App.Constants {
   export enum e{
        Hello= ("Hello") as any,
World= ("World") as any
    }
}

tôi đang tìm kiếm một cách để thực hiện các mô tả trong enum bản thảo (v2,5) và mẫu này đã làm việc cho tôi:

export enum PriceTypes {
    Undefined = 0,
    UndefinedDescription = 'Undefined' as any,
    UserEntered = 1,
    UserEnteredDescription = 'User Entered' as any,
    GeneratedFromTrade = 2,
    GeneratedFromTradeDescription = 'Generated From Trade' as any,
    GeneratedFromFreeze = 3,
    GeneratedFromFreezeDescription = 'Generated Rom Freeze' as any
}

...

    GetDescription(e: any, id: number): string {
        return e[e[id].toString() + "Description"];
    }
    getPriceTypeDescription(price: IPricePoint): string {
        return this.GetDescription(PriceTypes, price.priceType);
    }

TypeScript 0.9.0.1

enum e{
    hello = 1,
    somestr = 'world'
};

alert(e[1] + ' ' + e.somestr);

Sân chơi TypeScript