Skip to content
  • About
    • What is Symfony?
    • Community
    • News
    • Contributing
    • Support
  • Documentation
    • Symfony Docs
    • Symfony Book
    • Screencasts
    • Symfony Bundles
    • Symfony Cloud
    • Training
  • Services
    • SensioLabs Professional services to help you with Symfony
    • Platform.sh for Symfony Best platform to deploy Symfony apps
    • SymfonyInsight Automatic quality checks for your apps
    • Symfony Certification Prove your knowledge and boost your career
    • Blackfire Profile and monitor performance of your apps
  • Other
  • Blog
  • Download
sponsored by SensioLabs
  1. Home
  2. Documentation
  3. Reference
  4. The YAML Format
  • Documentation
  • Book
  • Reference
  • Bundles
  • Cloud

Table of Contents

  • Scalars
    • Strings
    • Numbers
    • Nulls
    • Booleans
    • Dates
  • Collections
  • Comments
  • Explicit Typing
  • Symfony Specific Features
  • Unsupported YAML Features

The YAML Format

Edit this page

The YAML Format

The Symfony Yaml Component implements a selected subset of features defined in the YAML 1.2 version specification.

Scalars

The syntax for scalars is similar to the PHP syntax.

Strings

Strings in YAML can be wrapped both in single and double quotes. In some cases, they can also be unquoted:

1
2
3
4
5
A string in YAML

'A single-quoted string in YAML'

"A double-quoted string in YAML"

Quoted styles are useful when a string starts or end with one or more relevant spaces, because unquoted strings are trimmed on both end when parsing their contents. Quotes are required when the string contains special or reserved characters.

When using single-quoted strings, any single quote ' inside its contents must be doubled to escape it:

1
'A single quote '' inside a single-quoted string'

Strings containing any of the following characters must be quoted. Although you can use double quotes, for these characters it is more convenient to use single quotes, which avoids having to escape any backslash \:

  • :, {, }, [, ], ,, &, *, #, ?, |, -, <, >, =, !, %, @, `

The double-quoted style provides a way to express arbitrary strings, by using \ to escape characters and sequences. For instance, it is very useful when you need to embed a \n or a Unicode character in a string.

1
"A double-quoted string in YAML\n"

If the string contains any of the following control characters, it must be escaped with double quotes:

  • \0, \x01, \x02, \x03, \x04, \x05, \x06, \a, \b, \t, \n, \v, \f, \r, \x0e, \x0f, \x10, \x11, \x12, \x13, \x14, \x15, \x16, \x17, \x18, \x19, \x1a, \e, \x1c, \x1d, \x1e, \x1f, \N, \_, \L, \P

Finally, there are other cases when the strings must be quoted, no matter if you're using single or double quotes:

  • When the string is true or false (otherwise, it would be treated as a boolean value);
  • When the string is null or ~ (otherwise, it would be considered as a null value);
  • When the string looks like a number, such as integers (e.g. 2, 14, etc.), floats (e.g. 2.6, 14.9) and exponential numbers (e.g. 12e7, etc.) (otherwise, it would be treated as a numeric value);
  • When the string looks like a date (e.g. 2014-12-31) (otherwise it would be automatically converted into a Unix timestamp).

When a string contains line breaks, you can use the literal style, indicated by the pipe (|), to indicate that the string will span several lines. In literals, newlines are preserved:

1
2
3
|
  \/ /| |\/| |
  / / | |  | |__

Alternatively, strings can be written with the folded style, denoted by >, where each line break is replaced by a space:

1
2
3
4
5
6
7
8
9
10
11
12
13
>
  This is a very long sentence
  that spans several lines in the YAML.

# This will be parsed as follows: (notice the trailing \n)
# "This is a very long sentence that spans several lines in the YAML.\n"

>-
  This is a very long sentence
  that spans several lines in the YAML.

# This will be parsed as follows: (without a trailing \n)
# "This is a very long sentence that spans several lines in the YAML."

Note

