Aquí el documento

En informática , un documento here ( here-document , here-text , heredoc , hereis , here-string o here-script ) es un literal de archivo o un literal de flujo de entrada : es una sección de un archivo de código fuente que se trata como si fuera un archivo separado . El término también se utiliza para una forma de literales de cadena de varias líneas que utilizan una sintaxis similar, conservando los saltos de línea y otros espacios en blanco (incluida la sangría) en el texto.

Aquí los documentos se originan en el shell de Unix , ^[1] y se encuentran en el shell Bourne desde 1979, y la mayoría de los shells posteriores. Aquí los literales de cadena de estilo de documento se encuentran en varios lenguajes de alto nivel , en particular el lenguaje de programación Perl (sintaxis inspirada en el shell de Unix) y lenguajes influenciados por Perl, como PHP y Ruby . JavaScript también admite esta funcionalidad a través de literales de plantilla , una característica agregada en su sexta revisión ( ES6 ). Otros lenguajes de alto nivel como Python , Julia y Tcl tienen otras facilidades para cadenas multilínea.

Aquí los documentos pueden tratarse como archivos o cadenas. Algunos shells los tratan como un literal de cadena de formato, lo que permite la sustitución de variables y de comandos dentro del literal.

La sintaxis más común para los documentos here, que se originan en los shells de Unix, es <<la de ir seguida de un identificador delimitador (a menudo la palabra o ^[2] ), seguido, a partir de la línea siguiente, por el texto que se va a citar y, a continuación, cerrado por el mismo identificador delimitador en su propia línea. Esta sintaxis se debe a que los documentos here son formalmente literales de flujo y el contenido del documento here suele redirigirse a la entrada estándar ( stdin ) del comando anterior o del script/ejecutable de shell actual. EOFEND

La sintaxis del documento aquí es análoga a la sintaxis del shell para la redirección de entrada , <a la que sigue el nombre del archivo que se utilizará como entrada.

Otros lenguajes suelen utilizar una sintaxis sustancialmente similar, pero los detalles de la sintaxis y la funcionalidad real pueden variar significativamente. Cuando se utiliza simplemente para literales de cadena, <<no indica indirección, sino que es simplemente una convención delimitadora inicial. En algunos lenguajes, como Ruby, <<también se utiliza para la redirección de entrada, por lo que <<se utiliza dos veces si se desea redirigir desde un literal de cadena de documento here.

En términos estrictos, los documentos son literales de archivo o literales de flujo. Estos se originan en el shell de Unix, aunque existen funciones similares en otros lenguajes.

Los documentos aquí están disponibles en muchos shells de Unix. ^[1] En el siguiente ejemplo, se pasa texto al trcomando (transliterando de minúsculas a mayúsculas) utilizando un documento aquí. Este podría estar en un archivo de shell o ingresarse de manera interactiva en un indicador.

$ LANG = C tr a-z A-Z << FIN > uno dos tres > cuatro cinco seis > FIN
UNO DOS TRES       CUATRO  CINCO  SEIS

En este caso ENDse utilizó como identificador delimitador. Especificó el inicio y el final del documento aquí. La redirección y el identificador delimitador no necesitan estar separados por un espacio: <<ENDo << ENDambos funcionan igualmente bien.

De forma predeterminada, el comportamiento es en gran medida idéntico al contenido de las comillas dobles: los nombres de las variables se reemplazan por sus valores, los comandos dentro de las comillas invertidas se evalúan, etc. ^[a]

$  cat << EOF > \$ Directorio de trabajo "$PWD" `pwd` > EOF
$ Directorio de trabajo "/home/user" /home/user     

Esto se puede desactivar entrecomillando cualquier parte de la etiqueta, que luego termina con el valor no entrecomillado; ^[b] el comportamiento es esencialmente idéntico al que se obtendría si el contenido estuviera entre comillas simples. Por ejemplo, si se coloca entre comillas simples:

$ cat  << 'EOF' > \$ Directorio de trabajo "$PWD" `pwd` > EOF \$ Directorio de trabajo "$PWD" `pwd` 

