स्ट्रिंग मानों के साथ एक एनम बनाएँ


262

enumटाइपस्क्रिप्ट में एक बनाने के लिए निम्नलिखित कोड का उपयोग किया जा सकता है :

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

और मूल्यों द्वारा पहुँचा जा सकता है:

e.hello;
e.world;

मैं enumस्ट्रिंग मानों के साथ कैसे बनाऊं ?

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

जवाबों:


409

टाइपस्क्रिप्ट 2.4

अब आपके पास काम करने के लिए स्ट्रिंग एनम हैं:

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

🌹

टाइपस्क्रिप्ट 1.8

टाइपस्क्रिप्ट 1.8 के बाद से आप नाम के स्ट्रिंग मानों के लिए एक विश्वसनीय और सुरक्षित अनुभव प्रदान करने के लिए स्ट्रिंग शाब्दिक प्रकारों का उपयोग कर सकते हैं (जो कि आंशिक रूप से एनमों के लिए उपयोग किया जाता है)।

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

और अधिक: https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types

विरासत का समर्थन

TypeScript में Enums नंबर आधारित हैं।

आप स्थैतिक सदस्यों के साथ एक वर्ग का उपयोग कर सकते हैं, हालांकि:

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

आप सादे भी जा सकते हैं:

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

अद्यतन: आवश्यकता के आधार पर var test:E = E.hello;निम्न की तरह कुछ करने में सक्षम होना यह संतुष्ट करता है:

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

थोड़ा सुधार:toString(): string { return this.value; }
11-28 को

@puselk वास्तव में टाइपस्क्रिप्ट अनुमान लगाएगा कि toStringएक स्ट्रिंग लौटाता है क्योंकि यह रिटर्न करता है this.valueऔर valueटाइप स्ट्रिंग का है। तो आप ऐसा नहीं कर सकते हैं var x:number = E.hello.toString();और यदि आप var x = E.hello.toString();x करते हैं तो यह टाइप का stringभी है। :)
बैसारट

2
@BASarat यह सच है कि टाइपस्क्रिप्ट इस तरह के मामले को संभालती है, लेकिन मेरा मतलब है कि हर बार जब हम जानते हैं कि रिटर्न के प्रकारों के साथ हमेशा सजाए गए तरीके हैं, यहां तक ​​कि यह टीएस कंपाइलर के लिए भी आवश्यक नहीं है, लेकिन हमारे लिए कोडर्स के लिए यह जानना जरूरी है कि हमने विधि की परिभाषा कब देखी। इसे टाइप करें।
प्यूलसक

@basarat get()विधि को बदलने के लिए कोई नकारात्मक पहलू है return this.value? इस तरह यह स्ट्रिंग मान को वापस लौटा देगा जब तक पहुँचा नहीं और केवल परिवर्तित करते समय toString()
जॉन

@basarat यदि आपके पास कई "एनम" हैं, तो कंपाइलर संरचनात्मक टाइपिंग के कारण उनके बीच अंतर नहीं करेगा - कंपाइलर valueसभी प्रकार के सदस्यों को देखेगा और उन्हें तुलनीय प्रकारों के रूप में मानेगा। valueहालांकि आप सदस्य को निजी बना सकते हैं । इस तरह संकलक इसे नहीं देखेगा और संरचनात्मक टाइपिंग को लागू करने की कोशिश नहीं करेगा।
किरिल जी।

113

टाइपस्क्रिप्ट के नवीनतम संस्करण (1.0RC) में, आप इस तरह से एनम का उपयोग कर सकते हैं:

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

अपडेट १

स्ट्रिंग मान से एनुम सदस्य की संख्या मान प्राप्त करने के लिए, आप इसका उपयोग कर सकते हैं:

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

अपडेट २

नवीनतम टाइपस्क्रिप्ट 2.4 में, इस तरह स्ट्रिंग एनम पेश किए गए थे:

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

    // Aliases
    RemoveUser = DeleteUser,
}

टाइपस्क्रिप्ट 2.4 के बारे में अधिक जानकारी के लिए, MSDN पर ब्लॉग पढ़ें ।


2
आम तौर पर, इस समाधान को प्राथमिकता दी जाती है (जैसा कि यह एक वास्तविक एनम है) लेकिन आप एनुम नाम (इसलिए 'स्ट्रिंग') पर बहुत विवश हैं।
जेसन

2
आज के रूप में सबसे अच्छा समाधान।
अलोन अमीर

