ජාවාස්ක්‍රිප්ට් හි එනූම්ස් අර්ථ දැක්වීම සඳහා වඩාත් කැමති වාක්‍ය ඛණ්ඩය කුමක්ද? වැනි දෙයක්:

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

// later on

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

නැතහොත් ඊට වඩා හොඳ මෝඩකමක් තිබේද?

1.8.5 සිට වස්තුව මුද්‍රා තැබීමට සහ කැටි කිරීමට හැකිය, එබැවින් ඉහත අර්ථ දක්වන්න:

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

හෝ

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

සහ වොයිලා! JS enums.

කෙසේ වෙතත්, මෙය විචල්‍යයකට අනවශ්‍ය අගයක් පැවරීමෙන් ඔබව වළක්වන්නේ නැත, එය බොහෝ විට enums හි ප්‍රධාන ඉලක්කය වේ:

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

වඩා ශක්තිමත් ආකාරයේ ආරක්ෂාවක් සහතික කිරීම සඳහා එක් ක්‍රමයක් නම් (එනූම්ස් හෝ වෙනත් ආකාරයකින්) වැනි මෙවලමක් භාවිතා කිරීමයි ටයිප්ස්ක්‍රිප්ට් හෝ ප්‍රවාහ .

මූලාශ්රය

මිල ගණන් අවශ්‍ය නොවන නමුත් මම ඒවා අනුකූලතාව සඳහා තබා ගතිමි.

මෙය එතරම් පිළිතුරක් නොවේ, නමුත් මම කියන්නේ එය පෞද්ගලිකව හොඳින් ක්‍රියාත්මක වන බවයි

සාරධර්ම කුමක් වුවත් (ඔබ 0, 1, 2 භාවිතා කර ඇත) එය වැදගත් නොවන බැවින්, වර්තමාන අගය ප්‍රතිදානය කිරීමට ඔබට අවශ්‍ය නම් මම අර්ථවත් නූලක් භාවිතා කරමි.

යාවත්කාලීන කරන්න

සියලු දෙනාගේ සියලු දෙනාටම ස්තූතියි, නමුත් පහත දැක්වෙන මගේ පිළිතුර තවදුරටත් ජාවාස්ක්‍රිප්ට් හි එනූම් ලිවීමට හොඳම ක්‍රමය යැයි මම නොසිතමි. වැඩි විස්තර සඳහා මගේ බ්ලොග් සටහන බලන්න: ජාවාස්ක්‍රිප්ට් හි එනූම්ස් .

නම දැනුම් දීම දැනටමත් කළ හැකිය:

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

විකල්පයක් ලෙස, ඔබට වටිනාකම් වස්තු බවට පත් කළ හැකිය, එවිට ඔබට කේක් තබා එය අනුභව කළ හැකිය:

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

ජාවාස්ක්‍රිප්ට් හි, එය ගතික භාෂාවක් බැවින්, පසුව කට්ටලයට enum අගයන් එකතු කිරීමට පවා හැකිය:

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

මතක තබා ගන්න, අනන්‍යතා පරීක්‍ෂණය සඳහා එනූම් (මෙම උදාහරණයේ වටිනාකම, නම සහ කේතය) අවශ්‍ය නොවන අතර ඒවා ඇත්තේ පහසුව සඳහා පමණි. ප්‍රමාණයේ දේපලවල නමම කේතගත කිරීම අවශ්‍ය නොවන අතර ගතිකව සැකසිය හැකිය. එබැවින් ඔබ ඔබගේ නව එනුම් අගය සඳහා නම පමණක් දනී යැයි සිතමු, ඔබට එය ගැටළු නොමැතිව එකතු කළ හැකිය:

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

ඇත්ත වශයෙන්ම මෙයින් අදහස් කරන්නේ සමහර උපකල්පන තවදුරටත් කළ නොහැකි බවයි (එම අගය නිදසුනක් ලෙස ප්‍රමාණය සඳහා නිවැරදි අනුපිළිවෙල නියෝජනය කරයි).

මතක තබා ගන්න, ජාවාස්ක්‍රිප්ට් හි වස්තුවක් සිතියමක් හෝ හැෂ් වගුවක් වැනි ය . නම-අගය යුගල කට්ටලයක්. කල්තියාම ඒවා ගැන වැඩි යමක් නොදැන ඔබට ඒවා හරහා ලූප හෝ වෙනත් ආකාරයකින් හැසිරවිය හැකිය.

උදාහරණයක්

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

මාර්ගය වන විට, ඔබ නාම අවකාශයන් ගැන උනන්දුවක් දක්වන්නේ නම්, ජාවාස්ක්‍රිප්ට් සඳහා සරල නමුත් බලගතු නාම අවකාශයක් සහ යැපුම් කළමනාකරණය සඳහා මගේ විසඳුම දෙස බැලීමට ඔබට අවශ්‍ය විය හැකිය: පැකේජ JS

නිගමනය: ඔබට බැහැ.

ඔබට එය ව්‍යාජ කළ හැකිය, නමුත් ඔබට වර්ගයේ ආරක්ෂාව නොලැබේ. සාමාන්‍යයෙන් මෙය සිදු කරනුයේ පූර්ණ සංඛ්‍යා අගයන්ට අනුරූප වන සරල අගයන් සරල ශබ්ද කෝෂයක් නිර්මාණය කිරීමෙනි. උදාහරණයක් වශයෙන්:

var DaysEnum = {"monday":1, "tuesday":2, "wednesday":3, ...}

Document.Write("Enumerant: " + DaysEnum.tuesday);

මෙම ප්රවේශයේ ගැටළුව? ඔබට අහම්බෙන් ඔබේ ගණන්කරු නැවත අර්ථ දැක්විය හැකිය, නැතහොත් අහම්බෙන් අනුපිටපත් සංඛ්‍යාත්මක අගයන් ඇත. උදාහරණයක් වශයෙන්:

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

සංස්කරණය කරන්න