También se pueden usar comillas dobles, pero esto puede dar lugar a confusión, porque la expansión ocurre en una cadena entre comillas dobles, pero no ocurre en un documento aquí con delimitador entre comillas dobles. ^[4] Los delimitadores entre comillas simples y dobles se distinguen en algunos otros lenguajes, especialmente Perl (ver más abajo), donde el comportamiento es paralelo al de las comillas de cadena correspondientes.

En el shell POSIX, pero no en csh/tcsh, agregar un signo menos al <<(ie <<-) tiene el efecto de que se ignoran las tabulaciones iniciales. ^[5] Esto permite sangrar aquí los documentos en scripts de shell (principalmente para alinearlos con la sangría existente) sin cambiar su valor: ^[c]

Un guión que contiene:

LANG = C  tr  a-z  A-Z <<- END_TEXT Aquí doc con <<- Un solo carácter de espacio (es decir, 0x20) está al comienzo de esta línea. Esta línea comienza con un solo carácter de TAB, es decir, 0x09, al igual que la siguiente línea END_TEXT echo  El final  previsto estaba antes de esta línea echo y estos no fueron procesados ​​por tr echo +++++++++++++++              LANG = C  tr  a-z  A-Z << END_TEXT Aquí doc con << Un solo carácter de espacio (es decir, 0x20) está al comienzo de esta línea. Esta línea comienza con un solo carácter de TAB, es decir, 0x09, al igual que la siguiente línea. END_TEXT echo  El final  previsto estaba antes de esta línea, echo pero debido a que la línea con el Identificador delimitador comenzaba con una TABULACIÓN, NO fue reconocida y echo el comando tr continuó procesándose .                            

produce:

AQUÍ DOC CON <<- UN SOLO CARÁCTER DE ESPACIO (IE 0X20) ESTÁ AL COMIENZO DE ESTA LÍNEA ESTA LÍNEA COMIENZA CON UN SOLO CARÁCTER DE TABULADURAS IE 0X09 AL IGUAL QUE LA SIGUIENTE LÍNEA El final previsto estaba antes de esta línea y estos no fueron procesados ​​​​por tr +++++++++++++++ AQUÍ DOC CON << UN SOLO CARÁCTER DE ESPACIO (IE 0X20) ESTÁ AL COMIENZO DE ESTA LÍNEA ESTA LÍNEA COMIENZA CON UN SOLO CARÁCTER DE TABULADURAS IE 0X09 AL IGUAL QUE LA SIGUIENTE LÍNEA END_TEXTECHO EL FINAL PREVISTO ESTABA ANTES DE ESTA LÍNEA, ECHO PERO DEBIDO A QUE LA LÍNEA CON EL IDENTIFICADOR DELIMITADOR COMENZABA CON UNA TABLACIÓN, NO SE RECONOCIÓ Y ECHO EL COMANDO TR SIGUIÓ PROCESÁNDOSE.

Otro uso es exportar a un archivo:

$ cat  <<  EOF  >  ~/testFile001 > 3 espacios preceden a este texto. > Un solo carácter de tabulación está al principio de esta línea. > Nada precede a este texto EOF

Una cadena here (disponible en bash , ksh o zsh ) es sintácticamente similar, consiste en <<<y efectúa la redirección de entrada desde una palabra (una secuencia tratada como una unidad por el shell, en este contexto generalmente un literal de cadena). En este caso se utiliza la sintaxis habitual del shell para la palabra (“sintaxis de cadena here”), siendo la única sintaxis la redirección: una cadena here es una cadena ordinaria utilizada para la redirección de entrada, no un tipo especial de cadena.

No es necesario citar una sola palabra:

$ LANG = C  tr  a-z  A-Z <<< uno UNO  

En el caso de una cadena con espacios, se debe entrecomillar:

$ LANG = C  tr  a-z  A-Z <<< 'uno dos tres' UNO DOS TRES  

Esto también podría escribirse como:

$ foo = 'uno dos tres' $ LANG = C  tr  a-z  A-Z <<< " $foo " UNO DOS TRES  