2
इस पर कुछ भी नया? क्योंकि States[str]आजकल काम नहीं करता है। Type 'string' is not assignable to type 'States'
14 अक्टूबर को MrCroft

1
@MrCoft आप उपयोग कर सकते हैं: टाइपस्क्रिप्ट के States[str as any]वर्तमान (2.x) संस्करण में करने के लिए।
5

स्टेट्स [str] वही है जिसकी मुझे तलाश थी। धन्यवाद!
मार्टिन कोनिसक

81

टाइपस्क्रिप्ट 2.4+

अब आप सदस्यों को सीधे एनुम में स्ट्रिंग मान निर्दिष्ट कर सकते हैं:

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

अधिक जानकारी के लिए # 15486 देखें ।

टाइपस्क्रिप्ट 1.8+

टाइपस्क्रिप्ट 1.8+ में, आप मानों की सूची के लिए समान नाम के साथ एक प्रकार और ऑब्जेक्ट को परिभाषित करने के लिए एक स्ट्रिंग शाब्दिक प्रकार बना सकते हैं। यह एक स्ट्रिंग एनम के अपेक्षित व्यवहार की नकल करता है।

यहाँ एक उदाहरण है:

type MyStringEnum = "member1" | "member2";

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

जो एक स्ट्रिंग एनम की तरह काम करेगा:

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

ऑब्जेक्ट में सभी स्ट्रिंग्स टाइप करना सुनिश्चित करें! यदि आप तब पहले उदाहरण में परिवर्तनशील से ऊपर नहीं आते हैं, तो इसका तात्पर्य टाइपिंग से नहीं होगा MyStringEnum


1
मैं एक घोषणा फ़ाइल में कुछ इसी तरह कैसे परिभाषित कर सकता हूं?
ज़ेव स्पिट्ज

आप कर सकते हैं @ZevSpitz इस
डेविड Sherret

वर्थ नोटिंग, कि वर्तमान संकलक के साथ, आप MyStringEnum में स्ट्रिंग मानों को गलत कर सकते हैं और यह शिकायत नहीं करेगा। मैं यह सुनिश्चित करने के लिए एक 'Enforcer' इंटरफेस बना रहा हूं कि मेरे तार हमेशा वैध होते हैं। उदाहरण के लिए: इंटरफ़ेस MyStringEnumEnforcer {सदस्य 1: MyStringEnum, Member2: MyStringEnum} तब MyStringEnum: const MyStringEnumEnforcer = सदस्य = 1: "सदस्य 1", मेंबर 2: "मेंबर 2"} यह गलत संकलक के लिए अनुमति नहीं देता है: हालाँकि मूल परिदृश्य अंततः। इस दृष्टिकोण के साथ बहुत सारे समारोह हैं लेकिन मुझे सुरक्षा पसंद है।
jmorc


40

टाइपस्क्रिप्ट 0.9.0.1 में, हालांकि यह एक संकलक त्रुटि होती है, संकलक अभी भी ts फ़ाइल को js फ़ाइल में संकलित कर सकता है। कोड हमारी अपेक्षा के अनुसार काम करता है और विजुअल स्टूडियो 2012 स्वचालित कोड पूरा करने के लिए समर्थन कर सकता है।

अपडेट करें :

सिंटैक्स में, टाइपस्क्रिप्ट हमें स्ट्रिंग मानों के साथ एक एनम बनाने की अनुमति नहीं देता है, लेकिन हम संकलक को हैक कर सकते हैं: पी

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

खेल का मैदान


1
अच्छा हैक, लेकिन आप इन एनुम / स्थिरांक का उपयोग स्विच स्टेटमेंट में नहीं कर सकते हैं। उदाहरण के case Link.LEARN:लिए Cannot convert 'Link.LEARN' to 'string'बिल्ड एरर मिलेगा । कास्टिंग नहीं चलेगी।
कोडिंग हुई

@TrueBlueAussie यह मुझे TSC 1.0.0.0 चलाने के लिए ठीक काम करने लगता है। इसके अलावा, यदि किसी कारण से आपको केस स्टेटमेंट में एक स्ट्रिंग निरंतर / चर लगाने की आवश्यकता है तो यह काम करेगा यदि आप इसे किसी पर भी डालते हैं।
कोडएंडकैट्स

1
इसके अलावा, धन्यवाद @ zjc0816, मुझे इस समाधान से प्यार हो गया :)
CodeAndCats

यही उपाय मुझे चाहिए था।
मुराफ सूसिल