ආටුර් සාජ්කාගේ Object.freeze ගැන කුමක් කිව හැකිද? සඳුදා සිට බ්‍රහස්පතින්දා දක්වා කාලය සැකසීම වළක්වා ගැනීමට එය ක්‍රියා නොකරන්නේද? - ෆ්රයි ක්වාඩ්

නියත වශයෙන්ම, Object.freezeමා පැමිණිලි කළ ගැටලුව මුළුමනින්ම විසඳනු ඇත. ඉහත සඳහන් දේ ලියන විට Object.freezeසැබවින්ම නොපවතින බව මම සෑම කෙනෙකුටම මතක් කිරීමට කැමැත්තෙමි .

දැන් .... දැන් එය ඉතා රසවත් හැකියාවන් විවර කරයි .

2 සංස්කරණය කරන්න
enums සෑදීම සඳහා ඉතා හොඳ පුස්තකාලයක් මෙන්න.

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

බොහෝ විට වලංගු එනූම් භාවිතයට එය නොගැලපෙන නමුත් එය බොහෝ දුරක් යයි.

මෙන්න අපි හැමෝටම අවශ්‍ය දේ:

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

දැන් ඔබට ඔබේ එනූම්ස් සෑදිය හැකිය:

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

මෙය කිරීමෙන්, නියතයන් සුපුරුදු ආකාරයෙන් ලබා ගත හැකිය (YesNo.YES, Color.GREEN) ඒවාට අනුක්‍රමික int අගයක් ලැබේ (NO = 0, YES = 1; RED = 0, GREEN = 1, BLUE = 2).

Enum.prototype භාවිතා කිරීමෙන් ඔබට ක්‍රම එකතු කළ හැකිය:

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

සංස්කරණය කරන්න - කුඩා වැඩිදියුණු කිරීම - දැන් වරග්ස් සමඟ: (අවාසනාවකට එය IE මත නිසි ලෙස ක්‍රියා නොකරයි: එස් ... පෙර අනුවාදය සමඟ බැඳී තිබිය යුතුය)

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

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

බොහෝ නවීන බ්‍රව්සර්වල, ගණනය කිරීමක් නිර්මාණය කිරීම සඳහා භාවිතා කළ හැකි සංකේතාත්මක ප්‍රාථමික දත්ත වර්ගයක් ඇත. සෑම සංකේත අගයක්ම ජාවාස්ක්‍රිප්ට් මගින් අද්විතීය බව සහතික කර ඇති බැවින් එය එනුම් වල වර්ගයේ ආරක්ෂාව සහතික කරනු ඇත Symbol() != Symbol(). උදාහරණයක් වශයෙන්:

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

නිදොස්කරණය සරල කිරීම සඳහා, ඔබට enum අගයන්ට විස්තරයක් එක් කළ හැකිය:

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

ප්ලන්කර් නිරූපණය

මත GitHub ඔබ නිඛිල ආරම්භ කිරීමට අවශ්ය කේතය සරළ බව දවටනය සොයා ගත හැකි:

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

𝗣𝗹𝗮𝗶𝗻 𝗩𝗮𝗻𝗶𝗹𝗹𝗮𝗝𝗦 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲

අපි ගැටළුවට කෙලින්ම කපා ගනිමු: ගොනු ප්‍රමාණය. මෙහි ලැයිස්තුගත කර ඇති අනෙක් සෑම පිළිතුරක්ම ඔබේ කේතය අන්තයටම තල්ලු කරයි. හැකි උපරිම කාර්ය සාධනය, කේත කියවීමේ හැකියාව, මහා පරිමාණ ව්‍යාපෘති කළමනාකරණය, බොහෝ කේත සංස්කාරකවරුන්ගේ සින්ටැක්ස් ඉඟි කිරීම සහ අවම කිරීම මඟින් කේත ප්‍රමාණය අඩු කිරීම සඳහා ගණනය කිරීම් සඳහා නිවැරදි ක්‍රමය මෙය බව මම ඔබට ඉදිරිපත් කරමි.

^wvwvwvvv

ඉහත වගුවේ සහ පහත උදාහරණයේ පෙන්වා ඇති පරිදි, ආරම්භ කිරීමට පහසු පියවර පහක් මෙන්න:

1. ගණන් ගැනීමේ කණ්ඩායම සඳහා නමක් තීරණය කරන්න. ගණනය කිරීමේ අරමුණ හෝ අවම වශයෙන් ගණන් බැලීමේ ඇතුළත් කිරීම් විස්තර කළ හැකි නාම පදයක් ගැන සිතන්න. නිදසුනක් ලෙස, පරිශීලකයා විසින් තෝරා ගත හැකි වර්ණ නියෝජනය කරන ගණන් බැලීම් සමූහයක් COLORS වලට වඩා COLORCHOICES ලෙස නම් කළ හැකිය.
2. කණ්ඩායමේ ගණනය කිරීම් අන්‍යෝන්‍ය වශයෙන් හෝ ස්වාධීනද යන්න තීරණය කරන්න. අන්‍යෝන්‍ය වශයෙන් නම්, එක් එක් ගණනය කළ විචල්‍ය නාමය ආරම්භ කරන්න ENUM_. ස්වාධීන හෝ පැත්තකින් නම්, භාවිතා කරන්න INDEX_.
3. සෑම ප්‍රවේශයක් සඳහාම, නව දේශීය විචල්‍යයක් සාදන්න, එහි නම ආරම්භ වන්නේ ENUM_හෝ INDEX_පසුව කණ්ඩායමේ නම, පසුව අවධාරනය කිරීම, පසුව දේපල සඳහා අද්විතීය මිත්‍රශීලී නමක්
4. එක් කරන්න ENUMLENGTH_, ENUMLEN_, INDEXLENGTH_, හෝ INDEXLEN_යන්න ( LEN_හෝLENGTH_ගණනය කළ විචල්‍යයක් අවසානයේ පුද්ගලික මනාපයන් ) . ගණනය කිරීම සඳහා අමතර ප්‍රවේශයක් එකතු කිරීම සහ මෙම අගය වැඩි කිරීම ඔබේ කේතය බිඳ නොදමන බව සහතික කිරීම සඳහා ඔබේ කේතයේ හැකි සෑම තැනකම ඔබ මෙම විචල්‍යය භාවිතා කළ යුතුය.
5. සෑම අනුයාත ගණනය කිරීමත් විචල්ය අගය එක් දෙන්න පසුගිය වඩා, 0 න් පටන් මෙම පිටුවේ අදහස් මතය බව ඇත 0බැවින් ගණනය කිරීමත් අගය ලෙස භාවිතා කළ යුතු නැහැ 0 == null, 0 == false, 0 == "", සහ වෙනත් JS කරනසුලු. මම ඔබට ඉදිරිපත් කරන්නේ, මෙම ගැටළුව මඟහරවා ගැනීමට සහ එකවර කාර්ය සාධනය ඉහළ නැංවීමට, සෑම විටම භාවිතා කරන්න ===සහ (උදා ) ==හැර ඔබේ කේතයේ කිසි විටෙකත් දර්ශනය වීමට ඉඩ නොදෙන්න . මගේ සෑම වසරකදීම, ගණන් කිරීමේ අගයක් ලෙස 0 භාවිතා කිරීම පිළිබඳව මට කිසි විටෙකත් ගැටළුවක් නොවීය. ඔබ තවමත් අශෝභන නම්, බොහෝ අවස්ථාවන්හි කාර්ය සාධන ද penalty ුවමක් නොමැතිව ගණන් බැලීම්වල ආරම්භක අගය ලෙස (නමුත් ගණන් බැලීම්වල නොවේ ) භාවිතා කළ හැකිය .typeoftypeof X == "string"===1ENUM_INDEX_