Se aceptan cadenas multilínea, lo que produce:

$ LANG = C  tr  a-z  A-Z <<< ' uno > dos tres' UNO DOS TRES  

Tenga en cuenta que las nuevas líneas iniciales y finales, si están presentes, se incluyen:

$ LANG = C  tr  a-z  A-Z <<< ' > uno > dos tres > '  UNO, DOS, TRES$

La diferencia clave con los documentos here es que, en estos, los delimitadores están en líneas separadas; las líneas nuevas iniciales y finales se eliminan. A diferencia de los documentos here, las cadenas here no utilizan delimitadores.

Aquí las cadenas son particularmente útiles para comandos que a menudo requieren entradas cortas, como la calculadora bc:

$ bc <<< 2 ^10 1024  

Tenga en cuenta que aquí el comportamiento de la cadena también se puede lograr (invirtiendo el orden) a través de la canalización y el echocomando, como en:

$ echo 'uno dos tres' | LANG = C tr a-z A-Z UNO DOS TRES      

Sin embargo, aquí las cadenas son particularmente útiles cuando el último comando necesita ejecutarse en el proceso actual, como es el caso con el readcomando incorporado:

$ echo 'uno dos tres' | leer -r a b c $ echo " $a $b $c "          

no produce nada, mientras

$ read  -r  a  b  c <<< 'uno dos tres' $ echo " $a $b $c " uno dos tres     

Esto sucede porque en el ejemplo anterior la canalización hace readque se ejecute en un subproceso y, como tal, no puede afectar el entorno del proceso principal.

En Microsoft NMAKE , los documentos se denominan archivos en línea . Los archivos en línea se denominan <<o <<pathname: la primera notación crea un archivo temporal, la segunda notación crea (o sobrescribe) el archivo con la ruta de acceso especificada. Un archivo en línea termina con en una línea por sí mismo, opcionalmente seguido por la palabra clave o <<(sin distinción entre mayúsculas y minúsculas) para indicar si se debe conservar el archivo creado.KEEPNOKEEP

target0 : dependiente 0 command0 << archivo temporal en línea ... <<     target1 : dependiente 1 command1 << temporal, pero conservado archivo en línea ... <<KEEP target2 : dependiente 2 command2 <<filename2 nombrado, pero descartado archivo en línea ... <<NOKEEP target3 : dependiente 3 command3 <<filename3 nombrado archivo en línea ... <<KEEP                   

R no tiene literales de archivo, pero proporciona una funcionalidad equivalente combinando literales de cadena con una función de conversión de cadena a archivo. R permite espacios en blanco arbitrarios, incluidas las nuevas líneas, en las cadenas. Una cadena puede convertirse en un descriptor de archivo mediante la textConnection()función. Por ejemplo, lo siguiente convierte una tabla de datos incrustada en el código fuente en una variable de marco de datos:

str <- "Estado Población Ingresos Analfabetismo Vida.Exp Asesinato Graduado.secundario Frost Alabama 3615 3624 2.1 69.05 15.1 41.3 20 Alaska 365 6315 1.5 69.31 11.3 66.7 152 Arizona 2212 4530 1.8 70.55 7.8 58.1 15 Arkansas 2110 3378 1.9 70.66 10.1 39.9 65" x <- read.table ( textConnection ( str ), header = TRUE , row.names = 1 )     

Perl ^[6] y Ruby ^[7] tienen una forma de literal de archivo, que puede considerarse una forma de segmento de datos . En estos lenguajes, la línea __DATA__(Perl) o __END__(Ruby, antiguo Perl) marca el final del segmento de código y el inicio del segmento de datos. Solo se ejecuta el contenido anterior a esta línea, y el contenido del archivo fuente después de esta línea está disponible como un objeto de archivo: PACKAGE::DATAen Perl (por ejemplo, main::DATA) y DATAen Ruby. Como archivo en línea, estos son semánticamente similares a los documentos here, aunque solo puede haber uno por script. Sin embargo, en estos lenguajes el término "documento here" se refiere en cambio a literales de cadena de varias líneas, como se analiza a continuación.

