javascript - জাভাস্ক্রিপ্ট বাংলা পরিপুর্ন টিউটোরিয়াল মিজানুর রহমান




জাভাস্ক্রিপ্ট enums সংজ্ঞা জন্য পছন্দের সিনট্যাক্স কি? (20)

জাভাস্ক্রিপ্ট Proxies ব্যবহার করুন

টিএলডিআর: এই ক্লাসটি আপনার ইউটিলিটি পদ্ধতিতে যুক্ত করুন এবং এটি আপনার কোড জুড়ে ব্যবহার করুন, এটি ঐতিহ্যগত প্রোগ্রামিং ভাষাগুলি থেকে Enum আচরণকে ঠকায় এবং প্রকৃতপক্ষে এমন কোনও সংখ্যার অ্যাক্সেস করার চেষ্টা করলে ত্রুটিগুলি ছোঁড়ে।

class Enum {
  constructor(enumObj) {
    const handler = {
      get(target, name) {
        if (target[name]) {
          return target[name];
        }
        throw new Error(`No such enumerator: ${name}`);
      },
    };

    return new Proxy(Object.freeze(enumObj), handler);
  }
}

তারপর ক্লাস তাত্ক্ষণিক দ্বারা enums তৈরি করুন:

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

সম্পূর্ণ ব্যাখ্যা:

আপনি ঐতিহ্যবাহী ভাষাগুলি থেকে যে এনমসগুলি পেতে পারেন তার একটি খুব উপকারী বৈশিষ্ট্য হল যে আপনি যদি কোনও সংখ্যার অ্যাক্সেস করার চেষ্টা করেন তবে এটি ঝাপসা হয়ে যায় (একটি কম্পাইল-টাইম ত্রুটি নিক্ষেপ করুন)।

অতিরিক্ত মূল্যগুলি দুর্ঘটনাক্রমে / দূষিতভাবে যোগ করা থেকে বিরত থাকার জন্য মাকড্ড এনম গঠনকে হিমায়িত করার পাশাপাশি অন্য কোনও উত্তর Enums এর অন্তর্নিহিত বৈশিষ্ট্যকে চিহ্নিত করে না।

আপনি সম্ভবত সচেতন হিসাবে, জাভাস্ক্রিপ্ট মধ্যে অ বিদ্যমান সদস্যদের অ্যাক্সেস সহজভাবে undefined ফিরে এবং আপনার কোড গাট্টা না। যেহেতু সংখ্যাসূচক পূর্বনির্ধারিত সংস্থিত (সপ্তাহের দিন), যেহেতু একটি সংখ্যার অনির্ধারিত হওয়া উচিত এমন কোন ক্ষেত্রেই হওয়া উচিত নয়।

আমাকে ভুল করবেন না, অনির্ধারিত বৈশিষ্ট্যগুলি অ্যাক্সেস করার সময় জাভাস্ক্রিপ্টের undefined প্রত্যাবর্তনের আচরণ আসলে ভাষার একটি খুব শক্তিশালী বৈশিষ্ট্য, তবে আপনি যখন ঐতিহ্যগত Enum কাঠামোগুলি ঠকানোর চেষ্টা করছেন তখন এটি এমন একটি বৈশিষ্ট্য নয়।

এই প্রক্সি বস্তু চকমক যেখানে এই। ES6 (ES2015) প্রবর্তনের সাথে ভাষাগুলিতে প্রক্সিগুলি মানানসই ছিল। এখানে MDN এর বর্ণনা রয়েছে:

প্রক্সি বস্তু মৌলিক ক্রিয়াকলাপের জন্য কাস্টম আচরণ সংজ্ঞায়িত করতে ব্যবহৃত হয় (যেমন সম্পত্তি সন্ধান, অ্যাসাইনমেন্ট, গণনা, ফাংশন আহরণ, ইত্যাদি)।