5
मजेदार, मुझे आश्चर्य है कि टाइपस्क्रिप्ट पहले से ही एनम स्ट्रिंग्स का समर्थन क्यों नहीं करता है ... बहुत सारे लोग यह चाहते हैं (मुझे शामिल किया गया)।
हेंडी इरावन

23

टाइपस्क्रिप्ट 2.1 +

टाइपस्क्रिप्ट 2.1 में प्रस्तुत लुकअप प्रकार , स्ट्रिंग एनमों के अनुकरण के लिए एक और पैटर्न की अनुमति देता है:

// 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');            // 🙁 

टाइपस्क्रिप्ट 2.4 +

संस्करण 2.4 के साथ, टाइपस्क्रिप्ट ने स्ट्रिंग एनम के लिए मूल समर्थन पेश किया, इसलिए उपरोक्त समाधान की आवश्यकता नहीं है। टीएस डॉक्स से:

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

अगर एनम कुंजी नाम स्ट्रिंग मान से अलग है (क्योंकि यह बहुत लंबा है, उदाहरण के लिए) मैं यह कैसे करूंगा?
CletusW

कोई बात नहीं! @ Asukasz-pniewski के जवाब के नीचे दिए गए stackoverflow.com/a/42820134/1431146
CletusW

tslint उस String-Enum उदाहरण पर एक एरर फेकेगा जब Enum को रिवर्स-मैप करने की कोशिश की जाएगी: एलीमेंट का स्पष्ट रूप से एक 'कोई' प्रकार होता है क्योंकि इंडेक्स एक्सप्रेशन 'टाइप' नंबर का नहीं होता है। मुझे लगता है कि मुद्दा यह है कि टीएस स्ट्रिंग एनम में रिवर्स मैप नहीं किया जा सकता है, टाइपिंग-एनम उदाहरण में टाइपस्क्रिप्टब्लैंड . org / docs / handbook / release -notes/… पर टिप्पणी देखें - यह टीएस 2.4 के लिए सही प्रतीत होता है जहां स्ट्रिंग-एनम पेश किया गया था, लेकिन मुझे टीएस 2.6.2 में भी त्रुटि मिली। उदाहरण: Colors["RED"]काम नहीं करेगा। किसी भी विचार यह कैसे हल करने के लिए (JSON रूपांतरण के लिए आवश्यक)।
मासी

19

क्यों न केवल एक एनम के तारों तक पहुँचने के मूल तरीके का उपयोग करें।

enum e {
  WHY,
  NOT,
  USE,
  NATIVE
}

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

2
यह वह उत्तर है जिसकी मुझे तलाश थी, धन्यवाद! अन्य समाधान चतुर
कामचोर हैं

19
इस सवाल का जवाब नहीं है। सवाल किसी एनम के तार तक पहुँचने के बारे में नहीं है। enum Why { Because = "You Can't", Always = "Do Things That Way." };)
जेम्स विल्किंस

संख्यात्मक मान का उपयोग करते समय कुछ समस्याएँ होती हैं, जैसे कि 0 का
गलत

@robmcm ने enum e {WHY = 1, NOT = 2, USE = 3, NATIVE = 4} e [e.WHY] // इस रिटर्न को स्ट्रिंग किया 'WHY'
Mient-jan Stelling

16

आप नवीनतम टाइपस्क्रिप्ट में स्ट्रिंग एनम का उपयोग कर सकते हैं:

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

स्रोत: https://blog.rsuter.com/how-to-implement-an-enum-with-string-values-in-typescript/


अद्यतन - २०१६

इन दिनों रिएक्ट के लिए उपयोग किए जाने वाले तार का एक सेट बनाने का थोड़ा अधिक मजबूत तरीका इस प्रकार है:

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

1
यह सबसे संक्षिप्त तरीका था जिसने मेरे लिए काम किया ... कम से कम जब तक मैं यह पता नहीं लगा सकता कि टीएस 1.8 के साथ संकलन करने के लिए अपने मचान को कैसे अपडेट किया जाए
थिंकबोनोबो

हालाँकि, इसके साथ एक समस्या यह है कि <string>e.helloएक त्रुटि को ट्रिगर करता है। e.helloअभी भी संकलक द्वारा एक संख्या के रूप में माना जाता है। <number>e.helloहालांकि काम करता है। क्या इसके आसपास कोई रास्ता है? सब मैं सोच सकता हूँ <string><any>e.hello
रेनचंचिन

