用javascript编写类

我想基于此对象结构创建一个类：

var ourStorage = {
"variableItem1":    {
    "drawer": ""
  },
"variableItem2": {
    "top drawer": {
      "folder1": "",
      "folder2": "harhar"
    },
    "bottom drawer": ""
  }
};

var accessStr = 'variableItem2'
var drawerPart = 'top drawer'
console.log(ourStorage[accessStr][drawerPart].folder2)

基本上，我希望能够通过此样式访问对象内容，因为我将在参数修改方面进行大量工作：

我们的存储[accessStr][DroperPart].folder2

因此，我的问题是：

如何在维护这种结构的同时将其转换为类？可能吗

如果我想插入另一个项目/对象，例如variableItem3-如何插入

如果我还想在更深的层次（如中间抽屉）插入另一个项目/对象，我该怎么做

---

多谢

有很多方法可以将其转换为类，但是如果您想将其作为json点或括号符号进行交互，那么我会说将其保留为json，并创建一个用于与存储结构交互的类

在代码片段中，我创建了一个存储类，让您将json作为起始结构传入

然后我们给这个类2个方法：get和update

更新将允许您插入任何新节点，您可以在任何地方添加一个新的variableItem5，其中包含抽屉、文件夹、橱柜和衣柜，其中包含任意多个嵌套节点

然后，使用get方法，您可以使用括号表示法，就像您正在查找的那样：

console.log(os.get[accessStr][drawerPart]);

变量存储={ 可变项1：{ 出票人： }, 可变项2：{ 顶部抽屉：{ folder1:， 第2页：哈哈尔 }, 底部抽屉： } }; var accessStr='variableItem2' var drawerPart='最上面的抽屉' 分级存储{ 构造函数开始存储={}{ 这个。存储=启动存储； } 得到{ 返回JSON.parseJSON.stringifythis.storage； } updatestore={}{ this.storage=$.extendtrue，this.storage，store； } } var os=新的OurStorageourStorage； console.logos.get[accessStr]； console.logos.get[accessStr][drawerPart]； os.update{variableItem2:{ secretBananaFolder:{id:banana} }}; console.logos.get[accessStr]； os.update{variableItem3:{ 顶部抽屉：{ folder1:， folder2:太棒了！ }, 底部抽屉： }}; accessStr=可变项3； console.logos.get[accessStr][drawerPart]；

---

有两个选项可用于执行此操作

选项1：通过以param形式传入所需对象来初始化类

class Storage 
{
  constructor(init)
  {
    return init;
}
}

let ourStorage = new Storage({
    "variableItem1":   {
        "drawer": ""
      },
    "variableItem2": {
        "top drawer": {
          "folder1": "",
          "folder2": "harhar"
        },
        "bottom drawer": ""
      }
    });

var accessStr = 'variableItem2'
var drawerPart = 'top drawer'
console.log(ourStorage[accessStr][drawerPart].folder2);

选项2：在类的构造函数中初始化对象

class Storage 
{
  constructor(init)
  {
    return {
    "variableItem1":   {
        "drawer": ""
      },
    "variableItem2": {
        "top drawer": {
          "folder1": "",
          "folder2": "harhar"
        },
        "bottom drawer": ""
      }
    };
}
}

let ourStorage = new Storage();

var accessStr = 'variableItem2'
var drawerPart = 'top drawer'
console.log(ourStorage[accessStr][drawerPart].folder2);

---

一个选项是创建一个模型类，该模型类具有一个存储分配给它的所有值的数据属性。使用get/set/unset API修改数据属性。使用解析方法获取模型的普通对象表示。这允许您创建嵌套模型

如果您正在创建应用程序，我建议您创建一个API，而不是直接访问数据模型上的属性。语法可能看起来有点长，但从长远来看，如果需要执行数据转换，则向类中添加方法会更容易。与初始方法一样，如果要向类中添加其他方法，则可能会用实际数据覆盖它们。最好有一个存储所有值的数据属性。否则，您不一定需要创建一个类，您可以像现在这样使用一个普通对象

阶级

用法

---

你为什么要上课？是因为您需要此结构对象的多个实例吗？这很有帮助。谢谢

const Model = class {
  constructor() {}
  get data() {
    if(!this._data) this._data = {}
    return this._data
  }
  setDataProperty(key, value) {
    if(!this.data[key]) {
      Object.defineProperties(this.data, {
        ['_'.concat(key)]: {
          configurable: true,
          writable: true, 
          enumerable: false,
        },
        [key]: {
          configurable: true,
          enumerable: true,
          get() { return this['_'.concat(key)] },
          set(value) { this['_'.concat(key)] = value }
        },
      })
    }
    this.data[key] = value
    return this
  }
  unsetDataProperty(key) {
    if(this.data[key]) {
      delete this.data[key]
    }
    return this
  }
  get() {
    if(arguments[0]) return this.data[arguments[0]]
    return Object.entries(this.data)
      .reduce((_data, [key, value]) => {
        _data[key] = value
        return _data
      }, {})
  }
  set() {
    if(arguments.length === 2) {
      this.setDataProperty(arguments[0], arguments[1])
    } else if(
      arguments.length === 1 &&
      !Array.isArray(arguments[0]) &&
      typeof arguments[0] === 'object'
    ) {
      Object.entries(arguments[0]).forEach(([key, value]) => {
        this.setDataProperty(key, value)
      })
    }
    return this
  }
  unset() {
    if(arguments[0]) {
      this.unsetDataProperty(arguments[0])
    } else {
      Object.keys(this.data).forEach((key) => {
        this.unsetDataProperty(key)
      })
    }
    return this
  }
  parse(data = this.data) {
    return Object.entries(data).reduce((_data, [key, value]) => {
      if(value instanceof Model) {
        _data[key] = value.parse()
      } else {
        _data[key] = value
      }
      return _data
    }, {})
  }
}

let model = new Model()
// Add a property
model.set('a', 1)
console.log(model.get())

/*
{
  "a": 1
}
*/

// Add multiple properties
model.set({
  'b': 2,
  'c': { a: 1, b: 2, }
})
console.log(model.get())
/*
{
  "a": 1,
  "b": 2,
  "c": {
    "a": 1,
    "b": 2
  }
}
*/

// Replace a property
model.set({
  a: ['meh', 'heh',]
})
console.log(model.get())
/*
{
  "a": [
    "meh",
    "heh"
  ],
  "b": 2,
  "c": {
    "a": 1,
    "b": 2
  }
}
*/

// Remove a single properties
model.unset('a')
console.log(model.get())
/*
{
  "b": 2,
  "c": {
    "a": 1,
    "b": 2
  }
}
*/

// Remove all properties
model.unset()
console.log(model.get())
/*
{}
*/

// Add another property
model.set('a', 2354234)

// Create a nested model
let nestedModel = new Model()
nestedModel.set('nestedValue', 35234534254)
model.set('nestedModel', nestedModel)
console.log(model.parse())
/*
{
  "a": 2354234,
  "nestedModel": {
    "nestedValue": 35234534254
  }
}
*/

// Update the nested model
model.get('nestedModel').set('someNewValue', 'asdfasgaerwkjghak')
console.log(model.parse())
/*
{
  "a": 2354234,
  "nestedModel": {
    "nestedValue": 35234534254,
    "someNewValue": "asdfasgaerwkjghak"
  }
}
*/