¿Cómo rompo una cuerda en varias líneas?

En YAML, tengo una cadena que es muy larga. Quiero mantener esto dentro de la vista de 80 columnas (más o menos) de mi editor, así que me gustaría romper la cadena. ¿Cuál es la sintaxis de esto?

En otras palabras, tengo esto:

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

y me gustaría tener esto (o algo por el estilo):

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

Me gustaría usar comillas como se indicó anteriormente, por lo que no necesito escapar nada dentro de la cadena.

Usando estilo plegado yaml. Se ignorará la sangría en cada línea. Se insertará un salto de línea al final.

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

Puede utilizar el "indicador de mordida de bloque" para eliminar el salto de línea final, de la siguiente manera:

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.

En cualquier caso, cada salto de línea se reemplaza por un espacio.

También hay otras herramientas de control disponibles (para controlar la sangría, por ejemplo).

Ver https://yaml-multiline.info/

Hay 5 6 NUEVE (o 63 *, dependiendo de cómo se cuente) diferentes formas de escribir cadenas de varias líneas en YAML.

TL; DR

• Utilice la >mayor parte del tiempo: los saltos de línea interiores se eliminan, aunque obtiene uno al final:

  key: >
    Your long
    string here.
  

• Úselo |si desea que esos saltos de línea se conserven como \n(por ejemplo, rebajas incrustadas con párrafos).

  key: |
    ### Heading
  
    * Bullet
    * Points
  

• Utilice >-o |-en su lugar si no desea que se agregue un salto de línea al final.

• Úselo "..."si necesita dividir líneas en medio de palabras o si desea escribir literalmente saltos de línea como \n:

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

• YAML está loco.

Bloquear estilos escalares ( >, |)

Estos permiten caracteres como \y "sin escapar, y agregan una nueva línea ( \n) al final de su cadena.

> El estilo plegado elimina líneas nuevas individuales dentro de la cadena (pero agrega una al final y convierte líneas nuevas dobles en líneas simples):

Key: >
  this is my very very very
  long string

→ this is my very very very long string\n

| El estilo literal convierte cada nueva línea dentro de la cadena en una nueva línea literal y agrega una al final:

Key: |
  this is my very very very 
  long string

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

Aquí está la definición oficial de YAML Spec 1.2

El contenido escalar se puede escribir en notación de bloque, usando un estilo literal (indicado por “|”) donde todos los saltos de línea son significativos. Alternativamente, se pueden escribir con el estilo plegado (indicado por “>”) donde cada salto de línea se dobla en un espacio a menos que termine en una línea vacía o con más sangría.

Estilos de molde con el indicador masticando bloque ( >-, |-, >+, |+)

Puede controlar el manejo de la última línea nueva en la cadena y cualquier línea en blanco final ( \n\n) agregando un carácter indicador de mordida de bloque :

• >, |: "clip": mantiene el avance de línea, elimina las líneas en blanco finales.
• >-, |-: "strip": elimina el salto de línea, elimina las líneas en blanco finales.
• >+, |+: "mantener": mantener el avance de línea, seguir trazando líneas en blanco.

"Flujo" estilos escalares ( , ", ')

Estos tienen un escape limitado y construyen una cadena de una sola línea sin caracteres de nueva línea. Pueden comenzar en la misma línea que la clave o con nuevas líneas adicionales primero.

estilo sencillo (sin escapar, sin#o:combinaciones, los límites en primer carácter):

Key: this is my very very very 
  long string

estilo entre comillas dobles (\y"debe ser escapado\, se pueden insertar nuevas\nlíneascon unasecuencialiteral, las líneas se pueden concatenar sin espacios con trailing\):

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

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

estilo de comillas simples (el literal'debe estar duplicado, sin caracteres especiales, posiblemente útil para expresar cadenas que comienzan con comillas dobles):

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

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

Resumen

En esta tabla, _significa space character. \nsignifica "carácter de nueva línea" ( \nen JavaScript), excepto por la fila de "líneas nuevas en línea", donde significa literalmente una barra invertida y una 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       |

Ejemplos de

Tenga en cuenta los espacios finales en la línea antes de "espacios".

- >
  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."
]

Estilos de bloque con indicadores de sangría

En caso de que lo anterior no sea suficiente para usted, puede agregar un " indicador de sangría de bloque " (después de su indicador de mordida de bloque, si tiene uno):

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

Apéndice

Si inserta espacios adicionales al comienzo de las líneas que no son las primeras en el estilo Plegado, se mantendrán con una nueva línea adicional. Esto no sucede con los estilos de flujo:

- >
    my long
      string
- my long
    string

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

Ni siquiera puedo.

*2 estilos de bloque, cada uno con 2 posibles indicadores de mordida de bloque (o ninguno), y con 9 posibles indicadores de sangría (o ninguno), 1 estilo simple y 2 estilos entre comillas: 2 x (2 + 1) x (9 + 1) + 1 + 2 = 63

Parte de esta información también se ha resumido aquí .

Para preservar el uso de nuevas líneas| , por ejemplo:

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

se traduce a "Esta es una oración muy larga‌ \ n que abarca varias líneas en el YAML‌ \ n pero que se representará como una cadena‌ \ n con nuevas líneas conservadas. \ n "

1. Notación de bloque (simple, de estilo de flujo, escalar): las líneas nuevas se convierten en espacios y líneas nuevas adicionales después de eliminar el bloque

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

...

JSON equivalente

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

2. Escalar de bloque literal: un escalar de bloque literal | incluirá las nuevas líneas y los espacios finales. pero quita extra

nuevas líneas después del bloque.

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


...

JSON equivalente

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

3. + indicador con escalar de bloque literal: mantenga nuevas líneas extra después del bloque

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


...

JSON equivalente

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

4. - indicador con escalar de bloque literal: - significa que se elimina la nueva línea al final de la cadena.

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


...

JSON equivalente

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

5. Escalar de bloque plegado (>):

plegará nuevas líneas a espacios y, pero eliminará nuevas líneas adicionales después del bloque.

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


...

JSON equivalente

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

para más puedes visitar mi Blog

Para concatenar líneas largas sin espacios en blanco , use comillas dobles y escape las líneas nuevas con barras invertidas:

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

(Gracias @Tobia)

Puede que no lo crea, pero YAML también puede hacer claves de varias líneas:

?
 >
 multi
 line
 key
:
  value

En caso de que esté usando YAML y Twig para traducciones en Symfony, y quiera usar traducciones de varias líneas en Javascript, se agrega un retorno de carro justo después de la traducción. Así que incluso el siguiente código:

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

Que tiene la siguiente traducción yml:

key: >
    This is a
    multi line 
    translation.

Aún resultará en el siguiente código en html:

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

Entonces, el signo menos en Twig no resuelve esto. La solución es agregar este signo menos después del signo mayor que en yml:

key: >-
    This is a
    multi line 
    translation.

Tendrá el resultado correcto, traducción de varias líneas en una línea en Twig:

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

Para situaciones en las que la cadena puede contener espacios o no, prefiero comillas dobles y continuación de línea con barras invertidas:

key: "String \
  with long c\
  ontent"

Pero tenga en cuenta el peligro en el caso de que una línea de continuación comience con un espacio, debe escaparse (porque se eliminará en otro lugar):

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

Si la cadena contiene saltos de línea, esto tiene que ser escrita en el estilo C \n.

Vea también esta pregunta .