Comment rompre une chaîne sur plusieurs lignes?

En YAML, j'ai une chaîne très longue. Je veux garder cela dans la vue de 80 colonnes (ou plus) de mon éditeur, donc je voudrais casser la chaîne. Quelle est la syntaxe pour cela?

En d'autres termes, j'ai ceci:

Key: 'this is my very very very very very very long string'

et j'aimerais avoir ceci (ou quelque chose à cet effet):

Key: 'this is my very very very ' +
     'long string'

Je voudrais utiliser des guillemets comme ci-dessus, donc je n'ai pas besoin d'échapper quoi que ce soit dans la chaîne.

En utilisant le style plié en yaml, chaque saut de ligne est remplacé par un espace. L'indentation dans chaque ligne sera ignorée. Un saut de ligne sera inséré à la fin.

Key: >
  This is a very long sentence
  that spans several lines in the YAML
  but which will be rendered as a string
  with only a single carriage return appended to the end.

http://symfony.com/doc/current/components/yaml/yaml_format.html

Vous pouvez utiliser l'indicateur de blocage de bloc pour éliminer la coupure de ligne de fin, comme suit:

Key: >-
  This is a very long sentence
  that spans several lines in the YAML
  but which will be rendered as a string
  with NO carriage returns.

Il existe également d'autres outils de contrôle (pour contrôler l'indentation par exemple).

Voir https://yaml-multiline.info/

Il y a 5 6 NEUF (ou 63 *, selon la façon dont vous comptez) différentes façons d'écrire des chaînes multilignes en YAML.

TL; DR

• En général, vous voulez >:

  key: >
    Your long
    string here.
  

• Si vous souhaitez que les sauts de ligne soient conservés comme \ndans la chaîne (par exemple, démarque intégrée avec des paragraphes), utilisez |.

  key: |
    ### Heading
  
    * Bullet
    * Points
  

• Utilisez >-ou à la |-place si vous ne souhaitez pas ajouter de saut de ligne à la fin.

• Si vous devez fractionner des lignes au milieu des mots ou taper littéralement des sauts de ligne comme \n, utilisez plutôt des guillemets:

  key: "Antidisestab\
   lishmentarianism.\n\nGet on it."
  

• YAML est fou.

Bloquer les styles scalaires ( >, |)

Ceux-ci autorisent les caractères tels que \et "sans s'échapper, et ajoutent une nouvelle ligne ( \n) à la fin de votre chaîne.

> Le style plié supprime les sauts de ligne simples dans la chaîne (mais en ajoute un à la fin et convertit les doubles sauts de ligne en simples):

Key: >
  this is my very very very
  long string

→ this is my very very very long string\n

| Le style littéral transforme chaque nouvelle ligne de la chaîne en une nouvelle ligne littérale et en ajoute une à la fin:

Key: |
  this is my very very very 
  long string

→ this is my very very very\nlong string\n

Voici la définition officielle de la spécification YAML 1.2

Le contenu scalaire peut être écrit en notation bloc, en utilisant un style littéral (indiqué par «|») où tous les sauts de ligne sont significatifs. Alternativement, ils peuvent être écrits avec le style plié (désigné par «>») où chaque saut de ligne est plié en un espace à moins qu'il ne termine une ligne vide ou plus en retrait.

Styles de bloc avec bloc indicateur chomping ( >-, |-, >+, |+)

Vous pouvez contrôler le traitement de la nouvelle ligne finale de la chaîne et de toutes les lignes vides de fin ( \n\n) en ajoutant un caractère indicateur de hachage de bloc :

• >, |: "clip": conservez le saut de ligne, supprimez les lignes vierges de fin.
• >-, |-: "strip": supprimez le saut de ligne, supprimez les lignes vierges de fin.
• >+, |+: "garder": garder le saut de ligne, garder les lignes vides à la fin.