Como se explica con más detalle en Esquema de URI de datos , todos los navegadores web principales entienden los URI que comienzan con datos: como aquí document.

El término "documento aquí" o "cadena aquí" también se utiliza para literales de cadena de varias líneas en varios lenguajes de programación, en particular Perl (sintaxis influenciada por el shell de Unix) y lenguajes influenciados por Perl, en particular PHP y Ruby. La sintaxis de estilo shell <<se suele conservar, a pesar de no utilizarse para la redirección de entrada.

En Perl hay varias formas diferentes de invocar here docs. ^[8] Los delimitadores alrededor de la etiqueta tienen el mismo efecto dentro del here doc que tendrían en un literal de cadena regular: por ejemplo, usar comillas dobles alrededor de la etiqueta permite que las variables se interpolen , pero usar comillas simples no, y usar la etiqueta sin ninguna de ellas se comporta como comillas dobles. Usar comillas invertidas como delimitadores alrededor de la etiqueta ejecuta el contenido del heredoc como un script de shell. Es necesario asegurarse de que la etiqueta de finalización esté al principio de la línea o el intérprete no reconocerá la etiqueta.

Tenga en cuenta que el documento aquí no comienza en la etiqueta, sino en la línea siguiente. Por lo tanto, la declaración que contiene la etiqueta continúa después de la etiqueta.

He aquí un ejemplo con comillas dobles:

mi $remitente = "Buffy la cazavampiros" ; mi $destinatario = "Spike" ;      imprimir <<" FIN "; Estimado destinatario:Deseo que te vayas de Sunnydale y nunca regreses.No es exactamente amor, $senderFIN

Producción:

Querido Spike,Deseo que te vayas de Sunnydale y nunca regreses.No es exactamente amor, Buffy la cazavampiros

A continuación se muestra un ejemplo con comillas simples:

imprimir <<' FIN '; Estimado $destinatario, Deseo que te vayas de Sunnydale y nunca regreses.No es exactamente amor, $sender FIN

Producción:

Estimado destinatario:Deseo que te vayas de Sunnydale y nunca regreses.No es exactamente amor, $sender

Y un ejemplo con comillas invertidas (puede que no sea portable):

mi $shell_script_stdout = << `FIN` ; echo foo echo bar FIN     

Es posible iniciar varios heredocs en la misma línea:

decir ( << BEGIN . "este es el medio\n" . << END ); Este es el comienzo: BEGIN ¡ Y ahora se acabó ! END           # esto es equivalente a: decir ( "Este es el comienzo:\neste es el medio\n¡Y ahora se acabó!\n" );

La etiqueta en sí puede contener espacios en blanco, lo que puede permitir que se utilicen heredocs sin romper la sangría .

 decir << ' FIN' ; Hola Mundo FIN   

Aunque desde la versión 5.26 de Perl, ^[9] los documentos heredado pueden incluir sangría:

 #imprime "Hola\n" sin espacios iniciales. if ( 1 ) { print << ~ EOF ; Hola EOF }         

Además de estas cadenas, Perl también incluye literales de archivo, es decir, el contenido del archivo que sigue __DATA__(anteriormente __END__) en una línea por sí mismo. Se puede acceder a esto como objeto de archivo , PACKAGE::DATAcomo main::DATA, y se puede ver como una forma de segmento de datos .

En PHP, los documentos heredoc se denominan heredocs . En PHP, los heredocs no son cadenas literales. El texto heredoc se comporta como una cadena entre comillas dobles, pero sin las comillas dobles. Por ejemplo, el significado `$` se analizará como el inicio de una variable, y `${` o `{$` como el inicio de una variable compleja.

<?php $nombre  =  "Joe Smith" ; $ocupación  =  "Programador" ; echo  <<< EOFEsta es una sección de documentación heredada. Para obtener más información, comuníquese con $name, su $occupation local.¡Gracias!EOF ;$toprint  =  <<< EOF¡Hola, $name! ¡De hecho, puedes asignar la sección heredoc a una variable!EOF ; echo  $toprint ;?>

