45 Soru: JavaScript'te enums tanımlamak için tercih edilen sözdizimi nedir? [kapalı]

tarafından oluşturulan soru Wed, Dec 26, 2018 12:00 AM

JavaScript'te enums'ı tanımlamak için tercih edilen sözdizimi nedir? Gibi bir şey:

 
my.namespace.ColorEnum = {
    RED : 0,
    GREEN : 1,
    BLUE : 2
}

// later on

if(currentColor == my.namespace.ColorEnum.RED) {
   // whatever
}

Yoksa daha çok tercih edilen bir deyim var mı?

    
1901
  1. 0'u numaralandırma numarası olarak kullanmayın. Ayarlanmamış bir şey için kullanılmazsa. JS, false || undefined || null || 0 || "" || '' || NaN’u ==’u kullandığında aynı değere sahip olur.
    2015-01-17 18: 10: 32Z
  2. @ matsko ==?
    kullanımına karşı çıkılmaz
    2015-02-24 21: 40: 24Z
  3. 0 == null yanlış döndürüyor
    2015-04-03 14: 58: 10Z
  4. Ancak false == 0 ve +null == 0 (ve sayılara dönüşümler beklemiyorsanız bazen olur), null == undefined ve +undefined ise NaN (NaN != NaN olsa da). div>
    2015-05-30 15: 59: 53Z
  5. İkili eşitlik matrisi, microsoft word'ün otomatik biçimlendirmesinden daha kafa karıştırıcıdır
    2016-03-23 ​​20: 32: 15Z
  6. 30 Yanıtlar                              30                         

    1.8.5'ten beri nesneyi kapatmak ve dondurmak mümkündür, bu nedenle yukarıdakileri tanımlayın:

     
    var DaysEnum = Object.freeze({"monday":1, "tuesday":2, "wednesday":3, ...})
    

    veya

     
    var DaysEnum = {"monday":1, "tuesday":2, "wednesday":3, ...}
    Object.freeze(DaysEnum)
    

    ve işte! JS numaralandırması.

    Not: 2011'de yazdım, ancak enum sözlüğünüzün üzerine yazılmasını önlemek için 2019 - const kullanıyor .

    Ancak, bu genellikle değişkenlerin ana hedefi olan bir değişkene istenmeyen bir değer atamanızı engellemez:

     
    let day = DaysEnum.tuesday
    day = 298832342 // goes through without any errors
    

    Daha güçlü bir tür güvenlik derecesi sağlamanın bir yolu (enums ile veya başka şekilde) TypeScript bir araç kullanmaktır a> veya Akış .

    Kaynak

    Tırnaklara gerek yok ama tutarlılık için onları sakladım.

        
    735
    2019-04-01 12: 56: 40Z
    1. Wikipedia'ya Göre ( en.wikipedia .org /wiki /JavaScript # Sürümleri ) Firefox 4, IE 9, Opera 11.60 için geçerlidir ve Chrome'da çalıştığını biliyorum.
      2012-03-15 11: 05: 04Z
    2. Bu, 2012'de şu anda doğru cevaptır. Daha basit: var DaysEnum = Object.freeze ({ monday: {}, tuesday: {}, ... });. Bir kimlik belirtmenize gerek yoktur, sadece enumları karşılaştırmak için boş bir nesne kullanabilirsiniz. if (incommingEnum === DaysEnum.monday) //incommingEnum is monday
      2012-04-07 10: 29: 14Z
    3. Geriye dönük uyumluluk için, if (Object.freeze) { Object.freeze(DaysEnum); }
      2012-08-24 15: 56: 11Z
    4. ({ monday: {}, vb. işlemin, bu nesneyi stringify ile JSON'a dönüştürürseniz işe yaramayacak olan [{"day": {}}] alacağınızı belirtmek istiyorum.
      2013-02-01 00: 20: 43Z
    5. @ Supuhstar Bu soru hakkında şimdi fikrim farklı. Freeze () kullanmayın, tamamen işe yaramaz ve "aptal" şeyler yaparken zaman kaybı. Bir enum ortaya çıkarmak istiyorsanız, sadece şunu göster: var DaysEnum = {"monday":1, "tuesday":2, "wednesday":3, ...}. Önceki yorumumdaki gibi nesneleri karşılaştırmak, sayıları karşılaştırmak yerine ÇOK DAHA FAZLASI.
      2014-04-09 07: 58: 00Z

    Bu çok fazla bir cevap değil, ancak bunun kişisel olarak işe yarayacağını söyleyebilirim

    Bunu söyledikten sonra, değerlerin ne olduğu önemli olmadığı için (0, 1, 2 kullandınız), şimdiki değeri çıkarmak istemeniz durumunda anlamlı bir dize kullanırım.

        
    594
    2008-11-13 19: 22: 44Z
    1. Bu, başka bir cevapta belirtildi, ancak bu cevap, kabul edilen cevap olduğundan, bunu burada göndereceğim. OP'nin çözümü doğru. Object.freeze() ile birlikte kullanıldığında, daha da iyi olacak. Bu, diğer kodların enum değerlerini değiştirmesini önleyecektir. Örnek: var ColorEnum = Object.freeze({RED: 0, GREEN: 1, BLUE: 2});
      2014-01-16 19: 29: 59Z
    2. @ TolgaE bu kütüphane için teşekkürler! Sadece onu en aza indirgemekle kalmadı, aynı zamanda birkaç özellik de ekledi! Sizinkini çatalladım ve hepsini buraya koydum: github.com/BlueHuskyStudios/Micro-JS-Enum
      2014-04-09 05: 26: 44Z
    3. @ Supuhstar Bu harika! Kullanabildiğine sevindim .. Bu kitaplıkta birleştirilmesini istiyorsan, istek üzerine çekinmeyin, sonra npm kitaplığını güncelleyebilirim
      2014-04-09 15: 00: 41Z
    4. Herhangi biri ilgileniyorsa, uygulandı type-safe Java’da olmalarına benzer numaralar Bu, instanceof çek yapabileceğiniz anlamına gelir. Örneğin ColorEnum.RED instanceof ColorEnum (true döndürür). ColorEnum.fromName("RED") === ColorEnum.RED adındaki bir örneği de çözebilirsiniz (true döndürür). Her örnek ayrıca .name() ve .ordinal() yöntemine sahiptir ve enum'un kendisi de tüm sabitlerin bir dizisini döndüren values() yöntemine sahiptir.
      2015-09-18 22: 16: 01Z
    5. "Anlamlı dize" önerisine katılıyorumdan emin değilim. Enums'ler dizge veya sayı olarak düşünülmemelidir; soyut veri türleridir. Bazı yardımcı metotlar olmadan “akım değerini” vermek mümkün olmamalıdır. Java ve .NET'te ToString() yöntemidir. Biz JS devs zaten zaten "sadece çalışan" şeylere güveniyor! Ayrıca, kişi bir numara üzerinde hızla switch yapabilmelidir. Dizeleri karşılaştırmak sayılara kıyasla daha yavaştır, bu nedenle tamsayılar yerine dizeleri kullanırsanız switch performansınız biraz daha kötüleşir.
      2017-07-06 18: 51: 31Z

    GÜNCELLEME : Herkese teşekkürler için herkese teşekkürler, ancak aşağıdaki cevabım artık Javascript’te enums yazmanın en iyi yolu olduğunu sanmıyorum. Daha fazla ayrıntı için blog gönderime bakın: Javascriptteki Sayılar .


    Adı uyarmak zaten mümkün:

     
    if (currentColor == my.namespace.ColorEnum.RED) {
       // alert name of currentColor (RED: 0)
       var col = my.namespace.ColorEnum;
       for (var name in col) {
         if (col[name] == col.RED)
           alert(name);
       }
    }
    

    Alternatif olarak, değerler nesnelerini yapabilir, böylece pastayı alabilir ve yiyebilirsiniz:

     
    var SIZE = {
      SMALL : {value: 0, name: "Small", code: "S"}, 
      MEDIUM: {value: 1, name: "Medium", code: "M"}, 
      LARGE : {value: 2, name: "Large", code: "L"}
    };
    
    var currentSize = SIZE.MEDIUM;
    if (currentSize == SIZE.MEDIUM) {
      // this alerts: "1: Medium"
      alert(currentSize.value + ": " + currentSize.name);
    }
    

    Javascript'te, dinamik bir dil olduğu için kümeye enum değerlerini eklemek bile mümkündür:

     
    // Add EXTRALARGE size
    SIZE.EXTRALARGE = {value: 3, name: "Extra Large", code: "XL"};
    

    Unutmayın, kimlik kontrolü için enum alanlarına (bu örnekteki değer, isim ve kod) gerek yoktur ve sadece kolaylık sağlamak için oradasınız. Ayrıca size özelliğin adının sabit kodlanması gerekmez, ancak dinamik olarak da ayarlanabilir. Dolayısıyla, yalnızca yeni enum değerinizin adını bildiğinizi varsayarak, hala sorunsuz bir şekilde ekleyebilirsiniz:

     
    // Add 'Extra Large' size, only knowing it's name
    var name = "Extra Large";
    SIZE[name] = {value: -1, name: name, code: "?"};
    

    Elbette bu, bazı varsayımların artık yapılamayacağı anlamına gelir (bu değer örneğin boyut için doğru sırayı temsil eder).

    Unutmayın, Javascript'te bir nesne tıpkı bir harita veya karma tablo gibidir. Bir ad-değer çiftleri kümesi. Önceden fazla bir şey bilmeden bunlar arasında döngü oluşturabilir veya başka şekillerde manipüle edebilirsiniz.

    örn:

     
    for (var sz in SIZE) {
      // sz will be the names of the objects in SIZE, so
      // 'SMALL', 'MEDIUM', 'LARGE', 'EXTRALARGE'
      var size = SIZE[sz]; // Get the object mapped to the name in sz
      for (var prop in size) {
        // Get all the properties of the size object, iterates over
        // 'value', 'name' and 'code'. You can inspect everything this way.        
      }
    } 
    

    Ayrıca btw, ad alanlarıyla ilgileniyorsanız, javascript için basit ama güçlü bir ad alanı ve bağımlılık yönetimi çözümüne bakmak isteyebilirsiniz: JS Paketleri

        
    488
    2017-09-09 18: 41: 26Z
    1. öyleyse sadece isminiz varsa nasıl gidip basit bir SIZE oluşturabilirsin?
      2011-11-10 04: 06: 54Z
    2. @ Johanisma: Bu kullanım durumu, tüm fikirleri önceden bildiğinizden dolayı, enumsiyonlar için mantıklı gelmiyor. Ancak daha sonra Javascript’te fazladan değer eklemenizi engelleyen hiçbir şey yoktur. Cevabımı buna bir örnek ekleyeceğim.
      2011-11-29 10: 43: 19Z
    3. + 1, özellikler yaklaşımınızla gönderinize bağlantı için. Zarif, temel bildirimler, OP'de olduğu gibi, istendiğinde ilave özellikler eklenmiş olarak basittir.
      2014-04-29 15: 35: 28Z
    4. @ Stijin, güncellenmiş çözümünüzü gerçekten beğendi. Blogunuzdaki yorumlarda ve aşağıda bir yorum olarak kod gönderildi. Temel olarak, bir işlev kullanarak, varolan bir karma listesinden özellikleri inşa et ve istediğin şekilde dondur (listemde mkenum_2). Şerefe.
      2014-09-05 19: 10: 47Z
    5. Ayrıca karşılaştırma ve ters arama ile ilgili hoş özellikler içeren bir kitaplık da var: github.com/adrai/enum
      2014-09-27 15: 35: 07Z

    Alt satır: Yapamazsınız.

    Sahte yapabilirsin, ancak tip güvenliği alamazsın. Genellikle bu, tamsayı değerlerine eşlenmiş basit bir dize değerleri sözlüğü oluşturarak yapılır. Örneğin:

     
    var DaysEnum = {"monday":1, "tuesday":2, "wednesday":3, ...}
    
    Document.Write("Enumerant: " + DaysEnum.tuesday);
    

    Bu yaklaşımla ilgili sorun mu var? Kazayla numaralandırıcınızı yeniden tanımlayabilir veya kazara yinelenen numaralandırılmış değerlere sahip olabilirsiniz. Örneğin:

     
    DaysEnum.monday = 4; // whoops, monday is now thursday, too
    

    Düzenle

      

    Peki ya Artur Czajka'nın Object.freeze'i? Bu pazartesiden perşembeye gitmenizi engellemek için olmaz mı? - Fry Quad

    Kesinlikle, Object.freeze şikayet ettiğim sorunu tamamen düzeltirdi. Herkese yukarıdakileri yazarken Object.freeze'un gerçekten var olmadığını hatırlatmak isterim.

    Şimdi .... şimdi bazı çok ilginç olanaklar açılıyor.

    2'yi Düzenle
    Enums oluşturmak için çok iyi bir kütüphane.

    http://www.2ality.com/2011/10/enums.html

    Muhtemelen her emzik kullanımına uymuyor olsa da, çok uzun bir yol alır.

        
    80
    2012-06-06 16: 09: 02Z
    1. javascript'te tür güvenliği var mı?
      2009-08-21 21: 02: 09Z
    2. Böylece değerleri nesne özelliklerine eşleme. Numaralandırıcıya erişmek için getter kullanın ("private" nesnesinin bir özelliği olarak saklanır). Saf bir uygulama şöyle görünür - var daysEnum = (function(){ var daysEnum = { monday: 1, tuesday: 2 }; return { get: function(value){ return daysEnum[value]; } } })(); daysEnum.get('monday'); // 1
      2009-08-22 03: 20: 21Z
    3. @ Scott Evernden: puan alındı. @kangax: Mesele şu ki hala bir hack. Enums, basitçe Javascript, periyod ve hikayenin sonunda yoktur. Tim Sylvester tarafından önerilen model bile, hala ideal kesmekten daha az.
      2009-08-22 20: 14: 12Z
    4. Kodu değişmezler ile serpiştirmek çok fazla bakım gerektirmez, bu yüzden bunun için sabitler oluşturmak mantıklıdır. Tabii ki Javascript’in sabitleri de yoktur. Yani temelde bu sadece temiz kod yazmanın bir yoludur. Uygulanamaz, fakat Javascript'te pek yoktur. Sabitleri, işlevleri veya çoğunlukla herhangi bir şeyi yeniden tanımlayabilirsiniz. EG: document.getElementById = function () {alert ("Sizsinizberbat. Javascript typesafe değil. ");};
      2011-11-29 11: 04: 37Z
    5. @ Randolpho: Artur Czajka'nın Object.freeze'i ne durumda? Bu pazartesiden perşembeye ayarlanmamanızı engellemez mi?
      2012-01-05 15: 58: 23Z

    İşte hepimizin istediği şey:

     
    function Enum(constantsList) {
        for (var i in constantsList) {
            this[constantsList[i]] = i;
        }
    }
    

    Artık enums'lerinizi oluşturabilirsiniz:

     
    var YesNo = new Enum(['NO', 'YES']);
    var Color = new Enum(['RED', 'GREEN', 'BLUE']);
    

    Bunu yaparak, sabitler normal yoldan (YesNo.YES, Color.GREEN) eklenebilir ve sıralı bir int değeri alırlar (NO = 0, YES = 1; RED = 0, GREEN = 1, BLUE = 2).

    Ayrıca Enum.prototype kullanarak yöntemleri ekleyebilirsiniz:

     
    Enum.prototype.values = function() {
        return this.allValues;
        /* for the above to work, you'd need to do
                this.allValues = constantsList at the constructor */
    };
    


    Düzenleme - küçük iyileştirme - şimdi varargs ile: (ne yazık ki IE: S ... 'de düzgün çalışmıyor, önceki sürümde kalmalı)

     
    function Enum() {
        for (var i in arguments) {
            this[arguments[i]] = i;
        }
    }
    
    var YesNo = new Enum('NO', 'YES');
    var Color = new Enum('RED', 'GREEN', 'BLUE');
    
        
    54
    2011-07-19 01: 21: 59Z
    1. Bu cevabın basitliğini sevin!
      2019-06-19 22: 00: 31Z

    Çoğu modern tarayıcıda bir simgesi numaralandırma oluşturmak için kullanılabilecek ilkel veri türü. Her sembol değerinin JavaScript tarafından benzersiz olması güvence altına alındığından, yani Symbol() != Symbol() numaralandırmanın tür güvenliğini sağlayacaktır. Örneğin:

     
    const COLOR = Object.freeze({RED: Symbol(), BLUE: Symbol()});
    

    Hata ayıklamayı basitleştirmek için, enum değerlerine bir açıklama ekleyebilirsiniz:

     
    const COLOR = Object.freeze({RED: Symbol("RED"), BLUE: Symbol("BLUE")});
    

    Plunker demosu

    GitHub 'da, enum'u başlatmak için gereken kodu basitleştiren bir sarıcı bulabilirsiniz:  

    const color = new Enum("RED", "BLUE")
    
    color.RED.toString() // Symbol(RED)
    color.getName(color.RED) // RED
    color.size // 2
    color.values() // Symbol(RED), Symbol(BLUE)
    color.toString() // RED,BLUE
    
        
    47
    2017-12-31 23: 33: 29Z
    1. Teoride doğru cevap budur. Uygulamada, 2015 tarayıcı desteği yeterli olmaktan uzak. Şimdiye kadar üretime hazır değil.
      2015-06-16 08: 14: 37Z
    2. Tarayıcı desteği henüz mevcut olmasa da, bu en iyi cevaptır, çünkü Symbol'un amaçladığı şeye yakındır.
      2016-07-12 22: 49: 48Z
    3. Meh ... enum değerlerinin genellikle serileştirilmesi gerekir ve Semboller serileştirmek ve seri hale getirmek için çok kullanışlı değildir.
      2018-07-25 00: 09: 21Z
    4. Sadece ben miyim veya Object.freeze sadece "kendi sorumluluğunuzda maymun avlama" nin JS'nin sosyal sözleşmesi olduğunu kabul etmemiş insanlar için mi? >
      2018-12-19 02: 10: 34Z

      Enumlarımı sevdiğim için bununla oynuyordum. =)

      Object.defineProperty'u kullanarak sanırım biraz uygun bir çözüm buldum.

      İşte bir jsfiddle: http://jsfiddle.net/ZV4A6/

      Bu yöntemi kullanarak .. (teoride), o nesnenin diğer özelliklerini etkilemeden, herhangi bir nesne için enum değerlerini çağırabilir ve tanımlayabilmelisiniz.

       
      Object.defineProperty(Object.prototype,'Enum', {
          value: function() {
              for(i in arguments) {
                  Object.defineProperty(this,arguments[i], {
                      value:parseInt(i),
                      writable:false,
                      enumerable:true,
                      configurable:true
                  });
              }
              return this;
          },
          writable:false,
          enumerable:false,
          configurable:false
      }); 
      

      writable:false özelliği nedeniyle bu türünü güvenli hale getirmelidir.

      Özel bir nesne yaratabilmeniz için Enum()'u aramanız gerekir. Atanan değerler 0'dan başlar ve öğe başına artım.

       
      var EnumColors={};
      EnumColors.Enum('RED','BLUE','GREEN','YELLOW');
      EnumColors.RED;    // == 0
      EnumColors.BLUE;   // == 1
      EnumColors.GREEN;  // == 2
      EnumColors.YELLOW; // == 3
      
          
      23
      2013-08-21 17: 20: 55Z
      1. Enum'un sonuna return this; eklerseniz, şunları yapabilirsiniz: var EnumColors = {}.Enum('RED','BLUE','GREEN','YELLOW');
        2013-08-21 17: 15: 30Z
      2. Bunu, normal iş yapma yöntemim olmadığı için düşünmedim. Ama kesinlikle haklısın! Bunu düzenleyeceğim.
        2013-08-21 17: 20: 16Z
      3. Nesne alanını büyütmek konusunda büyük bir hayranı olmasam da bunu gerçekten seviyorum (global ENUM işleviyle). Bunu bir mkenum işlevine dönüştürdü ve isteğe bağlı sayısal atamalar ekledi = > var mixedUp = mkenum ('SİYAH', {KIRMIZI: 0x0F00, MAVİ: 0X0F, YEŞİL: 0x0F0, BEYAZ: 0x0FFF, BİR: 1}, İKİ, ÜÇ, DÖRT); //Kodumu aşağıya bir cevap olarak ekliyorum. Teşekkürler.
        2014-09-05 18: 44: 16Z
      4. Dürüst olmak gerekirse, artık bunu kullanmıyorum. Google’ın Kapatma Derleyicisini kullanıyorum ve Gelişmiş ayarını kullanıyorsanız bu çok iyi çalışmıyor (veya yalnızca işleri karmaşıklaştırıyor). Bu yüzden standart nesne notasyonuna geri döndüm.
        2014-09-08 17: 32: 33Z
      5. false, writable, enumerable ve configurable için varsayılandır. Varsayılanları çiğnemeye gerek yok.
        2015-11-02 16: 03: 25Z

      Çoğu kişi tarafından "Tercih Edilen Sözdizimi" zaten yukarıda listelenmiştir. Ancak, büyük bir genel sorun var: kod boyutu. Burada listelenen diğer her cevap, kodunuzun boyutunu aşırı derecede şişirir. Ayrıca, eldeki soru, çok fazla görüş içerdiği için bekletildi . Bu nedenle, size mümkün olan en iyi performans, kodun okunabilirliği, büyük ölçekli proje yönetimi, birçok kod editöründe sözdizimi ipucu ve kod boyutunda küçültmeyle küçültme için gerçeğini teklif ediyorum. numaralandırma yapmak için: alt çizgi gösterim değişkenleri.

      Alt çizgi-gösterim değişkenleri

       
          const ENUM_COLORENUM_RED   = 0,
                ENUM_COLORENUM_GREEN = 1,
                ENUM_COLORENUM_BLUE  = 2,
                ENUMLEN_COLORENUM    = 3;
      
          // later on
      
          if(currentColor === ENUM_COLORENUM_RED) {
             // whatever
          }
      

      Büyük Harf Değişkenlerini İlave Olarak Genişlet

      Büyük harfli değişkenleri ekleme ile genişletme. Ek olarak, bu sözdizimi, aşağıda görüldüğü gibi genişleyen açık ve öz bir sınıf sağlar.

       
      (function(window){
          "use strict";
          var parseInt = window.parseInt
      
          // use INDEX_ when representing the index in an array instance
          const INDEX_PIXELCOLOR_TYPE = 0, // is a ENUM_PIXELTYPE
                INDEXLEN_PIXELCOLOR   = 1,
                INDEX_SOLIDCOLOR_R    = INDEXLEN_PIXELCOLOR+0,
                INDEX_SOLIDCOLOR_G    = INDEXLEN_PIXELCOLOR+1,
                INDEX_SOLIDCOLOR_B    = INDEXLEN_PIXELCOLOR+2,
                INDEXLEN_SOLIDCOLOR   = INDEXLEN_PIXELCOLOR+3,
                INDEX_ALPHACOLOR_R    = INDEXLEN_PIXELCOLOR+0,
                INDEX_ALPHACOLOR_G    = INDEXLEN_PIXELCOLOR+1,
                INDEX_ALPHACOLOR_B    = INDEXLEN_PIXELCOLOR+2,
                INDEX_ALPHACOLOR_A    = INDEXLEN_PIXELCOLOR+3,
                INDEXLEN_ALPHACOLOR   = INDEXLEN_PIXELCOLOR+4,
          // use ENUM_ when representing a mutually-exclusive species or type
                ENUM_PIXELTYPE_SOLID = 0,
                ENUM_PIXELTYPE_ALPHA = 1,
                ENUM_PIXELTYPE_UNKNOWN = 2,
                ENUMLEN_PIXELTYPE    = 2;
      
          function parseHexColor(inputString) {
              var rawstr = inputString.trim().substring(1);
              var result = [];
              if (rawstr.length === 8) {
                  result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_ALPHA;
                  result[INDEX_ALPHACOLOR_R] = parseInt(rawstr.substring(0,2), 16);
                  result[INDEX_ALPHACOLOR_G] = parseInt(rawstr.substring(2,4), 16);
                  result[INDEX_ALPHACOLOR_B] = parseInt(rawstr.substring(4,6), 16);
                  result[INDEX_ALPHACOLOR_A] = parseInt(rawstr.substring(4,6), 16);
              } else if (rawstr.length === 4) {
                  result[INDEX_ALPHACOLOR_R] = parseInt(rawstr[0], 16) * 0x11;
                  result[INDEX_ALPHACOLOR_G] = parseInt(rawstr[1], 16) * 0x11;
                  result[INDEX_ALPHACOLOR_B] = parseInt(rawstr[2], 16) * 0x11;
                  result[INDEX_ALPHACOLOR_A] = parseInt(rawstr[3], 16) * 0x11;
              } else if (rawstr.length === 6) {
                  result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_SOLID;
                  result[INDEX_SOLIDCOLOR_R] = parseInt(rawstr.substring(0,2), 16);
                  result[INDEX_SOLIDCOLOR_G] = parseInt(rawstr.substring(2,4), 16);
                  result[INDEX_SOLIDCOLOR_B] = parseInt(rawstr.substring(4,6), 16);
              } else if (rawstr.length === 3) {
                  result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_SOLID;
                  result[INDEX_SOLIDCOLOR_R] = parseInt(rawstr[0], 16) * 0x11;
                  result[INDEX_SOLIDCOLOR_G] = parseInt(rawstr[1], 16) * 0x11;
                  result[INDEX_SOLIDCOLOR_B] = parseInt(rawstr[2], 16) * 0x11;
              } else {
                  result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_UNKNOWN;
              }
              return result;
          }
      
          // the red component of green
          console.log(parseHexColor("#0f0")[INDEX_SOLIDCOLOR_R]);
          // the alpha of transparent purple
          console.log(parseHexColor("#f0f7")[INDEX_ALPHACOLOR_A]); 
          // the enumerated array for turquoise
          console.log(parseHexColor("#40E0D0"));
      })(self);

      (Uzunluk: 2.450 bayt)

      Bazıları bunun diğer çözümlere göre daha az pratik olduğunu söyleyebilir: tonlarca alan bekler, yazması uzun zaman alır ve şeker sözdizimi ile kaplanmış değildir. Bu insanlar, kodlarını küçültmezlerse haklılar. Bununla birlikte, makul bir kişi son üründe unifified kod bırakmaz. Bu küçültme için, Closure Compiler henüz bulamamış olduğum en iyisi. Çevrimiçi erişim burada bulunabilir. Kapanış derleyicisi, tüm bu numaralandırma verilerini alabilir ve satır içi olarak düzenleyebilir, böylece Javascript'in süper duper küçük olmasını ve süper duper hızlı çalışmasını sağlar. Böylece, Kapatma Derleyici ile küçültün. Gözlemleyin.

      Kapatma Derleyicisi ile küçültün

       
      'use strict';(function(e){function d(a){a=a.trim().substring(1);var b=[];8===a.length?(b[0]=1,b[1]=c(a.substring(0,2),16),b[2]=c(a.substring(2,4),16),b[3]=c(a.substring(4,6),16),b[4]=c(a.substring(4,6),16)):4===a.length?(b[1]=17*c(a[0],16),b[2]=17*c(a[1],16),b[3]=17*c(a[2],16),b[4]=17*c(a[3],16)):6===a.length?(b[0]=0,b[1]=c(a.substring(0,2),16),b[2]=c(a.substring(2,4),16),b[3]=c(a.substring(4,6),16)):3===a.length?(b[0]=0,b[1]=17*c(a[0],16),b[2]=17*c(a[1],16),b[3]=17*c(a[2],16)):b[0]=2;return b}var c=
      e.parseInt;console.log(d("#0f0")[1]);console.log(d("#f0f7")[4]);console.log(d("#40E0D0"))})(self);

      (Uzunluk: 605 bayt)

      Küçük Kod Boyutu

      Şimdi, eşdeğer dosyanın bu numaralandırmaların hiçbiri olmadan ne kadar büyük olacağını görelim.

      Numaralandırma Kullanmadan Kaynak (uzunluk: 1.973 bayt (numaralandırılmış koddan daha kısa 477 bayt!))
      Numaralandırmaları Kullanmadan küçültülmüş (uzunluk: 843 bayt (238 bayt numaralandırılmış koddan daha uzun) ))

      Görüldüğü gibi, numaralandırma olmadan, kaynak kodu daha büyük küçültülmüş bir kodun maliyetinde daha kısadır. Hakkında bir şey bilmiyorum; ancak kaynak kodu son ürüne dahil etmediğimden eminim. Bu nedenle, bu numaralandırma biçimi, daha küçük küçültülmüş dosya boyutlarıyla sonuçlanmasından çok daha üstündür.

      Bu numaralandırma biçiminin bir başka avantajı, küçültülmüş kod boyutundan ödün vermeden büyük ölçekli projeleri kolayca yönetmek için kullanılabiliyor olmasıdır. Çok sayıda başka kişiyle büyük bir projede çalışırken, kodu oluşturan değişken adlarını açıkça işaretlemek ve etiketlemek faydalı olabilir.Kodun orijinal oluşturucusu, ortak hata düzeltmesi için hızlı bir şekilde tanımlanabilir.

      Kooperatif Hata Düzeltme

       
      // JG = Jack Giffin
      const ENUM_JG_COLORENUM_RED   = 0,
            ENUM_JG_COLORENUM_GREEN = 1,
            ENUM_JG_COLORENUM_BLUE  = 2,
            ENUMLEN_JG_COLORENUM    = 3;
      
      // later on
      
      if(currentColor === ENUM_JG_COLORENUM_RED) {
         // whatever
      }
      
      // PL = Pepper Loftus
      // BK = Bob Knight
      const ENUM_PL_ARRAYTYPE_UNSORTED   = 0,
            ENUM_PL_ARRAYTYPE_ISSORTED   = 1,
            ENUM_BK_ARRAYTYPE_CHUNKED    = 2, // added by Bob Knight
            ENUM_JG_ARRAYTYPE_INCOMPLETE = 3, // added by jack giffin
            ENUMLEN_PL_COLORENUM         = 4;
      
      // later on
      
      if(
        randomArray === ENUM_PL_ARRAYTYPE_UNSORTED ||
        randomArray === ENUM_BK_ARRAYTYPE_CHUNKED
      ) {
         // whatever
      }
      

      Üstün Performans

      Dahası, bu numaralandırma formu da minifikasyondan sonra çok daha hızlıdır. Normal adlandırılmış özelliklerde, tarayıcının özelliğin nesnede nerede olduğunu bulmak için hashmaps kullanmak zorundadır. Her ne kadar JIST derleyicileri nesnenin üzerindeki bu yeri akıllıca önbelleğe alsa da, nesneden daha düşük bir özelliği silmek gibi özel durumlar için hala çok fazla masraf var.

       Ancak, sürekli seyrek olmayan tamsayı indeksli sürekli PACKED_ELEMENTS dizileriyle tarayıcı, iç dizideki değerin dizini zaten belirtildiği için bu ek yükün çoğunu atlayabilir. Evet, ECMAScript standardına göre, tüm özelliklerin karakter dizisi olarak kabul edilmesi gerekiyor. Bununla birlikte, ECMAScript standardının bu yönü performans konusunda çok yanıltıcıdır, çünkü tüm tarayıcılar dizilerdeki sayısal dizinler için özel optimizasyonlara sahiptir.

      Kolay Hata Ayıklama

      Ayrıca, kişisel üstte kirazım , CodeMirror Javascript modunda metin editörü. CodeMirror'un Javascript sözdizimi vurgulama modu, geçerli kapsamdaki yerel değişkenleri vurgular. Bu şekilde, bir değişken adını doğru yazdığınızda anında anlarsınız çünkü değişken ismi önceden var anahtar kelimesiyle bildirilmişse, değişken ismi özel bir renge döner (varsayılan olarak camgöbeği). CodeMirror'ı kullanmasanız bile, en azından tarayıcı yanlış yazılmış numaralandırma adlarıyla kod çalıştırırken yararlı bir [variable name] is not defined istisna atar. Ayrıca, JSLint ve Closure Compiler gibi JavaScript araçları, bir numaralandırma değişkeni adında yanlış yazdığınızda size bildirme konusunda oldukça yüksek. CodeMirror, tarayıcı ve bir araya getirilmiş çeşitli Javascript araçları, bu numaralandırma biçiminde hata ayıklamayı çok basit ve çok kolay hale getirir.

      Bunun Mükemmel Bir Sonuç Olduğu

      Bu nedenle, aslında, bu numaralandırma biçiminin yalnızca küçültülmüş kod boyutu için değil aynı zamanda performans, netlik ve işbirliği için de en iyi yol olduğu sonucuna varıyorum.

      Size Yardımcı Olan Sorulara Teşekkür Verin

      Bir hesabı olanlar için, yapıcı yararlı bir soruyu okuduktan sonra, yazara bu kadar güzel bir soru sordukları için teşekkür etmek üzere sayfanın solundaki "Upvote" okunu tıklayabilirsiniz. Aynısı cevaplar için de geçerlidir: Sağlam yapıcı bir cevap yazmak için çok zaman ve çaba harcayanlara teşekkür etmek için her cevap için ayrı bir sol ok vardır.

          
      20
      2019-06-26 15: 44: 35Z

      Bu eski bir tanim, ama o zamandan beri TypeScript arayüzüyle uygulanma şekli:

       
      var MyEnum;
      (function (MyEnum) {
          MyEnum[MyEnum["Foo"] = 0] = "Foo";
          MyEnum[MyEnum["FooBar"] = 2] = "FooBar";
          MyEnum[MyEnum["Bar"] = 1] = "Bar";
      })(MyEnum|| (MyEnum= {}));
      

      Bu, bildirim sırasına bakılmaksızın hem 1 döndüren hem de "Bar" döndüren MyEnum.Bar’a bakmanıza olanak sağlar.

          
      17
      2013-06-24 16: 11: 14Z
      1. Artı MyEnum ["Bar"] şu ana kadar 1 ... < 3 TypeScript döndüren çalışır ...
        2014-01-05 09: 41: 21Z
      2. ve tabii ki Typescript: A350 kullanıyorsanız elbette
        2015-07-28 23: 42: 54Z

        Javascript'i kullanın Proxy'ler

        TLDR: Bu sınıfı hizmet yöntemlerinize ekleyin ve kodunuz boyunca kullanın, geleneksel programlama dillerinden Enum davranışını aştı ve gerçekte herhangi bir numaralandırıcıya erişmeye çalıştığınızda hatalar atar. var veya bir numaralandırıcı ekleyin /güncelleyin. MyEnum[1]'a güvenmenize gerek yok.

         enum MyEnum { Foo, Bar, Foobar }

        Ardından sınıfı başlatarak enums'lar oluşturun:

         Object.freeze()

        Tam Açıklama:

        Enums'ın çok faydalı bir özelliğigeleneksel dillerden aldığınız şey, mevcut olmayan bir numaralandırıcıya erişmeye çalışırsanız havaya uçurmaları (bir derleme zamanı hatası atma) olmasıdır.

        Yanlışlıkla /kötü amaçlı olarak ilave değerlerin eklenmesini önlemek için sahte enum yapısının dondurulmasının yanı sıra, diğer cevapların hiçbiri Enums’in kendine özgü özelliğini ele almıyor.

        Muhtemelen bildiğiniz gibi, JavaScript’te mevcut olmayan üyelere erişmek sadece

        class Enum {
          constructor(enumObj) {
            const handler = {
              get(target, name) {
                if (typeof target[name] != 'undefined') {
                  return target[name];
                }
                throw new Error(`No such enumerator: ${name}`);
              },
              set() {
                throw new Error('Cannot add/update properties on an Enum instance after it is defined')
              }
            };
        
            return new Proxy(enumObj, handler);
          }
        }
        
        ’u döndürür ve kodunuzu patlatmaz. Numaralandırıcılar önceden tanımlanmış sabitler (yani haftanın günleri) olduğundan, bir numaralandırıcının tanımsız olması gerektiği durumlarda hiçbir zaman bir durum olmamalıdır.

        Beni yanlış anlamayın, tanımsız özelliklere erişirken JavaScript’in

        const roles = new Enum({
          ADMIN: 'Admin',
          USER: 'User',
        });
        
        döndürme davranışı aslında dilin çok güçlü bir özelliğidir, ancak geleneksel Enum yapılarıyla alay etmeye çalışırken istediğiniz bir özellik değildir.

        Burası Proxy nesnelerinin parladığı yerdir. ES6 (ES2015) tanıtımıyla vekiller dilde standardize edildi. İşte MDN'den açıklama:

          

        Proxy nesnesi, temel işlemler için özel davranış tanımlamak için kullanılır (örneğin, özellik arama, atama, numaralandırma, işlev   çağrı, vb.)

        Bir web sunucusu proxy'sine benzer şekilde, JavaScript proxy'leri nesnelerdeki işlemleri ("tuzaklar" kullanarak) arayabilir, isterseniz kanca olarak adlandırabilir ve daha önce çeşitli denetimler, işlemler ve /veya manipülasyonlar gerçekleştirmenize izin verebilir tamamlandı (ya da bazı durumlarda işlemlerin tamamen durması; bu, var olmayan bir numaralandırıcıya başvurmaya çalıştığımızda tam olarak ne yapmak istediğimizdir).

        İşte Enums'leri taklit etmek için Proxy nesnesini kullanan tartışmalı bir örnek. Bu örnekteki numaralayıcılar standart HTTP Metodlarıdır (yani, "GET", "POST", vb.):

         undefined

        ASIDE: Bir vekil nedir?

        Proxy kelimesini her yerde görmeye başladığımı hatırlıyorum, uzun zamandır kesinlikle bana bir şey ifade etmiyordu. Şu anda sizseniz, proxy'leri genelleştirmenin kolay bir yolu, onları yazılım, kurum veya hatta iki sunucu, şirket veya kişi arasında aracı veya aracı olarak davranan insanlar olarak düşünmektir.

            
        17
        2019-02-12 17: 31: 20Z
        1. myEnum.valueOf ("someStringValue") gibi bir şey nasıl yapılır? Beklenen: giriş dizesinin numaralandırıcının bir öğesinin bir değeri varsa, öğeyi döndürmelidir. Hiçbir öğenin bu dize değerine sahip olmaması durumunda, istisna atma.
          2019-01-31 17: 51: 16Z
        2. @ sscarduzio, Enum sınıfında örnek yöntem olarak belirterek, varsayılan undefined yöntemini geçersiz kılabilirsiniz. Ancak, neden bu noktaya erişmek istiyorsanız, sadece nokta gösterimi ile erişmek yerine?
          2019-01-31 18: 00: 16Z
        3. Enum'um const logLevelEnum = new Enum ({INFO: "info", DEBUG: "debug"}) ve isteğe bağlı bir "info" dizesini girip ayrıştırıyorum. "debug". Bu yüzden currentLogLevel = logLevelEnum.parseOrThrow (settings.get ("log_level"))
          gibi bir şeye ihtiyacım var
          2019-02-01 13: 33: 13Z
        4. Neden
          // Class for creating enums (13 lines)
          // Feel free to add this to your utility library in 
          // your codebase and profit! Note: As Proxies are an ES6 
          // feature, some browsers/clients may not support it and 
          // you may need to transpile using a service like babel
          
          class Enum {
            // The Enum class instantiates a JavaScript Proxy object.
            // Instantiating a `Proxy` object requires two parameters, 
            // a `target` object and a `handler`. We first define the handler,
            // then use the handler to instantiate a Proxy.
          
            // A proxy handler is simply an object whose properties
            // are functions which define the behavior of the proxy 
            // when an operation is performed on it. 
            
            // For enums, we need to define behavior that lets us check what enumerator
            // is being accessed and what enumerator is being set. This can be done by 
            // defining "get" and "set" traps.
            constructor(enumObj) {
              const handler = {
                get(target, name) {
                  if (typeof target[name] != 'undefined') {
                    return target[name]
                  }
                  throw new Error(`No such enumerator: ${name}`)
                },
                set() {
                  throw new Error('Cannot add/update properties on an Enum instance after it is defined')
                }
              }
          
          
              // Freeze the target object to prevent modifications
              return new Proxy(enumObj, handler)
            }
          }
          
          
          // Now that we have a generic way of creating Enums, lets create our first Enum!
          const httpMethods = new Enum({
            DELETE: "DELETE",
            GET: "GET",
            OPTIONS: "OPTIONS",
            PATCH: "PATCH",
            POST: "POST",
            PUT: "PUT"
          })
          
          // Sanity checks
          console.log(httpMethods.DELETE)
          // logs "DELETE"
          
          try {
            httpMethods.delete = "delete"
          } catch (e) {
          console.log("Error: ", e.message)
          }
          // throws "Cannot add/update properties on an Enum instance after it is defined"
          
          try {
            console.log(httpMethods.delete)
          } catch (e) {
            console.log("Error: ", e.message)
          }
          // throws "No such enumerator: delete"
          'u yapamadı? valueOf’un eklenmesi, proxy tuzaklarının zaten sizin için ne yaptığını tekrarlardı.
          2019-02-01 22: 26: 54Z

        Bu benim kullandığım çözüm.

         logLevelEnum[settings.get("log_level")]

        Siz de enumslarınızı şöyle tanımlayın:

         parseOrThrow

        Ve bu, enums'larınıza erişme şeklinizdir:

         
        function Enum() {
            this._enums = [];
            this._lookups = {};
        }
        
        Enum.prototype.getEnums = function() {
            return _enums;
        }
        
        Enum.prototype.forEach = function(callback){
            var length = this._enums.length;
            for (var i = 0; i < length; ++i){
                callback(this._enums[i]);
            }
        }
        
        Enum.prototype.addEnum = function(e) {
            this._enums.push(e);
        }
        
        Enum.prototype.getByName = function(name) {
            return this[name];
        }
        
        Enum.prototype.getByValue = function(field, value) {
            var lookup = this._lookups[field];
            if(lookup) {
                return lookup[value];
            } else {
                this._lookups[field] = ( lookup = {});
                var k = this._enums.length - 1;
                for(; k >= 0; --k) {
                    var m = this._enums[k];
                    var j = m[field];
                    lookup[j] = m;
                    if(j == value) {
                        return m;
                    }
                }
            }
            return null;
        }
        
        function defineEnum(definition) {
            var k;
            var e = new Enum();
            for(k in definition) {
                var j = definition[k];
                e[k] = j;
                e.addEnum(j)
            }
            return e;
        }
        

        Mesaj nesnelerinden enumları eşlemek için genellikle son 2 yöntemi kullanırım.

        Bu yaklaşımın bazı avantajları:

        • Enums bildirmek kolay
        • Enumlarınıza erişmek kolay
        • Enumslarınız karmaşık tiplerde olabilir
        • Enum sınıfında, getByValue çok kullanıyorsanız, bazı önbelleğe alma işlemleri vardır

        Bazı dezavantajlar:

        • Orada bazı dağınık bellek yönetimi var.
        • Hala tür güvenliği yok
        15
        2012-05-15 09: 31: 57Z

        ES7 'de statik özelliklere dayanan zarif bir ENUM yapabilirsiniz. :

         
        var COLORS = defineEnum({
            RED : {
                value : 1,
                string : 'red'
            },
            GREEN : {
                value : 2,
                string : 'green'
            },
            BLUE : {
                value : 3,
                string : 'blue'
            }
        });
        

        sonra

         
        COLORS.BLUE.string
        COLORS.BLUE.value
        COLORS.getByName('BLUE').string
        COLORS.getByValue('value', 1).string
        
        COLORS.forEach(function(e){
            // do what you want with e
        });
        

        Bunun avantajı (değişmez nesne yerine sınıf kullanmanın)

        class ColorEnum  {
            static RED = 0 ;
            static GREEN = 1;
            static BLUE = 2;
        }
        
        ebeveyn sınıfına sahip olmaktır; bu durumda tüm Enums'larınız bu sınıfı genişletir .  
        if (currentColor === ColorEnum.GREEN ) {/*-- coding --*/}
        
            
        15
        2017-01-06 07: 07: 59Z
        1. Bir ebeveyn sınıfına sahip olmanın neden bir avantaj olduğunu açıklayabilir misiniz? Bir şeyleri özlüyorum gibi hissediyorum!
          2017-02-01 09: 57: 22Z
        2. Bunu yapma. Enum kesinlikle anlamsız.
          2017-06-09 01: 43: 14Z
        3. bir enum genişletmek çılgınca geliyor, gerçekten
          2017-07-06 13: 30: 12Z
        4. dil yerel olarak desteklemediğinde, bu sözleşmeyi sürdürmek ve bunun gibi kullanmak mantıklı olacaktır! katılıyorum!
          2017-10-06 07: 31: 38Z

        Bir nesne hazır bilgisi oluşturun:

         
         class ColorEnum  extends Enum {/*....*/}
        
            
        14
        2017-06-01 17: 03: 41Z
        1. new ColorEnum(), nesnenin özelliklerini değiştirilemez kılmıyor, yalnızca
          const Modes = {
            DRAGGING: 'drag',
            SCALING:  'scale',
            CLICKED:  'click'
          };
          
          değişkeninin başka bir şeye atanamayacağı anlamına geliyor. Daha eksiksiz hale getirmek için const Modes ile birlikte.
          2016-07-12 22: 47: 16Z
        2. Lütfen Object.freeze() kullanmayın. Closure Compiler'ın nesnenin içine girmesini önler.
          2018-10-07 13: 21: 02Z

        Omurga kullanıyorsanız, tam gelişmiş enum işlevselliği elde edebilirsiniz (kimliğe, isme ve özel üyelere göre bulabilirsiniz) ) Backbone.Collection . kullanarak ücretsiz  const     

        11
        2012-04-24 14: 04: 46Z

        cevaplarınız çok karmaşık.

         Object.freeze     
        8
        2014-05-15 04: 20: 02Z
        1. @ JackGiffin Cevabınızın daha performanslı olduğu ve benimkinin daha fazla hafıza alabileceği konusunda hemfikirsiniz, ancak herkesin C ++ uygulamasının enum yolunu istediğini varsaymamalısınız. Lütfen diğer cevaplara ve bunu sizin tercihinize göre tercih edebilecek geliştiricilere saygı gösterin.
          2018-12-14 15: 09: 14Z

        Andre 'Fi'nin çözümünü değiştirdim:

         
        // enum instance members, optional
        var Color = Backbone.Model.extend({
            print : function() {
                console.log("I am " + this.get("name"))
            }
        });
        
        // enum creation
        var Colors = new Backbone.Collection([
            { id : 1, name : "Red", rgb : 0xFF0000},
            { id : 2, name : "Green" , rgb : 0x00FF00},
            { id : 3, name : "Blue" , rgb : 0x0000FF}
        ], {
            model : Color
        });
        
        // Expose members through public fields.
        Colors.each(function(color) {
            Colors[color.get("name")] = color;
        });
        
        // using
        Colors.Red.print()
        

        Test:

         
        var buildSet = function(array) {
          var set = {};
          for (var i in array) {
            var item = array[i];
            set[item] = item;
          }
          return set;
        }
        
        var myEnum = buildSet(['RED','GREEN','BLUE']);
        // myEnum.RED == 'RED' ...etc
        
            
        7
        2013-04-12 17: 04: 16Z

        Java’da numaralandırıldıktan sonra modellenmiş bu yaklaşımla geldim. Bunlar güvenlidir ve böylece

          function Enum() {
            var that = this;
            for (var i in arguments) {
                that[arguments[i]] = i;
            }
            this.name = function(value) {
                for (var key in that) {
                    if (that[key] == value) {
                        return key;
                    }
                }
            };
            this.exist = function(value) {
                return (typeof that.name(value) !== "undefined");
            };
            if (Object.freeze) {
                Object.freeze(that);
            }
          }
        
        adet kontrol de yapabilirsiniz.

        Bunun gibi enumları tanımlayabilirsiniz:

         
        var Color = new Enum('RED', 'GREEN', 'BLUE');
        undefined
        Color.name(Color.REDs)
        undefined
        Color.name(Color.RED)
        "RED"
        Color.exist(Color.REDs)
        false
        Color.exist(Color.RED)
        true
        

        instanceof şimdi

        var Days = Enum.define("Days", ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]);
        
        numaralandırmasını ifade ediyor:  Days

        Uygulama:

         Days     
        6
        2015-09-18 22: 11: 20Z
        1. Güzel görünüyor, belki de geriye dönük uyumluluk için
          Days.Monday instanceof Days; // true
          
          Days.Friday.name(); // "Friday"
          Days.Friday.ordinal(); // 4
          
          Days.Sunday === Days.Sunday; // true
          Days.Sunday === Days.Friday; // false
          
          Days.Sunday.toString(); // "Sunday"
          
          Days.toString() // "Days { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday } "
          
          Days.values().map(function(e) { return e.name(); }); //["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
          Days.values()[4].name(); //"Friday"
          
          Days.fromName("Thursday") === Days.Thursday // true
          Days.fromName("Wednesday").name() // "Wednesday"
          Days.Friday.fromName("Saturday").name() // "Saturday"
          
          yönteminin varlığını kontrol etmelisiniz? Örneğin,
          var Enum = (function () {
              /**
               * Function to define an enum
               * @param typeName - The name of the enum.
               * @param constants - The constants on the enum. Can be an array of strings, or an object where each key is an enum
               * constant, and the values are objects that describe attributes that can be attached to the associated constant.
               */
              function define(typeName, constants) {
          
                  /** Check Arguments **/
                  if (typeof typeName === "undefined") {
                      throw new TypeError("A name is required.");
                  }
          
                  if (!(constants instanceof Array) && (Object.getPrototypeOf(constants) !== Object.prototype)) {
          
                      throw new TypeError("The constants parameter must either be an array or an object.");
          
                  } else if ((constants instanceof Array) && constants.length === 0) {
          
                      throw new TypeError("Need to provide at least one constant.");
          
                  } else if ((constants instanceof Array) && !constants.reduce(function (isString, element) {
                          return isString && (typeof element === "string");
                      }, true)) {
          
                      throw new TypeError("One or more elements in the constant array is not a string.");
          
                  } else if (Object.getPrototypeOf(constants) === Object.prototype && !Object.keys(constants).reduce(function (isObject, constant) {
                          return Object.getPrototypeOf(constants[constant]) === Object.prototype;
                      }, true)) {
          
                      throw new TypeError("One or more constants do not have an associated object-value.");
          
                  }
          
                  var isArray = (constants instanceof Array);
                  var isObject = !isArray;
          
                  /** Private sentinel-object used to guard enum constructor so that no one else can create enum instances **/
                  function __() { };
          
                  /** Dynamically define a function with the same name as the enum we want to define. **/
                  var __enum = new Function(["__"],
                      "return function " + typeName + "(sentinel, name, ordinal) {" +
                          "if(!(sentinel instanceof __)) {" +
                              "throw new TypeError(\"Cannot instantiate an instance of " + typeName + ".\");" +
                          "}" +
          
                          "this.__name = name;" +
                          "this.__ordinal = ordinal;" +
                      "}"
                  )(__);
          
                  /** Private objects used to maintain enum instances for values(), and to look up enum instances for fromName() **/
                  var __values = [];
                  var __dict = {};
          
                  /** Attach values() and fromName() methods to the class itself (kind of like static methods). **/
                  Object.defineProperty(__enum, "values", {
                      value: function () {
                          return __values;
                      }
                  });
          
                  Object.defineProperty(__enum, "fromName", {
                      value: function (name) {
                          var __constant = __dict[name]
                          if (__constant) {
                              return __constant;
                          } else {
                              throw new TypeError(typeName + " does not have a constant with name " + name + ".");
                          }
                      }
                  });
          
                  /**
                   * The following methods are available to all instances of the enum. values() and fromName() need to be
                   * available to each constant, and so we will attach them on the prototype. But really, they're just
                   * aliases to their counterparts on the prototype.
                   */
                  Object.defineProperty(__enum.prototype, "values", {
                      value: __enum.values
                  });
          
                  Object.defineProperty(__enum.prototype, "fromName", {
                      value: __enum.fromName
                  });
          
                  Object.defineProperty(__enum.prototype, "name", {
                      value: function () {
                          return this.__name;
                      }
                  });
          
                  Object.defineProperty(__enum.prototype, "ordinal", {
                      value: function () {
                          return this.__ordinal;
                      }
                  });
          
                  Object.defineProperty(__enum.prototype, "valueOf", {
                      value: function () {
                          return this.__name;
                      }
                  });
          
                  Object.defineProperty(__enum.prototype, "toString", {
                      value: function () {
                          return this.__name;
                      }
                  });
          
                  /**
                   * If constants was an array, we can the element values directly. Otherwise, we will have to use the keys
                   * from the constants object.
                   */
                  var _constants = constants;
                  if (isObject) {
                      _constants = Object.keys(constants);
                  }
          
                  /** Iterate over all constants, create an instance of our enum for each one, and attach it to the enum type **/
                  _constants.forEach(function (name, ordinal) {
                      // Create an instance of the enum
                      var __constant = new __enum(new __(), name, ordinal);
          
                      // If constants was an object, we want to attach the provided attributes to the instance.
                      if (isObject) {
                          Object.keys(constants[name]).forEach(function (attr) {
                              Object.defineProperty(__constant, attr, {
                                  value: constants[name][attr]
                              });
                          });
                      }
          
                      // Freeze the instance so that it cannot be modified.
                      Object.freeze(__constant);
          
                      // Attach the instance using the provided name to the enum type itself.
                      Object.defineProperty(__enum, name, {
                          value: __constant
                      });
          
                      // Update our private objects
                      __values.push(__constant);
                      __dict[name] = __constant;
                  });
          
                  /** Define a friendly toString method for the enum **/
                  var string = typeName + " { " + __enum.values().map(function (c) {
                          return c.name();
                      }).join(", ") + " } ";
          
                  Object.defineProperty(__enum, "toString", {
                      value: function () {
                          return string;
                      }
                  });
          
                  /** Freeze our private objects **/
                  Object.freeze(__values);
                  Object.freeze(__dict);
          
                  /** Freeze the prototype on the enum and the enum itself **/
                  Object.freeze(__enum.prototype);
                  Object.freeze(__enum);
          
                  /** Return the enum **/
                  return __enum;
              }
          
              return {
                  define: define
              }
          
          })();
          
          2015-09-23 11: 25: 27Z
        2. İyi nokta! Yapacak!
          2015-09-23 14: 06: 39Z

        IE8, freeze () yöntemini desteklemez.
        Kaynak: http://kangax.github.io/compat-table/es5/ , "Eski tarayıcıları göster?" üstüne, ve IE8 & satır sütun kesişimini dondur.

        Mevcut oyun projemde aşağıda çok kullandım, çünkü az sayıda müşteri hala IE8 kullanıyor:

         freeze

        Ayrıca şunları yapabiliriz:

         if (Object.freeze) { Object.freeze(values); }

        veya bu bile:

         
        var CONST_WILD_TYPES = {
            REGULAR: 'REGULAR',
            EXPANDING: 'EXPANDING',
            STICKY: 'STICKY',
            SHIFTING: 'SHIFTING'
        };
        

        Sonuncusu, dize için en verimli görünüyor, sunucunuz varsa, toplam bant genişliğinizi azaltır. müşteri bu verileri değiştiriyor.
        Tabii ki, şimdi verilerde herhangi bir çelişki olmadığından emin olmak sizin görevinizdir (RE, EX vb. Benzersiz olmalı, ayrıca 1, 2, vb benzersiz olmalı). Bunları geriye dönük uyumluluk için sonsuza kadar korumanız gerektiğini unutmayın.

        Atama:

         
        var CONST_WILD_TYPES = {
            REGULAR: 'RE',
            EXPANDING: 'EX',
            STICKY: 'ST',
            SHIFTING: 'SH'
        };
        

        Karşılaştırma:

         
        var CONST_WILD_TYPES = {
            REGULAR: '1',
            EXPANDING: '2',
            STICKY: '3',
            SHIFTING: '4'
        };
        
            
        6
        2016-08-02 04: 50: 50Z
         
        var wildType = CONST_WILD_TYPES.REGULAR;
        

        Bu şekilde farklı enum değerlerine yinelenen sayılar atamadığınızdan emin olmanıza gerek yoktur. Yeni bir nesne başlatılır ve tüm enum değerlerine atanır.

            
        4
        2015-01-29 01: 32: 23Z
        1. Bu cevabı çok az dikkate alıyor. Sadeliği için en sevdiğim fikirlerden biri. Uygulamada dizgilere bağlı kalacağımı düşünüyorum çünkü şimdilik hata ayıklamak daha kolay.
          2015-12-08 21: 16: 10Z

        Az önce bir NPM paketi yayınladım gen_enum , Javascript'te Enum veri yapısı oluşturmanıza olanak sağlar çabuk:

         
        if (wildType === CONST_WILD_TYPES.REGULAR) {
            // do something here
        }
        

        Bu küçük araçla ilgili güzel bir şey modern ortamda (nodejs ve IE 9+ tarayıcılar dahil) döndürülen Enum nesnesi değişmez.

        Daha fazla bilgi için lütfen https://github.com/greenlaw110/enumjs adresini ziyaret edin.

        Güncellemeler

        var ColorEnum = {
            red: {},
            green: {},
            blue: {}
        }
        
        paketini kullanmıyorum ve işlevi, değiştirilemezler dahil daha fazla özellik sağlayan constjs paketiyle birleştiriyorum nesneler, JSON dizi seri kaldırma, dize sabitleri ve bitmap oluşturma vb. Ödeme https://www.npmjs.com/package /constjs daha fazla bilgi için

        var genEnum = require('gen_enum');
        
        var AppMode = genEnum('SIGN_UP, LOG_IN, FORGOT_PASSWORD');
        var curMode = AppMode.LOG_IN;
        console.log(curMode.isLogIn()); // output true 
        console.log(curMode.isSignUp()); // output false 
        console.log(curMode.isForgotPassword()); // output false 
        
        ’dan gen_enum’a yükseltme yapmak için yalnızca bildirimi değiştirin  gen_enum

        için

         constjs     
        4
        2015-05-01 23: 44: 40Z

        O (1) 'de değerler ve adlar alabilen bir Enum sınıfı yaptım. Ayrıca, tüm İsimleri ve Değerleri içeren bir Nesne Dizisi de oluşturabilir..

         
        var genEnum = require('gen_enum');
        

        Bu şekilde başlatabilirsiniz:

         
        var genEnum = require('constjs').enum;
        

        Bir değer almak için (C #'daki Enums gibi):

         
        function Enum(obj) {
            // Names must be unique, Values do not.
            // Putting same values for different Names is risky for this implementation
        
            this._reserved = {
                _namesObj: {},
                _objArr: [],
                _namesArr: [],
                _valuesArr: [],
                _selectOptionsHTML: ""
            };
        
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    this[k] = obj[k];
                    this._reserved._namesObj[obj[k]] = k;
                }
            }
        }
        (function () {
            this.GetName = function (val) {
                if (typeof this._reserved._namesObj[val] === "undefined")
                    return null;
                return this._reserved._namesObj[val];
            };
        
            this.GetValue = function (name) {
                if (typeof this[name] === "undefined")
                    return null;
                return this[name];
            };
        
            this.GetObjArr = function () {
                if (this._reserved._objArr.length == 0) {
                    var arr = [];
                    for (k in this) {
                        if (this.hasOwnProperty(k))
                            if (k != "_reserved")
                                arr.push({
                                    Name: k,
                                    Value: this[k]
                                });
                    }
                    this._reserved._objArr = arr;
                }
                return this._reserved._objArr;
            };
        
            this.GetNamesArr = function () {
                if (this._reserved._namesArr.length == 0) {
                    var arr = [];
                    for (k in this) {
                        if (this.hasOwnProperty(k))
                            if (k != "_reserved")
                                arr.push(k);
                    }
                    this._reserved._namesArr = arr;
                }
                return this._reserved._namesArr;
            };
        
            this.GetValuesArr = function () {
                if (this._reserved._valuesArr.length == 0) {
                    var arr = [];
                    for (k in this) {
                        if (this.hasOwnProperty(k))
                            if (k != "_reserved")
                                arr.push(this[k]);
                    }
                    this._reserved._valuesArr = arr;
                }
                return this._reserved._valuesArr;
            };
        
            this.GetSelectOptionsHTML = function () {
                if (this._reserved._selectOptionsHTML.length == 0) {
                    var html = "";
                    for (k in this) {
                        if (this.hasOwnProperty(k))
                            if (k != "_reserved")
                                html += "<option value='" + this[k] + "'>" + k + "</option>";
                    }
                    this._reserved._selectOptionsHTML = html;
                }
                return this._reserved._selectOptionsHTML;
            };
        }).call(Enum.prototype);
        

        Bir değer için bir ad almak için (aynı adı farklı adlar için koyarken belirsiz olabilir):

         
        var enum1 = new Enum({
            item1: 0,
            item2: 1,
            item3: 2
        });
        

        Her isimde bir dizi almak için & bir nesnedeki değer:

         
        var val2 = enum1.item2;
        

        Üretilecek:

         
        var name1 = enum1.GetName(0);  // "item1"
        

        Ayrıca html seçim seçeneklerini kolayca alabilirsiniz:

         
        var arr = enum1.GetObjArr();
        

        Hangisi:

         
        [{ Name: "item1", Value: 0}, { ... }, ... ]
        
            
        4
        2016-12-08 18: 22: 27Z

        es7 yolu, (yineleyici, donma), kullanım:

         values

        Kod:

         
        'use strict';
        
        class Status {
        
        constructor(code, displayName = code) {
            if (Status.INSTANCES.has(code))
                throw new Error(`duplicate code value: [${code}]`);
            if (!Status.canCreateMoreInstances)
                throw new Error(`attempt to call constructor(${code}`+
               `, ${displayName}) after all static instances have been created`);
            this.code        = code;
            this.displayName = displayName;
            Object.freeze(this);
            Status.INSTANCES.set(this.code, this);
        }
        
        toString() {
            return `[code: ${this.code}, displayName: ${this.displayName}]`;
        }
        static INSTANCES   = new Map();
        static canCreateMoreInstances      = true;
        
        // the values:
        static ARCHIVED    = new Status('Archived');
        static OBSERVED    = new Status('Observed');
        static SCHEDULED   = new Status('Scheduled');
        static UNOBSERVED  = new Status('Unobserved');
        static UNTRIGGERED = new Status('Untriggered');
        
        static values      = function() {
            return Array.from(Status.INSTANCES.values());
        }
        
        static fromCode(code) {
            if (!Status.INSTANCES.has(code))
                throw new Error(`unknown code: ${code}`);
            else
                return Status.INSTANCES.get(code);
        }
        }
        
        Status.canCreateMoreInstances = false;
        Object.freeze(Status);
        exports.Status = Status;
        
            
        4
        2018-02-14 23: 44: 34Z

        Typescript'in

        const ThreeWiseMen = new Enum('Melchior', 'Caspar', 'Balthazar')
        
        for (let name of ThreeWiseMen)
            console.log(name)
        
        
        // with a given key
        let key = ThreeWiseMen.Melchior
        
        console.log(key in ThreeWiseMen) // true (string conversion, also true: 'Melchior' in ThreeWiseMen)
        
        for (let entry from key.enum)
             console.log(entry)
        
        
        // prevent alteration (throws TypeError in strict mode)
        ThreeWiseMen.Me = 'Me too!'
        ThreeWiseMen.Melchior.name = 'Foo'
        
        'u Javascript'e çevirme biçimi:  
        class EnumKey {
        
            constructor(props) { Object.freeze(Object.assign(this, props)) }
        
            toString() { return this.name }
        
        }
        
        export class Enum {
        
            constructor(...keys) {
        
                for (let [index, key] of keys.entries()) {
        
                    Object.defineProperty(this, key, {
        
                        value: new EnumKey({ name:key, index, enum:this }),
                        enumerable: true,
        
                    })
        
                }
        
                Object.freeze(this)
        
            }
        
            *[Symbol.iterator]() {
        
                for (let key of Object.keys(this))
                    yield this[key]
        
            }
        
            toString() { return [...this].join(', ') }
        
        }
        

        Şimdi:

         enum

        İlk başta neden

        var makeEnum = function(obj) {
            obj[ obj['Active'] = 1 ] = 'Active';
            obj[ obj['Closed'] = 2 ] = 'Closed';
            obj[ obj['Deleted'] = 3 ] = 'Deleted';
        }
        
        'un
        makeEnum( NewObj = {} )
        // => {1: "Active", 2: "Closed", 3: "Deleted", Active: 1, Closed: 2, Deleted: 3}
        
        'u döndürdüğü kafam karıştı, ancak sonra ölü durumunun basit olduğunu anladım - Atama operatörü değer atar ve sonra onu döndürür:  obj[1]     
        4
        2018-05-03 18: 44: 59Z

        Böyle bir şey yapabilirsiniz

         'Active'

        Bu kütüphanede tanımlandığı şekilde. https://github.com/webmodule/foo/blob/master/foo.js # L217

        Tam bir örnek https://gist.github.com/lnt/bb13a2fd63cdb8bce85fd629p_2006     

        4
        2018-12-26 06: 11: 55Z

        Hızlı ve basit bir yol şudur:

         
        obj['foo'] = 1
        // => 1
        
            
        3
        2013-10-06 22: 07: 47Z
        1. İşlev gereksizdir ve size OP’nin yayınladığı ile aynı sonucu verir.
          2014-01-16 19: 19: 28Z

        Yazılı olarak, Ekim 2014 - işte çağdaş bir çözüm. Çözümü bir Düğüm Modülü olarak yazıyorum ve Mocha ve Chai'nin yanı sıra alt çizgiJS kullanarak bir test de ekledim. Bunları kolayca görmezden gelebilir ve isterseniz Enum kodunu alabilirsiniz.

        Aşırı kıvrılmış kütüphaneleri olan bir sürü gönderi gördüm. Javascript'te enum desteği almanın çözümü gerçekten çok gerekli değil. İşte kod:

        Dosya: enums.js

         
            var Enum = (function(foo) {
        
            var EnumItem = function(item){
                if(typeof item == "string"){
                    this.name = item;
                } else {
                    this.name = item.name;
                }
            }
            EnumItem.prototype = new String("DEFAULT");
            EnumItem.prototype.toString = function(){
                return this.name;
            }
            EnumItem.prototype.equals = function(item){
                if(typeof item == "string"){
                    return this.name == item;
                } else {
                    return this == item && this.name == item.name;
                }
            }
        
            function Enum() {
                this.add.apply(this, arguments);
                Object.freeze(this);
            }
            Enum.prototype.add = function() {
                for (var i in arguments) {
                    var enumItem = new EnumItem(arguments[i]);
                    this[enumItem.name] = enumItem;
                }
            };
            Enum.prototype.toList = function() {
                return Object.keys(this);
            };
            foo.Enum = Enum;
            return Enum;
        })(this);
        var STATUS = new Enum("CLOSED","PENDING", { name : "CONFIRMED", ackd : true });
        var STATE = new Enum("CLOSED","PENDING","CONFIRMED",{ name : "STARTED"},{ name : "PROCESSING"});
        

        Size ne verdiğini gösteren bir test:

        dosyası: enumsSpec.js

         
        var Colors = function(){
        return {
            'WHITE':0,
            'BLACK':1,
            'RED':2,
            'GREEN':3
            }
        }();
        
        console.log(Colors.WHITE)  //this prints out "0"
        

        Gördüğünüz gibi, bir Enum fabrikası alırsınız, tüm anahtarları sadece enum.keys'i arayarak alabilirsiniz ve anahtarları kendileri tamsayı sabitleriyle eşleştirebilirsiniz. Ve fabrikayı farklı değerlerle yeniden kullanabilir ve üretilen Enums'leri Node'un modüler yaklaşımını kullanarak dışa aktarabilirsiniz.

        Bir kez daha, yalnızca geçici bir kullanıcıysanız veya tarayıcıda vb. çalışıyorsanız, kodun fabrika kısmını kullanın, kodunuzda kullanmak istemiyorsanız, alt çizgi kütüphanesini de kaldırın. >     

        3
        2014-11-20 17: 44: 48Z
        1. Sadece "burada, bunun sadece fabrikaları, alt çizgileri ya da herhangi bir şeyi fantezi isteyen" sıradan bir kullanıcı olarak nasıl yapılacağını "yazarak cevap verebilir misiniz?
          2015-01-02 03: 08: 51Z
        2. Geliştiricilerin gözlerinden gelen müthiş olmasına rağmen, çok temiz veya okunaklı değil. OP'nin Enum çözümü her yönden daha kolay ve daha okunaklıdır ve bu nedenle kullanımı daha iyidir. Yine de, bununla geldiğiniz için çok güzel.
          2015-01-17 19: 55: 44Z

        İşte size TypeScript kodları 'nı uygulamanın birkaç farklı yolu var.

        En kolay yol, nesneye ters çevrilmiş anahtar /değer çiftleri ekleyerek, yalnızca bir nesnenin üzerinde yineleme yapmaktır. Tek dezavantajı, her üye için değeri el ile ayarlamanız gerektiğidir.

         
        _ = require('underscore');
        
        var _Enum = function () {
        
           var keys = _.map(arguments, function (value) {
              return value;
           });
           var self = {
              keys: keys
           };
           for (var i = 0; i < arguments.length; i++) {
              self[keys[i]] = i;
           }
           return self;
        };
        
        var fileFormatEnum = Object.freeze(_Enum('CSV', 'TSV'));
        var encodingEnum = Object.freeze(_Enum('UTF8', 'SHIFT_JIS'));
        
        exports.fileFormatEnum = fileFormatEnum;
        exports.encodingEnum = encodingEnum;
        


        Ve işte bir dize kullanarak enum oluşturmak için lodash mixin var. Bu sürüm biraz daha dahil olmakla birlikte, numaralandırmayı sizin için otomatik olarak yapar. Bu örnekte kullanılan tüm lodash yöntemlerinin normal bir JavaScript eşdeğeri vardır, böylece isterseniz kolayca değiştirebilirsiniz.

         
        var chai = require("chai"),
            assert = chai.assert,
            expect = chai.expect,
            should = chai.should(),
            enums = require('./enums'),
            _ = require('underscore');
        
        
        describe('enums', function () {
        
            describe('fileFormatEnum', function () {
                it('should return expected fileFormat enum declarations', function () {
                    var fileFormatEnum = enums.fileFormatEnum;
                    should.exist(fileFormatEnum);
                    assert('{"keys":["CSV","TSV"],"CSV":0,"TSV":1}' === JSON.stringify(fileFormatEnum), 'Unexpected format');
                    assert('["CSV","TSV"]' === JSON.stringify(fileFormatEnum.keys), 'Unexpected keys format');
                });
            });
        
            describe('encodingEnum', function () {
                it('should return expected encoding enum declarations', function () {
                    var encodingEnum = enums.encodingEnum;
                    should.exist(encodingEnum);
                    assert('{"keys":["UTF8","SHIFT_JIS"],"UTF8":0,"SHIFT_JIS":1}' === JSON.stringify(encodingEnum), 'Unexpected format');
                    assert('["UTF8","SHIFT_JIS"]' === JSON.stringify(encodingEnum.keys), 'Unexpected keys format');
                });
            });
        
        });
        
            
        3
        2015-03-17 21: 24: 32Z
        1. çok zekice, teşekkürler
          2017-02-03 09: 22: 57Z

        Kullanımı kolay, sanırım. https://stackoverflow.com/a/32245370/4365315

         
        function _enum(list) {       
          for (var key in list) {
            list[list[key] = list[key]] = key;
          }
          return Object.freeze(list);
        }
        
        var Color = _enum({
          Red: 0,
          Green: 5,
          Blue: 2
        });
        
        // Color → {0: "Red", 2: "Blue", 5: "Green", "Red": 0, "Green": 5, "Blue": 2}
        // Color.Red → 0
        // Color.Green → 5
        // Color.Blue → 2
        // Color[5] → Green
        // Color.Blue > Color.Green → false
        

        GÜNCELLEME:

        Yardımcı kodlarım var (

        function enum() {
            var key, val = -1, list = {};
            _.reduce(_.toArray(arguments), function(result, kvp) {    
                kvp = kvp.split("=");
                key = _.trim(kvp[0]);
                val = _.parseInt(kvp[1]) || ++val;            
                result[result[val] = key] = val;
                return result;
            }, list);
            return Object.freeze(list);
        }    
        
        // Add enum to lodash 
        _.mixin({ "enum": enum });
        
        var Color = _.enum(
            "Red",
            "Green",
            "Blue = 5",
            "Yellow",
            "Purple = 20",
            "Gray"
        );
        
        // Color.Red → 0
        // Color.Green → 1
        // Color.Blue → 5
        // Color.Yellow → 6
        // Color.Purple → 20
        // Color.Gray → 21
        // Color[5] → Blue
        
        ).

         
        var A = {a:11, b:22}, 
        enumA = new TypeHelper(A);
        
        if(enumA.Value === A.b || enumA.Key === "a"){ 
        ... 
        }
        
        var keys = enumA.getAsList();//[object, object]
        
        //set
        enumA.setType(22, false);//setType(val, isKey)
        
        enumA.setType("a", true);
        
        enumA.setTypeByIndex(1);
        
            
        3
        2017-05-23 11: 47: 32Z

        numaralandırmayı bir adrese çok küçük bir kütüphane yazdım tür güvenliğini garanti eden , enum sabitlerinin prototipten devralmalarına izin verme , enum sabitlerini ve enum türlerinin değişmez olmasını garanti etme + çok küçük özellikler. Bir çok kodu yeniden aktive etmeye ve enum tanımında bazı mantıkları hareket ettirmeye izin verir. İşte bir örnek:

         TypeHelper

        var Helper = {
            isEmpty: function (obj) {
                return !obj || obj === null || obj === undefined || Array.isArray(obj) && obj.length === 0;
            },
        
            isObject: function (obj) {
                return (typeof obj === 'object');
            },
        
            sortObjectKeys: function (object) {
                return Object.keys(object)
                    .sort(function (a, b) {
                        c = a - b;
                        return c
                    });
            },
            containsItem: function (arr, item) {
                if (arr && Array.isArray(arr)) {
                    return arr.indexOf(item) > -1;
                } else {
                    return arr === item;
                }
            },
        
            pushArray: function (arr1, arr2) {
                if (arr1 && arr2 && Array.isArray(arr1)) {
                    arr1.push.apply(arr1, Array.isArray(arr2) ? arr2 : [arr2]);
                }
            }
        };
        function TypeHelper() {
            var _types = arguments[0],
                _defTypeIndex = 0,
                _currentType,
                _value,
                _allKeys = Helper.sortObjectKeys(_types);
        
            if (arguments.length == 2) {
                _defTypeIndex = arguments[1];
            }
        
            Object.defineProperties(this, {
                Key: {
                    get: function () {
                        return _currentType;
                    },
                    set: function (val) {
                        _currentType.setType(val, true);
                    },
                    enumerable: true
                },
                Value: {
                    get: function () {
                        return _types[_currentType];
                    },
                    set: function (val) {
                        _value.setType(val, false);
                    },
                    enumerable: true
                }
            });
            this.getAsList = function (keys) {
                var list = [];
                _allKeys.forEach(function (key, idx, array) {
                    if (key && _types[key]) {
        
                        if (!Helper.isEmpty(keys) && Helper.containsItem(keys, key) || Helper.isEmpty(keys)) {
                            var json = {};
                            json.Key = key;
                            json.Value = _types[key];
                            Helper.pushArray(list, json);
                        }
                    }
                });
                return list;
            };
        
            this.setType = function (value, isKey) {
                if (!Helper.isEmpty(value)) {
                    Object.keys(_types).forEach(function (key, idx, array) {
                        if (Helper.isObject(value)) {
                            if (value && value.Key == key) {
                                _currentType = key;
                            }
                        } else if (isKey) {
                            if (value && value.toString() == key.toString()) {
                                _currentType = key;
                            }
                        } else if (value && value.toString() == _types[key]) {
                            _currentType = key;
                        }
                    });
                } else {
                    this.setDefaultType();
                }
                return isKey ? _types[_currentType] : _currentType;
            };
        
            this.setTypeByIndex = function (index) {
                for (var i = 0; i < _allKeys.length; i++) {
                    if (index === i) {
                        _currentType = _allKeys[index];
                        break;
                    }
                }
            };
        
            this.setDefaultType = function () {
                this.setTypeByIndex(_defTypeIndex);
            };
        
            this.setDefaultType();
        }
        
        var TypeA = {
            "-1": "Any",
            "2": "2L",
            "100": "100L",
            "200": "200L",
            "1000": "1000L"
        };
        
        var enumA = new TypeHelper(TypeA, 4);
        
        document.writeln("Key = ", enumA.Key,", Value = ", enumA.Value, "<br>");
        
        
        enumA.setType("200L", false);
        document.writeln("Key = ", enumA.Key,", Value = ", enumA.Value, "<br>");
        
        enumA.setDefaultType();
        document.writeln("Key = ", enumA.Key,", Value = ", enumA.Value, "<br>");
        
        
        enumA.setTypeByIndex(1);
        document.writeln("Key = ", enumA.Key,", Value = ", enumA.Value, "<br>");
        
        document.writeln("is equals = ", (enumA.Value == TypeA["2"]));
        temelde bir fabrikadır.

        Tamamen belgelenen kılavuz burada mevcuttur. yardım eder.

            
        3
        2015-10-25 04: 30: 59Z
        1. Bu gerçekten bir numaralandırma değil. Ancak bunun çok faydalı olduğunu görebiliyorum.
          2016-07-14 17: 23: 19Z
        2. @ Will, onları nasıl çağırırsınız ^^?
          var Helper = {
              isEmpty: function (obj) {
                  return !obj || obj === null || obj === undefined || Array.isArray(obj) && obj.length === 0;
              },
          
              isObject: function (obj) {
                  return (typeof obj === 'object');
              },
          
              sortObjectKeys: function (object) {
                  return Object.keys(object)
                      .sort(function (a, b) {
                          c = a - b;
                          return c
                      });
              },
              containsItem: function (arr, item) {
                  if (arr && Array.isArray(arr)) {
                      return arr.indexOf(item) > -1;
                  } else {
                      return arr === item;
                  }
              },
          
              pushArray: function (arr1, arr2) {
                  if (arr1 && arr2 && Array.isArray(arr1)) {
                      arr1.push.apply(arr1, Array.isArray(arr2) ? arr2 : [arr2]);
                  }
              }
          };
          function TypeHelper() {
              var _types = arguments[0],
                  _defTypeIndex = 0,
                  _currentType,
                  _value,
                  _allKeys = Helper.sortObjectKeys(_types);
          
              if (arguments.length == 2) {
                  _defTypeIndex = arguments[1];
              }
          
              Object.defineProperties(this, {
                  Key: {
                      get: function () {
                          return _currentType;
                      },
                      set: function (val) {
                          _currentType.setType(val, true);
                      },
                      enumerable: true
                  },
                  Value: {
                      get: function () {
                          return _types[_currentType];
                      },
                      set: function (val) {
                          _value.setType(val, false);
                      },
                      enumerable: true
                  }
              });
              this.getAsList = function (keys) {
                  var list = [];
                  _allKeys.forEach(function (key, idx, array) {
                      if (key && _types[key]) {
          
                          if (!Helper.isEmpty(keys) && Helper.containsItem(keys, key) || Helper.isEmpty(keys)) {
                              var json = {};
                              json.Key = key;
                              json.Value = _types[key];
                              Helper.pushArray(list, json);
                          }
                      }
                  });
                  return list;
              };
          
              this.setType = function (value, isKey) {
                  if (!Helper.isEmpty(value)) {
                      Object.keys(_types).forEach(function (key, idx, array) {
                          if (Helper.isObject(value)) {
                              if (value && value.Key == key) {
                                  _currentType = key;
                              }
                          } else if (isKey) {
                              if (value && value.toString() == key.toString()) {
                                  _currentType = key;
                              }
                          } else if (value && value.toString() == _types[key]) {
                              _currentType = key;
                          }
                      });
                  } else {
                      this.setDefaultType();
                  }
                  return isKey ? _types[_currentType] : _currentType;
              };
          
              this.setTypeByIndex = function (index) {
                  for (var i = 0; i < _allKeys.length; i++) {
                      if (index === i) {
                          _currentType = _allKeys[index];
                          break;
                      }
                  }
              };
          
              this.setDefaultType = function () {
                  this.setTypeByIndex(_defTypeIndex);
              };
          
              this.setDefaultType();
          }
          
          var TypeA = {
              "-1": "Any",
              "2": "2L",
              "100": "100L",
              "200": "200L",
              "1000": "1000L"
          };
          
          var enumA = new TypeHelper(TypeA, 4);
          
          document.writeln("Key = ", enumA.Key,", Value = ", enumA.Value, "<br>");
          
          
          enumA.setType("200L", false);
          document.writeln("Key = ", enumA.Key,", Value = ", enumA.Value, "<br>");
          
          enumA.setDefaultType();
          document.writeln("Key = ", enumA.Key,", Value = ", enumA.Value, "<br>");
          
          
          enumA.setTypeByIndex(1);
          document.writeln("Key = ", enumA.Key,", Value = ", enumA.Value, "<br>");
          
          document.writeln("is equals = ", (enumA.Value == TypeA["2"]));
          ?
          2016-07-14 18: 07: 57Z
        3. Emin değilim ... Bu bir tür enums + meta veri karışımı (örneğinizde). Bir enum sadece /dan atılabileceği bir isim ve yapı değerine sahiptir. Bunu kullanarak her birine sınırsız sayıda özellik koyabilirsiniz. Daha önce kalıbı görmüştüm ve onu yazan takım sonuç sabitleri olarak adlandırılıyor ... DataType gibi bireysel isimler sadece bir ismi değil, bir ID değeri, geçerli operatörleri (başka bir sabitler grubu! ), geçerli dönüşümler vb. Gerçekten yararlıdır, ancak basit bir numaralandırmadan çok daha fazlasıdır.
          2016-07-14 18: 13: 02Z
        4. Çok kötü performans. Tüm kodu yavaşlatır. Küçültülmüş kodu birkaç kez daha büyük yapar. Çok kötü.
          2018-06-23 23: 27: 21Z
        var CloseEventCodes = new Enumeration("closeEventCodes", {
          CLOSE_NORMAL:          { _id: 1000, info: "Connection closed normally" },
          CLOSE_GOING_AWAY:      { _id: 1001, info: "Connection closed going away" },
          CLOSE_PROTOCOL_ERROR:  { _id: 1002, info: "Connection closed due to protocol error"  },
          CLOSE_UNSUPPORTED:     { _id: 1003, info: "Connection closed due to unsupported operation" },
          CLOSE_NO_STATUS:       { _id: 1005, info: "Connection closed with no status" },
          CLOSE_ABNORMAL:        { _id: 1006, info: "Connection closed abnormally" },
          CLOSE_TOO_LARGE:       { _id: 1009, info: "Connection closed due to too large packet" }
        },{ talk: function(){
            console.log(this.info); 
          }
        });
        
        
        CloseEventCodes.CLOSE_TOO_LARGE.talk(); //prints "Connection closed due to too large packet"
        CloseEventCodes.CLOSE_TOO_LARGE instanceof CloseEventCodes //evaluates to true
        
kaynak yerleştirildi İşte
Diğer sorular