It’s always good to write down the basics, rehearse the syntax and go trough the motions. So let’s do that with YAML.

YAML is a data serialisation language. It’s used to store and display information. I always think of it as JSON 2.0 . You can create value pairs in YAML like:

• lists
• values
• objects

YAML files are identfied by the extenion .yml and .yaml . You can use # for comments and you want to start of with a --- on top. YAML is used by a lot of software like Ansible.

Creating object’s in YAML

Let’s start with an example or a car. We are going to create an object called myCar and fill it up with some information:

myCar:
  name: "My cool car"
  function: "driving"
  wheels: 4
  gallonPerMile: 7.6
  apk: true
  buildDate: 2019-06-04 14:33:22
  broken: null

No we created a car object myCar . All child items that are indented (meaning they are 2 spaces to the right under myCar ) are part of the myCar object. You can use a lot of different datatype in YAML. In the myCar object we are using:

• STRING —> name
• INT —> wheels
• BOOL —> APK
• DATE —> buildDate
• FLOAT —> gallonPerMile

Making a list, checking it once

Using YAML we can also use lists. Image we have 3 drivers that are registered to myCar. We can create a list of drivers using the following notations:

Driver list using indent:

drivers:
  - Bob
  - Frank
  - Margret

We can also create a list on a single line using:

drivers: ["Bob", "Frank", "Margret"]

You can even go one step further and an object in to a list using:

drivers:
  - name: "Bob"
    age: 23
    canDrive: true
  - name: "Frank"
    age: 41
    canDrive: false
  - name: "Margret"
    age: 33
    canDrive: true

This can also be done using inline style:

drivers:
  - {name: "Bob", age: 23, canDrive: true}

Text rendering

YAML has been built to be readable and to take up a small space on you screen. This is primarily done so you can have multiple files open next to each-other (especially handy when using git and comparing different versions). To this extend there are few cool functions build in to YAML, like:

Rendering text to a single line

Example. What if one of our drivers has a complicated backstory. One of lipsum’s and lorems. In YAML you can break up this blok to make it more readable for you (human):

- name: "Margret"
    age: 33
    canDrive: true
    backStory:
      Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed 
      do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
      Ut enim ad minim veniam, quis nostrud exercitation ullamco 
      laboris nisi ut aliquip ex ea commodo consequat. Duis aute 
      irure dolor in reprehenderit in voluptate velit esse cillum 
      dolore eu fugiat nulla pariatur.

Now, for some reason you want to render this textblok to be displayed on one line? No problem, ad a > after backStory . Example:

- name: "Margret"
    age: 33
    canDrive: true
    backStory: >
      Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed 
      do eiusmod tempor incididunt ut labore et dolore magna aliqua.

Now, on rendering, this will be displayed as one long line.

Rendering text while preserving formatting

Almost the opposite of the single line option, using | after backStory will render the text including all formatting (newlines and tabs included). Example:

- name: "Margret"
    age: 33
    canDrive: true
    backStory: |
      Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed 
      do eiusmod tempor incididunt
            ut labore et 
                dolore magna 
                            aliqua. 

Will print out the example above with all the crazy spacing

Anchors

You can use anchors & to recall information later. For example, we started giving Margret the age of 33. Maybe we want to reuse that information later. We can do so by using an anchor like:

- name: "Margret"
    age: &age 33
    canDrive: true

Now we are going to calculate how long she had her driving licence. We going to add the age she got it and then calculate it:

- name: "Margret"
    age: &age 33
    obtainedLicenceAt: &gotLicenceAt 19
    allowedToDriveSinceYears: *age - *gotLicenceAt
    canDrive: true

You can also anchor an entire object. So, if you have a car and want 2 cars of a different make you can do:

baseCar: &base
  wheels: 4
  needsDriver: true

hondaCar:
  <<: *base
  manufacturer: "Honda"

teslaCar:
  <<: *base
  manufacturer: "Tesla"
  type: "⚡️"

This creates a base car with a few values. Then we use <<: *base to anchor it back to baseCar. You can also add extra values after that.

Converting datatypes

YAML will do it’s best to identify datatypes based on your input. If your don’t want it to to that you can force a date type like:

myCar:
  wheels: !!float 4
  gallonPerMile: !!str 7.6

Using these additions will force the wheels to be seen as a float (as 4.0) and the gallonPerMile to be seen as a string. More conversion options over at: https://github.com/yaml/YAML2/wiki/Type-casting