YAML-strings over meerdere lijnen breken

1. Overzicht

In dit artikel zullen we leren over het breken van YAML-strings over meerdere regels.

Om onze YAML-bestanden te ontleden en te testen, zullen we gebruik maken van de SnakeYAML-bibliotheek.

2. Meerlijnige snaren

Laten we, voordat we beginnen, een methode maken om eenvoudig een YAML-sleutel uit een bestand in een Draad:

String parseYamlKey (String bestandsnaam, String-sleutel) {InputStream inputStream = this.getClass () .getClassLoader () .getResourceAsStream (bestandsnaam); Kaart ontleed = yaml.load (inputStream); return parsed.get (sleutel); }

In de volgende paragrafen zullen we enkele strategieën bekijken om strings over meerdere regels te splitsen.

We zullen ook leren hoe YAML omgaat met voorloop- en eindregeleindes die worden weergegeven door lege regels aan het begin en einde van een blok.

3. Letterlijke stijl

De letterlijke operator wordt weergegeven door het pijpsymbool ("|"). Het behoudt onze regeleinden, maar reduceert lege regels aan het einde van de string tot een enkele regeleinde.

Laten we het YAML-bestand eens bekijken literal.yaml:

sleutel: | Lijn1 Lijn2 Lijn3

We kunnen zien dat onze regeleinden behouden blijven:

String key = parseYamlKey ("literal.yaml", "key"); assertEquals ("Line1 \ nLine2 \ nLine3", key);

Laten we vervolgens eens kijken naar literal2.yaml, welke heeft enkele voorloop- en eindregeleindes:

sleutel: | Lijn1 Lijn2 Lijn3 ...

We kunnen zien dat elke regeleinde aanwezig is, behalve de laatste regeleinden, die worden teruggebracht tot één:

String key = parseYamlKey ("literal2.yaml", "key"); assertEquals ("\ n \ nLine1 \ n \ nLine2 \ n \ nLine3 \ n", sleutel);

Vervolgens zullen we het hebben over block chomping en hoe het ons meer controle geeft over het starten en beëindigen van regeleinden.

We kunnen het standaardgedrag wijzigen door twee kauwmethoden: houden en strippen.

3.1. Houden

Keep wordt weergegeven door "+" zoals we kunnen zien in literal_keep.yaml:

toets: | + Lijn1 Lijn2 Lijn3 ...

Door het standaardgedrag te overschrijven, kunnen we dat zien elke lege eindregel blijft behouden:

String key = parseYamlKey ("literal_keep.yaml", "key"); assertEquals ("Line1 \ nLine2 \ nLine3 \ n \ n", key);

3.2. Strip

De strip wordt weergegeven door "-" zoals we kunnen zien in literal_strip.yaml:

toets: | - Lijn1 Lijn2 Lijn3 ...

Zoals we misschien hadden verwacht, resulteert dit in het verwijderen van elke lege eindregel:

String key = parseYamlKey ("literal_strip.yaml", "key"); assertEquals ("Line1 \ nLine2 \ nLine3", key);

4. Gevouwen stijl

De gevouwen operator wordt weergegeven door ">" zoals we kunnen zien in gevouwen.yaml:

toets:> Lijn1 Lijn2 Lijn3

Regeleindes worden standaard vervangen door spaties voor opeenvolgende niet-lege regels:

String key = parseYamlKey ("fold.yaml", "key"); assertEquals ("Line1 Line2 Line3", key);

Laten we naar een soortgelijk bestand kijken, gevouwen2.yaml, die een paar lege eindregels heeft:

toets:> Lijn1 Lijn2 Lijn3 ...

Dat kunnen we zien lege regels blijven behouden, maar eindregeleindes worden ook teruggebracht tot één:

String key = parseYamlKey ("fold2.yaml", "key"); assertEquals ("Line1 Line2 \ n \ nLine3 \ n", key);

Daar moeten we rekening mee houden blok kauwen beïnvloedt de vouwstijl op dezelfde manier als de letterlijke stijl.

5. Citeren

Laten we eens kijken naar het splitsen van strings met behulp van dubbele en enkele aanhalingstekens.

5.1. Dubbele aanhalingstekens

Met dubbele aanhalingstekens kunnen we eenvoudig tekenreeksen met meerdere regels maken door '\ n“:

key: "Line1 \ nLine2 \ nLine3"
String key = parseYamlKey ("plain_double_quotes.yaml", "key"); assertEquals ("Line1 \ nLine2 \ nLine3", key);

5.2. Enkele aanhalingstekens

Aan de andere kant behandelt een enkel aanhalingsteken "\ n”Als onderdeel van de string, dus de enige manier om een ​​regeleinde in te voegen is door een lege regel te gebruiken:

key: 'Line1 \ nLine2 Line3'
String key = parseYamlKey ("plain_single_quotes.yaml", "key"); assertEquals ("Line1 \ nLine2 \ nLine3", key);

6. Conclusie

In deze korte tutorial hebben we verschillende manieren bekeken om YAML-strings over meerdere regels te breken door middel van snelle en praktische voorbeelden.

Zoals altijd is de code beschikbaar op GitHub.