Dize değerleriyle bir numaralandırma oluşturma

Aşağıdaki kod bir enumTypeScript oluşturmak için kullanılabilir :

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

Ve değerlere şu yolla erişilebilir:

e.hello;
e.world;

enumDize değerleriyle nasıl oluştururum ?

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

TypeScript 2.4

Şimdi dize sıralamaları vardır, böylece kodunuz sadece çalışır:

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

🌹

TypeScript 1.8

TypeScript 1.8'den beri, adlandırılmış dize değerleri için güvenilir ve güvenli bir deneyim sağlamak için dize değişmez türlerini kullanabilirsiniz (bu, kısmen numaralandırmaların ne için kullanıldığıdır).

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

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

Miras yardımı

TypeScript'teki numaralandırmalar sayı tabanlıdır.

Yine de statik üyeleri olan bir sınıfı kullanabilirsiniz:

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

Siz de sade olabilirsiniz:

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

Güncelleme:var test:E = E.hello; Aşağıdaki gibi bir şey yapabilme gereksinimine dayanarak bunu karşılar:

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

TypeScript'in en son sürümünde (1.0RC), aşağıdaki gibi numaralandırmaları kullanabilirsiniz:

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

Güncelleme 1

Dize değerinden numaralandırma üyesinin sayı değerini almak için şunu kullanabilirsiniz:

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

Güncelleme 2

En son TypeScript 2.4'te, dize sıralamaları tanıtıldı, örneğin:

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

    // Aliases
    RemoveUser = DeleteUser,
}

TypeScript 2.4 hakkında daha fazla bilgi için MSDN'deki blogu okuyun .

TypeScript 2.4+

Artık dize değerlerini doğrudan numaralandırma üyelerine atayabilirsiniz:

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

Daha fazla bilgi için # 15486'ya bakın .

TypeScript 1.8+

TypeScript 1.8+ sürümünde, türü tanımlamak için bir dize hazır bilgisi türü ve değerler listesi için aynı ada sahip bir nesne oluşturabilirsiniz. Bir string enum'un beklenen davranışını taklit eder.

İşte bir örnek:

type MyStringEnum = "member1" | "member2";

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

Hangi bir dize numaralandırma gibi çalışacaktır:

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

Nesnedeki tüm dizeleri yazdığınızdan emin olun! Yukarıdaki ilk örnekte bunu yapmazsanız, değişken örtük olarak yazılmaz MyStringEnum.

TypeScript 0.9.0.1'de, bir derleyici hatası oluşmasına rağmen, derleyici yine de ts dosyasını js dosyasına derleyebilir. Kod beklediğimiz gibi çalışır ve Visual Studio 2012 otomatik kod tamamlamayı destekleyebilir.

Güncelleme :

Sözdiziminde, TypeScript dize değerleriyle bir numaralandırma oluşturmamıza izin vermez, ancak derleyiciyi hackleyebiliriz: 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']);

Oyun alanı

TypeScript 2.1 +

TypeScript 2.1'de sunulan arama türleri , dize numaralandırmalarını simüle etmek için başka bir desene izin verir:

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

2.4 sürümünde, TypeScript dize sıralamaları için yerel destek sağladı, bu nedenle yukarıdaki çözüme gerek yoktur. TS belgelerinden:

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

Neden sadece bir numaralandırmanın dizelerine erişmenin yerel yolunu kullanmıyorsunuz?

enum e {
  WHY,
  NOT,
  USE,
  NATIVE
}

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

Dize sıralarını en son TypeScript'te kullanabilirsiniz:

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

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

GÜNCELLEME - 2016

Bu günlerde React için kullandığım bir dizi dizeyi oluşturmanın biraz daha sağlam bir yolu şöyle:

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

İşte TypeScript 2.0 kullanarak kalıtıma izin veren oldukça temiz bir çözüm. Bunu daha önceki bir sürümde denemedim.

Bonus: değer herhangi bir tip olabilir!

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

Bunun hacky bir yolu: -

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

Nasıl kullanılır

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

Bu benim için çalışıyor:

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

veya

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

8)

