在Javascript中返回类的类静态getter

Question

我有一些代码：

//Main class
class Tools { 

  //Subclass implemented by static getter 
  static get SUPPORTED_UNITS () {
    return class {  
      //Another one
      static get Size () {
        return class {
          //Some data (constants in my case)
        };
      }
    };
  }
}

我想像Tools.SUPPORTED_UNITS.Size 一样使用它，并且我想收到一些数据作为它的结果。 我使用 WebStorm 编写 JavaScript 代码，所以当我尝试使用它时它会显示给我。

我不太清楚，也许我只是还没有对我的 WebStorm 进行一些设置，但是.. 我需要做的是我可以使用像 Class.Subclass.SubClassMethod/SubSubclass 这样的构造。

我需要那个：

• 这不是方法
• 它是静态的
• 它是不可变的（没有 Object.freeze 或类似的东西） - 所以我不能通过输入 Class.Subclass = foo; 来更改我的 Class.Subclass
• 它由 IDE 编制索引 - 所以我从 IDE 获得了一些帮助（比如我输入 Class.Su 而她建议使用 Class.Subclass）

在 ES6 和 WebStorm 中是真的吗？或者也许我必须使用 ES7 和 Babel 或类似的东西？

附：该代码工作，但我需要来自 IDE 的建议，否则它将像地狱一样。

Answer 1

遵循@estus 和@Felix Kling 的建议...（可能在此处被歪曲）

const TOOLS = {
    get SUPPORTED_UNITS() {
        return {
            get SIZE() {
                return {
                    get Bar() { 
                        return 1;
                    }
                }
            }
        }
    }
};
console.log(TOOLS.SUPPORTED_UNITS.SIZE.Bar) // 1;

TOOLS.SUPPORTED_UNITS.SIZE = "Hello";
// TOOLS.SUPPORTED_UNITS.SIZE = "Hello";
//                            ^
// TypeError: Cannot set property SIZE of #<Object> which has only a getter

这可行，但正如@bergi 所说，它会在每次查找中创建一个新对象：

console.log(TOOLS.SUPPORTED_UNITS === TOOLS.SUPPORTED_UNITS); // false

是的……

仍然使用 getter 的替代方法是将所有这些对象封装在 IIFE 中：

const TOOLS = (function () {
    const SIZE = {
        get Bar() { return 1; }
    }
    const SUPPORTED_UNITS = {
        get SIZE() {
            return SIZE;
        }
    }
    return {
        get SUPPORTED_UNITS() {
            return SUPPORTED_UNITS;
        }
    }
}());

console.log(TOOLS.SUPPORTED_UNITS.SIZE.Bar === TOOLS.SUPPORTED_UNITS.SIZE.Bar); // true
console.log(TOOLS.SUPPORTED_UNITS.SIZE === TOOLS.SUPPORTED_UNITS.SIZE);  // true
console.log(TOOLS === TOOLS); // true

TOOLS.SUPPORTED_UNITS = "hello"; // still throws an error

第三次更新：

第二个示例解决了与每次查找创建新对象相关的问题，但它也没有考虑到对每个嵌套属性的访问会导致函数调用以重新评估不应更改的内容：

//A naive measurement:
for(let counter = 0; counter < 5; counter++) {
    let start = Date.now();    
    for(let i = 0; i < 200000; i++){
        let somevar = Tools.SUPPORT_UNITS.SIZE;
    }
    let end = Date.now();
    console.log(`Elapsed using nested getters: ${end - start}ms.`);
}
// Something like:
/** Elapsed using nested getters: 20ms.
 * Elapsed using nested getters: 14ms.
 * Elapsed using nested getters: 9ms.
 * Elapsed using nested getters: 10ms.
 * Elapsed using nested getters: 10ms.
 *
 // While the same as ordinary properties:
 * Elapsed ordinary properties: 2ms.
 * Elapsed ordinary properties: 5ms.
 * Elapsed ordinary properties: 1ms.
 * Elapsed ordinary properties: 0ms.
 * Elapsed ordinary properties: 0ms.
 */

因此，如果在可预见的将来运行 200000 次循环，则最好在使用此方法之前检查替代方案。