एक और मुद्दा यह है कि जब एनम का सदस्य एनम मूल्य के बराबर होता है। Ex:enum Test { a = <any>"b", b = <any>"c", c = <any>"a" } Test.a === 'c'
रेनिंगचैन

मैं हर समय इस पद्धति का उपयोग करता हूं। स्ट्रिंग एनम की चट्टान। यह निराशाजनक है कि संकलक में स्ट्रिंग शाब्दिकों के लिए प्रथम श्रेणी का समर्थन नहीं है, लेकिन इसमें द्वितीय श्रेणी का समर्थन है। कंपाइलर वास्तव में जानता है कि आपने <किसी भी> हैक का उपयोग किया है क्योंकि यह आपको .d.ts फ़ाइल में इसका उपयोग करने से रोक देगा - जो कि मुझे इस "हैक" के उपयोग के लिए कुछ वैधता देता है क्योंकि कंपाइलर स्पष्ट रूप से अवगत है इसमें से लेकिन यह पूरी तरह से बंद नहीं करता है।
कोडएंडकैट्स

Btw, यदि आप एक स्ट्रिंग <any><string>someStringValue == someEnumValue.toString()
एनम

10

यहां टाइपस्क्रिप्ट 2.0 का उपयोग करके एक काफी साफ समाधान है जो वंशानुक्रम की अनुमति देता है। मैंने पहले वाले संस्करण पर यह कोशिश नहीं की थी।

बोनस: मूल्य किसी भी प्रकार का हो सकता है !

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

1
बहुत बढ़िया जवाब! मैं वंशानुक्रम समर्थन के साथ कुछ एनुम जैसी वस्तु बनाने के लिए संघर्ष कर रहा था।
डैनियलएम

क्लास-आधारित Enum का उपयोग करने वाला एक उदाहरण: goo.gl/SwH4zb (टाइपस्क्रिप्ट के खेल के मैदान के लिए लिंक)।
डैनियलएम

8

इसके लिए एक आसान तरीका है: -

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

कैसे इस्तेमाल करे

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

7

यह मेरे लिए काम करता है:

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

या

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

8)

अपडेट: इसे पोस्ट करने के कुछ समय बाद मैंने एक और तरीका खोजा, लेकिन एक अपडेट पोस्ट करना भूल गया (हालाँकि, किसी ने पहले से ही ऊपर उल्लेख किया है):

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

4

मैं सिर्फ एक इंटरफ़ेस घोषित करता हूं और उस प्रकार के वैरिएबल का उपयोग करता हूं जो एनम को एक्सेस करता है। इंटरफ़ेस और एनम को सिंक में रखना वास्तव में आसान है, क्योंकि टाइपस्क्रिप्ट शिकायत करता है कि एनुम में कुछ परिवर्तन होता है, जैसे।

त्रुटि TS2345: प्रकार 'टाइपऑफ EAbFlagEnum' का तर्क 'IAbFlagEnum' प्रकार के पैरामीटर के लिए उपलब्ध नहीं है। प्रॉपर्टी Property मूव ’टाइप EA टाइपऑफ ईएबीफ्लैगएनम’ में गायब है।

इस विधि का लाभ विभिन्न प्रकार की स्थितियों में एनम (इंटरफ़ेस) का उपयोग करने के लिए किसी प्रकार की कास्टिंग की आवश्यकता नहीं है, और अधिक प्रकार की स्थितियों का समर्थन किया जाता है, जैसे स्विच / केस।

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

वैरिएबल का उपयोग करना, एनम के बजाय वांछित परिणाम पैदा करता है।

var strVal: string = AbFlagEnum.Edit;

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

झंडे मेरे लिए एक और आवश्यकता थी, इसलिए मैंने एक एनपीएम मॉड्यूल बनाया जो इस उदाहरण में जोड़ता है, और परीक्षण शामिल हैं।

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


यह एकमात्र ऐसा उत्तर है जो मैंने पाया जो आयातों के साथ परिभाषाओं को मिलाने की अनुमति देता है। अच्छा! आप export default EAbFlagEnum as IAbFlagEnum;एक चर redeclaring के बजाय उपयोग कर सकते हैं । मैंने भी एनम में <any>डाली को हटा दिया , यह ठीक काम करता है।
गिल्लाउम एफ।

4

अद्यतन: टाइपस्क्रिप्ट 3.4

आप बस का उपयोग कर सकते हैं as const:

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

