TypeScript
enums

सभी एनम मूल्यों को कैसे प्राप्त करें

enum SomeEnum { A, B }

let enumValues:Array<string>= [];

for(let value in SomeEnum) {
    if(typeof SomeEnum[value] === 'number') {
        enumValues.push(value);
    }
}

enumValues.forEach(v=> console.log(v))
//A
//B

स्पष्ट मूल्यों के साथ Enums

डिफ़ॉल्ट रूप से सभी enum मान संख्याओं के लिए हल किए जाते हैं। मान लीजिए कि आपके पास कुछ ऐसा है

enum MimeType {
  JPEG,
  PNG,
  PDF
}

MimeType.PDF पीछे वास्तविक मूल्य 2 होगा।

लेकिन कुछ समय के लिए एक अलग प्रकार के लिए एनम का समाधान होना महत्वपूर्ण है। उदाहरण के लिए आपको बैकएंड / फ्रंटेंड / एक और सिस्टम से मूल्य प्राप्त होता है जो निश्चित रूप से एक स्ट्रिंग है। यह दर्द हो सकता है, लेकिन सौभाग्य से यह तरीका है:

enum MimeType {
  JPEG = <any>'image/jpeg',
  PNG = <any>'image/png',
  PDF = <any>'application/pdf'
}

यह MimeType.PDF को application/pdf हल करता है।

टाइपप्रति 2.4 चूंकि यह घोषणा करने के लिए संभव है स्ट्रिंग enums :

enum MimeType {
  JPEG = 'image/jpeg',
  PNG = 'image/png',
  PDF = 'application/pdf',
}

आप समान पद्धति का उपयोग करके स्पष्ट रूप से संख्यात्मक मान प्रदान कर सकते हैं

enum MyType {
   Value = 3,
   ValueEx = 30,
   ValueEx2 = 300
}

फैनसीयर प्रकार भी काम करते हैं, क्योंकि गैर-कॉन्स्टेबल एनम रनटाइम पर वास्तविक वस्तुएं हैं, उदाहरण के लिए

enum FancyType {
   OneArr = <any>[1],
   TwoArr = <any>[2, 2],
   ThreeArr = <any>[3, 3, 3]
}

हो जाता है

var FancyType;
(function (FancyType) {
    FancyType[FancyType["OneArr"] = [1]] = "OneArr";
    FancyType[FancyType["TwoArr"] = [2, 2]] = "TwoArr";
    FancyType[FancyType["ThreeArr"] = [3, 3, 3]] = "ThreeArr";
})(FancyType || (FancyType = {}));

कस्टम enum कार्यान्वयन: enums के लिए फैली हुई है

कभी-कभी अपने दम पर एनम को लागू करना आवश्यक होता है। उदाहरण के लिए, अन्य बातों का विस्तार करने का कोई स्पष्ट तरीका नहीं है। कस्टम कार्यान्वयन यह अनुमति देता है:

class Enum {
  constructor(protected value: string) {}

  public toString() {
    return String(this.value);
  }

  public is(value: Enum | string) {
    return this.value = value.toString();
  }
}

class SourceEnum extends Enum {
  public static value1 = new SourceEnum('value1');
  public static value2 = new SourceEnum('value2');
}

class TestEnum extends SourceEnum {
  public static value3 = new TestEnum('value3');
  public static value4 = new TestEnum('value4');
}

function check(test: TestEnum) {
  return test === TestEnum.value2;
}

let value1 = TestEnum.value1;

console.log(value1 + 'hello');
console.log(value1.toString() === 'value1');
console.log(value1.is('value1'));
console.log(!TestEnum.value3.is(TestEnum.value3));
console.log(check(TestEnum.value2));
// this works but perhaps your TSLint would complain
// attention! does not work with ===
// use .is() instead
console.log(TestEnum.value1 == <any>'value1'); 

कस्टम ईनम कार्यान्वयन के बिना विस्तार से

enum SourceEnum {
  value1 = <any>'value1',
  value2 = <any>'value2'
}

enum AdditionToSourceEnum {
  value3 = <any>'value3',
  value4 = <any>'value4'
}

// we need this type for TypeScript to resolve the types correctly
type TestEnumType = SourceEnum | AdditionToSourceEnum;
// and we need this value "instance" to use values
let TestEnum = Object.assign({}, SourceEnum, AdditionToSourceEnum);
// also works fine the TypeScript 2 feature
// let TestEnum = { ...SourceEnum, ...AdditionToSourceEnum };

function check(test: TestEnumType) {
  return test === TestEnum.value2;
}

console.log(TestEnum.value1);
console.log(TestEnum.value2 === <any>'value2');
console.log(check(TestEnum.value2));
console.log(check(TestEnum.value3));