枚举中的Javascript枚举

我在javascript中有以下“Enum”来指示我的应用程序的状态：

var State = {
   STATE_A: 0,
   STATE_B: 1,
   STATE_C: 2
   //...
}

现在，我希望每个州都有一个“子州”。例如，

状态B

可能处于

状态B1

或

状态B2

构建此结构的最佳方式是什么？我是否会在

状态

的“enum”中嵌套一个“enum”？谢谢

---

如果有更好的方法来构建这个整体（而不是枚举），我洗耳恭听。基本上，我需要能够设置和检查我的应用程序的状态，每个状态可以（但不是必需的）有一个子状态附加到它可以设置和检查。如果解决方案允许我进行超过1级的嵌套深度，那就更好了。

您所做的并不是真正的枚举。您使用的是本机Javascript对象，只需将它们视为枚举，如果您希望在Javascript中使用类似枚举的对象，这是完全可以接受的

要回答您的问题，可以完全嵌套对象：

var State = {
   STATE_A: 0,
   STATE_B:{
      SUBSTATE_1 : "active",
      SUBSTATE_2 : "inactive"
   },
   STATE_C: 2
   //...
}

然后使用点符号来设置这些值，如

---

State.State\u B.SUBSTATE\u 2=“active”

我想你应该写一些类似的东西

if (State.STATE_A === someState) { ... }

您可以简单地在状态对象中定义另一层，如

var State = {
  STATE_A : 0
  STATE_B : {
    B1 : 1,
    B2 : 2,
  }
};
...
if (State.STATE_B.B1 == someState){...}

编辑：根据对您问题的评论，另一种方法可能是这样

//Creates state objects from you json.
function createStates(json) {
  var result = {};
  for(var key in json) {
    result[key] = new State(json[key]);
  }
  return result;
}

//State class
function State(value) {
  //If the state value is an atomic type, we can do a simple comparison.
  if (typeof value !== "object") {
    this.value = value;
    this.check = function(comp){ return value === comp; };
  }
  // Or else we have more substates and need to check all substates
  else if (typeof value === "object") {
    this.value = createStates(value);
    for(var key in this.value) {
      //Allows to access StateA.SubStateA1. Could really mess things up :(
      this[key] = this.value[key];
    }
    this.check = function(comp){
      for(var key in this.value) {
        if (this.value[key].check(comp) === true){
          return true;
        }
      }
      return false;
    };
  }
};

现在你可以打电话给任何人了

var stateJson = {
      STATE_A : 0,
      STATE_B : {
        B1 : 1,
        B2 : 2
      }
    };
var states = createStates(stateJson);
alert(states.stateA.check(0)); // Should give true
alert(states.STATE_B.B1.check(1)); // Same here
alert(states.STATE_B.check(1)); //And again because value is valid for one of the substates.

---

如果需要，可以使用某种位字段：

var State = function() {
  // Note this must increment in powers of 2.
  var subStates = 8;
  var A = 1 << subStates;
  var B = 2 << subStates;
  var C = 4 << subStates;
  var D = 8 << subStates;

  return {

    // A
    // Note this must increment in powers of 2.
    STATE_A:  A,
    STATE_A1: A | 1,
    STATE_A2: A | 2,
    STATE_A3: A | 4,
    STATE_A4: A | 8,
    STATE_A5: A | 16

    // B
    STATE_B:  B,
    STATE_B1: B | 1,

    // C
    STATE_C: C,
    STATE_C1: C | 1,
    STATE_C2: C | 2,
    STATE_C3: C | 4,
    STATE_C4: C | 8,

    // D
    STATE_D: D
  };
}();

// Set a state.
var x = State.STATE_A1; // Same as State.STATE_A | State.STATE_A1

// Determine if x has root state of A?
if(x & State.STATE_A == State.STATE_A) {
   console.log("Root state is A.");
}
else {
   console.log("Nope, not root state A.");
}

// Determine if x has sub-state A1?
if(x & State.STATE_A1 == State.STATE_A1) {
   console.log("A with Substate 1");
}

var State=function（）{
//注意，这必须以2的幂递增。
var子状态=8；
var A=1由于JavaScript不支持运算符重载，因此无法使用
=
运算符直接测试子状态是否相等。最接近的方法是使用
instanceof
运算符检查状态是否为给定类型，例如：

// All these functions are empty because we only need the type and there is no data

function State() {
}

function State_A() {
}
State_A.prototype = new State();

function State_B() {
}
State_B.prototype = new State();

function State_B1() {
}
State_B1.prototype = new State_B();

function State_B2() {
}
State_B2.prototype = new State_B();

由于函数也是对象，您可以将嵌套直接添加到
状态
函数中：

State.STATE_A = new State_A();
State.STATE_B = new State_B();
State.STATE_B.STATE_B1 = new State_B1();
State.STATE_B.STATE_B2 = new State_B2();

并检查其类型：

var myState = State.STATE_B1;
myState instanceof State    // true
myState instanceof State_A  // false
myState instanceof State_B  // true
myState instanceof State_B1 // true


如果你把某个东西设置为状态_B2，你想和状态_B的比较也是真的吗？Empirededmassa-是的，我绝对想，谢谢你的澄清。兰多姆想：一些答案突然出现了，但它们是针对状态_B==1还是状态_B.B1==1？回到Empirededmassa点（经过思考，这是一个非常重要的问题）：事实上，我确实希望这个比较是真实的。但我不认为下面的解决方案允许这样做。有什么想法吗？我提供的答案应该能够满足您的要求。我对我上面的评论感到困惑了一段时间。但是说州是州。州B.B1：我确实希望检查州。州B的评估结果是否为真。我如何才能做到这一点是吗？谢谢。@aeq请查看注释后面的部分。虽然您不能再使用
=
进行计算，但必须使用
检查（值）
方法。我还希望对State.State\u B.SUBSTATE\u 2==State.State\u B求值为真。关于如何实现这一点，有什么想法吗？@aeq：除非
SUBSTATE\u 2
和
State\u B
是相同的对象，否则这种比较永远不会是真的。@thecloudlessky：好吧，这是你能得到的最接近比较的结果…：）
function State () {
  this.superState = null;
}

State.prototype = {
    constructor: State

  , mkSubState () {
      var subState = new State ();
      subState.superState = this;
      return subState;
    }

  , isSubStateOf (superState) {
      var state = this;
      while (state !== null) {
        if (this.superState === superState) {
          return true;
        }
        state = this.superState;
      }
      return false;
    }

  , isSuperStateOf (subState) {
      while (subState !== null) {
        if (subState.superState === this) {
          return true;
        }
        subState = subState.superState;
      }
      return false;
    }
};

var States = {};
States.A = new State ();
States.A1 = States.A.mkSubState ();
States.A2 = States.A1.mkSubState ();
States.B = new State ();
States.B1 = States.B.mkSubState ();
States.B2 = States.B1.mkSubState ();


States.B2.isSubStateOf (B);   // true
States.B2.isSubStateOf (B1);  // true

States.B2.isSubStateOf (B2);  // false
States.B2.isSubStateOf (A);   // false
States.B2.isSubStateOf (A1);  // false
States.B2.isSubStateOf (A2);  // false