Güncelleme: Bunu gönderdikten kısa bir süre sonra başka bir yol keşfettim, ancak bir güncelleme yayınlamayı unuttum (ancak, birileri yukarıda bahsetti):

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

Ben sadece bir arayüz beyan ve bu tür bir değişken enum erişmek kullanın. Arabirim ve numaralandırmayı senkronize tutmak aslında kolaydır, çünkü TypeScript numarada bir şey değiştiğinde şikayet eder, örneğin.

hata TS2345: 'tipeof EAbFlagEnum' türünün bağımsız değişkeni 'IAbFlagEnum' türündeki parametreye atanamaz. 'Tür' EAbFlagEnum 'türünde' Move 'özelliği eksik.

Bu yöntemin avantajı, enumun (arayüz) çeşitli durumlarda kullanılması için tipte döküm gerekmemesi ve anahtar / kasa gibi daha fazla durumun desteklenmesidir.

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

Enum yerine değişkenin kullanılması istenen sonuçları verir.

var strVal: string = AbFlagEnum.Edit;

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

Bayraklar benim için başka bir zorunluluktu, bu yüzden bu örneğe eklenen ve testler içeren bir NPM modülü oluşturdum.

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

GÜNCELLEME: TypeScript 3.4

Sadece şunu kullanabilirsiniz as const:

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

TypeScript 2.1

Bu da bu şekilde yapılabilir. Umarım birine yardım eder.

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

Sonraki yazı tipinde @ mevcut olan özel transformatörlerle ( https://github.com/Microsoft/TypeScript/pull/13940 ), dizgi değişmezi türlerinden dize değerlerine sahip dize benzeri bir nesne oluşturabilirsiniz.

Lütfen npm paketime bakın, ts-transformer-enumerate .

Örnek kullanım:

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

Yazı Tipi <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!

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

Kaynak bağlantıya dizgi değişmezi türünü gerçekleştirmenin daha ve daha kolay yollarını bulabilirsiniz

Çok fazla cevap var, ama tam bir çözüm göremiyorum. Kabul edilen yanıtın yanı sıra enum { this, one }, kullandığınız dize değerini birçok dosyada dağıtmasıdır. Ben de "güncelleme" gerçekten sevmiyorum, karmaşık ve türleri de kaldıraç yok. Michael Bromley'nin cevabı en doğru olduğunu düşünüyorum , ancak arayüzü biraz zor ve bir türle yapabilirdi.

TypeScript 2.0 kullanıyorum. * İşte yapacağım şey

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

let greet: Greeting = Greeting.hello

Ayrıca, yararlı bir IDE kullanırken çok daha hoş bir tip / fareyle üzerine gelme bilgisi vardır. Çekiliş, dizeleri iki kez yazmak zorundasınız, ancak en azından sadece iki yerde.

@ basarat'ın cevabı harikaydı. İşte basitleştirilmiş ama kullanabileceğiniz biraz genişletilmiş örnek:

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

Son zamanlarda TypeScript 1.0.1 ile bu sorunla karşılaştı ve şu şekilde çözüldü:

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)

Ben bunu denemek gerektiğini düşünüyorum, bu durumda değişkenin değeri değişmez ve enums gibi çalışır, bir sınıf gibi kullanmak da tek dezavantajı yanlışlıkla statik değişkenin değerini değiştirebilirsiniz ve bu ne numaralandırmada istemiyoruz.

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

Küçük js-hacky ama çalışıyor: e[String(e.hello)]

İstediğiniz şey çoğunlukla kolay hata ayıklama (oldukça tür denetimi ile) ve numaralandırma için özel değerler belirtmeniz gerekmiyorsa, yaptığım şey budur:

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

Eski kodu / veri depolamayı desteklemek istiyorsanız, sayısal tuşları saklayabilirsiniz.

Bu şekilde, değerleri iki kez yazmaktan kaçınabilirsiniz.

Çok, çok, çok basit Dize ile numaralandırma (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))
}

Aşağıdaki gibi TypeScript 1.5'te denedim ve benim için çalıştı

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

daktilo numaralandırma (v2.5) açıklamaları uygulamak için bir yol arıyordu ve bu desen benim için çalıştı:

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 Oyun Alanı