如何在JS中将环境变量转换为对象?

Question

我正在尝试将环境变量转换为JavaScript中配置的值对象，但我不知道实现这一目标的最佳方法。

将SAMPLE_ENV_VAR=value输出为:

{
    sample: {
        env: {
            var: value
        }
    }
}

目前为止我有什么:

const _ = require('lodash');
const process = require('process');
_.each(process.env, (value, key) => {
    key = key.toLowerCase().split('_');
    // Convert to object here
}

Answer 1

下面是一个基于您的更完整的解决方案:

const _ = require('lodash');
const result = {};
// We'll take the following as an example:
// process.env = { HELLO_WORLD_HI: 5 }
// We'll expect the following output:
// result = { hello: { world: { hi: 5 } } }
_.each(process.env, (value, key) => {
    // We'll separate each key every underscore.
    // In simple terms, this will turn:
    // "HELLLO_WORLD_HI" -> ['HELLO', 'WORLD', 'HI']
    const keys = key.toLowerCase().split('_');
    // We'll start on the top-level object
    let current = result;
    // We'll assign here the current "key" we're iterating on
    // It will have the values:
    // 'hello' (1st loop), 'world' (2nd), and 'hi' (last)
    let currentKey;
    // We'll iterate on every key. Moreover, we'll
    // remove every key (starting from the first one: 'HELLO')
    // and assign the removed key as our "currentKey".
    // currentKey = 'hello', keys = ['world', 'hi']
    // currentKey = 'world', keys = ['hi'], and so on..
    while ( (currentKey = keys.shift()) ) {
        // If we still have any keys to nest,
        if ( keys.length ) {
          // We'll assign that object property with an object value
          // result =// { HELLO: {} }
          current[currentKey] = {};
          // And then move inside that object so
          // could nest for the next loop
          // 1st loop: { HELLO: { /*We're here*/ } }
          // 2nd loop: { HELLO: { WORLD: { /*We're here*/ } } }
          // 3rd loop: { HELLO: { WORLD: { HI : { /*We're here*/ } } } }
          current = current[currentKey];
        } else {
          // Lastly, when we no longer have any key to nest
          // e.g., we're past the third loop in our example
          current[currentKey] = process.env[key]
        }
    }
});
console.log(result);

简单地说:

• 我们将遍历每个环境变量(from process.env)
• 用下划线分隔键名，并再次循环每个键(['HELLO', 'WORLD', 'HI'])
• 将其分配给对象({ hello: {} } -> { hello: { world: {} } } -> { hello: world: { hi: ? } } })
• 当我们不再有任何键时，将其分配给实际值({ hello: { world: { hi: 5 } } })

Answer 2

有趣的是，我昨晚刚刚完成了一个个人项目的代码。我最终使用的是不理想的，但对我来说是有效的:

export function keyReducer(
  src: any,
  out: any,
  key: string,
  pre: string,
  del: string
): ConfigScope {
  const path = key.toLowerCase().split(del);
  if (path[0] === pre.toLowerCase()) {
    path.shift();
  }
  if (path.length === 1) { // single element path
    const [head] = path;
    out[head] = src[key];
  } else {
    const tail = path.pop();
    const target = path.reduce((parent: any, next: string) => {
      if (parent[next]) {
        return parent[next];
      } else {
        return (parent[next] = <ConfigScope>{});
      }
    }, out);
    target[tail] = src[key];
  }
  return out;
}
static fromEnv(env: Environment, {prefix = 'ABC', delimiter = '_'} = {}) {
  const data: ConfigScope = Object.keys(env).filter(key => {
    return StringUtils.startsWith(key, prefix);
  }).reduce((out, key) => {
    return keyReducer(env, out, key, prefix, '_');
  }, <ConfigScope>{});
  return new Config(data);
}

(带TypeScript类型注解)

这里的想法是拆分每个键，在向下的过程中创建目标对象，然后设置最终值。

Answer 3

这是我对它的快速理解:

var object = {}; // the object to store the value in 
var name = "SAMPLE_ENV_VAR"; // the environment variable key
var value = "value"; // the value of the environment variable
// helper function to automatically create an inner object if none exists
function getOrCreateInnerObj(obj, name) {
  if (!obj.hasOwnProperty()) {
    obj[name] = {};
  }
  return obj[name];
}
// an array of the individual parts (e.g. ["sample", "env", "var"])
var keyParts = name.toLowerCase().split("_");
// innerObj will contain the second to last element object in the tree based on the array of keys
var innerObj = getOrCreateInnerObj(object, keyParts[0]);
for (var i = 1; i < keyParts.length - 1; i++) {
  innerObj = getOrCreateInnerObj(innerObj, keyParts[i]);
}
// set the value itself
innerObj[keyParts[keyParts.length - 1]] = value;
$("body").html(JSON.stringify(object));

它的要点是，对于键部分数组中除最后一个元素外的所有元素，您可以在当前父对象中获取或创建该键的对象，一旦您对除最后一个键外的所有元素重复此操作，您将获得倒数第二个内部对象，然后您可以在其上设置值。

编辑:工作示例

编辑2:下面是一个更简洁的示例，它使用了一点递归来完成相同的事情

Answer 4

const basic = {};
let current;
`YOUR_VARIABLE_NAME`
  .split(`_`)
  .forEach((item, index, array) => {
    if(index === 0) {
      return current = basic[item] = {};
    }
    if(index === array.length - 1) {
      return current[item] = process.env.HE_LO_NA;
    }
    current = current[item] = {};
});
console.log(require('util').inspect(basic, {depth: 10}));

Answer 5

const _ = require('lodash');
const process = require('process');
const result = Object.entries(process.env).reduce((acc, [key, value]) => {
    _.set(acc, key.toLowerCase().replace('_', '.'), value);
    return acc;
}, {})