Buat enum dengan nilai string

Kode berikut dapat digunakan untuk membuat enumdalam TypeScript:

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

Dan nilai-nilai dapat diakses oleh:

e.hello;
e.world;

Bagaimana cara membuat nilai enumdengan string?

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

TypeScript 2.4

Sekarang memiliki string enum sehingga kode Anda hanya berfungsi:

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

🌹

TypeScript 1.8

Sejak TypeScript 1.8 Anda dapat menggunakan tipe string literal untuk memberikan pengalaman yang dapat diandalkan dan aman untuk nilai string yang diberi nama (yang sebagian digunakan untuk enum).

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

Lebih lanjut: https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types

Dukungan Warisan

Enum dalam TypeScript berbasis angka.

Anda dapat menggunakan kelas dengan anggota statis:

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

Anda bisa menjadi jelas juga:

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

Pembaruan: Berdasarkan pada persyaratan untuk dapat melakukan sesuatu seperti var test:E = E.hello;yang berikut memenuhi:

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); 

Dalam versi terbaru (1.0RC) dari TypeScript, Anda dapat menggunakan enum seperti ini:

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]);

Perbarui 1

Untuk mendapatkan nilai angka anggota enum dari nilai string, Anda dapat menggunakan ini:

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

Perbarui 2

Di TypeScript 2.4 terbaru, diperkenalkan string enum, seperti ini:

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

    // Aliases
    RemoveUser = DeleteUser,
}

Untuk info lebih lanjut tentang TypeScript 2.4, baca blog di MSDN .

TypeScript 2.4+

Anda sekarang dapat menetapkan nilai string secara langsung ke anggota enum:

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

Lihat # 15486 untuk informasi lebih lanjut.

TypeScript 1.8+

Di TypeScript 1.8+, Anda bisa membuat tipe string literal untuk menentukan tipe dan objek dengan nama yang sama untuk daftar nilai. Ini meniru perilaku string enum yang diharapkan.

Ini sebuah contoh:

type MyStringEnum = "member1" | "member2";

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

Yang akan bekerja seperti string 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

Pastikan untuk mengetik semua string di objek! Jika Anda tidak melakukannya, pada contoh pertama di atas variabel tidak akan diketik secara implisit MyStringEnum.

Dalam TypeScript 0.9.0.1, meskipun terjadi kesalahan kompiler, kompiler masih dapat mengkompilasi file ts ke file js. Kode berfungsi seperti yang kami harapkan dan Visual Studio 2012 dapat mendukung penyelesaian kode otomatis.

Perbarui:

Dalam sintaksis, TypeScript tidak memungkinkan kita membuat enum dengan nilai string, tetapi kita dapat meretas kompiler: 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']);

Tempat bermain

TypeScript 2.1 +

Jenis pencarian , diperkenalkan dalam TypeScript 2.1 memungkinkan pola lain untuk mensimulasikan string enum:

// 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 +

Dengan versi 2.4, TypeScript memperkenalkan dukungan asli untuk string enum, sehingga solusi di atas tidak diperlukan. Dari dokumen TS:

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

Mengapa tidak menggunakan cara asli untuk mengakses string enum.

enum e {
  WHY,
  NOT,
  USE,
  NATIVE
}

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

Anda dapat menggunakan string enum di TypeScript terbaru:

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

Sumber: https://blog.rsuter.com/how-to-implement-an-enum-with-string-values-in-typescript/

UPDATE - 2016

Cara yang sedikit lebih kuat untuk membuat serangkaian string yang saya gunakan untuk Bereaksi hari ini adalah seperti ini:

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);

Inilah solusi yang cukup bersih yang memungkinkan pewarisan, menggunakan TypeScript 2.0. Saya tidak mencoba ini pada versi sebelumnya.

Bonus: nilainya bisa berupa apa saja !

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: // ...
}

Cara hacky untuk ini adalah: -

CallStatus.ts

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

export = Status

Utils.ts

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

Cara Penggunaan

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

Ini bekerja untuk saya:

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

atau

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

8)

Pembaruan: Tidak lama setelah memposting ini saya menemukan cara lain, tetapi lupa memposting pembaruan (namun, seseorang sudah menyebutkannya di atas):

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

