Erstellen Sie eine Aufzählung mit Zeichenfolgenwerten

Der folgende Code kann verwendet werden, um ein enumin TypeScript zu erstellen :

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

Auf die Werte kann zugegriffen werden durch:

e.hello;
e.world;

Wie erstelle ich eine enummit String-Werten?

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

TypeScript 2.4

Hat jetzt String-Aufzählungen, so dass Ihr Code einfach funktioniert:

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

🌹

TypeScript 1.8

Seit TypeScript 1.8 können Sie String-Literal-Typen verwenden, um eine zuverlässige und sichere Erfahrung für benannte String-Werte bereitzustellen (wofür teilweise Aufzählungen verwendet werden).

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

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

Legacy-Unterstützung

Aufzählungen in TypeScript basieren auf Zahlen.

Sie können jedoch eine Klasse mit statischen Elementen verwenden:

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

Sie könnten auch klar gehen:

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

Update: Basierend auf der Anforderung, etwas wie var test:E = E.hello;das Folgende tun zu können, wird dies erfüllt:

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

In der neuesten Version (1.0RC) von TypeScript können Sie folgende Aufzählungen verwenden:

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

Update 1

Um den Zahlenwert des Enum-Elements aus dem Zeichenfolgenwert abzurufen, können Sie Folgendes verwenden:

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

Update 2

In der neuesten Version von TypeScript 2.4 wurden Zeichenfolgenaufzählungen wie folgt eingeführt:

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

    // Aliases
    RemoveUser = DeleteUser,
}

Weitere Informationen zu TypeScript 2.4 finden Sie im Blog auf MSDN .

TypeScript 2.4+

Sie können jetzt Aufzählungsmitgliedern direkt Zeichenfolgenwerte zuweisen:

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

Weitere Informationen finden Sie unter # 15486 .

TypeScript 1.8+

In TypeScript 1.8+ können Sie einen Zeichenfolgenliteraltyp erstellen, um den Typ und ein Objekt mit demselben Namen für die Werteliste zu definieren. Es ahmt das erwartete Verhalten einer Zeichenfolgenaufzählung nach.

Hier ist ein Beispiel:

type MyStringEnum = "member1" | "member2";

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

Welches wird wie eine String-Aufzählung funktionieren:

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

Stellen Sie sicher, dass Sie alle Zeichenfolgen im Objekt eingeben! Wenn Sie dies nicht tun, wird im ersten Beispiel oben die Variable nicht implizit eingegeben MyStringEnum.

In TypeScript 0.9.0.1 kann der Compiler die ts-Datei in eine js-Datei kompilieren, obwohl ein Compilerfehler auftritt. Der Code funktioniert wie erwartet und Visual Studio 2012 unterstützt die automatische Code-Vervollständigung.

Update:

In der Syntax erlaubt TypeScript nicht, eine Aufzählung mit Zeichenfolgenwerten zu erstellen, aber wir können den Compiler hacken: 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']);

Spielplatz

TypeScript 2.1 +

In TypeScript 2.1 eingeführte Nachschlagetypen ermöglichen ein anderes Muster zum Simulieren von Zeichenfolgenaufzählungen:

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

Mit Version 2.4 hat TypeScript die native Unterstützung für Zeichenfolgenaufzählungen eingeführt, sodass die oben genannte Lösung nicht benötigt wird. Aus den TS-Dokumenten:

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

Warum nicht einfach die native Methode verwenden, um auf die Zeichenfolgen einer Aufzählung zuzugreifen?

enum e {
  WHY,
  NOT,
  USE,
  NATIVE
}

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

Sie können Zeichenfolgenaufzählungen im neuesten TypeScript verwenden:

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

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

UPDATE - 2016

Eine etwas robustere Methode zum Erstellen eines Satzes von Zeichenfolgen, die ich heutzutage für React verwende, lautet wie folgt:

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

Hier ist eine ziemlich saubere Lösung, die die Vererbung mit TypeScript 2.0 ermöglicht. Ich habe dies bei einer früheren Version nicht versucht.

Bonus: Der Wert kann beliebig sein !

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

Ein hackiger Weg dazu ist:

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

Wie benutzt man

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

Das funktioniert bei mir:

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

oder

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

8)

Update: Kurz nach dem Posten habe ich einen anderen Weg entdeckt, aber vergessen, ein Update zu posten (jemand hat es oben bereits erwähnt):

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