ওয়েব সার্ভার প্রক্সির অনুরূপ, জাভাস্ক্রিপ্ট প্রক্সিগুলি বস্তুগুলিতে অপারেশনগুলি আটকাতে সক্ষম হয় ("ফাঁদ" ব্যবহার করে, যদি আপনি চান তবে তাদের হুকগুলি কল করুন) এবং সম্পূর্ণ হওয়ার আগে আপনাকে বিভিন্ন চেক, কর্ম এবং / অথবা ম্যানিপুলেশন সঞ্চালন করতে দেয় (অথবা কিছু ক্ষেত্রে অপারেশনগুলি সম্পূর্ণভাবে বন্ধ করে দেওয়া হয় যা আমরা ঠিক করতে চাই, যখন আমরা কোন সংখ্যার উল্লেখ করার চেষ্টা করি, যা বিদ্যমান নেই)।

এখানে একটি প্রদত্ত উদাহরণ যা Enx অনুকরণ করতে প্রক্সি অবজেক্ট ব্যবহার করে। এই উদাহরণের পরিসংখ্যানগুলি হল স্ট্যান্ডার্ড 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(enumObj) {
  // 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. This can be done by defining the "get" trap.
  
  const handler = {
    get: function(target, name) {
      if (target[name]) {
        return target[name]
      }
      throw new Error(`No such enumerator: ${name}`)
    }
  }
  
  
  // Freeze the target object to prevent modifications
  return new Proxy(Object.freeze(enumObj), handler)
}


// Now that we have a generic way of creating Enums, lets create our first Enum!
const httpMethods = createEnum({
  DELETE: "DELETE",
  GET: "GET",
  OPTIONS: "OPTIONS",
  PATCH: "PATCH",
  POST: "POST",
  PUT: "PUT"
})

// Sanity checks
console.log(httpMethods.DELETE) 
// logs "DELETE"

httpMethods.delete = "delete" 
// no effect due to Object.freeze, fails silently (no error thrown)

try {
  console.log(httpMethods.delete) 
} catch (e) {
  console.log("Error: ", e.message)
}
// throws an error "Uncaught Error: No such enumerator: delete"

ASIDE: হ্যাক একটি প্রক্সি কি?

আমি মনে করি যখন আমি সর্বত্র সর্বত্র প্রক্সি শব্দটি দেখতে শুরু করলাম, তখন এটি আমার দীর্ঘদিন ধরে বুঝতে পারল না। যদি আপনি এই মুহূর্তে থাকেন তবে আমি মনে করি প্রক্সিজিকে সাধারণীকরণের একটি সহজ উপায় হল তাদের সফটওয়্যার, প্রতিষ্ঠান, এমনকি এমনও ব্যক্তি যারা দুই সার্ভার, কোম্পানি বা ব্যক্তিদের মধ্যস্থতাকারী বা মধ্যস্থতাকারী হিসাবে কাজ করে।

জাভাস্ক্রিপ্ট enums সংজ্ঞা জন্য পছন্দের সিনট্যাক্স কি? কিছুটা এইরকম:

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

// later on

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

নাকি আরও বেশি পছন্দসই মূর্তি আছে?


আপনার উত্তর পর্যন্ত খুব জটিল

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

আমি এই সঙ্গে প্রায় বাজানো হয়েছে, আমি আমার enums ভালবাসা। =)

Object.defineProperty ব্যবহার করে আমি মনে করি আমি কিছুটা কার্যকর সমাধান নিয়ে এসেছি।

এখানে একটি jsfiddle: http://jsfiddle.net/ZV4A6/

এই পদ্ধতি ব্যবহার করে .. আপনি (বস্তিতে) যে বস্তুর অন্যান্য বৈশিষ্ট্য প্রভাবিত ছাড়া, কোনো বস্তুর জন্য enum মান কল এবং সংজ্ঞায়িত করতে হবে।

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

একটি বস্তু আক্ষরিক তৈরি করুন:

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

এখানে আমরা যা চাই তা হল:

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

এখন আপনি আপনার enums তৈরি করতে পারেন:

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

এটি করার মাধ্যমে, স্থানাঙ্কগুলি স্বাভাবিক ভাবে (YesNo.YES, রঙ। GREEN) আকারে গ্রহণ করা যেতে পারে এবং তারা একটি ক্রমিক অন্তর্নিহিত মান পাবে (NO = 0, YES = 1; লাল = 0, গ্রিন = 1, নীল = 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 */
};


