Какой синтаксис является предпочтительным для определения перечислений в JavaScript?
Какой синтаксис является предпочтительным для определения перечислений в JavaScript? Что-то вроде:
my.namespace.ColorEnum = {
RED : 0,
GREEN : 1,
BLUE : 2
}
// later on
if(currentColor == my.namespace.ColorEnum.RED) {
// whatever
}
Или есть более предпочтительная идиома?
55 ответов
Начиная с 1.8.5 возможно запечатать и заморозить объект, поэтому определите вышеизложенное как:
var DaysEnum = Object.freeze({"monday":1, "tuesday":2, "wednesday":3, ...})
или же
var DaysEnum = {"monday":1, "tuesday":2, "wednesday":3, ...}
Object.freeze(DaysEnum)
и вуаля! JS перечисления.
Тем не менее, это не мешает вам присвоить нежелательное значение переменной, что часто является главной целью перечислений:
let day = DaysEnum.tuesday
day = 298832342 // goes through without any errors
Один из способов обеспечить более высокую степень безопасности типов (с помощью перечислений или иным образом) - использовать такой инструмент, как TypeScript или Flow.
Цитаты не нужны, но я сохранил их для согласованности.
Это не очень хороший ответ, но я бы сказал, что он работает очень хорошо, лично
Тем не менее, поскольку значения не имеют значения (вы использовали 0, 1, 2), я бы использовал значимую строку на случай, если вы когда-нибудь захотите вывести текущее значение.
ОБНОВЛЕНИЕ: Спасибо за все отзывы, но я не думаю, что мой ответ ниже - лучший способ написать перечисления в Javascript. Смотрите мой блог для более подробной информации: Перечисления в Javascript.
Оповещение имени уже возможно:
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);
}
В Javascript, поскольку это динамический язык, можно даже добавить значения enum в набор позже:
// Add EXTRALARGE size
SIZE.EXTRALARGE = {value: 3, name: "Extra Large", code: "XL"};
Помните, что поля перечисления (значение, имя и код в этом примере) не нужны для проверки идентичности и существуют только для удобства. Также имя свойства size не обязательно должно быть жестко закодировано, но также может быть установлено динамически. Итак, предположим, что вы знаете только имя для нового значения перечисления, вы все равно можете добавить его без проблем:
// Add 'Extra Large' size, only knowing it's name
var name = "Extra Large";
SIZE[name] = {value: -1, name: name, code: "?"};
Конечно, это означает, что некоторые предположения больше не могут быть сделаны (например, это значение представляет правильный порядок для размера).
Помните, в Javascript объект похож на карту или хеш-таблицу. Набор пар имя-значение. Вы можете просматривать их или иным образом манипулировать ими, не зная о них заранее.
НАПРИМЕР:
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.
}
}
И, между прочим, если вы заинтересованы в пространствах имен, вы можете взглянуть на мое решение для простого, но мощного управления пространством имен и зависимостей для javascript: Пакеты 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
Вот очень хорошая библиотека для создания перечислений.
http://www.2ality.com/2011/10/enums.html
Хотя он, вероятно, не подходит для каждого допустимого использования перечислений, он идет очень далеко.
В большинстве современных браузеров существует тип данных символьного примитива, который можно использовать для создания перечисления. Это обеспечит безопасность типов перечисления, так как каждое значение символа гарантировано JavaScript уникальным, т.е. Symbol() != Symbol(), Например:
const COLOR = Object.freeze({RED: Symbol(), BLUE: Symbol()});
Чтобы упростить отладку, вы можете добавить описание к перечисляемым значениям:
const COLOR = Object.freeze({RED: Symbol("RED"), BLUE: Symbol("BLUE")});
На GitHub вы можете найти оболочку, которая упрощает код, необходимый для инициализации enum:
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
Вот что мы все хотим:
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 */
};
Редактировать - небольшое улучшение - теперь с 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');
"Отточенный синтаксис" большинства людей уже был перечислен выше. Тем не менее, существует главная общая проблема: производительность. Ни один из приведенных выше ответов ни в малейшей степени не очень эффективен, и все они увеличивают размер вашего кода до предела. Для реальной производительности, простоты чтения кода и беспрецедентного уменьшения размера кода за счет минимизации это правильный способ выполнения перечислений.
const ENUM_COLORENUM_RED = 0,
ENUM_COLORENUM_GREEN = 1,
ENUM_COLORENUM_BLUE = 2,
ENUMLEN_COLORENUM = 3;
// later on
if(currentColor == ENUM_COLORENUM_RED) {
// whatever
}
Кроме того, этот синтаксис допускает ясное и краткое расширение классов, как показано ниже.
(Длина: 2450 байт)
(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);Кто-то может сказать, что это менее практично, чем другие решения: он занимает много места, требует много времени для написания и не содержит синтаксиса сахара. Да, эти люди были бы правы, если бы они не минимизировали свой код. Тем не менее, ни один разумный человек не оставит единый код в конечном продукте. Для этого миниатюры Closure Compiler - лучшее, что я пока не нашел. Онлайн доступ можно найти здесь. Компилятор Closure может взять все эти данные перечисления и встроить их, что делает ваш javascript быстрым и супер маленьким. Обратите внимание.
(Длина: 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 байтов короче!))
Сводится без этих перечислений (длина: 843 байта (на 238 байтов больше))
Как видно, без перечислений исходный код короче за счет большего уменьшенного кода. Я не знаю о вас, я точно знаю, что мне не нравится включать исходный код в конечный продукт, что делает этот способ перечисления намного лучше, так как это приводит к меньшим размерам файлов. Добавьте к этому, что эта форма перечисления намного быстрее. Действительно, эта форма перечисления - путь.
Используйте Javascript Proxies
TLDR: добавьте этот класс в свои служебные методы и используйте его во всем коде, он имитирует поведение 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);
}
}
Затем создайте перечисления, создав экземпляр класса:
const roles = new Enum({
ADMIN: 'Admin',
USER: 'User',
});
Полное объяснение:
Одна очень полезная особенность Enums, которую вы получаете от традиционных языков, заключается в том, что они взрываются (выдают ошибку времени компиляции), если вы пытаетесь получить доступ к перечислителю, который не существует.
Помимо замораживания поддельной структуры enum для предотвращения случайного / злонамеренного добавления дополнительных значений, ни один из других ответов не затрагивает эту внутреннюю особенность Enums.
Как вы, вероятно, знаете, доступ к несуществующим элементам в JavaScript просто возвращает undefined и не взорвать твой код. Поскольку перечислители являются предопределенными константами (т.е. днями недели), никогда не должно быть случая, когда перечислитель должен быть неопределенным.
Не поймите меня неправильно, поведение JavaScript возвращается undefined когда доступ к неопределенным свойствам на самом деле является очень мощной функцией языка, но это не та функция, которая вам нужна, когда вы пытаетесь высмеивать традиционные структуры Enum.
Здесь прокси объекты сияют. Прокси были стандартизированы в языке с введением ES6 (ES2015). Вот описание из MDN:
Объект Proxy используется для определения пользовательского поведения для основных операций (например, поиск свойств, присваивание, перечисление, вызов функции и т. Д.).
Подобно прокси-серверу веб-сервера, прокси-серверы JavaScript способны перехватывать операции над объектами (с использованием "ловушек", называть их хуками, если хотите) и позволяют выполнять различные проверки, действия и / или манипуляции до их завершения (или в некоторых случаях вообще прекращение операций, что мы и хотим делать, если и когда мы пытаемся сослаться на перечислитель, который не существует).
Вот надуманный пример, который использует объект Proxy для имитации Enums. В этом примере перечислители являются стандартными методами 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: Какого черта это прокси?
Я помню, когда я впервые начал видеть слово "прокси" везде, это определенно не имело смысла для меня долгое время. Если вы сейчас, я думаю, что простой способ обобщить прокси - это думать о них как о программном обеспечении, учреждениях или даже людях, которые выступают в качестве посредников или посредников между двумя серверами, компаниями или людьми.
Я играл с этим, так как я люблю свои перечисления. знак равно
С помощью 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
Это старая версия, которую я знаю, но с тех пор она была реализована через интерфейс TypeScript:
var MyEnum;
(function (MyEnum) {
MyEnum[MyEnum["Foo"] = 0] = "Foo";
MyEnum[MyEnum["FooBar"] = 2] = "FooBar";
MyEnum[MyEnum["Bar"] = 1] = "Bar";
})(MyEnum|| (MyEnum= {}));
Это позволяет вам смотреть на оба MyEnum.Bar который возвращает 1, и MyEnum[1] который возвращает "Бар" независимо от порядка объявления.
В ES7 вы можете сделать элегантный ENUM, опираясь на статические атрибуты:
class ColorEnum {
static RED = 0 ;
static GREEN = 1;
static BLUE = 2;
}
затем
if (currentColor === ColorEnum.GREEN ) {/*-- coding --*/}
Преимущество (использование класса вместо литерального объекта) состоит в том, чтобы иметь родительский класс Enum тогда все ваши Enums будут расширять этот класс.
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 метода для отображения перечислений из объектов сообщений.
Некоторые преимущества этого подхода:
- Легко объявлять перечисления
- Легко получить доступ к вашим перечислениям
- Ваши перечисления могут быть сложными типами
- Класс Enum имеет некоторое ассоциативное кэширование, если вы часто используете getByValue
Некоторые недостатки:
- Там происходит некоторое грязное управление памятью, так как я храню ссылки на перечисления
- Все еще нет типа безопасности
Создайте литерал объекта:
const Modes = {
DRAGGING: 'drag',
SCALING: 'scale',
CLICKED: 'click'
};
Если вы используете Backbone, вы можете получить полную функциональность перечисления (поиск по идентификатору, имени, пользовательским элементам) бесплатно с помощью 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
Я изменил решение Андре 'Fi':
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
Я придумал этот подход, который смоделирован после перечислений в Java. Они безопасны от типов, и поэтому вы можете выполнять instanceof проверяет также.
Вы можете определить перечисления следующим образом:
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
}
})();
Меня не удовлетворил ни один из ответов, поэтому я сделал еще одно перечисление (ДА!).
Эта реализация:
- использует более современный JS
- требуется только объявление этого одного класса, чтобы легко создавать перечисления
- имеет отображение по имени (
colors.RED), строка (colors["RED"]) и index (colors[0]), но вам нужно передать строки только как массив - связывает эквивалент
toString()а такжеvalueOf()функции для каждого объекта перечисления (если это почему-то нежелательно, его можно просто удалить - небольшие накладные расходы для JS) - имеет необязательное глобальное именование / хранение по строке имени
- замораживает объект enum после создания, чтобы его нельзя было изменить
Особая благодарность Андрею Фи за вдохновение.
Коды:
class Enums {
static create({ name = undefined, items = [] }) {
let newEnum = {};
newEnum.length = items.length;
newEnum.items = items;
for (let itemIndex in items) {
//Map by name.
newEnum[items[itemIndex]] = parseInt(itemIndex, 10);
//Map by index.
newEnum[parseInt(itemIndex, 10)] = items[itemIndex];
}
newEnum.toString = Enums.enumToString.bind(newEnum);
newEnum.valueOf = newEnum.toString;
//Optional naming and global registration.
if (name != undefined) {
newEnum.name = name;
Enums[name] = newEnum;
}
//Prevent modification of the enum object.
Object.freeze(newEnum);
return newEnum;
}
static enumToString() {
return "Enum " +
(this.name != undefined ? this.name + " " : "") +
"[" + this.items.toString() + "]";
}
}
Применение:
let colors = Enums.create({
name: "COLORS",
items: [ "RED", "GREEN", "BLUE", "PORPLE" ]
});
//Global access, if named.
Enums.COLORS;
colors.items; //Array(4) [ "RED", "GREEN", "BLUE", "PORPLE" ]
colors.length; //4
colors.RED; //0
colors.GREEN; //1
colors.BLUE; //2
colors.PORPLE; //3
colors[0]; //"RED"
colors[1]; //"GREEN"
colors[2]; //"BLUE"
colors[3]; //"PORPLE"
colors.toString(); //"Enum COLORS [RED,GREEN,BLUE,PORPLE]"
//Enum frozen, makes it a real enum.
colors.RED = 9001;
colors.RED; //0
Это может быть полезно:
const [CATS, DOGS, BIRDS] = ENUM();
Реализация проста и эффективна:
function * ENUM(count=1) { while(true) yield count++ }
Генератор может выдавать точную последовательность требуемых целых чисел, не зная, сколько там констант. Он также может поддерживать необязательный аргумент, указывающий, с какого (возможно отрицательного) числа начать (по умолчанию1).
var ColorEnum = {
red: {},
green: {},
blue: {}
}
Вам не нужно следить за тем, чтобы таким образом не назначать повторяющиеся числа различным значениям перечисления. Новый объект создается и присваивается всем значениям перечисления.
IE8 не поддерживает метод freeze().
Источник: 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;
Comparision:
if (wildType === CONST_WILD_TYPES.REGULAR) {
// do something here
}
es7 way, (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'
код:
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(', ') }
}
Я создал класс 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);
Вы можете initd это так:
var enum1 = new Enum({
item1: 0,
item2: 1,
item3: 2
});
Чтобы получить значение (как Enums в C#):
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>..."
Самое простое решение:
Создайте
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
Несмотря на то, что в ES2015 поддерживаются только статические методы (а не статические свойства) (см. Также п. 15.2.2.2), любопытно, что вы можете использовать ниже с Babel вместе с 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 из другого модуля), а также когда я импортирую модуль с помощью Webpack.
Преимущество этого метода перед большинством других ответов заключается в том, что вы можете использовать его вместе со средством проверки статического типа (например, Flow), и вы можете утверждать во время разработки, используя проверку статического типа, что ваши переменные, параметры и т. Д. CellState "enum", а не какой-либо другой enum (который невозможно было бы различить, если бы вы использовали общие объекты или символы).
Обновить
Приведенный выше код имеет недостаток в том, что он позволяет создавать дополнительные объекты типа CellState (хотя нельзя назначить их статическим полям CellState так как он заморожен) Тем не менее, приведенный ниже более усовершенствованный код предлагает следующие преимущества:
- больше нет объектов типа
CellStateможет быть создан - вам гарантировано, что никаким двум экземплярам enum не присвоен одинаковый код
- служебный метод для возврата перечисления из строкового представления
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;
Вы можете сделать что-то вроде этого
function Enum(){
this.add.apply(this,arguments);
}
Enum.prototype.add = function(){
for (var i in arguments) {
this[arguments[i]] = new String(arguments[i]);
}
};
Enum.prototype.toList = function(){
return Object.keys(this)
};
var STATUS = new Enum("CLOSED","PENDING");
var STATE = new Enum("CLOSED","PENDING");
STATE.CLOSED === STATUS.CLOSED // false;
STATE.CLOSED === "CLOSED" // false;
STATE.CLOSED.toString() === "CLOSED" // true;
Как определено в этой библиотеке. https://github.com/webmodule/foo/blob/master/foo.js#L217
Вам просто нужно создать неизменяемый объект с помощью Object.freeze(<your_object>):
export const ColorEnum = Object.freeze({
// you can only change the property values here
// in the object declaration like in the Java enumaration
RED: 0,
GREEN: 1,
BLUE: 2,
});
ColorEnum.RED = 22 // assigning here will throw an error
ColorEnum.VIOLET = 45 // even adding a new property will throw an error
Вот как Typescript переводит это enum в Javascript:
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
Быстрый и простой способ будет:
var Colors = function(){
return {
'WHITE':0,
'BLACK':1,
'RED':2,
'GREEN':3
}
}();
console.log(Colors.WHITE) //this prints out "0"
Вот несколько разных способов реализации перечислений TypeScript.
Самый простой способ - просто перебрать объект, добавив к нему инвертированные пары ключ-значение. Единственным недостатком является то, что вы должны вручную установить значение для каждого члена.
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
А вот микшин lodash для создания перечисления с использованием строки. Хотя эта версия немного сложнее, она выполняет нумерацию автоматически. Все методы lodash, используемые в этом примере, имеют обычный JavaScript-эквивалент, так что вы можете легко их отключить, если хотите.
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