Saya hanya mendeklarasikan antarmuka dan menggunakan variabel jenis itu mengakses enum. Menjaga antarmuka dan enum tetap sinkron sebenarnya mudah, karena TypeScript mengeluh jika ada perubahan di enum, seperti itu.

kesalahan TS2345: Argumen tipe 'typeof EAbFlagEnum' tidak dapat ditugaskan ke parameter tipe 'IAbFlagEnum'. Properti 'Move' tidak ada dalam tipe 'typeof EAbFlagEnum'.

Keuntungan dari metode ini adalah tidak diperlukan pengecoran tipe untuk menggunakan enum (antarmuka) dalam berbagai situasi, dan dengan demikian lebih banyak jenis situasi yang didukung, seperti sakelar / kasing.

// 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;

Menggunakan variabel, daripada enum, menghasilkan hasil yang diinginkan.

var strVal: string = AbFlagEnum.Edit;

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

Bendera adalah kebutuhan lain bagi saya, jadi saya membuat modul NPM yang menambah contoh ini, dan termasuk tes.

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

UPDATE: TypeScript 3.4

Anda cukup menggunakan as const:

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

TypeScript 2.1

Ini juga bisa dilakukan dengan cara ini. Semoga ini bisa membantu seseorang.

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

Dengan transformer khusus ( https://github.com/Microsoft/TypeScript/pull/13940 ) yang tersedia dalam typescript @ next, Anda dapat membuat objek enum seperti dengan nilai string dari nilai string dari tipe literal string.

Silakan lihat paket npm saya, ts-transformer-enumerate .

Contoh penggunaan:

// 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!

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

Untuk tautan sumber, Anda dapat menemukan lebih banyak dan lebih mudah cara untuk mencapai tipe literal string

Ada banyak jawaban, tetapi saya tidak melihat solusi yang lengkap. Masalah dengan jawaban yang diterima, dan juga enum { this, one }, adalah bahwa ia menyebarkan nilai string yang kebetulan Anda gunakan melalui banyak file. Saya juga tidak terlalu suka "pembaruan", itu rumit dan tidak memanfaatkan tipe juga. Saya pikir jawaban Michael Bromley paling benar, tetapi antarmuka itu agak merepotkan dan bisa dilakukan dengan tipe.

Saya menggunakan TypeScript 2.0. * Inilah yang akan saya lakukan

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

let greet: Greeting = Greeting.hello

Ini juga memiliki banyak jenis informasi yang lebih baik / melayang ketika menggunakan IDE yang bermanfaat. Kekurangannya adalah Anda harus menulis string dua kali, tetapi setidaknya itu hanya di dua tempat.

Jawaban @ basarat sangat bagus. Di sini disederhanakan tetapi sedikit contoh diperluas yang dapat Anda gunakan:

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...
}

Menghadapi masalah ini baru-baru ini dengan TypeScript 1.0.1, dan dipecahkan dengan cara ini:

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)

Saya pikir Anda harus mencoba dengan ini, dalam hal ini nilai variabel tidak akan berubah dan berfungsi seperti enum, menggunakan seperti kelas juga berfungsi satu-satunya kelemahan adalah dengan kesalahan Anda dapat mengubah nilai variabel statis dan itulah yang kami tidak ingin di 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]);
}

Sedikit js-hacky tetapi berfungsi: e[String(e.hello)]

Jika yang Anda inginkan terutama debug mudah (dengan cukup ketik centang) dan tidak perlu menentukan nilai khusus untuk enum, inilah yang saya lakukan:

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);

Jika Anda ingin mendukung kode lama / penyimpanan data, Anda dapat menyimpan kunci numerik.

Dengan cara ini, Anda dapat menghindari mengetik nilai dua kali.

Sangat, sangat, sangat sederhana dengan string (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))
}

Saya telah mencoba dalam TypeScript 1.5 seperti di bawah ini dan itu berhasil untuk saya

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

saya sedang mencari cara untuk mengimplementasikan deskripsi di encript skrip (v2.5) dan pola ini bekerja untuk saya:

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);

TypeScript Playground