从键/值对创建复杂对象

Question

我有一个包含键/值对的文件。该文件通过 Docker 在process.env 中加载。但出于开发目的，我手动加载它，所以最后它们是相同的；

配置：

process.env['ccc.logger.winston.level']='info';
process.env['ccc.logger.winston.transports.type.file']='File';
process.env['ccc.logger.winston.transports.filename']='logs/testOne.log';
process.env['ccc.logger.winston.transports.rotate']='false';

process.env['ccc.logger.winston.transports.type.file']='File';
process.env['ccc.logger.winston.transports.filename']='logs/testTwo.log';
process.env['ccc.logger.winston.transports.rotate']='true';

我的期望是拥有这个对象：

{
  "ccc": {
    "logger": {
      "winston": {
        "level": "info",
        "transports": [
          {
            "type": "File",
            "filename": "logs/testONE.log",
            "rotate": true
          },
          {
            "type": "File",
            "filename": "logs/testTWO.log",
            "rotate": false
          }
        ]
      }
    }
  }
}

我想出了可以正常工作的解决方案，但是如果我有一个对象数组，我就会遇到问题，就像上面的例子一样：

循环所有键/值并调用函数创建对象的代码：

let ENV_FROM_DOCKER = process.env;

for (let property in ENV_FROM_DOCKER) {
  let checkForShallowProperties = property.split(".")[1];

  if (typeof checkForShallowProperties === 'undefined') {
    continue;
  }

  let resultObject = this.expand(property, ENV_FROM_DOCKER[property]););

  emptyConfig = merge(emptyConfig, resultObject);
  let stop;
}

对象创建函数：

expand(str, value) {
  let items = str.split(".") // split on dot notation
  let output = {} // prepare an empty object, to fill later
  let ref = output // keep a reference of the new object

  //  loop through all nodes, except the last one
  for (let i = 0; i < items.length - 1; i++) {
    ref[items[i]] = {}; // create a new element inside the reference
    ref = ref[items[i]]; // shift the reference to the newly created object
  }

  ref[items[items.length - 1]] = value; // apply the final value
  return output // return the full object
}

此设置工作正常，但如果我有一个包含对象数组的对象（如上面的示例），则它无法正常工作。这是现在的输出：

{
  "ccc": {
    "logger": {
      "winston": {
        "level": "info",
        "transports": {
          "type": {
            "file": "File"
          },
          "filename": "logs/testTwo.log",
          "rotate": "true"
        }
      }
    }
  }
}

我现在正试图让这段代码工作几个小时，但只是在圈子里旋转。 ccc 对象就是一个例子。键/值列表中可能还有其他对象也可能有数组。

Answer 1

如果你稍微改变你的逻辑，并将值提供为 split-able，也许你可以做这样的事情，这样更容易检测什么是 keys 和values，如果一个值是split-able，你就知道push它是一个数组。

还有一个决定要做，那就是它应该如何理解何时应该将值添加到给定的对象数组中，例如transports数组对象，或者新建一个。

如果键存在于该数组对象中，比如下面的 sn-p？

堆栈sn-p

var res = {};
expand(res,'ccc.logger.winston.level','info');
expand(res,'ccc.logger.winston.transports','type=File1');
expand(res,'ccc.logger.winston.transports','filename=logs/testOne.log');
expand(res,'ccc.logger.winston.transports','rotate=false');

expand(res,'ccc.logger.winston.transports','type=File2');
expand(res,'ccc.logger.winston.transports','filename=logs/testTwo.log');
expand(res,'ccc.logger.winston.transports','rotate=true');

console.log( res )

function expand(ref, str, value) {
    let items = str.split(".") // split on dot notation

    //  loop through all key nodes
    for(let i = 0; i < items.length - 1; i ++)
    {
        if (!ref[items[i]])
          ref[items[i]] = {}; // create if not exist
          
        ref = ref[items[i]]; // shift the object reference
    }
    
    let values = value.split("=") // split on equal sign

    if (values.length > 1)
    {
        // apply array
        var item = ref[items[items.length - 1]];
        
        if (item) {
            //  add to array
            if(!item[item.length - 1][values[0]]) {
                item[item.length - 1][values[0]] = values[1]; // add to existing array
            } else {
                item.push( {[values[0]]: values[1]} ); // create new array item
            }
        } else {
            // create array        
            ref[items[items.length - 1]] = [ {[values[0]]: values[1]} ];
        }
        
    } else {
        // apply value
        ref[items[items.length - 1]] = value;
    }

    //return ref; // return the full object
}

---

几点说明：

• 当使用像这样的数组变量{[values[0]]: values[1]} 分配对象键时，键 需要括在括号[] 中。

  对于不支持 ES6 的浏览器，使用普通变量，例如

  var key = values[0];
  {key: values[1]}
  

• Object.assign 通常用于合并对象，但如果存在键，则值会被覆盖。

  为了克服这个问题，我将对象引用传递给 expand 函数。

Answer 2

为每个传输分配一个索引

在创建环境变量时，您可以将每个 transports.whatnot 分配给数组 transports[0].whatnot 和 transports[1].whatnot 中的索引。为了完成这项工作，我们必须像这样解析它：

const ENV = {
  'ccc.logger.winston.level': 'info',
  'ccc.logger.winston.transports[0].type': 'File',
  'ccc.logger.winston.transports[0].filename': 'logs/testOne.log',
  'ccc.logger.winston.transports[0].rotate': 'false',
  'ccc.logger.winston.transports[1].type': 'File',
  'ccc.logger.winston.transports[1].filename': 'logs/testTwo.log',
  'ccc.logger.winston.transports[1].rotate': 'true'
}

for (let property in ENV) {
  let checkForShallowProperties = property.split('.')[1]; 

  if (typeof checkForShallowProperties === 'undefined') {
    continue;
  }

  let resultObject = expand(property, ENV[property])
  console.log(resultObject)
}

function expand(string, value) {
  const items = string.split('.').map(name => {
    const match = name.match(/\[\d+?\]/)
    return {
      name: match ? name.slice(0, match.index) : name,
      usesBrackets: !!match,
      key: match && match[0].slice(1, -1)
    }
  })
  
  const output = {}
  let ref = output
  let parent
  
  for (const item of items) {
    ref[item.name] = {}
    parent = ref
    ref = ref[item.name]
    if (item.usesBrackets) {
      ref[item.key] = {}
      ref = ref[item.key]
    }
  }
  parent[items[items.length - 1].name] = value
  return output
}

这里的输出是 PRE-MERGE

如您所见，它的工作方式是将对象视为自己的数组，并将内容放在索引处，甚至是其他访问器。

但是，将所有这些转移到 .json 文件或某些内容管理系统很可能符合您的最大利益，因为这是一个非常不稳定的做事方式。如果您的需求发生变化，您可能需要重写它，使用 JSON，您只需加载 JSON。