JavaScript'te enums'─▒ tan─▒mlamak i├žin tercih edilen s├Âzdizimi nedir? [kapal─▒]


Al─▒nan cevaba git


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─▒?


1961









Cevap say─▒s─▒n─▒ say: 30






1.8.5'ten beri nesneyi kapatmak ve dondurmak m├╝mk├╝nd├╝r, bu nedenle yukar─▒dakileri a┼ča─č─▒daki gibi tan─▒mlay─▒n:

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

veya

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

ve i┼čte! JS numaraland─▒r─▒yor.

Bununla birlikte, bu genellikle de─či┼čkenlerin as─▒l amac─▒ 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 veya Flow gibi bir ara├ž kullanmakt─▒r .

Kaynak

T─▒rnaklara gerek yok ama tutarl─▒l─▒k i├žin saklad─▒m.


775







Bu ├žok fazla bir cevap de─čil, ama ki┼čisel olarak gayet iyi ├žal─▒┼čt─▒─č─▒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─▒rd─▒m.


598







G├ťNCELLEME : Herkese te┼čekk├╝rler i├žin herkese te┼čekk├╝rler, ama 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: Javascript'teki Enums .


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─čerleri nesneler haline getirebilir, 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─čundan, 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─▒z ki, enum alanlar─▒na (bu ├Ârnekteki de─čer, isim ve kod) kimlik kontrol├╝ i├žin gerekli de─čildir ve sadece kolayl─▒k sa─člamak i├žin vard─▒r. 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).

Javascript'te bir nesnenin bir harita ya da karma tablo gibi oldu─čunu unutmay─▒n. 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.

├ľrnek

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

Ve btw, e─čer ad alanlar─▒yla ilgileniyorsan─▒z, javascript i├žin basit ama g├╝├žl├╝ bir ad alan─▒ ve ba─č─▒ml─▒l─▒k y├Ânetimi i├žin ├ž├Âz├╝m├╝me bakmak isteyebilirsiniz: Paket JS


491







Alt sat─▒r: Yapamazs─▒n─▒z.

Sahte yapabilirsin, ama 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 i┼če yaram─▒yor mu? - Fry Quad

Kesinlikle, Object.freeze ┼čikayet etti─čim sorunu tamamen d├╝zeltirdi. Herkese yukar─▒dakileri yazarken Object.freeze ger├žekten var olmad─▒─č─▒n─▒ hat─▒rlatmak isterim .

┼×imdi .... ┼čimdi baz─▒ ├žok ilgin├ž olas─▒l─▒klar a├ž─▒l─▒yor .

D├╝zenleme 2
─░┼čte enums olu┼čturmak i├žin ├žok iyi bir k├╝t├╝phane.

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

Muhtemelen her bir enum kullan─▒m─▒na uymuyor olsa da, ├žok uzun bir yol gidiyor.


81







─░┼čte hepimizin istedi─či ┼čey:

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

┼×imdi enums'lerinizi olu┼čturabilirsiniz:

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

Bunu yaparak sabitler ola─čan ┼čekilde de─čerlendirilebilir (YesNo.YES, Color.GREEN) 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.

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

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

55







├ço─ču modern taray─▒c─▒da, bir numaraland─▒rma olu┼čturmak i├žin kullan─▒labilecek bir sembol ilkel veri t├╝r├╝ vard─▒r. Her sembol de─čerinin JavaScript taraf─▒ndan benzersiz olmas─▒ garanti edildi─činden enum t├╝r├╝n├╝n g├╝venli─čini sa─člar Symbol() != Symbol() . ├ľ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

On GitHub'dan E─čer enum ba┼člatmak i├žin gerekli kodu basitle┼čtiren bir sarmalay─▒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
 

51







Enumlar─▒m─▒ sevdi─čim i├žin bununla oynuyordum. =)

Kullan─▒lmas─▒ Object.defineProperty Ben biraz ya┼čayabilir ├ž├Âz├╝m geldi d├╝┼č├╝n├╝yorum.

─░┼č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
}); 
 

├ç├╝nk├╝ ├Âzelli─činin writable:false bu olmal─▒d─▒r g├╝venli yaz─▒n olun.

Bu y├╝zden ├Âzel bir nesne yaratabilmeli, sonra Enum() onu ├ža─č─▒rmal─▒s─▒n─▒z . Atanan de─čerler 0'dan ba┼člar ve ├Â─če ba┼č─▒na art─▒┼č.

 var EnumColors={};