const ENUM_COLORENUM_RED   = 0;
const ENUM_COLORENUM_GREEN = 1;
const ENUM_COLORENUM_BLUE  = 2;
const ENUMLEN_COLORENUM    = 3;

// later on

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

භාවිතා INDEX_කළ යුත්තේ කවදාද සහ කවදාද යන්න මට මතක ඇති ආකාරය මෙන්න ENUM_:

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

කෙසේ වෙතත්, ENUM_යම් යම් තත්වයන් යටතේ, එක් එක් අයිතමයේ සිදුවීම් ගණනය කිරීමේදී වැනි දර්ශකයක් ලෙස සුදුසු විය හැකිය.

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

ඉහත කේතයේ, නව ආකාරයේ සුරතල් සතෙකු එකතු කිරීම සැබවින්ම පහසු බව නිරීක්ෂණය කරන්න: ඔබට පසුව නව ප්‍රවේශයක් එකතු කර ඒ අනුව ENUM_PET_RATයාවත්කාලීන ENUMLEN_PETකළ යුතුය. ගණනය කිරීමේ වෙනත් පද්ධති සඳහා නව ප්‍රවේශයක් එක් කිරීම වඩා දුෂ්කර හා දෝෂ සහිත විය හැකිය.

^{wvwwvw wvwvwv wwwxvw wvwvw}

𝗘𝘅𝘁𝗲𝗻𝗱 𝗨𝗽𝗽𝗲𝗿𝗰𝗮𝘀𝗲 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 𝗪𝗶𝘁𝗵

මීට අමතරව, ගණනය කිරීම්වල මෙම වාක්‍ය ඛණ්ඩය පැහැදිලි හා සංක්ෂිප්ත පංතියක් පහත දැක්වෙන පරිදි විහිදේ. පංතියක් දීර් extend LEN_කිරීම සඳහා, මව් පන්තියේ ඇතුළත් කිරීමට වර්ධක අංකයක් එක් කරන්න . LEN_අනාගතයේ දී උප පංතිය තවදුරටත් දීර් to කර ගැනීම සඳහා උප පංතිය ස්වකීය පිවිසුමෙන් අවසන් කරන්න .

(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_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_ALPHA;
            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);

(දිග: බයිට් 2,450)

මෙය වෙනත් විසඳුම් වලට වඩා අඩු ප්‍රායෝගික යැයි සමහරු පැවසිය හැකිය: එය ටොන් ගණනක ඉඩක්, ලිවීමට බොහෝ කාලයක් ගත වන අතර එය සීනි සින්ටැක්ස් සමඟ ආලේප කර නැත. ඔවුන්ගේ කේතය අවම නොකරන්නේ නම් එම පුද්ගලයින් නිවැරදි වනු ඇත. කෙසේ වෙතත්, කිසිදු සාධාරණ පුද්ගලයෙක් අවසාන නිෂ්පාදනයේ සීමිත කේතයක් තබන්නේ නැත. මෙම අවම කිරීම සඳහා, වසා දැමීමේ සම්පාදකය මා තවමත් සොයාගෙන නැති හොඳම දේ වේ. මාර්ගගත ප්‍රවේශය මෙහි සොයාගත හැකිය . සංවෘත සම්පාදකයාට මෙම ගණන් ගැනීමේ දත්ත සියල්ලම ගෙන එය පේළිගත කිරීමට හැකි වන අතර එමඟින් ඔබේ ජාවාස්ක්‍රිප්ට් සුපිරි ඩුපර් කුඩා වන අතර සුපිරි ඩුපර් වේගයෙන් ධාවනය කරයි. මේ අනුව, වසා දැමීමේ සම්පාදකයා සමඟ අවම කරන්න. නිරීක්ෂණය කරන්න.

^{wvwwvw wvwvwv wwwxvw wvwvw}

𝗠𝗶𝗻𝗶𝗳𝘆 𝗪𝗶𝘁𝗵 𝗖𝗹𝗼𝘀𝘂𝗿𝗲

සංවෘත සම්පාදකයාට වෙනත් ඕනෑම ජාවාස්ක්‍රිප්ට් මිනිෆියරයක ධාරිතාවෙන් ඔබ්බට ගිය අනුමාන කිරීම් හරහා ඇදහිය නොහැකි තරම් ප්‍රශස්තිකරණයන් සිදු කළ හැකිය. සංවෘත සම්පාදකයාට ප්‍රාථමික අගයන් ස්ථාවර අගයකට සකසා ගත හැකිය. සංවෘත සම්පාදකයාට මෙම ආදාන අගයන් මත පදනම්ව අනුමාන කිරීම් සිදු කළ හැකි අතර if-statement සහ loops හි භාවිතයට නොගත් කොටස් ඉවත් කළ හැකිය.

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