সম্পাদনা - ছোট উন্নতি - এখন Varargs সঙ্গে: (দুর্ভাগ্যবশত এটি IE তে সঠিকভাবে কাজ করে না: S ... পূর্ববর্তী সংস্করণটির সাথে আটকে থাকা উচিত)

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

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

এটি একটি পুরোনো আমি জানি, কিন্তু যেহেতু এটি টাইপস্ক্রিপ্ট ইন্টারফেসের মাধ্যমে প্রয়োগ করা হয়েছে তা হল:

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

এটি আপনাকে MyEnum.Bar উভয় দিকে MyEnum.Bar যা 1 প্রদান করে এবং MyEnum[1] যা ঘোষণার আদেশ নির্বিশেষে "বার" প্রদান করে।


নিচের লাইন: আপনি পারবেন না।

আপনি এটা জাল করতে পারেন, কিন্তু আপনি টাইপ নিরাপত্তা পাবেন না। সাধারণত এই পূর্ণসংখ্যা মান ম্যাপ করা স্ট্রিং মান একটি সহজ অভিধান তৈরি করে সম্পন্ন করা হয়। উদাহরণ স্বরূপ:

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

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

এই পদ্ধতির সঙ্গে সমস্যা? আপনি ভুলভাবে আপনার সংখ্যার পুনর্বিবেচনা করতে পারেন, অথবা দুর্ঘটনাক্রমে সদৃশ enumerant মান আছে। উদাহরণ স্বরূপ:

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

সম্পাদন করা

আর্টুর সিজজকা এর অবজেক্ট.ফ্রিজ কি? সোমবার থেকে বৃহস্পতিবার থেকে আপনাকে রোধ করতে যে কাজটি করা হবে না? ফ্রাই Quad

অবশ্যই, Object.freeze আমার সম্পর্কে যে সমস্যাটি সম্পূর্ণভাবে সমাধান করবে। আমি প্রত্যেককে মনে করিয়ে দিতে চাই যে যখন আমি উপরে লিখেছিলাম, Object.freeze আসলেই অস্তিত্ব ছিল না।

এখন .... এখন এটি কিছু খুব আকর্ষণীয় সম্ভাবনার খোলা।

সম্পাদনা 2
এখানে enums তৈরি করার জন্য একটি খুব ভাল লাইব্রেরি।

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

এটি সম্ভবত enums প্রতিটি বৈধ ব্যবহার মাপসই করা হয় না, এটি একটি খুব দীর্ঘ পথ যায়।


যেহেতু 1.8.5 থেকে এটি বস্তুটি সীল এবং স্থির করা সম্ভব, তাই উপরের হিসাবে সংজ্ঞায়িত করুন:

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

অথবা

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

এবং ভয়েলা! জে। এস।

যাইহোক, এটি আপনাকে একটি পরিবর্তনশীলের অনির্ভরযোগ্য মান বরাদ্দ করতে বাধা দেয় না, যা প্রায়ই enums এর মূল লক্ষ্য:

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

টাইপ নিরাপত্তার একটি শক্তিশালী ডিগ্রী নিশ্চিত করতে (একমুখী বা অন্যথায়) TypeScript বা Flow মত একটি সরঞ্জাম ব্যবহার করা হয়।

Source

উদ্ধৃতি প্রয়োজন হয় না কিন্তু আমি সামঞ্জস্য জন্য তাদের রাখা।


সর্বাধিক মানুষের দ্বারা "প্রদত্ত সিনট্যাক্স" ইতিমধ্যে উপরে তালিকাভুক্ত করা হয়েছে। তবে, একটি প্রধান overarching সমস্যা আছে: কর্মক্ষমতা। উপরোক্ত উত্তরগুলির মধ্যে একটিও সামান্যতম মধ্যে খুব পারফরম্যান্স নয় এবং তারা সব চরম আপনার কোড আকার blot। বাস্তব কর্মক্ষমতা, পঠন কোড সহজে এবং ক্ষুদ্রীকরণ দ্বারা কোড আকারে একটি অভূতপূর্ব হ্রাসের জন্য, এটি সংখ্যার জন্য সঠিক উপায়।

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

// later on

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

