大胆的占位符如何工作？

Question

​I have joined a project which uses Swagger. I see they have​​ used this kind of placeholders in the Swagger.yaml :

  MYKey: &CONST_MY_KEY ""

How does this work and where do I define CONST_MY_KEY ?

Answer 1

This is a YAML construct known as an anchor and is not specific to swagger.

The code you wrote actually defines the anchor CONST_MY_KEY as an empty string. The & -prefix indicates that you are defining it. If you wanted to reuse this anchor later in the document you would reference it using a * -prefix instead like *CONST_MY_KEY .

Below is an explanatory excerpt from https://learnxinyminutes.com/docs/yaml/ :

# YAML also has a handy feature called 'anchors', which let you easily duplicate
# content across your document. Both of these keys will have the same value:
anchored_content: &anchor_name This string will appear as the value of two keys.
other_anchor: *anchor_name

# Anchors can be used to duplicate/inherit properties
base: &base
    name: Everyone has same name

foo: &foo
  <<: *base
  age: 10

bar: &bar
  <<: *base
  age: 20

Answer 2

You don't define CONST_MY_KEY anywhere, the & introduces this as an anchor for the object "" . You can reuse this in a later stage of a YAML file by using * to specify an alias: *CONST_MY_KEY .

The primary reason for anchors and aliases is not to duplicate content as @smartcaveman's answer indicates. It is to represent a node in multiple locations in the representation graph .

Without this feature even the following simple Python construct could not be dumped:

data = dict(a=1)
data['b'] = data

if you dump the above:

import sys
import ruamel.yaml

ruamel.yaml.round_trip_dump(data, sys.stdout)

you'll get:

&id001
a: 1
b: *id001

Depending on the language you use and its YAML parser, using an anchor on a scalar, might only be useful for not having to repeat the value later on, without the advantage you get with collections (mappings, sequences) that they actually refer to the same object. Again in Python, the loading of scalars by the more popular parsers is done in separate entities:

import ruamel.yaml

yaml_str = """\
a: &CONST_MY_KEY ""
b: *CONST_MY_KEY
"""

data = ruamel.yaml.round_trip_load(yaml_str)
print('a {a!r}'.format(**data))
print('b {b!r}'.format(**data))
data['a'] = 'hello'
print('a {a!r}'.format(**data))
print('b {b!r}'.format(**data))

gives you:

a ''
b ''
a 'hello'
b ''

Note that the value of data['b'] doesn't change because (in most parsers) scalars are not constructed as referenced objects.

If you do that with the original example:

import ruamel.yaml

yaml_str = """\
&id001
b: *id001
a: 1
"""

data = ruamel.yaml.round_trip_load(yaml_str)
print('a {a!r}'.format(**data))
data['b']['a'] = 2
print('a {a!r}'.format(**data))

Because data['a'] and data['b']['a'] actually are the same object, and changing one changes the other.

The usage of <<: *name is a non-standard YAML extension. It expects &name to be an anchor on a mapping, for which the key-value pairs are added to the mapping the alias is used upon.