有没有比巨大的条件运算符更好的方法来做到这一点？

Question

目前没有任何错误或任何不良问题，但每次我尝试向其中添加新数据时，它都会崩溃。 看起来也非常凌乱。 有没有任何更好的方法来做到这一点？

(
  s === "FFP" ? o.ffp : (
    s === 'XP' ? (await getXP(index, true)) || o.e.xpLvl * o.e.xp : (
      s === "FSC" ? o.fsc : (
        s === 'BGP' ? o.bgp : (
          s === "BTN" ? btns[index] || 0 : (
            s === 'CIV' ? await getCiv(index) || 0 : (
              s === "TIQ" ? await getTotalInv(index) || 0 : (
                s === 'IS1' ? isold[index] || 0 : (
                  s === "ITO" ? acn[index].cache.itemsObtained || 0 : (
                    s === 'FLW' ? flws[index] || 0 : (
                      s === "PLY" ? acn[index].playtime || 0 : (
                        s === "QSC" ? (qusc[index] ? qusc[index].completed : 0) : (
                          s === 'QSR' ? (qusc[index] ? qusc[index].rankings : 0) : (
                            s === "DXP" ? (dbs.xp[index] || 0) : (
                              s === 'FPS' ? etcscores.fps[index] || 0 : (
                                s === 'SMN' ? (index === "admin_907" ? 1 : 0) :
                                "N/A")
                            )
                          )
                        )
                      )
                    )
                  )
                )
              )
            )
          )
        )
      )
    )
  )
)

我尝试过 if/then/else 语句，但它实际上是同样混乱的事情，尽管中断的频率要少一些。

Answer 1

如果所有检查都在测试字符串变量的确切值

s

，则具有对象查找的解决方案应该保持事物清洁，如下所示：

const output = {
  'FFP': o.ffp,
  'XP': (await getXP(index, true)) || o.e.xpLvl * o.e.xp,
  'FSC': o.fsc,
  'BGP': o.bgp,
  // ...
}[s] ?? 'N/A';

但是要注意，这种形式没有短路，即使值不匹配，所有选项都会启动，这意味着结果必须等待所有

await

条件先解决。

如果这是一个问题，使用带有开关条件的 IIFE 也是一个不错的选择。

const output = await (async () => {
  switch (s) {
    case 'FFP':
      return o.ffp;
    case 'XP':
      return (await getXP(index, true)) || o.e.xpLvl * o.e.xp;
    case 'FSC':
      return o.fsc;
    case 'BGP': 
      return o.bgp;
    // ...
    default:
      return 'N/A';
  }
})();

Answer 2

switch 语句不起作用吗？我假设您可以在定义所有这些变量（如“o”）的上下文中定义它：

async function lookup(s) {
    switch (s) {
        case "FFP":
            return o.ffp;
        case "XP":
            return (await getXP(index, true)) || o.e.xpLvl * o.e.xp;
        case "FSC":
            return o.fsc;
        case "BGP":
            return o.bgp;

        //...

        default:
            return "N/A";
    }

为了便于阅读，我还会将所有案例重新排序为按字母顺序排列，除非您确定某些案例发生得更频繁，并且应该放在列表中的较高位置。

我建议将所有状态变量（如“o”和“btns”）存储在某个全局状态管理对象中，以便您也可以将它们传递进去，并在更全局的范围内定义它，如下所示：

 async function lookup(s, globalState):
      switch (s) {
           case "FFP":
                return globalState.o.ffp;
           // ...  

Answer 3

我认为这对于 switch 语句来说是一个很好的用例。就会是这样的。

switch (s) {
    case "FFP": return o.ffp;
    case "XP": return (await getXP(index, true)) || o.e.xpLvl * o.e.xp
    case "FSC": return o.fsc
    case "BGP": return o.bgp
    case "BTN": return btns[index] || 0
    case "CIV": return await getCiv(index) || 0
    case "TIQ": return await getTotalInv(index) || 0
    case "IS1": return isold[index] || 0
    case "ITO": return acn[index].cache.itemsObtained || 0
    case "FLW": return flws[index] || 0
    case "PLY": return acn[index].playtime || 0
    case "QSC": return qusc[index] ? qusc[index].completed : 0
    case "QSR": return qusc[index] ? qusc[index].rankings : 0
    case "DXP": return dbs.xp[index] || 0
    case "FPS": return etcscores.fps[index] || 0
    case "SMN": return index === "admin_907" ? 1 : 0
    default: return "N/A"
}

不过，这段代码相当神秘，因此您应该更好地将分支案例提取到正确命名/记录的函数中。

另一种选择是将每个键 -> 表达式对存储在字典中（您可以将表达式存储在函数内，命名或匿名，因此执行被推迟。）

它会是这样的：

const lookup = {
    "FFP": () => o.ffp,
    "XP": async () => (await getXP(index, true)) || o.e.xpLvl * o.e.xp,
    "FSC": () => o.fsc,
    "BGP": () => o.bgp,
    "BTN": () => btns[index] || 0,
    "CIV": async () => await getCiv(index) || 0,
    "TIQ": async () => await getTotalInv(index) || 0,
    "IS1": () => isold[index] || 0,
    "ITO": () => acn[index].cache.itemsObtained || 0,
    "FLW": () => flws[index] || 0,
    "PLY": () => acn[index].playtime || 0,
    "QSC": () => qusc[index] ? qusc[index].completed : 0,
    "QSR": () => qusc[index] ? qusc[index].rankings : 0,
    "DXP": () => dbs.xp[index] || 0,
    "FPS": () => etcscores.fps[index] || 0,
    "SMN": () => index === "admin_907" ? 1 : 0,
}

await lookup[s]?.() ?? "N/A"