Hispanopedia Wiki
Articulo de referencia

Aquí el documento

En informática , un documento aquí ( here-document , here-text , heredoc , hereis , here-string o here-script ) es un literal de archivo o un literal de flujo de entrada : es un...

Hispanopedia WikiContenido en espanolLectura gratuita

En informática , un documento aquí ( 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 independiente . El término también se usa para una forma de literales de cadena multilínea que usan 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 de Bourne desde 1979, y en la mayoría de los shells posteriores. Aquí los literales de cadena de estilo 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 como cadenas de texto. Algunos intérpretes de comandos los tratan como una cadena de formato literal, lo que permite la sustitución de variables y de comandos dentro de dicha cadena.

Descripción general

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

La sintaxis del documento here 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 usar una sintaxis muy similar, pero los detalles sintácticos y la funcionalidad real pueden variar significativamente. Cuando se usa simplemente para literales de cadena, no indica indirección, sino que es simplemente una convención de delimitador inicial. En algunos lenguajes, como Ruby, también se usa para la redirección de entrada, lo que resulta en que se use dos veces si se desea redirigir desde un literal de cadena de documento here.<<<<<<

literales de archivo

En sentido estricto, aquí los documentos son literales de archivo o literales de flujo. Estos se originan en el intérprete de comandos de Unix, aunque existen funcionalidades similares en otros lenguajes.

shells de Unix

Los documentos aquí están disponibles en muchos intérpretes de comandos de Unix. [ 1 ] En el siguiente ejemplo, se pasa texto al trcomando (transliterando de minúsculas a mayúsculas) usando un documento aquí. Esto podría estar en un archivo de shell o ingresarse interactivamente 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 usó como identificador delimitador. Especificaba el inicio y el final del documento aquí. La redirección y el identificador delimitador no necesitan estar separados por un espacio; <<ENDambos << ENDfuncionan igual de bien.

Por defecto, el comportamiento es prácticamente idéntico al del 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 deshabilitar citando cualquier parte de la etiqueta, que luego termina con el valor sin comillas; [ b ] el comportamiento es esencialmente idéntico al que se produciría si el contenido estuviera encerrado entre comillas simples. Por ejemplo, al colocarlo 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 generar confusión, ya que la expansión ocurre en una cadena entre comillas dobles, pero no en un documento here con delimitador de comillas dobles. [ 4 ] En otros lenguajes, especialmente en Perl (ver más abajo), se distinguen los delimitadores de comillas simples y dobles , donde el comportamiento es similar al de las comillas de cadena correspondientes.

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

Un script que contiene:

LANG = C tr a-z A-Z <<- FIN_TEXTO Aquí documento con <<- Un solo carácter de espacio (es decir, 0x20) está al principio de esta línea  Esta línea comienza con un solo carácter de tabulación, es decir, 0x09, al igual que la siguiente línea  FIN_TEXTOecho 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 principio de esta línea  Esta línea comienza con un solo carácter de tabulación, es decir, 0x09, al igual que la siguiente línea  END_TEXTecho El final previsto estaba antes de esta línea, echo pero como la línea con el identificador delimitador comenzaba con una TAB , NO fue reconocida y echo el comando tr continuó procesándose.

produce:

AQUÍ DOC CON <<- UN SOLO CARÁCTER DE ESPACIO (ES DECIR, 0X20) ESTÁ AL PRINCIPIO DE ESTA LÍNEA ESTA LÍNEA COMIENZA CON UN SOLO CARÁCTER DE TABULACIÓN, ES DECIR, 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 (ES DECIR, 0X20) ESTÁ AL PRINCIPIO DE ESTA LÍNEA  ESTA LÍNEA COMIENZA CON UN SOLO CARÁCTER DE TABULACIÓN, ES DECIR, 0X09, AL IGUAL QUE LA SIGUIENTE LÍNEA  FIN_TEXTOECHO EL FINAL PREVISTO ESTABA ANTES DE ESTA LÍNEA, ECHO PERO DEBIDO A QUE LA LÍNEA CON EL IDENTIFICADOR DE DELIMITACIÓN COMENZÓ CON UNA TABULACIÓN, NO FUE RECONOCIDA Y ECHO EL COMANDO TR CONTINUÓ PROCESÁNDOSE.

Otro uso es generar la salida a un archivo: 

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

Aquí cadenas

Una cadena here (disponible en bash , ksh o zsh ) es sintácticamente similar, consta de <<<y produce la redirección de entrada desde una palabra (una secuencia tratada como una unidad por el intérprete de comandos, en este contexto generalmente un literal de cadena). En este caso, se utiliza la sintaxis habitual del intérprete de comandos 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 ni una sola palabra:

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

En caso de una cadena con espacios, debe ir entre comillas:

$ 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 de varias líneas, lo que da como resultado:

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

Tenga en cuenta que los saltos de línea iniciales y finales, si los hay, se incluyen:

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

La principal diferencia con los documentos aquí radica en que, en los documentos aquí, los delimitadores se encuentran en líneas separadas; los saltos de línea iniciales y finales se eliminan. A diferencia de los documentos aquí, las cadenas aquí 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í también se puede lograr el comportamiento de cadena (invirtiendo el orden) mediante tuberías 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 integrado:

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

no produce nada, mientras que

$ 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 padre .

Microsoft NMAKE

En Microsoft NMAKE , los documentos se denominan archivos en línea . Estos archivos se referencian como o : la primera notación crea un archivo temporal , la segunda crea (o sobrescribe) el archivo con la ruta especificada. Un archivo en línea termina con en una línea aparte, opcionalmente seguida de la palabra clave (que no distingue entre mayúsculas y minúsculas) o para indicar si se debe conservar el archivo creado.<<<<pathname<<KEEPNOKEEP

objetivo0 : dependiente 0 comando0 << archivo en línea temporal ... <<objetivo1 : dependiente 1 comando1 << archivo en línea temporal, pero conservado ... <<CONSERVAR objetivo2 : dependiente 2 comando2 << archivo en línea con nombre de archivo2, pero descartado ... <<NO CONSERVAR objetivo3 : dependiente 3 comando3 << archivo en línea con nombre de archivo3 ... <<CONSERVAR

R

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, incluyendo saltos de línea, en las cadenas. Una cadena se puede convertir en un descriptor de archivo mediante la textConnection()función. Por ejemplo, el siguiente código convierte una tabla de datos incrustada en el código fuente en una variable de marco de datos:

str <- "Estado Población Ingresos Analfabetismo Esperanza de vida Homicidio Graduados de secundaria 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 )

Segmento de datos

Perl [ 6 ] y Ruby [ 7 ] tienen una forma de literal de archivo, que puede considerarse una forma de segmento de datos . En estos lenguajes, incluir la línea __DATA__(Perl) o __END__(Ruby, Perl antiguo) marca el final del segmento de código y el comienzo del segmento de datos. Solo se ejecuta el contenido anterior a esta línea, y el contenido del archivo fuente posterior a 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 aquí, aunque solo puede haber uno por script. Sin embargo, en estos lenguajes el término "documento aquí" se refiere en cambio a literales de cadena multilínea, como se explica más adelante.

Esquema URI de datos

Como se explica con más detalle en el esquema de URI de datos , todos los navegadores web principales entienden las URI que comienzan con data: como se documenta aquí.

Literales de cadena multilínea

El término "documento aquí" o "cadena aquí" también se utiliza para literales de cadena multilínea en varios lenguajes de programación, especialmente en Perl (cuya sintaxis está influenciada por la shell de Unix), y en lenguajes influenciados por Perl, como PHP y Ruby. A menudo se conserva la sintaxis de estilo shell , a pesar de no utilizarse para la redirección de entrada.<<

Influenciado por Perl

Perl

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 en un literal de cadena normal: 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 las dos se comporta como comillas dobles. Usar acentos graves como delimitadores alrededor de la etiqueta ejecuta el contenido del heredoc como un script de shell. Es necesario asegurarse de que la etiqueta de cierre esté al principio de la línea o la etiqueta no será reconocida por el intérprete.

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

Aquí hay un ejemplo con comillas dobles:

mi $sender = "Buffy la cazavampiros" ; mi $recipient = "Spike" ;imprimir <<" FIN ";Estimado/a $recipient,Deseo que te vayas de Sunnydale y no regreses jamás.No es exactamente amor, $senderFIN

Producción:

Querido Spike,Deseo que te vayas de Sunnydale y no regreses jamás.No es exactamente amor, Buffy la Cazavampiros

Aquí hay un ejemplo con comillas simples:

print <<' FIN '; Estimado $destinatario,Deseo que te vayas de Sunnydale y no regreses jamás.No es exactamente amor, $sender FIN

Producción:

Estimado/a $recipient,Deseo que te vayas de Sunnydale y no regreses jamás.No es exactamente amor, $sender

Y un ejemplo con acentos graves (puede que no sea portable):

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

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

decir ( << INICIO . "este es el medio\n" . << FIN ); Este es el comienzo: INICIO ¡ Y ahora se acabó ! FIN# 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 indentación .

decir << ' FIN' ; Hola Mundo FIN

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

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

Además de estas cadenas, Perl también cuenta con literales de archivo, es decir, el contenido del archivo que sigue a __DATA__(anteriormente __END__) en una línea aparte. Esto es accesible como el objeto de archivo PACKAGE::DATAcomo main::DATA, y puede verse como una forma de segmento de datos .

PHP

En PHP, los documentos aquí se denominan heredocs . En PHP, los heredocs no son literales de cadena. El texto de un heredoc se comporta como una cadena entre comillas dobles, pero sin las comillas dobles. Por ejemplo, `$` 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 <<< EOF Esta es una sección de heredoc.  Para obtener más información, hable 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 heredoc. Para más información, contacte con Joe Smith, su programador local.¡Gracias!¡Hola Joe Smith! ¡De hecho, puedes asignar la sección heredoc a una variable!

En las 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á buscándolo. Si no se encuentra un identificador de cierre adecuado, se producirá 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 un salto de línea. Además, el identificador de cierre puede estar indentado, en cuyo caso la indentación 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 no regreses jamás.No es exactamente amor, $sender FIN ;

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

Rubí

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

puts << LISTA_DE_COMPRAS Lista de compras ---- 1. Mezcla de ensalada. 2. Fresas.* 3. Cereal. 4. Leche.* * Orgánica LISTA_DE_COMPRAS

El resultado:

$ ruby ​​grocery-list.rb Lista de la compra ------------ 1. Mezcla de ensalada. 2. Fresas.* 3. Cereal. 4. Leche.* * Orgánica

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

Archivo :: abrir ( "lista_de_compras" , "w" ) hacer | f | f << << LISTA_DE_COMPRAS Lista de compras ---- 1. Mezcla de ensalada. 2. Fresas.* 3. Cereal. 4. Leche.* * Orgánica LISTA_DE_COMPRAS fin

Al igual que en 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 identificador de inicio ligeramente diferente <<-. Además, Ruby trata los documentos here como una cadena entre comillas dobles, y como tal, es posible usar la #{}construcción para interpolar código. El siguiente ejemplo ilustra ambas características:

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

Ruby amplía esto proporcionando la sintaxis "<<~" para omitir la sangría en el documento here:

puts <<~ 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

Se omite la sangría común de dos espacios 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 sola línea:

puts << BEGIN + "<--- medio ---> \n " + << END Este es el comienzo: BEGIN ¡Y ahora se acabó! END# esto equivale a esta expresión: pone "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 aparece __END__en una línea aparte. Se puede acceder a él como objeto de archivo DATAy se puede considerar como una forma de segmento de datos .

Pitón

Python admite cadenas de varias líneas como una cadena "verbatim". Estas pueden ir entre 3 comillas simples (') o dobles ("), como se muestra en los ejemplos a continuación.

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

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

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

Java

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

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

C++

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

#include <ostream>const char * str = R " mi_delimitador( Inicio de la cadena. Nueva línea barra \ comillas " ' paréntesis ) ( Fin de la cadena )mi_delimitador " ; std :: cout << str << std :: endl ;

imprimirá

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

D

Desde la versión 2.0, D admite cadenas de estilo documento aquí que utilizan el carácter de prefijo 'q'. Estas cadenas comienzan con q"IDENTseguido inmediatamente de un salto de línea (para un identificador arbitrario IDENT) y terminan con IDENT"al principio 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, con dichas cadenas comenzando con q"[y terminando con ]"o de manera similar para otro carácter delimitador (cualquiera de () <> {} o []).

Sistema operativo/JCL

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 con un flujo de trabajo se pueden identificar mediante un * en una instrucción DD, como o En el primer caso, las líneas de texto siguen y se combinan en un pseudo archivo 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 el operando DLM= se utiliza 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 , proporcionado como datos en línea al ensamblador.//SYSIN DD *//SYSIN DD *,DLM=text///*///*

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

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

Raqueta

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 un salto de línea que sigue a #<<, y termina antes de un salto de línea que es seguido por el terminador.

#lang raqueta( displayln #<<HERESTRING Esta es una cadena "here" simple en Racket.  * Uno  * Dos  * Tres HERESTRING )

Salidas:

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

No se reconocen secuencias de escape entre las líneas de inicio y fin; todos los caracteres se incluyen en la cadena (y en el terminador) literalmente.

#lang raqueta( displayln #<<Una cadena aquí en Racket ☺ Esta cadena abarca varias líneas y puede contener cualquier símbolo Unicode. Por lo tanto, cosas como λ, ☠, α, β, están bien.En la siguiente línea viene el terminador. ¡También puede contener cualquier símbolo Unicode, incluso espacios y emoticonos! Una cadena aquí en Racket ☺ )

Salidas:

Esta cadena abarca varias líneas y puede contener cualquier símbolo Unicode. Por lo tanto, símbolos como λ, ☠, α y β son perfectamente válidos.En la siguiente línea viene el terminador. ¡También puede contener cualquier símbolo Unicode, incluso espacios y emoticonos!

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

#lang raqueta( printf #<<FIN Estimado ~a,Gracias por la interesante conversación ~a. ~aFIN "Isaac" "ayer" "Carl" )

Salidas:

Querido Isaac,Gracias por la interesante conversación de ayer. Carl

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

#lang at-expracket (displayln @string-append{ Esta es una cadena larga, muy conveniente cuando un un largo fragmento de texto es necesario. No hay que preocuparse por escapar. "comillas" o \escapes. Es También está bien tener λ, γ, θ, ... Código de inserción: })@(number->string(+34))

Salidas:

Esta es una cadena larga, muy útil cuando se necesita un fragmento de texto extenso .No te preocupes por escapar las comillas o los caracteres de escape. También está bien tener λ, γ, θ, ...Código de inserción: 7

Una expresión @ no es específica ni se limita a las cadenas de texto; es una forma sintáctica que se puede combinar con el resto del lenguaje.

Windows PowerShell

En PowerShell , los documentos aquí se denominan cadenas aquí . Una cadena aquí es una cadena que comienza con un delimitador de apertura ( @"o @') y termina con un delimitador de cierre ( "@o '@) en una línea aparte, lo que finaliza la cadena. Todos los caracteres entre el delimitador de apertura y cierre se consideran el literal de cadena. Usar una cadena aquí con comillas dobles permite que las variables se interpreten , usar comillas simples no. La interpolación de variables ocurre con variables simples (por ejemplo $x, pero NO $x.yo $x[0]). Puede ejecutar un conjunto de instrucciones colocándolas en $()(por ejemplo, $($x.y)o $(Get-Process | Out-String)).

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

PS > función ConvertTo-UpperCase ( $string ) { $string . ToUpper () } PS > ConvertTo-UpperCase @ ' >> uno dos tres >> eins zwei drei >> '@ UNO DOS TRES EINS ZWEI DREI

Aquí hay un ejemplo que demuestra la interpolación de variables y la ejecución de sentencias utilizando una cadena aquí entre comillas dobles:

PS > $doc , $marty = 'Dr. Emmett Brown' , 'Marty McFly' PS > $time = [DateTime] 'Friday, October 25, 1985 8:00:00 AM' PS > $diff = New-TimeSpan -Minutes 25 PS > @" >> $doc : ¿Son mis relojes los que oigo? >> $marty : ¡Sí! ¡Eh, 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 las $(($time + $diff).ToShortTimeString())? >> $doc : Precisamente. >> $marty : ¡Maldita sea! ¡Llego tarde a la escuela! >> "@ Dr. Emmett Brown : ¿Son mis relojes los que oigo? Marty McFly: ¡Sí! ¡Son las 8! Dr. Emmett Brown: ¡Perfecto! ¡Mi experimento funcionó! Todos están exactamente 25 minutos atrasados. Marty McFly: Un momento. Un momento. Doctor... ¿Me está diciendo que son las 8:25? Dr. Emmett Brown: Exactamente. Marty McFly: ¡Maldita sea! ¡Llego tarde a la escuela!

En su lugar, si 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 están exactamente $($diff.Minutes) minutos atrasados. >> $marty : Espera un minuto. Espera un minuto. Doc... ¿Me estás diciendo que son las $(($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 están exactamente $($diff.Minutes) minutos atrasados. $marty : Espera un minuto. Espera un minuto. Doc... ¿Me estás diciendo que es $(($time + $diff).ToShortTimeString())? $doc : Exactamente. $marty : ¡Maldita sea! ¡Llego tarde a la escuela!

Lenguaje de comandos digitales (DCL)

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

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

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

produce:

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

Además, el comando DECK, inicialmente destinado a la compatibilidad con tarjetas perforadas (de ahí su nombre: significaba el comienzo de un conjunto de datos ), puede utilizarse para proporcionar entrada al comando precedente. [ 16 ] El conjunto 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 $ MAZO $13.53 $3.33 $2.33 $ EOD

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 comandos a partir de otro:

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

YAML

YAML se basa principalmente en la indentación con 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:

--- caption : "Ejemplo de funcionalidad estilo heredoc usando YAML" date : "2007-06-01" example : > HTML se convierte en YAML sin modificaciones message : |<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>

Véase también

Referencias

  1. 1 2 "Descripción de documento aquí en el estándar POSIX/SUS" . Archivado del original el 27 de abril de 2014. Recuperado el 20 de abril de 2018 .
  2. ↑ Wayne Pollock. "Descripción general del documento Shell Here" . hccfl.edu. Archivado del original el 29 de mayo de 2014. Consultado el 28 de mayo de 2014 .
  3. ↑ 3.6.6 Aquí Documentos
  4. ↑ Véase, por ejemplo, el uso de variables dentro de un heredoc de bash.
  5. ↑ "Página man de Darwin tcsh" . Archivado del original el 1 de julio de 2019. Consultado el 20 de abril de 2018 .
  6. ↑ "perldata: Literales especiales" . Archivado del original el 23/12/2017 . Consultado el 31/08/2013 .
  7. ↑ Ruby: Datos incrustados:
  8. ↑ "Operadores y precedencia de Perl" . Archivado del original el 17 de julio de 2012. Consultado el 22 de mayo de 2010 .
  9. ↑ "Perl5260delta - Novedades de Perl v5.26.0 - Perldoc Browser" . Archivado del original el 13 de mayo de 2024. Consultado el 21 de diciembre de 2018 .
  10. ↑ "Manual de Heredoc en PHP" . php.net . Consultado el 6 de abril de 2011 .{{cite web}}: CS1 maint: servicio de archivado obsoleto ( enlace )
  11. ↑ "PHP: Cadenas - Manual" . php.net . Archivado del original el 3 de julio de 2012. Consultado el 7 de septiembre de 2011 .
  12. ↑ "JEP 378: Bloques de texto" . openjdk.org . Consultado el 5 de junio de 2024 .
  13. ↑ "Bloques de texto (JEP 378) - javaalmanac.io" . javaalmanac.io . Consultado el 5 de junio de 2024 .
  14. ↑ "Cadena aquí en la documentación de Racket" . Archivado del original el 3 de septiembre de 2011. Consultado el 17 de septiembre de 2011 .
  15. ↑ "@ Sintaxis en la documentación de Racket" . Archivado del original el 22/01/2012 . Consultado el 17/09/2011 .
  16. ↑ "Diccionario DCL de HP OpenVMS" . Archivado del original el 4 de marzo de 2016. Consultado el 21 de abril de 2015 .

Notas

  1. ↑ En más detalle, en bash: "todas las líneas del documento aquí están sujetas a expansión de parámetros, sustitución de comandos y expansión aritmética. En este último caso, la secuencia de caracteres \newline se ignora y se debe usar '\' para entrecomillar los caracteres '\', '$' y '`'." [ 3 ] Nótese que"no tiene un significado especial en un documento aquí y no necesita ser escapado, a diferencia de en una cadena entre comillas dobles; por lo demás, son esencialmente idénticos.
  2. ↑ "Comillas" incluye escape, por lo que si\EOFse usa, se cita, por lo que no se produce interpolación de variables y termina conEOF, mientras que si\\EOFse usa, se cita y termina con\EOF. Sin embargo, este comportamiento, quizás sorprendente, se implementa fácilmente en un shell, haciendo que el tokenizador simplemente registre que un token fue citado (durante la fase de evaluación del análisis léxico ), sin necesidad de conservar el valor original citado. Una aplicación es usar\'como delimitador inicial y, por lo tanto,'como delimitador final, lo que es similar a un literal de cadena multilínea pero eliminando los saltos de línea iniciales y finales.
  3. ↑ Tenga en cuenta que, si bien las tabulaciones generalmente se pueden ingresar en los editores, en la línea de comandos generalmente se ingresan conCtrl + V+Tab ↹ en su lugar, debido al autocompletado de tabulaciones , y en el ejemplo son tabulaciones reales, por lo que el ejemplo se puede copiar y pegar.

General

  • Manual de referencia de Bash archivado el 14/07/2018 en Wayback Machine.
    • 3.6.6 Aquí se encuentran los documentos archivados el 14 de julio de 2018 en la Wayback Machine.
    • 3.6.7 Cadenas de texto archivadas el 14 de julio de 2018 en la Wayback Machine
  • Guía avanzada de programación en Bash. Archivada el 14 de agosto de 2013 en Wayback Machine , Mendel Cooper.
    • Capítulo 19. Documentos archivados el 28 de agosto de 2013 en la Wayback Machine.
    • 19.1. Aquí hay cadenas archivadas el 7 de febrero de 2018 en la Wayback Machine.