Styles scalaires "Flow" ( , ", ')

Ceux-ci ont un échappement limité et construisent une chaîne d'une seule ligne sans nouveaux caractères de ligne. Ils peuvent commencer sur la même ligne que la clé, ou avec des retours à la ligne supplémentaires en premier.

style simple (pas d'échappement, non#ou:combinaisons, limites sur le premier caractère):

Key: this is my very very very 
  long string

style entre guillemets (\et"doit être échappé par\, les sauts de ligne peuvent être insérés avec une\nséquencelittérale, les lignes peuvent être concaténées sans espaces avec des espaces\):

Key: "this is my very very \"very\" loooo\
  ng string.\n\nLove, YAML."

→ "this is my very very \"very\" loooong string.\n\nLove, YAML."

style guillemet simple (le littéral'doit être doublé, pas de caractères spéciaux, peut-être utile pour exprimer des chaînes commençant par des guillemets doubles):

Key: 'this is my very very "very"
  long string, isn''t it.'

→ "this is my very very \"very\" long string, isn't it."

Sommaire

Dans ce tableau, _signifie space character. \nsignifie "caractère de nouvelle ligne" ( \nen JavaScript), à l'exception de la ligne "nouvelles lignes en ligne", où il signifie littéralement une barre oblique inverse et un n).

                      >     |            "     '     >-     >+     |-     |+
-------------------------|------|-----|-----|-----|------|------|------|------  
Trailing spaces   | Kept | Kept |     |     |     | Kept | Kept | Kept | Kept
Single newline => | _    | \n   | _   | _   | _   | _    |  _   | \n   | \n
Double newline => | \n   | \n\n | \n  | \n  | \n  | \n   |  \n  | \n\n | \n\n
Final newline  => | \n   | \n   |     |     |     |      |  \n  |      | \n
Final dbl nl's => |      |      |     |     |     |      | Kept |      | Kept  
In-line newlines  | No   | No   | No  | \n  | No  | No   | No   | No   | No
Spaceless newlines| No   | No   | No  | \   | No  | No   | No   | No   | No 
Single quote      | '    | '    | '   | '   | ''  | '    | '    | '    | '
Double quote      | "    | "    | "   | \"  | "   | "    | "    | "    | "
Backslash         | \    | \    | \   | \\  | \   | \    | \    | \    | \
" #", ": "        | Ok   | Ok   | No  | Ok  | Ok  | Ok   | Ok   | Ok   | Ok
Can start on same | No   | No   | Yes | Yes | Yes | No   | No   | No   | No
line as key       |

Exemples

Notez les espaces de fin sur la ligne avant «espaces».

- >
  very "long"
  'string' with

  paragraph gap, \n and        
  spaces.
- | 
  very "long"
  'string' with

  paragraph gap, \n and        
  spaces.
- very "long"
  'string' with

  paragraph gap, \n and        
  spaces.
- "very \"long\"
  'string' with

  paragraph gap, \n and        
  s\
  p\
  a\
  c\
  e\
  s."
- 'very "long"
  ''string'' with

  paragraph gap, \n and        
  spaces.'
- >- 
  very "long"
  'string' with

  paragraph gap, \n and        
  spaces.

[
  "very \"long\" 'string' with\nparagraph gap, \\n and         spaces.\n", 
  "very \"long\"\n'string' with\n\nparagraph gap, \\n and        \nspaces.\n", 
  "very \"long\" 'string' with\nparagraph gap, \\n and spaces.", 
  "very \"long\" 'string' with\nparagraph gap, \n and spaces.", 
  "very \"long\" 'string' with\nparagraph gap, \\n and spaces.", 
  "very \"long\" 'string' with\nparagraph gap, \\n and         spaces."
]

Styles de bloc avec indicateurs d'indentation

Juste au cas où ce qui précède ne vous suffit pas, vous pouvez ajouter un " indicateur d'indentation de bloc " (après votre indicateur de blocage de bloc, si vous en avez un):

- >8
        My long string
        starts over here
- |+1
 This one
 starts here

Addenda

Si vous insérez des espaces supplémentaires au début des lignes qui ne sont pas les premières dans le style Plié, elles seront conservées, avec une nouvelle ligne bonus. Cela ne se produit pas avec les styles de flux:

- >
    my long
      string
- my long
    string

→ ["my long\n string\n", "my long string"]

Je ne peux même pas.

*2 styles de bloc, chacun avec 2 indicateurs de compression de bloc possibles (ou aucun), et avec 9 indicateurs d'indentation possibles (ou aucun), 1 style simple et 2 styles cités: 2 x (2 + 1) x (9 + 1) + 1 + 2 = 63

Certaines de ces informations ont également été résumées ici .

Pour conserver les sauts de ligne, utilisez |par exemple:

|
  This is a very long sentence
  that spans several lines in the YAML
  but which will be rendered as a string
  with newlines preserved.

est traduit par "Ceci est une très longue phrase‌ \ n qui s'étend sur plusieurs lignes dans le YAML‌ \ n mais qui sera rendue sous forme de chaîne‌ \ n avec des retours à la ligne préservés. \ n "

1. Notation de bloc (simple, de style fluide, scalaire): les nouvelles lignes deviennent des espaces et des nouvelles lignes supplémentaires après la suppression du bloc

---
# Note: It has 1 new line after the string
content:
    Arbitrary free text
    over multiple lines stopping
    after indentation changes...

...

JSON équivalent

{
 "content": "Arbitrary free text over multiple lines stopping after indentation changes..."
}

2. Scalaire bloc littéral: Un scalaire bloc littéral | comprendra les sauts de ligne et les espaces de fin. mais supprime extra

nouvelles lignes après le bloc.

---
# After string we have 2 spaces and 2 new lines
content1: |
 Arbitrary free text
 over "multiple lines" stopping
 after indentation changes...  


...

JSON équivalent

{
 "content1": "Arbitrary free text\nover \"multiple lines\" stopping\nafter indentation changes...  \n"
}

3. + indicateur avec Literal Block Scalar: gardez les nouvelles lignes supplémentaires après le bloc

---
# After string we have 2 new lines
plain: |+
 This unquoted scalar
 spans many lines.


...

JSON équivalent

{
 "plain": "This unquoted scalar\nspans many lines.\n\n\n"
}

4. - indicateur avec Literal Block Scalar: - signifie que la nouvelle ligne à la fin de la chaîne est supprimée.

---
# After string we have 2 new lines
plain: |-
 This unquoted scalar
 spans many lines.


...

JSON équivalent

{
 "plain": "This unquoted scalar\nspans many lines."
}

5. Bloc scalaire plié (>):

pliera les sauts de ligne en espaces et supprimera les sauts de ligne supplémentaires après le bloc.

---
folded_newlines: >
 this is really a
 single line of text
 despite appearances


...

JSON équivalent

{
 "fold_newlines": "this is really a single line of text despite appearances\n"
}

pour plus vous pouvez visiter mon Blog

Vous ne le croyez peut-être pas, mais YAML peut également utiliser des touches multi-lignes:

?
 >
 multi
 line
 key
:
  value

Pour concaténer de longues lignes sans espace , utilisez des guillemets doubles et échappez aux nouvelles lignes avec des barres obliques inverses:

key: "Loremipsumdolorsitamet,consecteturadipiscingelit,seddoeiusmodtemp\
  orincididuntutlaboreetdoloremagnaaliqua."

(Merci @Tobia)

Si vous utilisez YAML et Twig pour des traductions dans Symfony et que vous souhaitez utiliser des traductions multilignes en Javascript, un retour chariot est ajouté juste après la traduction. Donc, même le code suivant:

var javascriptVariable = "{{- 'key'|trans -}}";

Qui a la traduction yml suivante:

key: >
    This is a
    multi line 
    translation.

Donnera toujours le code suivant en html:

var javascriptVariable = "This is a multi line translation.
";

Ainsi, le signe moins dans Twig ne résout pas ce problème. La solution consiste à ajouter ce signe moins après le signe supérieur à en yml:

key: >-
    This is a
    multi line 
    translation.

Aura le bon résultat, la traduction multi-ligne sur une seule ligne dans Twig:

var javascriptVariable = "This is a multi line translation.";

Pour les situations où la chaîne peut contenir des espaces ou non, je préfère les guillemets doubles et la continuation de ligne avec des barres obliques inverses:

key: "String \
  with long c\
  ontent"

Mais notez l'écueil pour le cas où une ligne de continuation commence par un espace, elle doit être échappée (car elle sera supprimée ailleurs):

key: "String\
  \ with lon\
  g content"

Si la chaîne contient des sauts de ligne, cela doit être écrit dans le style C \n.

Voir aussi cette question .

Aucune des solutions ci-dessus n'a fonctionné pour moi, dans un fichier YAML dans un projet Jekyll. Après avoir essayé de nombreuses options, je me suis rendu compte qu'une injection HTML avec <br>pourrait faire aussi bien, car au final tout est rendu en HTML:

nom: | Dans un village de La Mancha <br>dont je ne <br>veux pas me souvenir du nom.

Au moins ça marche pour moi. Aucune idée sur les problèmes liés à cette approche.