EnumColors.Enum('RED','BLUE','GREEN','YELLOW');
EnumColors.RED;    // == 0
EnumColors.BLUE;   // == 1
EnumColors.GREEN;  // == 2
EnumColors.YELLOW; // == 3
 

24







????? ????????? Ôäó ???????? ?????

Sorunu do─črudan keselim: dosya boyutu. Burada listelenen di─čer her cevap, kodunuzu a┼č─▒r─▒ya indirir. M├╝mk├╝n olan en iyi performans, kodun okunabilirli─či, b├╝y├╝k ├Âl├žekli proje y├Ânetimi, bir├žok kod d├╝zenleyicide s├Âzdizimi ipucu ve kod k├╝├ž├╝ltmeyle k├╝├ž├╝ltmeyle k├╝├ž├╝lt├╝lmesi i├žin, numaraland─▒rma yapman─▒n do─čru yolunun bu oldu─čunu belirtiyorum: alt ├žizgi g├Âsterim de─či┼čkenleri.


wvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwv


Alt ├çizgi Notasyonu 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
}
 

Ne zaman INDEX_ ve ne zaman kullanaca─č─▒m─▒ ┼ču ┼čekilde hat─▒rl─▒yorum ENUM_ :

 // Precondition: var arr = []; //
arr[INDEX_] = ENUM_;
 

Ancak, ENUM_ baz─▒ durumlarda, her bir maddenin olu┼čumunu sayarken oldu─ču gibi bir endeks olarak uygun olabilir.

 const ENUM_PET_CAT = 0,
      ENUM_PET_DOG = 1,
      ENUM_PET_RAT = 2,
      ENUMLEN_PET  = 3;

var favoritePets = [ENUM_PET_CAT, ENUM_PET_DOG, ENUM_PET_RAT,
                    ENUM_PET_DOG, ENUM_PET_DOG, ENUM_PET_CAT,
                    ENUM_PET_RAT, ENUM_PET_CAT, ENUM_PET_DOG];

var petsFrequency = [];

for (var i=0; i<ENUMLEN_PET; i=i+1|0)
  petsFrequency[i] = 0;

for (var i=0, len=favoritePets.length|0, petId=0; i<len; i=i+1|0)
  petsFrequency[petId = favoritePets[i]|0] = (petsFrequency[petId]|0) + 1|0;

console.log({
    "cat": petsFrequency[ENUM_PET_CAT],
    "dog": petsFrequency[ENUM_PET_DOG],
    "rat": petsFrequency[ENUM_PET_RAT]
}); 

Yukar─▒daki kodda yeni bir evcil hayvan t├╝r├╝ne eklemenin ger├žekten kolay oldu─čunu g├Âz ├Ân├╝nde bulundurun: sonradan yeni bir giri┼č eklemeniz ENUM_PET_RAT ve ENUMLEN_PET buna g├Âre g├╝ncellemeniz gerekir . Di─čer numaraland─▒rma sistemlerine yeni bir giri┼č eklemek daha zor ve zorlay─▒c─▒ olabilir.


wvwwvw wvwvwvw wvwxvw wvwvwvwvwvwwvwvwwvwvwvwvwww

?????? ????????? ????????? ???? ????????

Ek olarak, bu numaraland─▒rma s├Âzdizimi, a┼ča─č─▒da g├Âr├╝ld├╝─č├╝ gibi uzanan a├ž─▒k ve ├Âz bir s─▒n─▒f sa─člar. Bir s─▒n─▒f─▒ geni┼čletmek i├žin LEN_ , ├╝st s─▒n─▒f─▒n giri┼čine artan bir say─▒ ekleyin . Ard─▒ndan, alt LEN_ s─▒n─▒f─▒ ileride daha da geni┼čletilebilmesi i├žin alt s─▒n─▒f─▒ kendi giri┼či ile tamamlay─▒n .