(දිග: බයිට් 605)

වසා දැමීමේ සම්පාදකයා ඔබට වඩා හොඳ කේතයක් සහ ඔබේ කේතය හොඳින් සංවිධානය කිරීම සඳහා ත්‍යාග පිරිනමයි. මක්නිසාද යත්, බොහෝ මිනිෆයර් සංවිධානාත්මක කේත විශාල ප්‍රමාණයේ ගොනු ප්‍රමාණයකින් ද punish ුවම් කරන අතරම, ඔබ උපක්‍රම භාවිතා කරන්නේ නම් ඊටත් වඩා කුඩා ගොනු ප්‍රමාණයක් ප්‍රතිදානය කිරීම සඳහා වසා දැමීමේ සම්පාදකයාට ඔබේ සියලු පිරිසිදුකම හා සනීපාරක්ෂාව විග්‍රහ කළ හැකිය. විචල්ය නාම ගණනය කිරීම් වැනි. මෙම එක් මනසකින්, කේතීකරණයේ ශුද්ධ ග්‍රේලය වේ: දෙකම ඔබේ කේතයට කුඩා ප්‍රමාණයෙන් සහාය වන අතර වඩා හොඳ ක්‍රමලේඛන පුරුදු පුහුණු කිරීමෙන් ඔබේ මනසට උපකාර කරයි.

^{wvwwvw wvwvwv wwwxvw wvwvw}

𝗦𝗺𝗮𝗹𝗹𝗲𝗿 𝗖𝗼𝗱𝗲

දැන්, මෙම ගණන් බැලීම් නොමැතිව සමාන ගොනුව කොතරම් විශාලදැයි බලමු.

ගණනය කිරීම් භාවිතා නොකර ප්‍රභවය (දිග: බයිට් 1,973 (ගණන් කළ කේතයට වඩා බයිට් 477 කෙටි!))
බැලීම් නොමැතිව භාවිතා නොකර අවම කර ඇත (දිග: බයිට් 843 ( ගණන් කළ කේතයට වඩා බයිට් 238 ))

දැක ඇති පරිදි, ගණන් බැලීමකින් තොරව, විශාල කේතයක පිරිවැය අනුව ප්‍රභව කේතය කෙටි වේ. මම ඔබ ගැන නොදනිමි; නමුත් මම අවසාන නිශ්පාදනයට ප්‍රභව කේත ඇතුළත් නොකරන බව මම දනිමි. මේ අනුව, මෙම ගණනය කිරීම් ක්‍රමයට වඩා බෙහෙවින් උසස් බැවින් එහි ප්‍රති min ලය වන්නේ කුඩා ගොනු ප්‍රමාණයන්ය.

^{wvwwvw wvwvwv wwwxvw wvwvw}

𝗖𝗼𝗼𝗽𝗲𝗿𝗮𝘁𝗶𝘃𝗲 🤝 𝗕𝘂𝗴

මෙම ගණනය කිරීමේ ක්‍රමයේ ඇති තවත් වාසියක් නම්, කුඩා කේත ප්‍රමාණය කැප නොකර මහා පරිමාණ ව්‍යාපෘති පහසුවෙන් කළමනාකරණය කිරීමට එය භාවිතා කළ හැකි වීමයි. වෙනත් පුද්ගලයින් විශාල ප්‍රමාණයක් සමඟ විශාල ව්‍යාපෘතියක වැඩ කරන විට, කේතය නිර්මාණය කළේ කවුරුන්ද යන්න සමඟ විචල්‍ය නම් පැහැදිලිව සලකුණු කිරීම සහ ලේබල් කිරීම ප්‍රයෝජනවත් විය හැකි අතර එමඟින් කේතයේ මුල් නිර්මාතෘ ඉක්මනින් සහයෝගී දෝෂ නිරාකරණය සඳහා හඳුනාගත හැකිය.

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

𝗦𝘂𝗽𝗲𝗿𝗶𝗼𝗿

තව දුරටත්, මෙම ගණනය කිරීමේ ක්‍රමය අවම කිරීමෙන් පසුව ද වේගවත් වේ. සාමාන්‍ය නම් කරන ලද ගුණාංග වලදී, වස්තුවෙහි දේපල තිබෙන්නේ කොතැනදැයි බැලීමට බ්‍රව්සරයට හැෂ්මැප් භාවිතා කළ යුතුය. JIT සම්පාදකයින් බුද්ධිමත්ව මෙම ස්ථානය වස්තුව මත රඳවාගෙන සිටියද, වස්තුවෙන් අඩු දේපලක් මකා දැමීම වැනි විශේෂ අවස්ථා හේතුවෙන් තවමත් විශාල පොදු කාර්යයක් පවතී.

එහෙත්, අඛණ්ඩ විරල නොවන පූර්ණ සංඛ්‍යා-සුචිගත කළ PACKED_ELEMENTS සමඟ අරා සමඟ, බ්‍රව්සරයට එම ඉහළ කොටස මඟ හැරිය හැකි වන්නේ අභ්‍යන්තර අරාවෙහි අගයෙහි දර්ශකය දැනටමත් නිශ්චිතව දක්වා ඇති බැවිනි. ඔව්, ECMAScript ප්‍රමිතියට අනුව, සියලු ගුණාංග නූල් ලෙස සැලකිය යුතුය. එසේ වුවද, ECMAScript ප්‍රමිතියේ මෙම අංගය කාර්ය සාධනය පිළිබඳ නොමඟ යවන සුළු බැවින් සියලු බ්‍රව්සර්වල අරා වල සංඛ්‍යාත්මක දර්ශක සඳහා විශේෂ ප්‍රශස්තිකරණ ඇත.

/// Hashmaps are slow, even with JIT juice
var ref = {};
ref.count = 10;
ref.value = "foobar";