Salidas

Esta es una sección de documentación. Para obtener más información, hable con Joe Smith, su programador local.¡Gracias!¡Hola, Joe Smith! ¡De hecho, puedes asignar la sección heredoc a una variable!

En versiones de PHP anteriores a la 7.3, la línea que contiene el identificador de cierre no debe contener ningún otro carácter, excepto un punto y coma final opcional. De lo contrario, no se considerará un identificador de cierre y PHP seguirá buscando uno. Si no se encuentra un identificador de cierre adecuado, se generará un error de análisis en la última línea del script. Sin embargo, a partir de la versión 7.3, ya no es necesario que el identificador de cierre vaya seguido de un punto y coma o una nueva línea. Además, el identificador de cierre puede tener sangría, en cuyo caso la sangría se eliminará de todas las líneas de la cadena de documentación. ^[10]

En PHP 5.3 y versiones posteriores, al igual que en Perl, es posible no interpolar variables rodeando la etiqueta con comillas simples; esto se denomina nowdoc : ^[11]

$x  =  <<<' FIN ' Estimado $destinatario,Deseo que te vayas de Sunnydale y nunca regreses.No es exactamente amor, $sender END ;

En PHP 5.3+ también es posible rodear la etiqueta con comillas dobles, lo que, como en Perl, tiene el mismo efecto que no rodear la etiqueta con nada.

El siguiente código Ruby muestra una lista de compras utilizando un documento aquí.

pone << LISTA_DE_COMPRA Lista de compras ---- 1. Mezcla de ensaladas. 2. Fresas.* 3. Cereales. 4. Leche.* * Orgánico LISTA_DE_COMPRA  

El resultado:

$ ruby  ​​grocery-list.rb Lista de compras ------------ 1. Mezcla de ensaladas. 2. Fresas.* 3. Cereales. 4. Leche.* * Orgánica 

El <<in a here document no indica redirección de entrada, pero Ruby también lo usa <<para redirección de entrada, por lo que redirigir a un archivo desde un documento here implica usarlo <<dos veces, en diferentes sentidos:

Archivo :: open ( "lista_de_la_compra" , "w" ) hacer | f | f << << LISTA_DE_LA_COMPRA Lista de la compra ---- 1. Mezcla de ensaladas. 2. Fresas.* 3. Cereales. 4. Leche.* * Orgánica LISTA_DE_LA_COMPRA fin       

Al igual que con los shells de Unix, Ruby también permite que el identificador delimitador no comience en la primera columna de una línea, si el inicio del documento here está marcado con el starter ligeramente diferente <<-. Además, Ruby trata los documentos here como una cadena entre comillas dobles y, como tal, es posible utilizar la #{}construcción para interpolar código. El siguiente ejemplo ilustra ambas características:

ahora = Hora . ahora pone <<- EOF  Son las #{now.hour} en punto John, ¿dónde están tus hijos?  EOF   

Ruby amplía esto al proporcionar la sintaxis "<<~" para omitir la sangría en el documento aquí:

pone <<~ EOF  Esta línea tiene una sangría de dos espacios.  Esta línea tiene una sangría de cuatro espacios.  Esta línea tiene una sangría de seis espacios.  EOF 

La sangría común de dos espacios se omite en todas las líneas:

$ ruby  ​​indented-heredoc.rb Esta línea tiene una sangría de dos espacios.  Esta línea tiene una sangría de cuatro espacios.  Esta línea tiene una sangría de seis espacios.

Al igual que Perl, Ruby permite iniciar varios documentos aquí en una línea:

pone << BEGIN + "<--- medio ---> \n " + << END Este es el comienzo: BEGIN ¡Y ahora se acabó! END     # esto equivale a esta expresión: puts "Este es el comienzo: \n <--- medio ---> \n ¡Y ahora se acabó!" 

Al igual que Perl, Ruby cuenta con literales de archivo, es decir, el contenido del archivo que sigue __END__en una línea por sí solo. Se puede acceder a esto como objeto de archivo DATAy verlo como una forma de segmento de datos .

