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

如果您稍微改变了逻辑，并提供了可拆分的值，也许您可以执行类似的操作，从而更容易检测到键 >和 values ，如果一个值是可分割的，则可以将其作为数组 push 。

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

也许键是否存在于该数组对象中，如下面的代码片段一样？

堆栈片段

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 。

从键/值对创建复杂对象

2 个答案:

为每个运输分配一个索引

此处的输出为PRE-MERGE