ඉහත කේතය පහත කේතය සමඟ සසඳන්න.

/// Arrays, however, are always lightning fast
const INDEX_REFERENCE_COUNT = 0;
const INDEX_REFERENCE_VALUE = 1;
const INDEXLENGTH_REFERENCE = 2;

var ref = [];
ref[INDEX_REFERENCE_COUNT] = 10;
ref[INDEX_REFERENCE_VALUE] = "foobar";

සාමාන්‍ය වස්තූන් සමඟ ඇති කේතයට වඩා දිගු යැයි පෙනෙන ගණන් බැලීම් සහිත කේතයට යමෙකු විරුද්ධ විය හැකි නමුත් පෙනුම රැවටිලිකාර විය හැකිය. එපික් වසා දැමීමේ සම්පාදකය භාවිතා කරන විට ප්‍රභව කේත ප්‍රමාණය ප්‍රතිදාන ප්‍රමාණයට සමානුපාතික නොවන බව මතක තබා ගැනීම වැදගත්ය. නිරීක්ෂණය කරන්න.

/// Hashmaps are slow, even with JIT juice
var a={count:10,value:"foobar"};

ගණන් බැලීම් නොමැතිව අවම කේතය ඉහළින් ඇති අතර ගණන් කිරීම් සහිත අවම කේතය පහතින් ඇත.

/// Arrays, however, are always lightning fast
var a=[10,"foobar"];

ඉහත උදාහරණයෙන් පෙන්නුම් කරන්නේ, ඉහළ කාර්ය සාධනයක් ලැබීමට අමතරව, ගණනය කරන ලද කේතය මඟින් කුඩා කළ කුඩා ගොනු ප්‍රමාණයක් ද ඇති බවයි.

^{wvwwvw wvwvwv wwwxvw wvwvw}

𝗘𝗮𝘀𝘆

තව දුරටත්, මෙම පුද්ගලයාගේ පෞද්ගලික චෙරි ජාවාස්ක්‍රිප්ට් මාදිලියේ කෝඩ් මිරර් පා editor සංස්කාරකය සමඟ මෙම ගණනය කිරීම් භාවිතා කරයි. කෝඩ් මිරර් හි ජාවාස්ක්‍රිප්ට් සින්ටැක්ස් ඉස්මතු කිරීමේ මාදිලිය වත්මන් විෂය පථයේ දේශීය විචල්‍යයන් ඉස්මතු කරයි. ඒ ආකාරයෙන්, ඔබ විචල්ය නාමයක් නිවැරදිව ටයිප් කරන විට ඔබ ක්ෂණිකව දනී, මන්ද විචල්ය නාමය කලින්var ප්රධාන පදය , විචල්ය නාමය විශේෂ වර්ණයක් බවට පත් කරයි (පෙරනිමියෙන් සයන්). ඔබ කෝඩ් මිරර් භාවිතා නොකළත්, අවම වශයෙන් බ්‍රව්සරය ප්‍රයෝජනවත් වේ[variable name] is not definedවැරදි ලෙස ගණනය කළ නාමයන් සමඟ කේතය ක්‍රියාත්මක කිරීමේදී ව්‍යතිරේකය. එසේම, JSLint සහ Closure Compiler වැනි ජාවාස්ක්‍රිප්ට් මෙවලම් ඔබ ගණන් කිරීමේ විචල්‍ය නාමයකින් වැරදියට ටයිප් කරන විට ඔබට පැවසීම ගැන ඉතා loud ෝෂාකාරී වේ. කෝඩ් මිරර්, බ්‍රව්සරය සහ විවිධ ජාවාස්ක්‍රිප්ට් මෙවලම් එකට එකතු කර මෙම ගණනය කිරීම් ඉතා සරල හා සැබවින්ම පහසු කරයි.

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
}

ඉහත ස්නිපටයේ, ENUM_COLORENUM_DNEනොපවතින බැවින් දෝෂයක් පිළිබඳව ඔබව දැනුවත් කරන ලදි .

^{wvwwvw wvwvwv wwwxvw wvwvw}

𝗖𝗼𝗻𝗰𝗹𝘂𝘀𝗶𝗼𝗻

ගණනය කිරීමේ මෙම ක්‍රමවේදය ඇත්ත වශයෙන්ම අවම කේත ප්‍රමාණයට පමණක් නොව කාර්ය සාධනය, නිදොස්කරණය සහ සහයෝගීතාව සඳහාද යා හැකි හොඳම ක්‍රමය යැයි පැවසීම ආරක්ෂිත යැයි මම සිතමි.

^{ප්‍රයෝජනවත් ප්‍රශ්නයක් කියවීමෙන් පසු, ප්‍රශ්න කොටුවේ ඉහළ වම්පස ඉහළ ඊතලය ක්ලික් කිරීමෙන් ඔවුන්ගේ ලිවීමට කාලය වත් කිරීම ගැන මම කතුවරයාට ස්තූතිවන්ත වෙමි. සෑම පිළිතුරු පෙට්ටියකම මෙම ඉහළ ඊතල වලින් එකක් ඇත.}

මම මගේ එනුම් වලට ආදරය කරන නිසා මම මේ සමඟ සෙල්ලම් කර ඇත්තෙමි. =)

භාවිතා Object.definePropertyමම තරමක් ශක්ය විසඳුමක් සමග පැමිණි කියලා.

මෙන්න jsfiddle: http://jsfiddle.net/ZV4A6/

මෙම ක්‍රමය භාවිතා කරමින් .. ඔබට (න්‍යායිකව) එම වස්තුවේ වෙනත් ගුණාංගවලට බලපෑම් නොකර ඕනෑම වස්තුවක් සඳහා එනුම් අගයන් ඇමතීමට සහ අර්ථ දැක්වීමට හැකි විය යුතුය.

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මෙම යුතු ආරක්ෂිත ටයිප් කරන්න.

එබැවින් ඔබට අභිරුචි වස්තුවක් නිර්මාණය කිරීමට හැකි විය යුතුය, ඉන්පසු Enum()එය අමතන්න . පවරා ඇති අගයන් 0 සිට ආරම්භ වන අතර එක් අයිතමයකට වර්ධක වේ.

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