─░lave uzatma diyagram─▒

 (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├╝mlerden daha az pratik oldu─čunu s├Âyleyebilir: tonlarca alan─▒ bo┼čalt─▒r, yazmas─▒ uzun zaman al─▒r ve ┼čeker s├Âzdizimi ile kaplanmaz. 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. Online 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├Âzlemek.


wvwwvw wvwvwvw wvwxvw wvwvwvwvwvwwvwvwwvwvwvwvwww

?????? ???? ??????? ????????

Kapatma derleyicisi, di─čer Javascript minifier'lerinin kapasitelerinin ├žok ├Âtesindeki ├ž─▒kar─▒mlar yoluyla olduk├ža inan─▒lmaz baz─▒ optimizasyonlar yapabilir. Kapan─▒┼č Derleyicisi, sabit bir de─čere ayarlanan ilkel de─či┼čkenleri s─▒raya koyabilir. Kapan─▒┼č Derleyicisi ayn─▒ zamanda bu belirtilen de─čerlere dayanarak ├ž─▒kar─▒mlar yapabilir ve if ifadelerinde ve d├Âng├╝lerinde kullan─▒lmayan bloklar─▒ ortadan kald─▒r─▒r.


Kapatma Derleyici ile s─▒kma kodu

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


wvwwvw wvwvwvw wvwxvw wvwvwvwvwvwwvwvwwvwvwvwvwww

??????? ???? ????

┼×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─▒rma Kullanmadan Minyat├╝rle┼čtirildi (uzunluk: 843 bayt ( numaraland─▒r─▒lm─▒┼č koddan 238 bayt daha uzun ))


Kod boyutlar─▒ tablosu



G├Âr├╝ld├╝─č├╝ gibi, numaraland─▒rma olmadan, kaynak kodu daha b├╝y├╝k bir k├╝├ž├╝lt├╝lm├╝┼č kodun maliyeti kar┼č─▒l─▒─č─▒nda 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.


wvwwvw wvwvwvw wvwxvw wvwvwvwvwvwwvwvwwvwvwvwvwww

??????????? ? ??? ??????

Bu numaraland─▒rma formunun 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. Pek ├žok ba┼čka ki┼čiyle birlikte b├╝y├╝k bir projede ├žal─▒┼č─▒rken, kodu olu┼čturan de─či┼čken adlar─▒n─▒ a├ž─▒k├ža i┼čaretlemek ve etiketlemek yararl─▒ olabilir; b├Âylece kodun orijinal olu┼čturucusu i┼čbirlik├ži hata d├╝zeltme i├žin h─▒zl─▒ bir ┼čekilde tan─▒mlanabilir.

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

???????? ???????????


Dahas─▒, bu say─▒m ┼čekli 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, i├ž dizideki de─čerin dizini zaten belirtildi─či i├žin taray─▒c─▒ 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.


wvwwvw wvwvwvw wvwxvw wvwvwvwvwvwwvwvwwvwvwvwvwww

???? ?????????

Ayr─▒ca, benim ki┼čisel ├╝st├╝nde kiraz ile birlikte numaraland─▒rma bu formu kullan─▒yor 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 daha ├Ânce var anahtar kelime ile 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─▒ [variable name] is not defined yanl─▒┼č yaz─▒lm─▒┼č numaraland─▒rma adlar─▒yla kod y├╝r├╝t├╝rken yararl─▒ bir 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 ger├žekten kolayla┼čt─▒r─▒r.


CodeMirror g├Âsteriyi vurgulayarak

 const ENUM_COLORENUM_RED   = 0,
      ENUM_COLORENUM_GREEN = 1,
      ENUM_COLORENUM_BLUE  = 2,
      ENUMLEN_COLORENUM    = 3;
var currentColor = ENUM_COLORENUM_GREEN;

if(currentColor === ENUM_COLORENUM_RED) {
   // whatever
}

if(currentColor === ENUM_COLORENUM_DNE) {
   // whatever
} 

Yukar─▒daki kod par├žas─▒nda, ENUM_COLORENUM_DNE mevcut olmad─▒─č─▒ i├žin bir hata ile bilgilendirildiniz .


wvwwvw wvwvwvw wvwxvw wvwvwvwvwvwwvwvwwvwvwvwvwww

?????????? ÔśĹ

Bu nedenle, asl─▒nda, bu numaraland─▒rma bi├žiminin yaln─▒zca k├╝├ž├╝lt├╝lm├╝┼č kod boyutu i├žin de─čil ayn─▒ zamanda performans, hata ay─▒klama ve i┼čbirli─či i├žin de en iyi yol oldu─ču sonucuna var─▒yorum.

Yararl─▒ bir soruyu okuduktan sonra, yazara zaman ay─▒rd─▒─č─▒ i├žin, soru kutusundaki sol ├╝st oku t─▒klatarak te┼čekk├╝r ediyorum. Her cevap kutusu ayr─▒ca bu yukar─▒ oklardan birine sahiptir.


24







Bu bildi─čim eski bir ┼čey, ancak daha ├Ânce TypeScript aray├╝z├╝ ile 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 MyEnum.Bar 1, hem de MyEnum[1] "Bar" de─čerini veren her ikisine de bakman─▒za olanak tan─▒r .


17







Javascript Proxy'lerini Kullanhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy

TLDR: Bu s─▒n─▒f─▒ yard─▒mc─▒ program y├Ântemlerine ekleyin ve kodunuz boyunca kullan─▒n, geleneksel programlama dillerinden Enum davran─▒┼č─▒n─▒ a┼čt─▒ ve asl─▒nda var olmayan bir numaraland─▒r─▒c─▒ya eri┼čmeye ├žal─▒┼čt─▒─č─▒n─▒zda veya bir numaraland─▒r─▒c─▒ eklemeye / g├╝ncellemeye ├žal─▒┼čt─▒─č─▒n─▒zda hatalar atar. G├╝venmeye gerek yok Object.freeze() .

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

Ard─▒ndan s─▒n─▒f─▒ ba┼člatarak enums olu┼čturun:

 const roles = new Enum({
  ADMIN: 'Admin',
  USER: 'User',
});
 

Tam a├ž─▒klama:

Enums'un geleneksel dillerden edindi─činiz ├žok yararl─▒ bir ├Âzelli─či, var olmayan bir numaraland─▒r─▒c─▒ya eri┼čmeye ├žal─▒┼č─▒rsan─▒z havaya u├žurmalar─▒ (bir derleme zaman─▒ hatas─▒).

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 almamaktad─▒r.

Muhtemelen bildi─činiz gibi, mevcut olmayan ├╝yelere JavaScript'te eri┼čmek basit├že geri d├Âner undefined 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─▒mlanmamas─▒ gereken bir durum asla olmamal─▒d─▒r.

Beni yanl─▒┼č anlamay─▒n, JavaScript'in undefined tan─▒ms─▒z ├Âzelliklere eri┼čirken geri d├Ânme davran─▒┼č─▒ asl─▒nda dilin ├žok g├╝├žl├╝ bir ├Âzelli─čidir, ancak geleneksel Enum yap─▒lar─▒yla alay etmeye ├žal─▒┼čt─▒─č─▒n─▒z zaman istedi─činiz bir ├Âzellik de─čildir.

Proxy nesnelerinin parlad─▒─č─▒ yer buras─▒d─▒r. 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 aramas─▒, atama, numaraland─▒rma, i┼člev ├ža─č─▒rma, vb.).