Python admite cadenas de varias líneas como cadenas "verbatim". Pueden estar entre comillas simples (') o dobles ("), estas últimas se muestran en los ejemplos siguientes.

print ( """ Cliente: No es una gran quesería, ¿verdad? Tendero: La mejor del distrito, señor. """ )

A partir de Python 3.6, las cadenas f literales admiten la interpolación de variables y expresiones.

shop_type  =  "CHEESE" accolade  =  "finest" print ( f """ Cliente: No es una gran tienda { shop_type . lower () } , ¿verdad? Tendero: { accolade . capitalize () } en el distrito, señor. """ )

Los bloques de texto son compatibles a partir de Java 15 a través de JEP 378: ^{[12] [13]}

Cadena html = """  <html>  <body>  <p>Hola, mundo</p>  </body>  </html> """ ;   

Desde C++11 , C++ admite literales de cadena con delimitador personalizado ("my_delimiter" en este ejemplo):

#include <ostream> const char * str = R " my_delimiter( Inicio de cadena. Nueva línea barra \ quote " ' parens ) ( Fin de cadena )my_delimiter " ; std :: cout << str << std :: endl ;        

se imprimirá

Inicio de cadena. Nueva línea.barra \ cita " ' paréntesis ) (Fin de cadena

Desde la versión 2.0, D admite cadenas de estilo de documento que utilizan el carácter de prefijo 'q'. Estas cadenas comienzan con q"IDENTseguido inmediatamente por una nueva línea (para un identificador arbitrario IDENT) y terminan con IDENT"al comienzo de una línea.

int main () { string lista = q "IDENT 1. Elemento Uno 2. Elemento Dos 3. Elemento Tres IDENT" ; writef ( lista ); }         

D también admite algunos delimitadores de comillas, con una sintaxis similar, en las que dichas cadenas comienzan q"[y terminan con, ]"o de manera similar para otro carácter delimitador (cualquiera de () <> {} o []).

En el lenguaje de control de trabajos (JCL) de IBM utilizado en sus sistemas operativos MVS anteriores y z/OS actuales, los datos que están en línea en un flujo de trabajos se pueden identificar mediante un * en una sentencia DD, como o En el primer caso, las líneas de texto siguen y se combinan en un pseudoarchivo con el nombre DD SYSIN. Todos los registros que siguen al comando se combinan hasta que se produce otro comando OS/JCL (cualquier línea que comience con ), se encuentra la secuencia EOF predeterminada ( ) o se produce el final físico de los datos. En el segundo caso, las condiciones son las mismas, excepto que se utiliza el operando DLM= para especificar la cadena de texto que señala el final de los datos, que se puede utilizar si un flujo de datos contiene JCL (de nuevo, cualquier línea que comience con ), o la secuencia (como comentarios en el código fuente C o C++). Lo siguiente compila y ejecuta un programa en lenguaje ensamblador, suministrado como datos en línea al ensamblador.//SYSIN DD *//SYSIN DD *,DLM=text///*///*

// AHAR JOB ( 'ALEX HARRIS' ) // EJECUTAR ASMLG // SYSIN DD * APROG INICIO  XR 15,15  BR 14  FIN /* //* FIN DEL TRABAJO    

La declaración es el equivalente funcional de Indicar que sigue un flujo de datos, terminado en .//SYSIN DD *<</*/*

Las cadenas de Racket comienzan con #<<seguidas de caracteres que definen un terminador para la cadena. ^[14] El contenido de la cadena incluye todos los caracteres entre la #<<línea y una línea cuyo único contenido es el terminador especificado. Más precisamente, el contenido de la cadena comienza después de una nueva línea que sigue a #<<, y termina antes de una nueva línea seguida por el terminador.

#raqueta de langosta( displayln #<<HERESTRING Esta es una cadena aquí simple en Racket.  * Uno  * Dos  * Tres HERESTRING )  

Salidas:

Esta es una cadena simple en Racket.  * Uno  * Dos  * Tres

No se reconocen secuencias de escape entre las líneas inicial y final; todos los caracteres están incluidos en la cadena (y en el terminador) literalmente.

#raqueta de langosta( displayln #<<A aquí cadena en Racket ☺ Esta cadena se extiende por varias líneas y puede contener cualquier símbolo Unicode. Por lo tanto, cosas como λ, ☠, α, β, están todas bien. En la siguiente línea viene el terminador. Puede contener cualquier símbolo Unicode, incluso espacios y emoticones. Una cadena aquí en Racket ☺ ) 

Salidas:

Esta cadena se extiende por varias líneas y puede contener cualquier símbolo Unicode. Por lo tanto, elementos como λ, ☠, α, β, están bien.En la siguiente línea viene el terminador. Puede contener cualquier símbolo Unicode, incluso espacios y emoticones.

Aquí las cadenas se pueden utilizar normalmente en contextos donde las cadenas normales:

#raqueta de langosta( printf #<<END Estimado ~a, Gracias por la esclarecedora conversación ~a. ~unFIN "Isaac" "ayer" "Carl" )   

Salidas:

Querido Isaac,Gracias por la esclarecedora conversación de ayer. Carlos

Una alternativa interesante es utilizar la extensión del lenguaje at-exppara escribir expresiones @. ^[15] Tienen este aspecto:

#lang at-exp racket(mostrar @string-append{Esta es una cadena larga,muy conveniente cuando unUn largo trozo de texto esnecesario.No te preocupes por escapar"comillas" o \escapes. EsTambién está bien tener λ, γ, θ, ...Código para insertar:@(number->string (+ 3 4))})

Salidas:

Esta es una cadena larga, muy conveniente cuando se necesita un fragmento largo de texto .No hay problema con el uso de "comillas" o "escapes". También está bien tener λ, γ, θ, ...Código de inserción: 7

Una expresión @ no es específica ni está restringida a cadenas, es una forma de sintaxis que se puede componer con el resto del lenguaje.

En PowerShell , los documentos here se denominan cadenas here . Una cadena here es una cadena que comienza con un delimitador abierto ( @"or @') y termina con un delimitador cerrado ( "@or '@) en una línea por sí misma, lo que termina la cadena. Todos los caracteres entre el delimitador abierto y el cerrado se consideran el literal de cadena. El uso de una cadena here con comillas dobles permite interpretar las variables , el uso de comillas simples no. La interpolación de variables ocurre con variables simples (por ejemplo $x, but NOT $x.yo $x[0]). Puede ejecutar un conjunto de instrucciones colocándolas $()(por ejemplo, $($x.y)or $(Get-Process | Out-String)).

En el siguiente código de PowerShell, se pasa texto a una función mediante una cadena here. La función ConvertTo-UpperCasese define de la siguiente manera:

PS > function  ConvertTo-UpperCase ( $string )  {  $string . ToUpper ()  } PS > ConvertTo-UpperCase @ ' >> uno dos tres >> uno dos tres >> '@ UNO DOS TRES UNO DOS TRES  

A continuación se muestra un ejemplo que demuestra la interpolación de variables y la ejecución de declaraciones utilizando una cadena aquí con comillas dobles:

PS > $doc ,  $marty  =  'Dr. Emmett Brown' ,  'Marty McFly' PS > $time  =  [DateTime] 'Viernes, 25 de octubre de 1985 8:00:00 AM' PS > $diff  =  New-TimeSpan  -Minutes  25 PS > @" >> $doc : ¿Son mis relojes los que escucho? >> $marty : ¡Sí! ¡Uh, son las $($time.Hour) en punto! >> $doc : ¡Perfecto! ¡Mi experimento funcionó! Todos están exactamente $($diff.Minutes) minutos atrasados. >> $marty : Espera un minuto. Espera un minuto. Doc... ¿Me estás diciendo que son $(($time + $diff).ToShortTimeString())? >> $doc : Precisamente. >> $marty : ¡Maldita sea! ¡Llego tarde a la escuela! >> "@ Dr. Emmett Brown : ¿Son mis relojes los que escucho? Marty McFly: ¡Sí! ¡Eh, son las 8 en punto! Dr. Emmett Brown: ¡Perfecto! ¡Mi experimento funcionó! Todos tienen exactamente 25 minutos de retraso. Marty McFly: Espere un minuto. Espere un minuto. Doc... ¿Me está diciendo que son las 08:25? Dr. Emmett Brown: Precisamente. Marty McFly: ¡Maldita sea! ¡Llego tarde a la escuela!

Si en su lugar se utiliza una cadena aquí con comillas simples, el resultado se vería así:

PS > @ ' >> $doc : ¿Son mis relojes los que oigo? >> $marty : ¡Sí! ¡Eh, son las $($time.Hour) en punto! >> $doc : ¡Perfecto! ¡Mi experimento funcionó! Todos van exactamente $($diff.Minutes) minutos atrasados. >> $marty : Espera un minuto. Espera un minuto. Doc... ¿Me estás diciendo que son $(($time + $diff).ToShortTimeString())? >> $doc : Precisamente. >> $marty : ¡Maldita sea! ¡Llego tarde a la escuela! >> '@ $doc : ¿Son mis relojes los que oigo? $marty : ¡Sí! ¡Eh, son las $($time.Hour) en punto! $doc : ¡Perfecto! ¡Mi experimento funcionó! Todos van exactamente $($diff.Minutes) minutos atrasados. $marty : Espera un minuto. Espera un minuto. Doc... ¿Me estás diciendo que es $(($time + $diff).ToShortTimeString())? $doc : Precisamente. $marty : ¡Maldita sea! ¡Llego tarde a la escuela!

En los scripts DCL , cualquier línea de entrada que no comience con un símbolo $ se trata implícitamente como entrada al comando anterior; todas las líneas que no comiencen con $ son documentos aquí. La entrada se pasa al programa o se puede hacer referencia explícita a ella mediante el nombre lógico SYS$INPUT (análogo al concepto Unix de stdin ).

Por ejemplo, haciendo referencia explícita a la entrada como SYS$INPUT:

$ TYPE  SYS $INPUT Este texto se reproducirá directamente en la pantalla mediante el comando TYPE. $ !  otros  comandos  ...

produce:

Este texto se reproducirá directamente en la pantalla mediante el comando TYPE.

Además, el comando DECK, inicialmente pensado para el soporte de tarjetas perforadas (de ahí su nombre: significaba el comienzo de una baraja de datos ), se puede utilizar para proporcionar entrada al comando precedente. ^[16] La baraja de entrada finaliza con el comando $ EOD o con el patrón de caracteres especificado por el parámetro /DOLLARS de DECK.

Ejemplo de un programa que suma valores monetarios:

$ EJECUTAR ADD_SUMS.EXE$ CUBIERTA$13,53$3,33$2,33$ al final del día

Produciría el siguiente resultado (suponiendo que ADD_SUMS se escribió para leer los valores y sumarlos):

$19,19

Ejemplo de uso de DECK /DOLLARS para crear un archivo de comando a partir de otro:

$ COPY  SYS $INPUT  SYS $SCRATCH :TEMP.COM $ DECK  /DOLLARS = $$$$ $ TYPE  SYS $INPUT Este es un ejemplo del uso de DECK para crear un archivo de comandos desde dentro de un archivo de comandos $ $$ $ $ ! siguen  otros  comandos ...  

YAML se basa principalmente en la sangría de espacios en blanco para la estructura, lo que lo hace resistente a la colisión de delimitadores y capaz de representar cadenas de varias líneas con literales de cadena plegados:

--- título : "Ejemplo de funcionalidad de estilo heredoc usando YAML" fecha : "2007-06-01" ejemplo : > HTML entra en YAML sin modificación mensaje : |           <blockquote style="font: italic 12pt Times"> <p>"Tres siempre es mayor que dos, incluso para valores grandes de dos"</p> <p>--Autor desconocido</p> </blockquote>    

• Datos CD
• Tubería (Unix)

• Documento aquí. Enlace a la tarea de Rosetta Code con ejemplos de documentos aquí en más de 15 idiomas.