ජාවාස්ක්‍රිප්ට් ප්‍රොක්සි භාවිතා කරන්න

ටීඑල්ඩීආර්: මෙම පංතිය ඔබේ උපයෝගිතා ක්‍රමවලට එකතු කර ඔබේ කේතය පුරාම භාවිතා කරන්න, එය සම්ප්‍රදායික ක්‍රමලේඛන භාෂාවලින් එනූම් හැසිරීම සමච්චලයට ලක් කරයි, ඇත්ත වශයෙන්ම ඔබ නොපවතින ගණන් ගන්නෙකුට ප්‍රවේශ වීමට හෝ ගණන් ගැනීමේ යන්ත්‍රයක් එකතු කිරීමට / යාවත්කාලීන කිරීමට උත්සාහ කරන විට දෝෂ ඇතිවේ. විශ්වාසය තැබීමට අවශ්ය නැත 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);
  }
}

පංතිය ස්ථාපනය කිරීමෙන් enums සාදන්න:

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

සම්පූර්ණ පැහැදිලි කිරීම:

සාම්ප්‍රදායික භාෂාවලින් ඔබට ලැබෙන එනූම්ස් හි ඉතා වාසිදායක ලක්ෂණයක් නම්, ඔබ නොපවතින ගණන් බැලීමේ යන්ත්‍රයකට ප්‍රවේශ වීමට උත්සාහ කළහොත් ඒවා පුපුරා යාම (සම්පාදක-කාල දෝෂයක් විසි කිරීම) ය.

අතිරේක අගයන් අහම්බෙන් / අනිෂ්ට ලෙස එකතු වීම වැළැක්වීම සඳහා සමච්චල් කරන ලද එනුම් ව්‍යුහය කැටි කිරීමට අමතරව, වෙනත් පිළිතුරු කිසිවක් එනුම්ස්හි සහජ ලක්ෂණයට ආමන්ත්‍රණය නොකරයි.

ඔබ බොහෝ විට දන්නා පරිදි, ජාවාස්ක්‍රිප්ට් හි දැනට නොමැති සාමාජිකයින්ට ප්‍රවේශ වීම සරලවම ආපසු පැමිණේ undefined අතර ඔබේ කේතය පුපුරවා හරිනු නොලැබේ. ගණන් ගන්නන් පූර්ව නිශ්චිත නියතයන් වන බැවින් (සතියේ දින), ගණන් කරන්නෙකු නිර්වචනය කළ යුතු අවස්ථාවක් කිසි විටෙකත් නොතිබිය යුතුය.

මාව වැරදියට තේරුම් ගන්න එපා, undefinedනිර්වචනය නොකළ දේපල වෙත ප්‍රවේශ වන විට නැවත පැමිණීමේ ජාවාස්ක්‍රිප්ට් හැසිරීම ඇත්ත වශයෙන්ම භාෂාවේ ඉතා ප්‍රබල ලක්ෂණයකි, නමුත් සාම්ප්‍රදායික එනුම් ව්‍යුහයන් සමච්චලයට ලක් කිරීමට උත්සාහ කරන විට එය ඔබට අවශ්‍ය අංගයක් නොවේ.

ප්‍රොක්සි වස්තු බැබළෙන්නේ මෙහිදීය. ES6 (ES2015) හඳුන්වාදීමත් සමඟ ප්‍රොක්සි භාෂාවෙන් ප්‍රමිතිකරණය කරන ලදී. MDN වෙතින් විස්තරය මෙන්න:

මූලික මෙහෙයුම් සඳහා අභිරුචි හැසිරීම නිර්වචනය කිරීමට ප්‍රොක්සි වස්තුව භාවිතා කරයි (උදා: දේපල බැලීම, පැවරීම, ගණන් බැලීම, ක්‍රියාකාරී ආයාචනය ආදිය).

වෙබ් සේවාදායක ප්‍රොක්සියකට සමානව, ජාවාස්ක්‍රිප්ට් ප්‍රොක්සි වලට වස්තූන් මත මෙහෙයුම් වලක්වා ගත හැකිය ("උගුල්" භාවිතා කරමින්, ඔබ කැමති නම් ඒවා කොකු ලෙස අමතන්න) සහ ඒවා සම්පූර්ණ කිරීමට පෙර විවිධ චෙක්පත්, ක්‍රියා සහ / හෝ හැසිරවීම් සිදු කිරීමට ඔබට ඉඩ සලසයි (හෝ සමහර අවස්ථාවන්හිදී මෙහෙයුම් මුළුමනින්ම නැවැත්වීම, අප විසින් සිදු කිරීමට අවශ්‍ය වන්නේ හරියටම නොපවතින ගණන් බැලීමේ යන්ත්‍රයක් යොමු කිරීමට උත්සාහ කළහොත් පමණි).

එනූම්ස් අනුකරණය කිරීමට ප්‍රොක්සි වස්තුව භාවිතා කරන ප්‍රතිවිරුද්ධ උදාහරණය මෙන්න. මෙම උදාහරණයේ ගණන් කරන්නන් සම්මත HTTP ක්‍රම (එනම් "GET", "POST" යනාදිය):

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

අසයිඩ්: ප්‍රොක්සිය යනු කුමක්ද?

මට මතකයි මම ප්‍රොක්සි යන වචනය සෑම තැනකම දැකීමට පටන් ගත් විට, එය නිසැකවම මට දීර් time කාලයක් තිස්සේ තේරුමක් නොතිබුණි. ඔබ දැන් එය නම්, ප්‍රොක්සි සාමාන්‍යකරණය කිරීමට පහසු ක්‍රමයක් නම් ඔවුන් මෘදුකාංග, ආයතන හෝ සේවාදායකයන් දෙදෙනෙකු, සමාගම් හෝ පුද්ගලයින් අතර අතරමැදියන් හෝ අතරමැදියන් ලෙස ක්‍රියා කරන පුද්ගලයන් ලෙස සිතීමයි.