Bir web sunucusu proxy'sine benzer ┼čekilde, JavaScript proxy'leri nesnelerdeki i┼člemlere m├╝dahale edebilir ("tuzaklar" kullanarak, isterseniz kanca olarak adland─▒rabilir) ve tamamlamadan ├Ânce ├že┼čitli denetimler, eylemler ve / veya manip├╝lasyonlar ger├žekle┼čtirmenize izin verebilir (veya baz─▒ durumlarda operasyonlar─▒ tamamen durdurmak, ki bu tam olarak ne yapmak istedi─čimizdir ve var olmayan bir numaraland─▒r─▒c─▒ya ba┼čvurmaya ├žal─▒┼čt─▒─č─▒m─▒zda).

Burada, Enums'leri taklit etmek i├žin Proxy nesnesini kullanan tart─▒┼čmal─▒ bir ├Ârnek var. Bu ├Ârnekteki numaralay─▒c─▒lar standart HTTP Metodlar─▒d─▒r (yani "GET", "POST", vb.):

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


ASIDE: Bir vekil nedir?

Her yerde proxy kelimesini ilk g├Ârmeye ba┼člad─▒─č─▒mda, 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







Kulland─▒─č─▒m ├ž├Âz├╝m bu.

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

Ve enums'lerinizi ┼č├Âyle tan─▒mlay─▒n:

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

Ve i┼čte enumsiyonlar─▒n─▒za ┼ču ┼čekilde eri┼čirsiniz:

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

Mesaj nesnelerinden enumlar─▒ e┼člemek i├žin genellikle son 2 y├Ântemi kullan─▒r─▒m.