टाइपस्क्रिप्ट 2.1

इस तरह भी किया जा सकता है। आशा है कि यह किसी की मदद करेगा।

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

मुझे ठीक इसी की आवश्यकता थी! यह समर्थन करता है कि कुंजी नाम स्ट्रिंग मान से अलग है, जैसा कि आपने अपने अपरकेस / लोअरकेस अंतर के साथ दिखाया है। धन्यवाद!
CletusW

2

कस्टम ट्रांसफॉर्मर ( https://github.com/Microsoft/TypeScript/pull/13940 ) के साथ, जो टाइपस्क्रिप्ट @ अगला में उपलब्ध है, आप स्ट्रिंग शाब्दिक प्रकारों से स्ट्रिंग मानों के साथ ऑब्जेक्ट की तरह एनम बना सकते हैं।

कृपया मेरे npm पैकेज, ts- ट्रांसफॉर्मर-एन्यूमरेट में देखें

उदाहरण का उपयोग:

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

2

टाइपस्क्रिप्ट <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!

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

स्रोत लिंक पर आप स्ट्रिंग शाब्दिक प्रकार को पूरा करने के लिए और अधिक और आसान तरीके पा सकते हैं


2

बहुत सारे उत्तर हैं, लेकिन मुझे कोई पूर्ण समाधान नहीं दिखता है। स्वीकार किए गए उत्तर के साथ-साथ समस्या enum { this, one }यह है कि यह आपके द्वारा होने वाली स्ट्रिंग मान को कई फ़ाइलों के माध्यम से उपयोग करने के लिए फैलाता है। मुझे वास्तव में "अपडेट" पसंद नहीं है, यह जटिल है और साथ ही प्रकार का लाभ नहीं उठाता है। मुझे लगता है कि माइकल ब्रॉमली का जवाब सबसे सही है, लेकिन यह इंटरफ़ेस थोड़ा परेशानी का है और एक प्रकार के साथ कर सकता है।

मैं टाइपस्क्रिप्ट 2.0 का उपयोग कर रहा हूँ। * यहाँ मैं क्या करूँगा

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

let greet: Greeting = Greeting.hello

यह भी एक उपयोगी आईडीई का उपयोग करते समय बहुत अच्छे प्रकार / हॉवर से अधिक जानकारी है। ड्रा बैक आपको दो बार स्ट्रिंग्स लिखना है, लेकिन कम से कम यह केवल दो स्थानों पर है।


1

@ बासरत का जवाब बहुत अच्छा था। यहाँ सरलीकृत किया गया है लेकिन थोड़ा सा विस्तारित उदाहरण जिसका आप उपयोग कर सकते हैं:

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

1

हाल ही में टाइपस्क्रिप्ट 1.0.1 के साथ इस समस्या का सामना किया, और इस तरह से हल किया:

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)

0

मुझे लगता है कि आपको इसके साथ प्रयास करना चाहिए, इस मामले में परिवर्तनशील का मान नहीं बदलेगा और यह काफी काम करता है हम दुश्मनी में नहीं चाहते।

namespace portal {

export namespace storageNames {

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

  }
}


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


0

यदि आप चाहते हैं कि मुख्य रूप से आसान डिबग है (काफी प्रकार की जांच के साथ) और एनम के लिए विशेष मान निर्दिष्ट करने की आवश्यकता नहीं है, तो यह है कि यह है:

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

यदि आप विरासत कोड / डेटा भंडारण का समर्थन करना चाहते हैं, तो आप संख्यात्मक कुंजियाँ रख सकते हैं।

इस तरह, आप दो बार मान टाइप करने से बच सकते हैं।


0

स्ट्रिंग के साथ बहुत, बहुत, बहुत सरल Enum (टाइपस्क्रिप्ट 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))
}

0

मैंने टाइपस्क्रिप्ट 1.5 में नीचे की तरह कोशिश की है और यह मेरे लिए काम कर रहा है

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

0

मैं टाइपस्क्रिप्ट एनम (v2.5) में विवरणों को लागू करने का एक तरीका ढूंढ रहा था और इस पैटर्न ने मेरे लिए काम किया:

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

-1

टाइपस्क्रिप्ट 0.9.0.1

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

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

टाइपस्क्रिप्ट खेल का मैदान


परिणामस्वरूप जावास्क्रिप्ट काम करता है, लेकिन यह एक संकलक त्रुटि उत्पन्न करता है Cannot convert 'string' to 'e'.:।
सैम
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.