මෙය මා දන්නා පැරණි එකක් වන නමුත් එතැන් සිට එය ටයිප්ස්ක්‍රිප්ට් අතුරුමුහුණත හරහා ක්‍රියාත්මක කර ඇති ආකාරය:

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

ප්‍රකාශන අනුපිළිවෙල නොතකා MyEnum.Bar1 ආපසු ලබා දෙන සහ MyEnum[1]"තීරුව" ලබා දෙන දෙකම සොයා බැලීමට මෙය ඔබට හැකියාව ලබා දෙයි .

දී ES7 , ඔබ විසින් ස්ථිතික ගුණාංග මත රඳා අලංකාර නිඛිල කළ හැකිය:

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

එවිට

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

වාසිය (වචනානුසාරයෙන් වස්තුව වෙනුවට පන්තිය භාවිතා කිරීමේ) මව් පංතියක් Enumතිබීමයි, එවිට ඔබේ සියලු එනූම්ස් එම පන්තිය පුළුල් කරයි.

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

මම භාවිතා කරන විසඳුම මෙයයි.

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

ඔබ ඔබේ එනූම්ස් මේ ආකාරයට අර්ථ දක්වයි:

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

ඔබ ඔබේ එනූම් වලට ප්‍රවේශ වන ආකාරය මෙයයි:

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

පණිවිඩ වස්තු වලින් එනූම් සිතියම් ගත කිරීම සඳහා මම සාමාන්‍යයෙන් අවසාන ක්‍රම 2 භාවිතා කරමි.

මෙම ප්රවේශයේ වාසි කිහිපයක්:

• Enums ප්රකාශ කිරීමට පහසුය
• ඔබේ එනූම් වලට ප්‍රවේශ වීම පහසුය
• ඔබේ එනූම්ස් සංකීර්ණ වර්ග විය හැකිය
• ඔබ getByValue ගොඩක් භාවිතා කරන්නේ නම් එනූම් පන්තියට යම් සහායක හැඹිලියක් ඇත

සමහර අවාසි:

• මම එනුම් සඳහා යොමු කිරීම් තබාගෙන සිටින විට සමහර අවුල් සහගත මතක කළමනාකරණය එහි සිදු වේ
• තවමත් වර්ගයේ ආරක්ෂාවක් නොමැත

වචනාර්ථයෙන් වස්තුවක් සාදන්න:

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

ඔබ භාවිතා කරන්නේ නම් ආධාරක , ඔබ නිදහස් භාවිත කිරීම සඳහා (id, නම, අභිරුචි සාමාජිකයන් විසින් සොයා) පූර්න පරිමාන නිඛිල ක්රියාකාරිත්වය ලබා ගත හැක 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()

ඔබගේ පිළිතුරු බෙහෙවින් සංකීර්ණ ය

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

මම ඇන්ඩ්‍රේ 'ෆයි' හි විසඳුම වෙනස් කර ඇත:

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

පරීක්ෂණය:

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 චෙක්පත් ද කළ හැකිය.

ඔබට මේ ආකාරයට enums අර්ථ දැක්විය හැකිය:

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

Daysදැන් Daysඑනූම් වෙත යොමු වේ :

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"

ක්‍රියාත්මක කිරීම:

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
    }

})();

IE8 කැටි () ක්‍රමයට සහය නොදක්වයි.
මුලාශ්‍රය: http://kangax.github.io/compat-table/es5/ , "යල්පැනගිය බ්‍රව්සර් පෙන්වන්නද?" මත ක්ලික් කරන්න. ඉහළින්, සහ IE8 පරීක්ෂා කර පේළි තීරු මංසන්ධිය කැටි කරන්න.

මගේ වර්තමාන ක්‍රීඩා ව්‍යාපෘතියේදී, ගනුදෙනුකරුවන් කිහිප දෙනෙකු තවමත් IE8 භාවිතා කරන බැවින් මම පහත භාවිතා කර ඇත:

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

අපට ද කළ හැකිය:

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

හෝ මෙය පවා:

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

අන්තිම එක, නූල් සඳහා වඩාත් කාර්යක්ෂම බව පෙනේ, ඔබට සේවාදායක සහ සේවාදායකයා මෙම දත්ත හුවමාරු කර ගන්නේ නම් එය ඔබගේ මුළු කලාප පළල අඩු කරයි.
ඇත්ත වශයෙන්ම, දත්තවල ගැටුම් නොමැති බවට වග බලා ගැනීම දැන් ඔබේ යුතුකමයි (RE, EX, ආදිය අද්විතීය විය යුතුය, එසේම 1, 2, ආදිය අද්විතීය විය යුතුය). පසුගාමී අනුකූලතාව සඳහා ඔබ මේවා සදහටම පවත්වා ගත යුතු බව සලකන්න.

පැවරුම:

var wildType = CONST_WILD_TYPES.REGULAR;

සංසන්දනය:

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

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

මේ ආකාරයට විවිධ එනුම් අගයන් සඳහා අනුපිටපත් අංක ලබා නොදෙන බවට ඔබ සහතික විය යුතු නැත. නව වස්තුවක් ක්ෂණිකව ලබාගෙන සියලු enum අගයන්ට පවරනු ලැබේ.

ටයිප්ස්ක්‍රිප්ට් එනූම්ස් ක්‍රියාත්මක කිරීමට විවිධ ක්‍රම කිහිපයක් මෙන්න .

පහසුම ක්‍රමය නම්, වස්තුවකට ප්‍රතිලෝමව යතුරු ලියනය කිරීම ය. එකම අඩුපාඩුව නම්, ඔබ එක් එක් සාමාජිකයා සඳහා වටිනාකම අතින් සකස් කළ යුතුය.

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

මෙන්න නූලක් භාවිතා කරමින් එනුම් එකක් සෑදීමට ලොඩාෂ් මික්සින් . මෙම අනුවාදය තව ටිකක් සම්බන්ධ වී ඇති නමුත්, එය ඔබ වෙනුවෙන් ස්වයංක්‍රීයව අංකනය කරයි. මෙම උදාහරණයේ භාවිතා කරන සියලුම ලොඩාෂ් ක්‍රම වලට සාමාන්‍ය ජාවාස්ක්‍රිප්ට් සමාන වේ, එබැවින් ඔබට අවශ්‍ය නම් ඒවා පහසුවෙන් මාරු කළ හැකිය.

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