Bu yakla┼č─▒m─▒n baz─▒ avantajlar─▒:

  • Enums bildirmek kolay
  • Enumslar─▒n─▒za kolayca eri┼čebilirsiniz
  • Enumslar─▒n─▒z karma┼č─▒k tipler olabilir
  • Enum s─▒n─▒f─▒ getByValue kullan─▒yorsan─▒z, baz─▒ ├Ânbelle─če alma i┼člemlerine sahiptir.

Baz─▒ dezavantajlar:

  • Orada baz─▒ da─č─▒n─▒k bellek y├Ânetimi devam ediyor;
  • Hala tip emniyet yok

15







In ES7 , statik niteliklerini g├╝venerek zarif enum yapabilirsiniz:

 class ColorEnum  {
    static RED = 0 ;
    static GREEN = 1;
    static BLUE = 2;
}
 

sonra

 if (currentColor === ColorEnum.GREEN ) {/*-- coding --*/}
 

(Yerine de─či┼čmez nesne s─▒n─▒f─▒n─▒ kullanman─▒n) avantaj─▒ bir ├╝st s─▒n─▒f sahip olmakt─▒r Enum sonra t├╝m Numaralamalar olacak uzan─▒r o s─▒n─▒f─▒.

  class ColorEnum  extends Enum {/*....*/}
 

15







Haz─▒r bir nesne olu┼čturun:

 const Modes = {
  DRAGGING: 'drag',
  SCALING:  'scale',
  CLICKED:  'click'
};
 

14


2015-07-26





E─čer kullan─▒yorsan─▒z Omurga , sen tam geli┼čmi┼č enum i┼člevsellik olsun ├╝cretsiz kullanmak i├žin (id, ad, ├Âzel ├╝yeleri taraf─▒ndan bulmak) olabilir Backbone.Collection .

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

11







cevaplar─▒n ├žok karma┼č─▒k

 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
 

8







Andre 'Fi'nin ├ž├Âz├╝m├╝n├╝ de─či┼čtirdim:

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

├ľl├žek:

 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
 

7







Ben ile geldi bu Java ├žeteleler sonra modellenmi┼čtir yakla┼č─▒m─▒. Bunlar g├╝venlidir ve instanceof ayr─▒ca kontroller de yapabilirsiniz .

Enums'leri ┼č├Âyle tan─▒mlayabilirsiniz:

 var Days = Enum.define("Days", ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]);
 

Days ┼čimdi Days enum anlam─▒na gelir :

 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"
 

Hayata ge├žirme:

 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
    }

})();
 

6







IE8 freeze () y├Ântemini desteklemez.
Kaynak: http://kangax.github.io/compat-table/es5/ , "Eski taray─▒c─▒lar─▒ g├Âster?" ├╝stte ve IE8'i kontrol et ve sat─▒rdaki kesi┼čme noktas─▒n─▒ dondur.

Mevcut oyun projemde a┼ča─č─▒da ├žok kulland─▒m, ├ž├╝nk├╝ ├žok az m├╝┼čteri hala IE8 kullan─▒yor:

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

Ayr─▒ca ┼čunlar─▒ da yapabiliriz:

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

hatta bu bile:

 var CONST_WILD_TYPES = {
    REGULAR: '1',
    EXPANDING: '2',
    STICKY: '3',
    SHIFTING: '4'
};
 

Sonuncusu, dize i├žin en verimli g├Âr├╝nmektedir, e─čer sunucu ve istemciniz bu verileri de─či┼čtiriyorsa, toplam bant geni┼čli─činizi azalt─▒r.
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 wildType = CONST_WILD_TYPES.REGULAR;
 

kar┼č─▒la┼čt─▒rma:

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

6







 var ColorEnum = {
    red: {},
    green: {},
    blue: {}
}
 

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







─░┼čte TypeScript enums uygulamak i├žin birka├ž farkl─▒ yol .

En kolay yol, nesneye ters ├ževrilmi┼č anahtar / de─čer ├žiftleri ekleyerek sadece bir nesnenin ├╝zerinde yineleme yapmakt─▒r. Tek dezavantaj─▒, her ├╝ye i├žin de─čeri el ile ayarlaman─▒z gerekti─čidir.

 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
 


