在某些语言中，你可以使用替代库，例如，tampax是YAML处理变量的实现:

const tampax = require('tampax');

const yamlString = `
dude:
  name: Arthur
weapon:
  favorite: Excalibur
  useless: knife
sentence: "{{dude.name}} use {{weapon.favorite}}. The goal is {{goal}}."`;

const r = tampax.yamlParseString(yamlString, { goal: 'to kill Mordred' });
console.log(r.sentence);

// output : "Arthur use Excalibur. The goal is to kill Mordred."

编者注:海报作者也是本包的作者。

您的示例无效只是因为您选择了一个保留字符作为标量的开头。如果你用其他非保留字符替换*(我倾向于使用非ascii字符，因为它们很少被用作某些规范的一部分)，你最终会得到完全合法的YAML:

paths:
  root: /path/to/root/
  patha: ♦root♦ + a
  pathb: ♦root♦ + b
  pathc: ♦root♦ + c

这将加载到解析器使用的语言中映射的标准表示形式中，并且不会神奇地展开任何内容。 为此，使用本地默认的对象类型，如下面的Python程序所示:

# coding: utf-8

from __future__ import print_function

import ruamel.yaml as yaml

class Paths:
    def __init__(self):
        self.d = {}

    def __repr__(self):
        return repr(self.d).replace('ordereddict', 'Paths')

    @staticmethod
    def __yaml_in__(loader, data):
        result = Paths()
        loader.construct_mapping(data, result.d)
        return result

    @staticmethod
    def __yaml_out__(dumper, self):
        return dumper.represent_mapping('!Paths', self.d)

    def __getitem__(self, key):
        res = self.d[key]
        return self.expand(res)

    def expand(self, res):
        try:
            before, rest = res.split(u'♦', 1)
            kw, rest = rest.split(u'♦ +', 1)
            rest = rest.lstrip() # strip any spaces after "+"
            # the lookup will throw the correct keyerror if kw is not found
            # recursive call expand() on the tail if there are multiple
            # parts to replace
            return before + self.d[kw] + self.expand(rest)
        except ValueError:
            return res

yaml_str = """\
paths: !Paths
  root: /path/to/root/
  patha: ♦root♦ + a
  pathb: ♦root♦ + b
  pathc: ♦root♦ + c
"""

loader = yaml.RoundTripLoader
loader.add_constructor('!Paths', Paths.__yaml_in__)

paths = yaml.load(yaml_str, Loader=yaml.RoundTripLoader)['paths']

for k in ['root', 'pathc']:
    print(u'{} -> {}'.format(k, paths[k]))

这将打印:

root -> /path/to/root/
pathc -> /path/to/root/c

展开是动态完成的，并处理嵌套定义，但必须注意不要调用无限递归。

通过指定转储器，你可以从加载的数据中转储原始的YAML，因为动态扩展:

dumper = yaml.RoundTripDumper
dumper.add_representer(Paths, Paths.__yaml_out__)
print(yaml.dump(paths, Dumper=dumper, allow_unicode=True))

这将改变映射键的顺序。如果你有这个问题的话 成就自我。d一个commenttedmap(从ruame .yaml.comments.py导入)

YML定义:

dir:
  default: /home/data/in/
  proj1: ${dir.default}p1
  proj2: ${dir.default}p2
  proj3: ${dir.default}p3 

在百里叶的某个地方

<p th:utext='${@environment.getProperty("dir.default")}' />
<p th:utext='${@environment.getProperty("dir.proj1")}' /> 

输出: / home /数据/ in / / home /数据/ in / p1

我用Python编写了自己的库来扩展从目录中加载的变量，其层次结构如下:

/root
 |
 +- /proj1
     |
     +- config.yaml
     |
     +- /proj2
         |
         +- config.yaml
         |
         ... and so on ...

这里的关键区别是，扩展必须在所有配置完成后才应用。Yaml文件被加载，其中来自下一个文件的变量可以覆盖来自前一个文件的变量，所以伪代码应该是这样的:

env = YamlEnv()
env.load('/root/proj1/config.yaml')
env.load('/root/proj1/proj2/config.yaml')
...
env.expand()

作为一个附加选项，xonsh脚本可以将结果变量导出到环境变量中(请参阅yaml_update_global_vars函数)。

脚本:

https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/python/cmdoplib/cmdoplib.yaml.xsh https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/python/tacklelib/tacklelib.yaml.py

优点:

简单，不支持递归和嵌套变量 可以将未定义的变量替换为占位符(${MYUNDEFINEDVAR} -> *$/{MYUNDEFINEDVAR}) 可以从环境变量(${env:MYVAR} ${env:MYVAR:path}可以替换所有的\\ to / in路径变量

缺点:

不支持嵌套变量，因此不能展开嵌套字典中的值(例如${MYSCOPE. xml)。MYVAR}未实现) 不检测展开递归，包括递归后的占位符放

另一种方法是简单地使用另一个字段。

paths:
  root_path: &root
     val: /path/to/root/
  patha: &a
    root_path: *root
    rel_path: a
  pathb: &b
    root_path: *root
    rel_path: b
  pathc: &c
    root_path: *root
    rel_path: c

是的，使用自定义标签。Python中的示例，使用!join标记连接数组中的字符串:

import yaml

## define custom tag handler
def join(loader, node):
    seq = loader.construct_sequence(node)
    return ''.join([str(i) for i in seq])

## register the tag handler
yaml.add_constructor('!join', join)

## using your sample data
yaml.load("""
paths:
    root: &BASE /path/to/root/
    patha: !join [*BASE, a]
    pathb: !join [*BASE, b]
    pathc: !join [*BASE, c]
""")

结果是:

{
    'paths': {
        'patha': '/path/to/root/a',
        'pathb': '/path/to/root/b',
        'pathc': '/path/to/root/c',
        'root': '/path/to/root/'
     }
}

join的参数数组可以包含任意数量的任何数据类型的元素，只要它们可以转换为字符串，因此!join [*a， "/"， *b， "/"， *c]就是您所期望的那样。