Pregunta En YAML, ¿cómo rompo una cuerda en múltiples 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 para 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 las anteriores, así que no necesito escapar de nada dentro de la cadena.


934
2017-09-24 19:47


origen


Respuestas:


Usando el estilo doblado de yaml, cada salto de línea es reemplazado por un espacio. La sangría en cada línea será ignorada.

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

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


535
2017-09-24 19:54



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

Bloquear estilos escalares (>, |)

Estos permiten caracteres como \ y " sin escaparse, y agrega una nueva línea (\n) hasta el final de su cadena.

>  Estilo doblado elimina las nuevas líneas sueltas dentro de la cadena (pero agrega una al final y convierte las líneas dobles dobles en singles):

Key: >
  this is my very very very
  long string

this is my very very very long string\n

|  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 la 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 pliega a un espacio a menos que termine una línea vacía o una línea más mellada.

Estilos de bloque con indicador de bloqueo de bloque (>-, |-, >+, |+)

Puede controlar el manejo de la nueva línea final en la cadena y cualquier línea en blanco al final (\n\n) agregando un indicador de mordida de bloque personaje:

  • >, |: "clip": mantener la línea de alimentación, eliminar las líneas en blanco al final.
  • >-, |-: "strip": elimina la alimentación de línea, elimina las líneas blancas finales.
  • >+, |+: "mantener": mantener la línea de alimentación, seguir las líneas en blanco.

Estilos escalares de "flujo" (, ", ')

Éstos tienen escapes limitados y construyen una cadena de una sola línea sin nuevos caracteres de línea. Pueden comenzar en la misma línea que la tecla, o con nuevas líneas adicionales primero.

estilo simple (sin escaparse, sin # o : combinaciones, límites en el primer carácter):

Key: this is my very very very 
  long string

estilo de doble cita (\ y " debe ser escapado por \, las líneas nuevas se pueden insertar con un literal \n secuencia, 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 una sola cita (literal ' debe doblarse, sin caracteres especiales, posiblemente útil para expresar cadenas comenzando 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, _ medio space character. \n significa "personaje de nueva línea" (\n en JavaScript), a excepción de la fila "nuevas líneas en línea", donde significa literalmente una barra diagonal inversa 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

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 ti, puedes agregar un "indicador de indentación de bloque"(después del indicador de bloqueo de mordida, 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 sean las primeras en estilo Plegado, se mantendrán, con una nueva línea de bonificación. Esto no sucede con los estilos de flujo:

- >
    my long
      string
- my long
    string

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

No puedo ni siquiera

*2 estilos de bloque, cada uno con 2 posibles indicadores de mordida de bloque (o ninguno), y con 9 posibles indicadores de sangrado (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í.


2230
2018-02-11 10:27



Para preservar nuevas líneas utilizar |, 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\norte que abarca varias líneas en el YAML\norte pero que se representará como una cadena\norte con nuevas líneas preservadas ".


149
2018-03-12 15:28



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

?
 >
 multi
 line
 key
:
  value

34
2017-10-24 21:17



1. Notación de bloque:  Las líneas nuevas se convierten en espacios y nuevas líneas 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. Literal Block Scalar:  un Literal Block Scalar | incluirá las líneas nuevas y cualquier espacio posterior. pero elimina 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 Literal Block Scalar: mantener nuevas líneas extras 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 Literal Block Scalar: - 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 el bloque plegado (>):

doblará líneas nuevas a espacios y 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


30
2018-04-06 05:08



Concatenar largas colas sin espacio en blanco, usa comillas dobles y escapa de las nuevas líneas con barras diagonales inversas:

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

(Gracias @Tobia)


22
2018-04-11 19:39



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

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

Que tiene la siguiente traducción yml:

key: >
    This is a
    multi line 
    translation.

Todavía 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, la traducción de múltiples líneas en una línea en Twig:

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

15
2018-05-06 15:02



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

key: "String \
  with long c\
  ontent"

Pero tenga en cuenta la trampa para el caso de que una línea de continuación comience con un espacio, necesita ser escapada (porque será eliminada en otro lugar):

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

Si la cadena contiene saltos de línea, esto debe escribirse en estilo C \n.

Ver también esta pregunta.


5
2017-09-06 08:13