Ve i┼čte bir string kullanarak enum olu┼čturmak i├žin bir lodash mixin . 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 d├╝zenli bir JavaScript e┼čde─čeri vard─▒r, b├Âylece isterseniz kolayca de─či┼čtirebilirsiniz.

 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
 

4







Az ├Ânce bir NPM paketi yay─▒nlad─▒m gen_enum , Javascript'te Enum veri yap─▒s─▒n─▒ h─▒zl─▒ bir ┼čekilde olu┼čturman─▒za olanak sa─člar:

 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 
 

Bu k├╝├ž├╝k ara├ž hakk─▒nda 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 ├Âdeme https://github.com/greenlaw110/enumjs

G├╝ncellemeler

Ben gen_enum paketin eski oldu─čunu ve fonksiyonun de─či┼čmeyen nesneler, JSON string seri kald─▒rma , string sabitler ve bitmap olu┼čturma vb. Dahil daha fazla ├Âzellik sa─člayan constjs paketini birle┼čtiriyorum. Daha fazla bilgi i├žin ├ľdeme https://www.npmjs.com/package/constjs

Y├╝kseltmek gen_enum i├žin constjs sadece deyimi de─či┼čtirmek i├žin

 var genEnum = require('gen_enum');
 

i├žin

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

4







O (1) 'de de─čerleri ve isimleri alabilen bir Enum s─▒n─▒f─▒ yapt─▒m. Ayr─▒ca t├╝m ─░simleri ve De─čerleri i├žeren bir Nesne Dizisi de olu┼čturabilir.

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

Bu ┼čekilde ba┼člatabilirsiniz:

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

Bir de─čer almak i├žin (C #'daki Enums gibi):

 var val2 = enum1.item2;
 

Bir de─čerin ismini almak i├žin (farkl─▒ isimler i├žin ayn─▒ de─čeri koyarken belirsiz olabilir):

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

Bir nesnede her isim ve de─čer i├žeren bir dizi elde etmek i├žin:

 var arr = enum1.GetObjArr();
 

├ťretecek:

 [{ Name: "item1", Value: 0}, { ... }, ... ]
 

Ayr─▒ca html se├žim se├ženeklerini kolayca alabilirsiniz:

 var html = enum1.GetSelectOptionsHTML();
 

Hangisi:

 "<option value='0'>item1</option>..."
 

4







Olsa sadece statik y├Ântemler (ve statik ├Âzellikleri) (bkz ES2015 desteklenir burada , hem de ┬ž15.2.2.2), merakla Birlikte Babel ile a┼ča─č─▒da kullanabilirsiniz es2015 ├Ânceden:

 class CellState {
    v: string;
    constructor(v: string) {
        this.v = v;
        Object.freeze(this);
    }
    static EMPTY       = new CellState('e');
    static OCCUPIED    = new CellState('o');
    static HIGHLIGHTED = new CellState('h');
    static values      = function(): Array<CellState> {
        const rv = [];
        rv.push(CellState.EMPTY);
        rv.push(CellState.OCCUPIED);
        rv.push(CellState.HIGHLIGHTED);
        return rv;
    }
}
Object.freeze(CellState);
 

Bunun mod├╝ller aras─▒nda bile beklendi─či gibi ├žal─▒┼čt─▒─č─▒n─▒ g├Ârd├╝m (├Ârne─čin, CellState enum'u ba┼čka bir mod├╝lden i├že aktar─▒rken ) ve ayr─▒ca Webpack kullanarak bir mod├╝l al─▒rken.

Bu y├Ântem ├╝zerinde en fazla di─čer cevaplar vard─▒r avantaj─▒ statik tip denetleyicisi ile birlikte kullanabilirsiniz olmas─▒d─▒r (├Ârne─čin Ak─▒┼č vb de─či┼čkenler, parametreler, spesifik oldu─ču, statik t├╝r denetlemesi kullanarak geli┼čtirme anda) ile iddia edebilir CellState " ("genel nesneler veya semboller kulland─▒ysan─▒z ay─▒rt etmek imkans─▒z olacak) ba┼čka bir numaradan ziyade".

g├╝ncelle┼čtirme

Yukar─▒daki kodun, bir ki┼činin ek t├╝r nesneler yaratmas─▒na izin vermesi konusunda bir eksikli─či vard─▒r CellState (biri CellState donduruldu─čundan beri statik alanlara atamasa da). Yine de, a┼ča─č─▒da daha ayr─▒nt─▒l─▒ kod a┼ča─č─▒daki avantajlar─▒ sunar:

  1. ba┼čka t├╝r nesne CellState olu┼čturulamaz
  2. ayn─▒ kod atanmam─▒┼č iki enum ├Ârne─čine sahip oldu─čunuz garanti edilir
  3. Enum bir dize g├Âsterimi geri almak i├žin yard─▒mc─▒ program─▒ y├Ântemi
  4. values enum d├Âner t├╝m ├Ârnekler yukar─▒daki k─▒lavuzu (ve hata e─čilimli) bir ┼čekilde geri d├Ân├╝┼č de─čeri yaratmak zorunda de─čildir bu i┼člevi.

     '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







es7 yolu, (yineleyici, donma), kullan─▒m:

 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'
 

kod:

 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(', ') }

}
 