මම ක NPM පැකේජය ප්රකාශයට පත් කර ඇත gen_enum ඔබ ඉක්මනින් ජාවාස්ක්රිප්ට් තුල නිඛිල දත්ත ව්යූහයක් නිර්මාණය සඳහා අවකාශ ලබා දෙයි:

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 

මෙම කුඩා මෙවලම පිළිබඳ එක් හොඳ දෙයක් වන්නේ නවීන පරිසරය තුළ (nodejs සහ IE 9+ බ්‍රව්සර් ද ඇතුළුව) ආපසු එන එනූම් වස්තුව වෙනස් කළ නොහැකි ය.

වැඩි විස්තර සඳහා කරුණාකර https://github.com/greenlaw110/enumjs බලන්න

යාවත්කාලීන කිරීම්

මම gen_enumපැකේජය යල්පැන ඇති අතර, ක්‍රියාකාරීත්වය constjs පැකේජයට ඒකාබද්ධ කරමි , එමඟින් වෙනස් කළ නොහැකි වස්තූන්, JSON string deserialization, string constants සහ bitmap generation ආදිය ඇතුළත් වේ. වැඩි විස්තර සඳහා https://www.npmjs.com/package/constjs

සිට ප්රගමනය කිරීම gen_enumසඳහා constjsපමණක් ප්රකාශය වෙනස්

var genEnum = require('gen_enum');

වෙත

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

සරලම විසඳුම:

සාදන්න

var Status = Object.freeze({
    "Connecting":0,
    "Ready":1,
    "Loading":2,
    "Processing": 3
});

අගය ලබා ගන්න

console.log(Status.Ready) // 1

යතුර ලබා ගන්න

console.log(Object.keys(Status)[Status.Ready]) // Ready

O (1) හි අගයන් සහ නම් ලබා ගත හැකි Enum පන්තියක් මම සාදා ඇත. එයට සියලු නම් සහ වටිනාකම් අඩංගු වස්තු අරාවක් ජනනය කළ හැකිය.

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

ඔබට එය මේ ආකාරයෙන් ආරම්භ කළ හැකිය:

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

අගයක් ලබා ගැනීම සඳහා (සී # හි එනූම්ස් වැනි):

var val2 = enum1.item2;

අගයක් සඳහා නමක් ලබා ගැනීම සඳහා (විවිධ නම් සඳහා එකම අගය තැබීමේදී අපැහැදිලි විය හැකිය):

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

වස්තුවක එක් එක් නම සහ අගය සහිත අරාවක් ලබා ගැනීමට:

var arr = enum1.GetObjArr();

ජනනය කරනු ඇත:

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

ඔබට පහසුවෙන් HTML තේරීම් විකල්ප ලබා ගත හැකිය:

var html = enum1.GetSelectOptionsHTML();

දරණ:

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

වුවත් ස්ථිතික ක්රම පමණක් (නොව ස්ථිතික ගුණ) (බලන්න ES2015 තුළ සහය දක්වයි මෙතන , මෙන්ම, §15.2.2.2) දරු දෙදෙනකුගේ පියෙකි ඔබ සමග බාබෙල් සමග පහත භාවිතා කළ හැකිය es2015අැති:

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

මොඩියුල හරහා (උදා: CellStateවෙනත් මොඩියුලයකින් එනූම් ආනයනය කිරීම) සහ වෙබ් පැක් භාවිතයෙන් මොඩියුලයක් ආනයනය කරන විට පවා මෙය අපේක්ෂා කළ පරිදි ක්‍රියාත්මක වන බව මට පෙනී ගියේය.

වෙනත් බොහෝ පිළිතුරු මෙම ක්රමය කට අධික වාසිය ඔබ ස්ථිතික වර්ගය අරඹන්න පසෙකින් එය භාවිතා කළ හැකි බව ය (උදා: ප්රවාහ ) සහ ඔබ ඔබේ විචල්ය, පරාමිති, ආදිය නිශ්චිත බව ස්ථිතික වර්ග පරික්ෂාව භාවිතා සංවර්ධන අවස්ථාවේ දී, තහවුරු කළ හැකි,CellState " enum "වෙනත් එනූම් වලට වඩා (ඔබ සාමාන්‍ය වස්තු හෝ සංකේත භාවිතා කළේ නම් වෙන්කර හඳුනාගත නොහැකි වනු ඇත).

යාවත්කාලීන කිරීම

ඉහත කේතයේ iency නතාවයක් ඇති අතර එමඟින් කෙනෙකුට අතිරේක වර්ගයේ වස්තූන් නිර්මාණය කිරීමට ඉඩ ලබා දේ CellState( CellStateඑය ශීත කළ දා සිට ස්ථිතික ක්ෂේත්‍රවලට ඒවා පැවරිය නොහැකි වුවද ). කෙසේ වෙතත්, පහත දැක්වෙන වඩාත් පිරිපහදු කළ කේතය පහත සඳහන් වාසි ලබා දෙයි:

1. තවත් වර්ගයේ වස්තු නොමැත CellState නිර්මාණය කළ නොහැක
2. එකම කේතය සඳහා enum අවස්ථා දෙකක් පවරා නොමැති බව ඔබට සහතික වේ
3. නූල් නිරූපණයකින් එනූම් ආපසු ලබා ගැනීමට උපයෝගීතා ක්‍රමය

4. valuesඑනූම් හි සියලු අවස්ථාවන් ආපසු ලබා දෙන ශ්‍රිතයට ඉහත අගය, අත්පොත (සහ දෝෂ සහිත) ආකාරයෙන් ප්‍රතිලාභ අගය නිර්මාණය කළ යුතු නොවේ.

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

es7 මාර්ගය, (iterator, freeze), භාවිතය:

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'