Ich deklariere nur eine Schnittstelle und verwende eine Variable dieses Typs, um auf die Aufzählung zuzugreifen. Das Synchronisieren der Benutzeroberfläche und der Aufzählung ist eigentlich einfach, da sich TypeScript beschwert, wenn sich etwas in der Aufzählung ändert.

Fehler TS2345: Das Argument vom Typ 'typeof EAbFlagEnum' kann nicht dem Parameter vom Typ 'IAbFlagEnum' zugewiesen werden. Die Eigenschaft 'Verschieben' fehlt im Typ 'Typ von EAbFlagEnum'.

Der Vorteil dieser Methode besteht darin, dass kein Typ Casting erforderlich ist, um die Aufzählung (Schnittstelle) in verschiedenen Situationen zu verwenden, und daher werden mehr Arten von Situationen unterstützt, wie z. B. der Schalter / Fall.

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

Die Verwendung der Variablen anstelle der Aufzählung führt zu den gewünschten Ergebnissen.

var strVal: string = AbFlagEnum.Edit;

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

Flags waren eine weitere Notwendigkeit für mich, daher habe ich ein NPM-Modul erstellt, das dieses Beispiel ergänzt und Tests enthält.

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

UPDATE: TypeScript 3.4

Sie können einfach verwenden as const:

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

TypeScript 2.1

Dies kann auch auf diese Weise erfolgen. Hoffe es hilft jemandem.

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

Mit benutzerdefinierten Transformatoren ( https://github.com/Microsoft/TypeScript/pull/13940 ), die in typescript @ next verfügbar sind, können Sie ein enumähnliches Objekt mit Zeichenfolgenwerten aus Zeichenfolgenliteraltypen erstellen.

Bitte schauen Sie in mein npm-Paket, ts-transformator-enumerate .

Anwendungsbeispiel:

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

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

Zum Quelllink finden Sie mehr und einfachere Möglichkeiten, um den String-Literal-Typ zu erreichen

Es gibt viele Antworten, aber ich sehe keine vollständigen Lösungen. Das Problem mit der akzeptierten Antwort ist auch enum { this, one }, dass sie den Zeichenfolgenwert, den Sie gerade verwenden, über viele Dateien verteilt. Ich mag das "Update" auch nicht wirklich, es ist komplex und nutzt auch keine Typen. Ich denke, Michael Bromleys Antwort ist am zutreffendsten, aber die Benutzeroberfläche ist ein bisschen mühsam und könnte einen Typ vertragen.

Ich verwende TypeScript 2.0. * Folgendes würde ich tun

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

let greet: Greeting = Greeting.hello

Es hat auch viel schönere Typ- / Hoverover-Informationen, wenn eine hilfreiche IDE verwendet wird. Der Nachteil ist, dass Sie die Zeichenfolgen zweimal schreiben müssen, aber zumindest nur an zwei Stellen.

Die Antwort von @ basarat war großartig. Hier ist ein vereinfachtes, aber etwas erweitertes Beispiel, das Sie verwenden können:

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

Dieses Problem wurde kürzlich mit TypeScript 1.0.1 behoben und folgendermaßen gelöst:

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)

Ich denke, Sie sollten es versuchen, in diesem Fall ändert sich der Wert der Variablen nicht und es funktioniert ganz wie Aufzählungen. Die Verwendung wie eine Klasse funktioniert auch. Der einzige Nachteil ist, dass Sie versehentlich den Wert der statischen Variablen ändern können, und das ist was Wir wollen nicht in Aufzählungen.

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

Wenig js-hacky aber funktioniert: e[String(e.hello)]

Wenn das, was Sie wollen, hauptsächlich einfaches Debuggen ist (mit ziemlich typisierter Prüfung) und keine speziellen Werte für die Aufzählung angegeben werden müssen, mache ich Folgendes:

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

Wenn Sie ältere Code- / Datenspeicher unterstützen möchten, behalten Sie möglicherweise die Zifferntasten bei.

Auf diese Weise können Sie vermeiden, die Werte zweimal einzugeben.

Sehr, sehr, sehr einfache Aufzählung mit Zeichenfolge (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))
}

Ich habe es in TypeScript 1.5 wie unten versucht und es hat bei mir funktioniert

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

Ich suchte nach einer Möglichkeit, Beschreibungen in Typoskript-Enums (v2.5) zu implementieren, und dieses Muster funktionierte für mich:

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-Spielplatz