4







Typescript bu enum ┼čekilde Javascript'e ├ževrilir :

 var makeEnum = function(obj) {
    obj[ obj['Active'] = 1 ] = 'Active';
    obj[ obj['Closed'] = 2 ] = 'Closed';
    obj[ obj['Deleted'] = 3 ] = 'Deleted';
}
 

┼×imdi:

 makeEnum( NewObj = {} )
// => {1: "Active", 2: "Closed", 3: "Deleted", Active: 1, Closed: 2, Deleted: 3}
 

─░lk ba┼čta neden obj[1] geri d├Ând├╝─č├╝me kafam kar─▒┼čt─▒ 'Active' , ama sonra ├Âl├╝ basit oldu─čunu fark ettim - Atama operat├Âr├╝ de─čer atar ve sonra geri verir:

 obj['foo'] = 1
// => 1
 

4







B├Âyle bir ┼čey yapabilirsin

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

Bu k├╝t├╝phanede tan─▒mland─▒─č─▒ gibi. https://github.com/webmodule/foo/blob/master/foo.js#L217

Komple ├Ârnek https://gist.github.com/lnt/bb13a2fd63cdb8bce85fd62965a20026


4


2016-05-25





H─▒zl─▒ ve basit bir yol ┼čudur:

 var Colors = function(){
return {
    'WHITE':0,
    'BLACK':1,
    'RED':2,
    'GREEN':3
    }
}();

console.log(Colors.WHITE)  //this prints out "0"
 

3







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├╝phaneler vb. Bir s├╝r├╝ yaz─▒ g├Ârd├╝m. JavascriptÔÇÖte enum deste─či alman─▒n ├ž├Âz├╝m├╝ o kadar basittir ki, ger├žekte gerekli de─čildir. ─░┼čte kod:

Dosya: enums.js

 _ = 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 size ne verdi─čini g├Âstermek i├žin bir test:

dosya: enumsSpec.js

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

});
 

G├Ârd├╝─č├╝n├╝z gibi, bir Enum fabrikas─▒ al─▒rs─▒n─▒z, t├╝m anahtarlar─▒ sadece enum.keys'i ├ža─č─▒rarak elde edebilirsiniz ve tu┼člar─▒ kendileri tamsay─▒ sabitleri ile 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. Varsa, kodun fabrika k─▒sm─▒n─▒ kullan─▒n, kodunuzda kullanmak istemiyorsan─▒z alt ├žizgi k├╝t├╝phanesini de kald─▒r─▒n.


3







San─▒r─▒m kullan─▒m─▒ kolay. https://stackoverflow.com/a/32245370/4365315

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

G├ťNCELLE┼×T─░RME:

─░┼čte yard─▒mc─▒ kodlar─▒m ( 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"])); 


3







Yazd─▒─č─▒m enumerationjs bir sorunu gidermek i├žin ├žok k├╝├ž├╝k bir k├╝t├╝phane tipi g├╝venlik sa─člar , i├žin enum sabitleri izin bir prototip gelen inherit , guaranties enum sabitleri ve enum t├╝rleri + de─či┼čmez bir├žok k├╝├ž├╝k ├Âzellikleri edilecek. Bir ├žok kodu yeniden aktive etmeye ve enum tan─▒m─▒nda baz─▒ mant─▒klar─▒ hareket ettirmeye izin verir. ─░┼čte bir ├Ârnek :

 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
 

Enumeration temelde bir fabrika.

Tam belgeli k─▒lavuz burada mevcuttur. Bu yard─▒mc─▒ olur umar─▒m.


3