En informática , un documento here ( here-document , here-text , heredoc , hereis , here-string o here-script ) es un literal de archivo o literal de flujo de entrada : es una sección de un archivo de código fuente que se trata como si era un archivo separado . El término también se usa para una forma de cadenas literales de varias líneas que usan una sintaxis similar, preservando 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 Unix , [1] y se encuentran en el shell Bourne ( sh
), shell C ( csh
), [2] tcsh ( tcsh
), [3] KornShell ( ksh
), Bash y Z shell ( zsh
), entre otros . Aquí, los literales de cadena de estilo documento se encuentran en varios lenguajes de alto nivel , notablemente el lenguaje de programación Perl (sintaxis inspirada en el shell de Unix) y lenguajes influenciados por Perl, como PHP y Ruby . Otros lenguajes de alto nivel como Python ,JavaScript y Tcl tienen otras facilidades para cadenas de varias líneas.
Aquí los documentos pueden tratarse como archivos o como cadenas. Algunos shells los tratan como un literal de cadena de formato , lo que permite la sustitución de variables y la sustitución de comandos dentro del literal.
La sintaxis más común para los documentos aquí, que se originan en shells de Unix, va <<
seguida de un identificador delimitador (a menudo la palabra EOF o END [4] ), seguido, comenzando en la siguiente línea, por el texto que se va a citar y luego cerrado por el mismo identificador delimitador en su propia línea. Esta sintaxis se debe a que aquí los documentos son literales de flujo formal y el contenido del documento se redirige a stdin (entrada estándar) del comando anterior; la sintaxis del documento aquí es por analogía con la sintaxis para la redirección de entrada , que es "tomar la entrada del siguiente archivo".<
Otros lenguajes utilizan a menudo una sintaxis sustancialmente similar, pero los detalles de la sintaxis y la funcionalidad real pueden variar significativamente. Cuando se usa simplemente para cadenas literales, <<
no indica indirección, sino que es simplemente una convención delimitador inicial. En algunos lenguajes, como Ruby, <<
también se usa para la redirección de entrada, por lo que resulta en <<
ser usado dos veces si se desea redirigir desde un literal de cadena de documento aquí.
Literales de archivo
Hablando en términos estrictos, aquí los documentos son literales de archivo o literales de flujo. Estos se originan en el shell de Unix, aunque hay instalaciones similares disponibles en algunos otros lenguajes.
Shells de Unix
Aquí los documentos están disponibles en muchos shells de Unix. [1] En el siguiente ejemplo, el texto se pasa al tr
comando (transliterando de minúsculas a mayúsculas) usando un documento aquí. Esto podría estar en un archivo de shell o ingresado de forma interactiva en un indicador.
$ LANG = C tr az AZ << FIN > uno dos tres > cuatro cinco seis > FINAL UNO DOS TRES CUATRO CINCO SEIS
END
se utilizó como identificador delimitador. Especificó el inicio y el final del documento aquí. El redireccionamiento y el identificador delimitador no necesitan estar separados por un espacio: <
<< END
ambos funcionan igual de bien.
Por defecto, el comportamiento es en gran parte idéntico al contenido de comillas dobles: los nombres de variables se sustituyen por sus valores, se evalúan comandos dentro de acentos abiertos, etc. [a]
$ cat << EOF > \ $ Directorio de trabajo "$ PWD" `pwd` > EOF $ Directorio de trabajo " / home / user " / home / user
Esto puede desactivarse citando cualquier parte de la etiqueta, que luego termina con el valor no citado; [b] el comportamiento es esencialmente idéntico al que tendría si el contenido estuviera entre comillas simples. Así, por ejemplo, poniéndolo entre comillas simples:
$ cat << 'EOF' > \ $ Directorio de trabajo "$ PWD" `pwd` > EOF \ $ Directorio de trabajo" $ PWD "` pwd`
Las comillas dobles también se pueden utilizar, pero esto está sujeto a confusión, porque la expansión no se producen en una cadena entre comillas dobles, pero ¿ no se producen en un documento aquí con delimitador entre comillas dobles. [5] Los delimitadores de comillas simples y dobles se distinguen en algunos otros lenguajes, notablemente Perl (ver más abajo), donde el comportamiento es paralelo a la cadena de comillas correspondiente.
En el shell POSIX, pero no en csh / tcsh, agregar un signo menos a <<
(ie <<-
) tiene el efecto de que se ignoran las pestañas iniciales. [3] Esto permite sangrar aquí documentos en scripts de shell (principalmente para alinearlos con sangría existente) sin cambiar su valor: [c]
Un guión que contiene:
LANG = C tr az AZ << - END_TEXT Aquí el documento con << - Un carácter de espacio simple (es decir, 0x20) está al principio de esta línea Esta línea comienza con un carácter TAB simple, es decir, 0x09 al igual que la línea siguiente END_TEXTecho El final previsto estaba antes de esta línea echo y estos no fueron procesados por tr echo +++++++++++++++LANG = C tr az AZ << END_TEXT Aquí el documento con << Un carácter de espacio simple (es decir, 0x20) está al principio de esta línea Esta línea comienza con un carácter TAB simple, es decir, 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 comenzó con una TAB, NO fue reconocida y echo el comando tr continuó procesándose.
produce:
AQUÍ DOCUMENTO CON << - UN PERSONAJE DE ESPACIO ÚNICO (IE 0X20) ESTÁ AL COMIENZO DE ESTA LÍNEAESTA LÍNEA COMIENZA CON UN CARÁCTER DE UNA SOLA PESTAÑA IE 0X09 COMO LO HACE LA SIGUIENTE LÍNEAEl final previsto estaba antes de esta línea.y estos no fueron procesados por tr+++++++++++++++AQUÍ DOCUMENTO CON << UN PERSONAJE DE ESPACIO ÚNICO (IE 0X20) ESTÁ AL COMIENZO DE ESTA LÍNEAESTA LÍNEA COMIENZA CON UN CARÁCTER DE UNA SOLA PESTAÑA IE 0X09 COMO LO HACE LA SIGUIENTE LÍNEAEND_TEXTECHO EL FINAL PREVISTO FUE ANTES DE ESTA LÍNEA, ECHO PERO PORQUE LA LÍNEA CON EL IDENTIFICADOR DELIMITADOR COMENZÓ CON UNA PESTAÑA NO SE RECONOCIÓ YECHO EL PROCESAMIENTO CONTINUADO DEL COMANDO TR.
Otro uso es la salida a un archivo:
$ cat << EOF> ~ / testFile001 > 3 espacios preceden a este texto. > Un solo carácter de tabulación se encuentra al principio de esta línea. > Nada precede a este texto EOF
Aquí cuerdas
Una cadena here (disponible en bash , ksh o zsh ) es sintácticamente similar, consiste en <<<
y efectúa la redirección de entrada de una palabra (una secuencia tratada como una unidad por el shell, en este contexto generalmente una cadena literal). En este caso, se usa la sintaxis de shell habitual para la palabra ("aquí sintaxis de cadena"), siendo la única sintaxis la redirección: una cadena aquí 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 az AZ <<< uno UNO
En caso de una cadena con espacios, se debe citar:
$ LANG = C tr az AZ <<< 'uno dos tres' UNO DOS TRES
Esto también podría escribirse como:
$ foo = 'uno dos tres' $ LANG = C tr az AZ <<< " $ foo " UNO DOS TRES
Las cadenas de varias líneas son aceptables y producen:
$ LANG = C tr az AZ <<< ' uno > dos tres' UNO DOS TRES
Tenga en cuenta que se incluyen nuevas líneas iniciales y finales, si están presentes:
$ LANG = C tr az AZ <<< ' > uno > dos tres >'UNO DOS TRESPS
La diferencia clave con los documentos aquí es que, en los documentos aquí, los delimitadores están en líneas separadas; se eliminan las nuevas líneas iniciales y finales. A diferencia de aquí los documentos, aquí las cadenas 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 tubería y el echo
comando, como en:
$ echo 'uno dos tres' | IDIOMA = C tr az AZ UNO DOS TRES
sin embargo, aquí las cadenas son particularmente útiles cuando el último comando debe ejecutarse en el proceso actual, como es el caso del read
incorporado:
$ echo 'uno dos tres' | leer -rabc $ echo " $ a $ b $ c "
no rinde nada, mientras
$ read -rabc <<< 'uno dos tres' $ echo " $ a $ b $ c " uno dos tres
Esto sucede porque en el ejemplo anterior, la tubería hace read
que se ejecute en un subproceso y, como tal, no puede afectar el entorno del proceso principal.
Microsoft NMAKE
En Microsoft NMAKE , aquí los documentos se denominan archivos en línea . Se hace referencia a los archivos en línea como <<
o <
<<
una línea por sí mismo, seguido opcionalmente por la palabra clave (que no distingue entre mayúsculas y minúsculas) KEEP
o NOKEEP
para indicar si el archivo creado debe conservarse.
target0 : dependiente 0 comando0 << archivo temporal en línea ... <<target1 : dependiente 1 comando1 << archivo en línea temporal, pero conservado ... << MANTENERtarget2 : dependiente 2 command2 << filename2 archivo en línea nombrado, pero descartado ... << NOKEEPtarget3 : dependiente 3 command3 << filename3 archivo en línea con nombre ...<< MANTENER
R
R no tiene literales de archivo, pero proporciona una funcionalidad equivalente al combinar literales de cadena con una función de cadena a archivo. R permite espacios en blanco arbitrarios, incluidas nuevas líneas, en cadenas. Luego, una cadena se puede convertir en un descriptor de archivo usando 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 HS.Grad 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, antiguo Perl) marca el final del segmento de código y el comienzo del segmento de datos. Sólo se ejecutan los contenidos antes de esta línea, y los contenidos del archivo fuente después de esta línea están disponibles como un objeto de archivo: PACKAGE::DATA
en Perl (por ejemplo, main::DATA
) y DATA
en 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 idiomas, el término "aquí documento" se refiere en cambio a literales de cadena de varias líneas, como se explica a continuación.
Esquema de URI de datos
Como se explica con más detalle en el esquema de URI de datos , todos los principales navegadores web comprenden los URI que comienzan con datos: como aquí se documenta.
Literales de cadena de varias líneas
El término "aquí documento" o "aquí cadena" también se utiliza para cadenas literales multilínea en varios lenguajes de programación, notablemente Perl (sintaxis influenciada por el shell de Unix), y lenguajes influenciados por Perl, notablemente PHP y Ruby. La <<
sintaxis de estilo shell a menudo se conserva, a pesar de que no se utiliza para la redirección de entrada.
Influenciado por Perl
Perl
En Perl hay varias formas diferentes de invocar aquí documentos. [8] Los delimitadores alrededor de la etiqueta tienen el mismo efecto dentro del documento aquí que en un literal de cadena normal: por ejemplo, usar comillas dobles alrededor de la etiqueta permite interpolar variables , pero usar comillas simples no lo hace, y usar la etiqueta sin ninguno de los dos se comporta como comillas dobles. El uso de comillas inversas como delimitadores alrededor de la etiqueta ejecuta el contenido del documento heredoc como un script de shell. Es necesario asegurarse de que la etiqueta final 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 que comienza en la siguiente línea. Entonces, la declaración que contiene la etiqueta continúa después de la etiqueta.
Aquí hay un ejemplo con comillas dobles:
my $ sender = "Buffy, la cazavampiros" ; mi $ destinatario = "Pico" ;print << " FIN ";Estimado $ destinatario:Deseo que te vayas de Sunnydale y nunca regreses.Not Quite Love, $ senderFINAL
Producción:
Estimado Spike,Deseo que te vayas de Sunnydale y nunca regreses.No del todo amorBuffy la caza vampiros
Aquí hay un ejemplo con comillas simples:
print << ' FIN '; Estimado $ destinatario:Deseo que te vayas de Sunnydale y nunca regreses.Not Quite Love, $ sender END
Producción:
Estimado $ destinatario:Deseo que te vayas de Sunnydale y nunca regreses.No del todo amor$ remitente
Y un ejemplo con comillas invertidas (puede que no sea portátil):
my $ shell_script_stdout = << `FIN` ; echo foo echo bar END
Es posible iniciar varios heredocs en la misma línea:
say ( << BEGIN . "este es el medio \ n" . << END ); Este es el principio: EMPEZAR Y ahora que es más ! FINAL# esto es equivalente a: say ( "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 el uso de heredocs sin romper la sangría .
diga << 'FIN' ; Hola Mundo FIN
Aunque desde la versión 5.26 de Perl, [9] heredocs pueden incluir sangría:
# imprime "Hola \ n" sin espacios en blanco iniciales. if ( 1 ) { imprimir << ~ EOF ; Hola allí EOF }
Además de estas cadenas, Perl también presenta literales de archivo, es decir, el contenido del archivo que sigue __DATA__
(anteriormente __END__
) en una línea por sí mismo. Esto es accesible como el objeto de archivo PACKAGE::DATA
como main::DATA
, y puede verse como una forma de segmento de datos .
PHP
En PHP, aquí los documentos se denominan heredocs . En PHP heredocs no son cadenas literales. El texto de Heredoc se comporta como una cadena entre comillas dobles, pero sin las comillas dobles. Por ejemplo, lo que significa que `$` se analizará como un inicio de variable y `$ {` o `{$` como un inicio de variable compleja.
php $ nombre = "Joe Smith" ; $ ocupación = "Programador" ; echo <<< EOFEsta es una sección de heredoc. Para obtener más información, hable con $ name, su ocupación $ local.¡Gracias!EOF ;$ toprint = <<< EOF¡Hola, $ nombre! ¡De hecho, puede asignar la sección heredoc a una variable!EOF ; echo $ toprint ;?>
Salidas
Esta es una sección de heredoc.Para obtener más información, hable con Joe Smith, su programador local.¡Gracias!¡Hola Joe Smith! ¡De hecho, puede asignar la sección heredoc a una variable!
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 producirá un error de análisis en la última línea del script. [10]
En PHP 5.3 y posteriores, como Perl, es posible no interpolar variables rodeando la etiqueta con comillas simples; esto se llama un nowdoc : [11]
$ x = <<< ' END ' Estimado $ destinatario:Deseo que te vayas de Sunnydale y nunca regreses.No es absolutamente amor, $ sender END ;
En PHP 5.3+ también es posible rodear la etiqueta con comillas dobles, que como Perl tiene el mismo efecto que no rodear la etiqueta con nada en absoluto.
Rubí
El siguiente código de Ruby muestra una lista de compras usando un documento aquí.
pone << GROCERY_LIST Lista de la compra ---- 1. Mezcla de ensalada. 2. Fresas. * 3. Cereales. 4. Leche. * * Organic GROCERY_LIST
El resultado:
$ ruby grocery-list.rb Lista de la compra ------------ 1. Mezcla de ensalada. 2. Fresas. * 3. Cereales. 4. Leche. * * Orgánica
El <<
documento in a here no indica redirección de entrada, pero Ruby también lo 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 la compra" , "w" ) hacer | f | f << << GROCERY_LIST Lista de la compra ---- 1. Mezcla de ensalada. 2. Fresas. * 3. Cereales. 4. Leche. * * Orgánica GROCERY_LIST final
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 aquí está marcado con un iniciador ligeramente diferente <<-
. Además, Ruby trata aquí los documentos como una cadena entre comillas dobles y, como tal, es posible utilizar la #{}
construcción para interpolar código. El siguiente ejemplo ilustra estas dos 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 aquí:
put << ~ EOF Esta línea tiene dos espacios sangrados. Esta línea tiene cuatro espacios sangrados. 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 sangrado-heredoc.rb Esta línea tiene dos espacios sangrados. Esta línea tiene cuatro espacios sangrados. 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 + "<--- middle ---> \ n " + << END Este es el comienzo: BEGIN ¡ Y ahora se acabó! FINAL# esto es igual a esta expresión: pone "Este es el comienzo: \ n <--- medio ---> \ n ¡ Y ahora se acabó!"
Al igual que con Perl, Ruby presenta literales de archivo, es decir, el contenido del archivo que sigue __END__
una línea por sí mismo. Esto es accesible como el objeto de archivo DATA
y puede verse como una forma de segmento de datos .
Pitón
Python admite cadenas de varias líneas como una cadena "literal".
print ( "" " Cliente: ¿No es una gran tienda de quesos? Comerciante: El mejor del distrito, señor. " "" )
Desde Python 3.6 en adelante, las cadenas f textuales admiten la interpolación de variables y expresiones.
shop_type = "CHEESE" accolade = "finest" print ( f "" " Cliente: No es una tienda { shop_type . lower () } ¿verdad? Comerciante: { accolade . capitalize () } en el distrito, señor. " " " )
D
Desde la versión 2.0, D tiene soporte para cadenas de estilo de documento usando el carácter de prefijo 'q'. Estas cadenas comienzan con q"IDENT
seguidas inmediatamente por una nueva línea (para un identificador arbitrario IDENT) y terminan con IDENT"
al comienzo de una línea.
int main () { string list = 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 cadenas que comienzan con q"[
y terminan con ]"
o de manera similar para otro carácter delimitador (cualquiera de () <> {} o []).
OS / JCL
En Job Control Language (JCL) de IBM utilizado en su MVS anterior y en los sistemas operativos z / OS actuales, los datos que están en línea con una secuencia de trabajos se pueden identificar mediante un * en una declaración DD, como o En el primer caso, las líneas de texto siguen y se combinan en un pseudoarchivo con el nombre de 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 usa para especificar la cadena de texto que indica el final de los datos, que se puede usar si un flujo de datos contiene JCL (nuevamente, cualquier línea que comience con ), o la secuencia (como comentarios en 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' ) // EXEC ASMLG // SYSIN DD * APROG START XR 15,15 BR 14 END / * // * FINALIZA EL TRABAJO
El enunciado es el equivalente funcional de Indicar que sigue el flujo de datos, terminado por .//SYSIN DD *
<
/*
Raqueta
Raqueta Es aquí cuerdas empezar con #<<
seguido de caracteres que definen un terminador de la cadena. [12] 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 siguiente #<<
y termina antes de una nueva línea seguida por el terminador.
#lang raqueta( displayln # << HERESTRING Esta es una simple cadena here 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 inicial y final; todos los caracteres están incluidos en la cadena (y terminador) literalmente.
#lang raqueta( displayln # << Una cadena aquí en Racket ☺ Esta cadena abarca varias líneas y puede contener cualquier símbolo Unicode. Así que 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 cuerda aquí en Racket ☺ )
Salidas:
Esta cadena abarca varias líneasy puede contener cualquier símbolo Unicode.Así que 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!
Aquí, las cadenas se pueden usar normalmente en contextos donde las cadenas normales:
#lang raqueta( printf # << END Estimado ~ a,Gracias por la perspicaz conversación ~ a. ~ aFIN "Isaac" "ayer" "Carl" )
Salidas:
Querido Isaac,Gracias por la perspicaz conversación de ayer. Carl
Una alternativa interesante es usar la extensión de idioma at-exp
para escribir expresiones @. [13] Se ven así:
#lang at-exp racket
(displayln @ string-append {Esta es una cadena largamuy conveniente cuando ungran parte del texto esnecesario.No te preocupes por escapar"comillas" o \ escapes. Estambién está bien tener λ, γ, θ, ...Código de inserción:@(number->string (+ 3 4))
})
Salidas:
Esta es una cadena largamuy conveniente cuando ungran parte del texto esnecesario.No te preocupes por escapar"comillas" o \ escapes. Estambié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.
Windows PowerShell
En Windows PowerShell , aquí los documentos se denominan here-strings . Una cadena aquí es una cadena que comienza con un delimitador abierto ( @"
o @'
) y termina con un delimitador cerrado ( "@
o '@
) en una línea por sí misma, que termina la cadena. Todos los caracteres entre el delimitador de apertura y cierre se consideran literal de cadena. El uso de una cadena here con comillas dobles permite interpretar las variables , mientras que el uso de comillas simples no. La interpolación de variables ocurre con variables simples (por ejemplo, $x
pero NO $x.y
o $x[0]
). Puede ejecutar un conjunto de declaraciones colocándolas en $()
(por ejemplo, $($x.y)
o $(Get-Process | Out-String)
).
En el siguiente código de PowerShell, el texto se pasa a una función mediante here-string. La función ConvertTo-UpperCase
se 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 declaraciones usando una cadena here con comillas dobles:
PD> $ 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 esos mis relojes que oigo? >> $ marty: ¡Sí! ¡Eh, son las $ ($ hora.Hora) en punto! >> $ doc: ¡Perfecto! ¡Mi experimento funcionó! Todos son exactamente $ ($ diff.Minutos ) minutos lento. >> $ marty: Espere un minuto. Espere un minuto. Doc ... ¿Me está diciendo que es $ (($ time + $ diff) .ToShortTimeString ())? >> $ doc: Precisamente. > > $ marty: ¡Maldita sea! ¡Llego tarde a la escuela! >> "@ Dr. Emmett Brown: ¿Son esos mis relojes que escucho? Marty McFly: ¡Sí! ¡Son las 8 en punto! Dr. Emmett Brown: ¡Perfecto! ¡Mi experimento funcionó! Todos son exactamente 25 minutos lentos. Marty McFly: Espera un minuto. Espera un minuto. Doc ... ¿Me estás diciendo que son las 08:25? Dr. Emmett Brown: Precisamente. Marty McFly: ¡Maldita sea! ¡Llego tarde a la escuela!
Usando una cadena here con comillas simples en su lugar, la salida se vería así: Salida:
PD> @ ' >> $ doc: ¿Son esos los relojes que escucho? >> $ marty: ¡Sí! ¡Eh, son las $ ($ time.Hour) en punto! >> $ doc: ¡Perfecto! ¡Mi experimento funcionó! Todos son exactamente $ ($ diff.Minutes) minutos lentos. >> $ 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! >> '@ $ doc: ¿Son esos mis relojes que escucho? $ marty: ¡Sí! ¡Eh, son las $ ($ time.Hour) en punto! $ doc: ¡Perfecto! ¡Mi experimento funcionó! Todos son exactamente $ ($ diff.Minutes) minutos lentos. $ 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!
Lenguaje de comandos DIGITAL (DCL)
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ícitamente con 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 repetirá directamente en la pantalla mediante el comando TYPE. $ ! otros comandos ...
produce:
Este texto se repetirá directamentea la pantalla mediante el comando TYPE.
Además, el comando DECK, inicialmente destinado al soporte de tarjetas perforadas (de ahí su nombre: significaba el comienzo de una baraja de datos ) se puede utilizar para proporcionar entrada al comando anterior. [14] La plataforma de entrada finaliza con el comando $ EOD o el patrón de caracteres especificado por el parámetro / DOLLARS para DECK.
Ejemplo de un programa que suma valores monetarios:
$ EJECUTAR ADD_SUMS.EXE$ CUBIERTA$ 13.53$ 3.33$ 2.33$ EOD
Produciría la siguiente salida (suponiendo que ADD_SUMS se escribió para leer los valores y agregarlos):
$ 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 comando desde dentro de un archivo de comando $ $$ $ $ ! siguen otros comandos ...
YAML
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 es capaz de representar cadenas de varias líneas con literales de cadena plegada:
--- título : "Ejemplo de funcionalidad estilo heredoc usando YAML" fecha : "2007-06-01" ejemplo : > HTML entra en YAML sin mensaje de modificación : |
"Tres siempre es mayor que dos,
incluso para valores grandes de dos" - Autor desconocido
Ver también
- Canalización (Unix)
Referencias
- ^ a b "Descripción de Here-Document en el estándar POSIX / SUS" . Archivado desde el original el 27 de abril de 2014 . Consultado el 20 de abril de 2018 .
- ^ "Aquí documento - Código Rosetta" . rosettacode.org . Consultado el 20 de febrero de 2017 .
- ^ a b Página de manual de Darwin tcsh
- ^ Wayne Pollock. "Descripción general del documento Shell Here" . hccfl.edu. Archivado desde el original el 29 de mayo de 2014 . Consultado el 28 de mayo de 2014 .
- ^ Ver, por ejemplo, Usar variables dentro de un heredoc bash
- ^ perldata: Literales especiales
- ^ Ruby: Objeto: __END__
- ^ Operadores de Perl y precedencia
- ^ https://perldoc.perl.org/perl5260delta.html#Indented-Here-documents
- ^ Heredoc en el manual de PHP
- ^ http://www.php.net/manual/en/language.types.string.php#language.types.string.syntax.nowdoc
- ^ Aquí cadena en la documentación de la raqueta
- ^ @ Sintaxis en la documentación de la raqueta
- ^ http://h71000.www7.hp.com/doc/83final/9996/9996pro_45.html
General
- Manual de referencia de Bash
- 3.6.6 Aquí Documentos
- 3.6.7 Aquí cadenas
- Guía avanzada de secuencias de comandos de Bash , Mendel Cooper
- Capítulo 19. Aquí Documentos
- 19.1. Aquí cadenas
- ^ Más detalladamente, en bash: “todas las líneas del documento here están sujetas a expansión de parámetros, sustitución de comandos y expansión aritmética. En el último caso, se ignora la secuencia de caracteres \ newline y se debe usar '\' para citar los caracteres '\', '$' y '`'.”, Según 3.6.6 Here Documents . Tenga en cuenta que
"
no tiene un significado especial en un documento aquí y no necesita escaparse, a diferencia de una cadena entre comillas dobles; de lo contrario, son esencialmente idénticos. - ^ "Citar" incluye el escape, por lo que si
\EOF
se usa, se cita, por lo que la interpolación de variables no ocurre y termina conEOF
, mientras que si\\EOF
se usa, se cita y termina con\EOF
. Sin embargo, este comportamiento quizás sorprendente se implementa fácilmente en un shell, ya que el tokenizador simplemente registra que se citó un token (durante la fase de evaluación del análisis léxico ), sin necesidad de preservar el valor cotizado original.
Una aplicación es usar\'
como delimitador inicial y, por lo tanto,'
como delimitador final, que es similar a un literal de cadena de varias líneas pero elimina los saltos de línea iniciales y finales. - ^ Tenga en cuenta que, si bien las pestañas generalmente se pueden ingresar en los editores, en la línea de comando generalmente se ingresan conCtrl+V+ en suTab ↹lugar, debido a la finalización de la pestaña , y en el ejemplo son pestañas reales, por lo que el ejemplo se puede copiar y pegar.
enlaces externos
- Aquí documento . Enlace a la tarea del Código Rosetta con ejemplos de estos documentos en más de 15 idiomas.