উপরন্তু, এই সিনট্যাক্স নীচের দেখা হিসাবে প্রসারিত স্পষ্ট এবং সংক্ষিপ্ত ক্লাসের জন্য অনুমতি দেয়।

(দৈর্ঘ্য: 2,450 বাইট)

(function(window){
    "use strict";
    var parseInt = window.parseInt

    const ENUM_PIXELCOLOR_TYPE = 0, // is a ENUM_PIXELTYPE
          ENUMLEN_PIXELCOLOR   = 1,
          ENUM_SOLIDCOLOR_R    = ENUMLEN_PIXELCOLOR+0,
          ENUM_SOLIDCOLOR_G    = ENUMLEN_PIXELCOLOR+1,
          ENUM_SOLIDCOLOR_B    = ENUMLEN_PIXELCOLOR+2,
          ENUMLEN_SOLIDCOLOR   = ENUMLEN_PIXELCOLOR+3,
          ENUM_ALPHACOLOR_R    = ENUMLEN_PIXELCOLOR+0,
          ENUM_ALPHACOLOR_G    = ENUMLEN_PIXELCOLOR+1,
          ENUM_ALPHACOLOR_B    = ENUMLEN_PIXELCOLOR+2,
          ENUM_ALPHACOLOR_A    = ENUMLEN_PIXELCOLOR+3,
          ENUMLEN_ALPHACOLOR   = ENUMLEN_PIXELCOLOR+4,
          ENUM_PIXELTYPE_SOLID = 0,
          ENUM_PIXELTYPE_ALPHA = 1,
          ENUM_PIXELTYPE_UNKNOWN = 2,
          ENUMLEN_PIXELTYPE    = 2;

    function parseHexColor(rawstr) {
        rawstr = rawstr.trim().substring(1);
        var result = [];
        if (rawstr.length === 8) {
            result[ENUM_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_ALPHA;
            result[ENUM_ALPHACOLOR_R] = parseInt(rawstr.substring(0,2), 16);
            result[ENUM_ALPHACOLOR_G] = parseInt(rawstr.substring(2,4), 16);
            result[ENUM_ALPHACOLOR_B] = parseInt(rawstr.substring(4,6), 16);
            result[ENUM_ALPHACOLOR_A] = parseInt(rawstr.substring(4,6), 16);
        } else if (rawstr.length === 4) {
            result[ENUM_ALPHACOLOR_R] = parseInt(rawstr[0], 16) * 0x11;
            result[ENUM_ALPHACOLOR_G] = parseInt(rawstr[1], 16) * 0x11;
            result[ENUM_ALPHACOLOR_B] = parseInt(rawstr[2], 16) * 0x11;
            result[ENUM_ALPHACOLOR_A] = parseInt(rawstr[3], 16) * 0x11;
        } else if (rawstr.length === 6) {
            result[ENUM_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_SOLID;
            result[ENUM_SOLIDCOLOR_R] = parseInt(rawstr.substring(0,2), 16);
            result[ENUM_SOLIDCOLOR_G] = parseInt(rawstr.substring(2,4), 16);
            result[ENUM_SOLIDCOLOR_B] = parseInt(rawstr.substring(4,6), 16);
        } else if (rawstr.length === 3) {
            result[ENUM_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_SOLID;
            result[ENUM_SOLIDCOLOR_R] = parseInt(rawstr[0], 16) * 0x11;
            result[ENUM_SOLIDCOLOR_G] = parseInt(rawstr[1], 16) * 0x11;
            result[ENUM_SOLIDCOLOR_B] = parseInt(rawstr[2], 16) * 0x11;
        } else {
            result[ENUM_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_UNKNOWN;
        }
        return result;
    }

    // the red component of green
    console.log(parseHexColor("#0f0")[ENUM_SOLIDCOLOR_R]);
    // the alpha of transparent purple
    console.log(parseHexColor("#f0f7")[ENUM_ALPHACOLOR_A]); 
    // the enumerated array for turquoise
    console.log(parseHexColor("#40E0D0"));
})(self);

কেউ কেউ বলতে পারে যে এটি অন্যান্য সমাধানগুলির চেয়ে কম ব্যবহারিক: এটি প্রচুর পরিমাণে স্থান কামনা করে, এটি লেখার জন্য অনেক সময় লাগে এবং এটি চিনি সিনট্যাক্সের সাথে লেপিত হয় না। হ্যাঁ, তারা যদি তাদের কোডটি খালি না করে তবে সেগুলি সঠিক হবে। যাইহোক, কোন যুক্তিসঙ্গত ব্যক্তি শেষ পণ্য মধ্যে অসমাপ্ত কোড ছেড়ে চলে যেতে হবে। এই খনির জন্য, ক্লোজার কম্পাইলার এখনও আমি খুঁজে পাওয়া যায় নি। অনলাইন অ্যাক্সেস here পাওয়া here । ক্লোজার কম্পাইলার এই গণনার তথ্য সব নিতে এবং এটি ইনলাইন করতে সক্ষম হয়, আপনার জাভাস্ক্রিপ্ট দ্রুত সুপার duper চালানো এবং সুপার সদৃশ ছোট হতে। কর।

(দৈর্ঘ্য: 605 বাইট)

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

এখন, দেখি সমতুল্য ফাইলটি কোনও সংখ্যার ব্যতীত কত বড় হবে।

এই পরিসংখ্যান ছাড়া উৎস (দৈর্ঘ্য: 1,973 বাইট (477 বাইট ছোট!))
এই পরিসংখ্যান ছাড়া minified (দৈর্ঘ্য: 843 বাইট (238 বাইট লম্বা ))

হিসাবে, সংখ্যার ছাড়া, সোর্স কোড একটি বৃহত্তর minified কোড খরচ কম। আমি আপনার সম্পর্কে জানি না, আমি নিশ্চিত যে আমি শেষ পণ্যটিতে সোর্স কোডটি অন্তর্ভুক্ত করতে পছন্দ করি না, এই পরিমাপটি এতদূর অসাধারণ যে এটি ছোট ফাইলের মাপের ফলাফল হিসাবে তৈরি করে। গণনার এই ফর্ম দ্রুত উপায় যে যোগ করুন। প্রকৃতপক্ষে, গণনার এই ফর্ম যেতে উপায়।


আপডেট : সকল উপভোগের জন্য ধন্যবাদ সবাই, কিন্তু আমি মনে করি না যে জাভাস্ক্রিপ্টে এখন enums লিখার সবচেয়ে ভাল উপায় আমার উত্তর। আরো বিস্তারিত জানার জন্য আমার ব্লগ পোস্টটি দেখুন: জাভাস্ক্রিপ্ট এ Enums

নাম সতর্কীকরণ ইতিমধ্যে সম্ভব:

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

মনে রাখবেন, enum ক্ষেত্র (এই উদাহরণে মান, নাম এবং কোড) পরিচয় চেকের জন্য প্রয়োজন হয় না এবং সুবিধার্থে শুধুমাত্র সেখানে রয়েছে। এছাড়াও আকারের সম্পত্তিটির নাম হার্ডকোড করা দরকার না, তবে গতিশীলভাবে সেট করা যেতে পারে। সুতরাং আপনি আপনার নতুন enum মানের জন্য শুধুমাত্র নামটি বোঝেন, আপনি এখনও সমস্যা ছাড়াই এটি যুক্ত করতে পারেন:

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

এবং btw, যদি আপনি নামস্থানগুলিতে আগ্রহী হন তবে আপনি সহজ কিন্তু শক্তিশালী নামস্থান এবং জাভাস্ক্রিপ্টের জন্য নির্ভরতা পরিচালনার জন্য আমার সমাধানটি দেখতে চাইতে পারেন: প্যাকেজগুলি JS


সহজ সমাধান:

সৃষ্টি

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

একটি দ্রুত এবং সহজ উপায় হতে হবে:

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

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

TypeScript enums বাস্তবায়ন করার জন্য এখানে কয়েকটি ভিন্ন উপায় রয়েছে ।

সবচেয়ে সহজ উপায় হল বস্তুর উপর উল্টানো কী-মান জোড়া যোগ করা, একটি বস্তুর উপর পুনরাবৃত্তি করা। একমাত্র ত্রুটি হ'ল আপনি প্রত্যেক সদস্যের জন্য মানটি ম্যানুয়ালি সেট করতে হবে।

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


এবং এখানে একটি লোডশ mixin একটি স্ট্রিং ব্যবহার করে একটি enum তৈরি করতে। এই সংস্করণটি একটু বেশি জড়িত হলেও, এটি স্বয়ংক্রিয়ভাবে আপনার জন্য সংখ্যায়ন করে। এই উদাহরণে ব্যবহৃত সকল লোডশ পদ্ধতির নিয়মিত জাভাস্ক্রিপ্ট সমতুল্য রয়েছে, তাই আপনি যদি চান তবে সহজে এটি স্যুইচ করতে পারেন।

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

আমি this পদ্ধতির সাথে এসেছি যা জাভাতে enums পর মডেল করা হয়। এই টাইপ-নিরাপদ, এবং তাই আপনি instanceofচেক সঞ্চালন করতে পারেন ।

আপনি এই মত enums সংজ্ঞায়িত করতে পারেন:

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

Daysএখন Daysenum বোঝায় :

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
    }

})();

আমি একটি Enum ক্লাস তৈরি করেছি যা O (1) এ মান এবং নামগুলি আনতে পারে। এটি একটি অবজেক্ট অ্যারেও তৈরি করতে পারে যা সমস্ত নাম এবং মান ধারণ করে।

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

আপনি এটি এইভাবে init'd করতে পারেন:

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

একটি মান আনতে (যেমন C # এ Enums):

var val2 = enum1.item2;

একটি মান জন্য একটি নাম আনতে (বিভিন্ন নামের জন্য একই মান নির্বাণ যখন দ্বিধান্বিত হতে পারে):

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

একটি বস্তুর প্রতিটি নাম এবং মান সহ একটি অ্যারে পেতে:

var arr = enum1.GetObjArr();

উৎপন্ন হবে:

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

আপনি এইচটিএমএল নির্বাচন অপশনগুলি সহজেই পেতে পারেন:

var html = enum1.GetSelectOptionsHTML();

যা holds:

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

আমি শুধু একটি এনপিএম প্যাকেজ প্রকাশ করেছি gen_enum আপনি জাভাস্ক্রিপ্টে 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 

এই সামান্য সরঞ্জাম সম্পর্কে একটি চমৎকার জিনিস আধুনিক পরিবেশে (নোডজ এবং IE 9+ ব্রাউজার সহ) ফেরত দেওয়া ইনাম বস্তুটি অপরিবর্তনীয়।

আরও তথ্যের জন্য https://github.com/greenlaw110/enumjs চেকআউট করুনhttps://github.com/greenlaw110/enumjs

আপডেট

আমি অপ্রচলিত gen_enumপ্যাকেজ এবং constjs প্যাকেজে ফাংশন মার্জ করি , যা constjs বস্তু, JSON স্ট্রিং ডিসেরিয়ালাইজেশন, স্ট্রিং স্টোনেন্টস এবং বিটম্যাপ প্রজন্ম ইত্যাদি সহ আরও বৈশিষ্ট্য সরবরাহ করে। আরও তথ্যের জন্য constjs চেকআউট করুন

শুধু বিবৃতি পরিবর্তন থেকে আপগ্রেড gen_enumকরতেconstjs

var genEnum = require('gen_enum');

থেকে

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

এইভাবে টাইপস্ক্রিপ্ট এটি enumজাভাস্ক্রিপ্টে অনুবাদ করে:

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

এখন:

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

প্রথমত আমি কেন obj[1]ফেরত নিয়ে বিভ্রান্ত ছিলাম 'Active', কিন্তু তারপরে বুঝতে পেরেছিলাম যে তার মৃত সাধারণ - অ্যাসাইনমেন্ট অপারেটর মূল্য নির্ধারণ করে এবং তারপরে এটি ফেরত দেয়:

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

যদিও শুধুমাত্র স্ট্যাটিক পদ্ধতি (এবং স্ট্যাটিক বৈশিষ্ট্য) ES2015 সমর্থিত হয় (দেখুন here পাশাপাশি, §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অন্য মডিউল থেকে enum আমদানি) এবং যখন আমি ওয়েবপ্যাক ব্যবহার করে একটি মডিউল আমদানি।

অন্যান্য পদ্ধতিতে এই পদ্ধতিটির সুবিধাটি হল যে আপনি এটি স্ট্যাটিক টাইপ পরীক্ষক (যেমন Flow ) পাশাপাশি এটি ব্যবহার করতে পারেন এবং আপনি স্ট্যাটিক টাইপ চেকিং ব্যবহার করে ডেভেলপমেন্ট সময়তে এটি প্রয়োগ করতে পারেন যে আপনার ভেরিয়েবল, পরামিতি ইত্যাদি নির্দিষ্ট CellState" enum "বরং অন্য কিছু enum (যা আপনি জেনেরিক বস্তু বা প্রতীক ব্যবহৃত হলে পার্থক্য অসম্ভব)।

হালনাগাদ

উপরোক্ত কোডটির অভাব রয়েছে যার ফলে এটি অতিরিক্ত ধরনের বস্তু তৈরি করতে পারে CellState(যদিও CellStateএটি হিমায়িত হওয়ার পরে স্ট্যাটিক ক্ষেত্রগুলিতে তাদের বরাদ্দ করতে পারে না )। তবুও, নীচের আরো পরিমার্জিত কোড নিম্নলিখিত সুবিধাগুলি প্রদান করে:

  1. কোন ধরনের বস্তু CellStateতৈরি করা যেতে পারে
  2. আপনি নিশ্চিত যে কোনও দুটি enum দৃষ্টান্ত একই কোড নিযুক্ত করা হয়
  3. একটি স্ট্রিং উপস্থাপনা থেকে enum ফিরে পেতে ইউটিলিটি পদ্ধতি
  4. যে valuesফাংশনটি enum এর সমস্ত দৃষ্টান্ত ফেরত দেয় সেটি উপরে, ম্যানুয়াল (এবং ত্রুটি-প্রবণ) উপায়ে ফেরত মান তৈরি করতে হবে না।

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

লেখার হিসাবে, অক্টোবর 2014 - তাই এখানে একটি সমসাময়িক সমাধান। আমি একটি নোড মডিউল হিসাবে সমাধান লিখছি, এবং Mocha এবং Chai, পাশাপাশি underscoreJS ব্যবহার করে একটি পরীক্ষা অন্তর্ভুক্ত করেছেন। আপনি সহজে এগুলি উপেক্ষা করতে পারেন এবং পছন্দসই হলে কেবল এনাম কোডটি গ্রহণ করুন।

অত্যধিক সংকীর্ণ লাইব্রেরি ইত্যাদির সাথে প্রচুর পোস্ট দেখেছি। জাভাস্ক্রিপ্টে এনম সাপোর্ট পাওয়ার সমাধানটি খুবই সহজ, এটি আসলেই প্রয়োজন হয় না। এখানে কোডটি রয়েছে:

ফাইল: 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;

এবং এটি আপনাকে যা দেয় তা ব্যাখ্যা করার জন্য একটি পরীক্ষা:

ফাইল: 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');
        });
    });

});

আপনি দেখতে পারেন যে, আপনি একটি এননাম কারখানা পাবেন, আপনি কেবল enum.keys এ কল করে সমস্ত কীগুলি পেতে পারেন এবং আপনি কীগুলিকে পূর্ণসংখ্যা সংহত করতে পারেন। এবং আপনি বিভিন্ন মানের সাথে ফ্যাক্টরিটি পুনঃব্যবহার করতে পারেন এবং নোডের মডুলার পদ্ধতি ব্যবহার করে উত্পন্ন এনামগুলি রপ্তানি করতে পারেন।

আবার, আপনি যদি শুধুমাত্র একটি নৈমিত্তিক ব্যবহারকারী বা ব্রাউজারে থাকেন তবে কোডের কারখানা অংশটি গ্রহণ করুন, যদি আপনি আপনার কোডটিতে এটি ব্যবহার করতে না চান তবে সম্ভাব্য আন্ডারস্কোর লাইব্রেরিও মুছে ফেলুন।







enums