Notice the two spaces before each line in the previous examples. They won't appear in the resulting PHP strings.

Numbers

1
2
# an integer
12
1
2
# an octal
0o14
1
2
# an hexadecimal
0xC
1
2
# a float
13.4
1
2
# an exponential number
1.2e+34
1
2
# infinity
.inf

Nulls

Nulls in YAML can be expressed with null or ~.

Booleans

Booleans in YAML are expressed with true and false.

Dates

YAML uses the ISO-8601 standard to express dates:

1
2001-12-14T21:59:43.10-05:00
1
2
# simple date
2002-12-14

Collections

A YAML file is rarely used to describe a simple scalar. Most of the time, it describes a collection. YAML collections can be a sequence (indexed arrays in PHP) or a mapping of elements (associative arrays in PHP).

Sequences use a dash followed by a space:

1
2
3
- PHP
- Perl
- Python

The previous YAML file is equivalent to the following PHP code:

1
['PHP', 'Perl', 'Python'];

Mappings use a colon followed by a space (: ) to mark each key/value pair:

1
2
3
PHP: 5.2
MySQL: 5.1
Apache: 2.2.20

which is equivalent to this PHP code:

1
['PHP' => 5.2, 'MySQL' => 5.1, 'Apache' => '2.2.20'];

Note

In a mapping, a key can be any valid scalar.

The number of spaces between the colon and the value does not matter:

1
2
3
PHP:    5.2
MySQL:  5.1
Apache: 2.2.20

YAML uses indentation with one or more spaces to describe nested collections:

1
2
3
4
5
6
'symfony 1.0':
  PHP:    5.0
  Propel: 1.2
'symfony 1.2':
  PHP:    5.2
  Propel: 1.3

The above YAML is equivalent to the following PHP code:

1
2
3
4
5
6
7
8
9
10
[
    'symfony 1.0' => [
        'PHP'    => 5.0,
        'Propel' => 1.2,
    ],
    'symfony 1.2' => [
        'PHP'    => 5.2,
        'Propel' => 1.3,
    ],
];

There is one important thing you need to remember when using indentation in a YAML file: Indentation must be done with one or more spaces, but never with tabulators.

You can nest sequences and mappings as you like:

1
2
3
4
5
6
'Chapter 1':
  - Introduction
  - Event Types
'Chapter 2':
  - Introduction
  - Helpers

YAML can also use flow styles for collections, using explicit indicators rather than indentation to denote scope.

A sequence can be written as a comma separated list within square brackets ([]):

1
[PHP, Perl, Python]

A mapping can be written as a comma separated list of key/values within curly braces ({}):

1
{ PHP: 5.2, MySQL: 5.1, Apache: 2.2.20 }

You can mix and match styles to achieve a better readability:

1
2
'Chapter 1': [Introduction, Event Types]
'Chapter 2': [Introduction, Helpers]
1
2
'symfony 1.0': { PHP: 5.0, Propel: 1.2 }
'symfony 1.2': { PHP: 5.2, Propel: 1.3 }

Comments

Comments can be added in YAML by prefixing them with a hash mark (#):

1
2
3
# Comment on a line
"symfony 1.0": { PHP: 5.0, Propel: 1.2 } # Comment at the end of a line
"symfony 1.2": { PHP: 5.2, Propel: 1.3 }

Note

Comments are ignored by the YAML parser and do not need to be indented according to the current level of nesting in a collection.

Explicit Typing

The YAML specification defines some tags to set the type of any data explicitly:

1
2
3
4
5
6
7
8
9
10
11
12
13
data:
    # this value is parsed as a string (it's not transformed into a DateTime)
    start_date: !!str 2002-12-14

    # this value is parsed as a float number (it will be 3.0 instead of 3)
    price: !!float 3

    # this value is parsed as binary data encoded in base64
    picture: !!binary |
        R0lGODlhDAAMAIQAAP//9/X
        17unp5WZmZgAAAOfn515eXv
        Pz7Y6OjuDg4J+fn5OTk6enp
        56enmleECcgggoBADs=

Symfony Specific Features

The Yaml component provides some additional features that are not part of the official YAML specification but are useful in Symfony applications:

  • !php/const allows to get the value of a PHP constant. This tag takes the fully-qualified class name of the constant as its argument:

    1
    2
    data:
        page_limit: !php/const App\Pagination\Paginator::PAGE_LIMIT
  • !php/object allows to pass the serialized representation of a PHP object (created with the serialize() function), which will be deserialized when parsing the YAML file:

    1
    2
    data:
        my_object: !php/object 'O:8:"stdClass":1:{s:3:"bar";i:2;}'
  • !php/enum allows to use a PHP enum case. This tag takes the fully-qualified class name of the enum case as its argument:

    1
    2
    3
    4
    5
    data:
        # You can use the typed enum case...
        operator_type: !php/enum App\Operator\Enum\Type::Or
        # ... or you can also use "->value" to directly use the value of a BackedEnum case
        operator_type: !php/enum App\Operator\Enum\Type::Or->value

6.2

The !php/enum tag was introduced in Symfony 6.2.

Unsupported YAML Features

The following YAML features are not supported by the Symfony Yaml component:

  • Multi-documents (--- and ... markers);
  • Complex mapping keys and complex values starting with ?;
  • Tagged values as keys;
  • The following tags and types: !!set, !!omap, !!pairs, !!seq, !!bool, !!int, !!merge, !!null, !!timestamp, !!value, !!yaml;
  • Tags (TAG directive; example: %TAG ! tag:example.com,2000:app/) and tag references (example: !<tag:example.com,2000:app/foo>);
  • Using sequence-like syntax for mapping elements (example: {foo, bar}; use {foo: ~, bar: ~} instead).
This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.
TOC
    Version
    We stand with Ukraine.
    Version:

    Symfony 6.2 is backed by

    Symfony 6.2 is backed by

    Save your teams and projects before they sink

    Save your teams and projects before they sink

    Check Code Performance in Dev, Test, Staging & Production

    Check Code Performance in Dev, Test, Staging & Production

    Symfony footer

    ↓ Our footer now uses the colors of the Ukrainian flag because Symfony stands with the people of Ukraine.

    Avatar of Michaël VEROUX, a Symfony contributor

    Thanks Michaël VEROUX for being a Symfony contributor

    1 commit • 2 lines changed

    View all contributors that help us make Symfony

    Become a Symfony contributor

    Be an active part of the community and contribute ideas, code and bug fixes. Both experts and newcomers are welcome.

    Learn how to contribute

    Symfony™ is a trademark of Symfony SAS. All rights reserved.

    • What is Symfony?

      • Symfony at a Glance
      • Symfony Components
      • Case Studies
      • Symfony Releases
      • Security Policy
      • Logo & Screenshots
      • Trademark & Licenses
      • symfony1 Legacy
    • Learn Symfony

      • Symfony Docs
      • Symfony Book
      • Reference
      • Bundles
      • Best Practices
      • Training
      • eLearning Platform
      • Certification
    • Screencasts

      • Learn Symfony
      • Learn PHP
      • Learn JavaScript
      • Learn Drupal
      • Learn RESTful APIs
    • Community

      • SymfonyConnect
      • Support
      • How to be Involved
      • Code of Conduct
      • Events & Meetups
      • Projects using Symfony
      • Downloads Stats
      • Contributors
      • Backers
    • Blog

      • Events & Meetups
      • A week of symfony
      • Case studies
      • Cloud
      • Community
      • Conferences
      • Diversity
      • Documentation
      • Living on the edge
      • Releases
      • Security Advisories
      • SymfonyInsight
      • Twig
      • SensioLabs
    • Services

      • SensioLabs services
      • Train developers
      • Manage your project quality
      • Improve your project performance
      • Host Symfony projects

      Deployed on

    Follow Symfony

    Search by Algolia