En informática , un documento aquí ( documento aquí , texto-aquí , texto -hered , aquí- es , cadena-aquí o script-aquí ) 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 era un archivo separado . El término también se utiliza para una forma de cadenas literales de varias líneas que utilizan 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), el shell C ( csh), [2] tcsh ( tcsh), [3] KornShell ( ksh), el shell Bourne Again ( bash) y el shell Z ( zsh), entre otros. 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 funciones para cadenas multilínea.
Aquí los documentos se pueden tratar 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 estos documentos, que se origina en shells de Unix, va <<seguida de un identificador delimitador (a menudo la palabra o [4] ), seguido, comenzando en la línea siguiente, 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 los documentos aquí son formalmente literales de flujo, y el contenido del documento aquí a menudo se redirige a la entrada estándar (entrada estándar) del comando anterior o al 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, <seguida del 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 usa simplemente para cadenas literales, <<no indica dirección indirecta, sino que es simplemente una convención delimitadora inicial. En algunos lenguajes, como Ruby, <<también se usa para la redirección de entrada, por lo que <<se usa dos veces si se desea redirigir desde un literal de cadena de documento aquí.
En sentido estricto, aquí los documentos son literales de archivo o literales de secuencia. Estos se originan en el shell de Unix, aunque hay funciones similares disponibles en algunos otros idiomas.
Aquí los documentos están disponibles en muchos shells de Unix. [1] En el siguiente ejemplo, el texto se pasa al trcomando (transliterando de minúsculas a mayúsculas) utilizando un documento aquí. Esto podría estar en un archivo de shell o ingresarse de forma interactiva cuando se le solicite.
$ LANG = C tr a-z A-Z << FIN > uno dos tres > cuatro cinco seis > FIN
UNO DOS TRES CUATRO CINCO SEISEn este caso ENDse utilizó como identificador delimitador. Especificó el inicio y el final del documento aquí. No es necesario que el redireccionamiento y el identificador delimitador estén separados por un espacio: <<ENDo << ENDambos funcionan igual de 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 entre 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 citando cualquier parte de la etiqueta, que luego termina con el valor sin comillas; [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` También se pueden usar comillas dobles, pero esto está sujeto a confusión, porque la expansión ocurre en una cadena entre comillas dobles, pero no ocurre en un documento aquí con un delimitador de comillas dobles. [5] Los delimitadores entre comillas simples y dobles se distinguen en algunos otros lenguajes, especialmente en Perl (ver más abajo), donde el comportamiento es paralelo al de las comillas de cadenas correspondientes.
En el shell POSIX , pero no en csh/tcsh, agregar un signo menos a <<(es decir, <<-) 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ías existentes) 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 principio de esta línea. Esta línea comienza con un solo carácter 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 principio de esta línea. Esta línea comienza con un solo carácter 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 comenzó con un TAB NO fue reconocida y echo el comando tr continuó procesándose. produce:
AQUÍ DOC CON <<- UN CARÁCTER DE ESPACIO ÚNICO (ES IE 0X20) ESTÁ AL PRINCIPIO DE ESTA LÍNEA ESTA LÍNEA COMIENZA CON UN CARÁCTER DE TABÚ ÚNICO, IE 0X09 COMO LO HACE LA SIGUIENTE LÍNEA El final previsto estaba antes de esta línea y estos no fueron procesados por tr +++++++++++++++ AQUÍ DOC CON << UN CARÁCTER DE ESPACIO ÚNICO (ES DECIR 0X20) ESTÁ AL PRINCIPIO DE ESTA LÍNEA ESTA LÍNEA COMIENZA CON UN CARÁCTER DE TABÚ ÚNICO, ES DECIR 0X09 COMO LA SIGUIENTE LÍNEA END_TEXTECHO EL FINAL DESEADO ESTABA ANTES DE ESTA LÍNEA, ECHO PERO PORQUE LA LÍNEA CON EL IDENTIFICADOR DELIMITADOR COMENZÓ CON UNA PESTAÑA NO FUE RECONOCIDA Y ECHO EL COMANDO TR CONTINUÓ PROCESANDO.Otro uso es enviar a un archivo:
$ cat << EOF > ~/testFile001 > 3 espacios preceden a este texto. > Hay un solo carácter de tabulación al principio de esta línea. >Nada precede a este texto EOFUna cadena aquí (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 utiliza la sintaxis de shell habitual para la palabra (“sintaxis de cadena aquí”), 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 a-z A-Z <<< uno UNO En caso de una cadena con espacios se debe citar:
$ 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, que producen:
$ LANG = C tr a-z A-Z <<< ' uno > dos tres' UNO DOS TRES Tenga en cuenta que se incluyen las nuevas líneas iniciales y finales, si están presentes:
$ LANG = C tr a-z A-Z <<< ' > uno > dos tres > ' UNO, DOS, TRES$La diferencia clave con respecto a estos documentos es que, en estos documentos, los delimitadores están en líneas separadas; las nuevas líneas iniciales y finales se eliminan. A diferencia de los documentos aquí, aquí las cadenas no utilizan delimitadores.
Aquí las cadenas son particularmente útiles para comandos que a menudo requieren entradas breves, como la calculadora bc:
$ antes de Cristo <<< 2 ^10 1024 Tenga en cuenta que aquí el comportamiento de la cadena también se puede lograr (invirtiendo el orden) mediante tuberías y el echocomando, como en:
$ echo 'uno dos tres' | IDIOMA = 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 del comando readintegrado:
$ echo 'uno dos tres' | leer -r a b c $ echo " $a $b $c " no produce nada, mientras
$ leer -r a b c <<< 'uno dos tres' $ echo " $a $b $c " uno dos tres Esto sucede porque en el ejemplo anterior la tubería hace readque se ejecute en un subproceso y, como tal, no puede afectar el entorno del proceso principal.
En Microsoft NMAKE , aquí los documentos se denominan archivos en línea . Se hace referencia a los archivos en línea como <<o <<pathname: la primera notación crea un archivo temporal, la segunda notación crea (o sobrescribe) el archivo con el nombre de ruta especificado. Un archivo en línea termina en <<una línea sola, seguida opcionalmente por la palabra clave (que no distingue entre mayúsculas y minúsculas) KEEPo NOKEEPpara indicar si el archivo creado debe conservarse.
target0 : dependiente 0 comando0 << archivo temporal en línea ... << destino1 : dependiente 1 comando1 << archivo en línea temporal, pero conservado ... <<KEEP destino2 : dependiente 2 comando2 <<nombre de archivo2 nombrado, pero archivo en línea descartado ... <<NOKEEP destino3 : dependiente 3 comando3 <<nombre de archivo3 archivo en línea nombrado ... <<MANTENER 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 1 5Arkansas 2110 3378 1,9 70,66 10,1 39,9 65" x <- read.table ( textConnection ( cadena ), encabezado = VERDADERO , fila.nombres = 1 ) Perl [6] y Ruby [7] tienen una forma de archivo literal, que puede considerarse una forma de segmento de datos . En estos lenguajes, incluso 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. Sólo 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 aquí, aunque solo puede haber uno por secuencia de comandos. Sin embargo, en estos idiomas el término "documento aquí" se refiere a cadenas literales 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 principales navegadores web entienden los URI que comienzan con datos: como se documenta aquí.
El término "documento aquí" o "cadena aquí" también se utiliza para literales de cadenas multilínea en varios lenguajes de programación, en particular Perl (sintaxis influenciada por el shell Unix) y lenguajes influenciados por Perl, en particular PHP y Ruby. La sintaxis de estilo shell <<a menudo se conserva, a pesar de no usarse para la redirección de entrada.
En Perl hay varias formas diferentes de invocar estos documentos. [8] Los delimitadores alrededor de la etiqueta tienen el mismo efecto dentro del documento aquí que lo tendrían en una cadena literal normal: por ejemplo, usar comillas dobles alrededor de la etiqueta permite interpolar variables , pero usar comillas simples no, y usar la etiqueta sin ninguno de los dos se comporta como comillas dobles. El uso de 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 final esté al principio de la línea o el intérprete no la reconocerá.
Tenga en cuenta que el documento aquí no comienza en la etiqueta, sino que comienza en la línea siguiente. Entonces, la declaración que contiene la etiqueta continúa después de la etiqueta.
Aquí hay un ejemplo con comillas dobles:
mi $remitente = "Buffy, la cazavampiros" ; mi $destinatario = "Spike" ; imprimir <<" FIN "; Estimado destinatario de $:Deseo que te vayas de Sunnydale y nunca regreses.No del todo amor, $ remitenteFINProducción:
Estimado Spike,Deseo que te vayas de Sunnydale y nunca regreses.No del todo amor, Buffy, la cazavampirosAquí hay un ejemplo con comillas simples:
imprimir <<' FIN '; Estimado destinatario de $: Deseo que te vayas de Sunnydale y nunca regreses.No del todo amor, $sender FINProducción:
Estimado destinatario de $:Deseo que te vayas de Sunnydale y nunca regreses.No del todo amor, $ remitenteY un ejemplo con comillas invertidas (puede que no sea portátil):
mi $shell_script_stdout = << `END` ; echo foo barra de eco FIN Es posible iniciar varios heredocs en la misma línea:
say ( << BEGIN . "este es el medio\n" . << END ); Este es el comienzo: COMENZAR ¡ Y ahora se acabó ! FIN # 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 fin del mundo Aunque desde la versión 5.26 de Perl, [9] los documentos aquí pueden incluir sangría:
#imprime "Hola\n" sin espacios en blanco al principio. si ( 1 ) { imprimir <<~ EOF ; Hola EOF } Además de estas cadenas, Perl también incluye literales de archivo, es decir, el contenido del archivo que sigue __DATA__(antes __END__) en una línea aparte. Es accesible como objeto de archivo , PACKAGE::DATApor ejemplo main::DATA, y puede verse como una forma de segmento de datos .
En PHP, aquí los documentos se denominan heredocs . En PHP, los heredocs no son cadenas literales. El texto Heredoc se comporta como una cadena entre comillas dobles, pero sin comillas dobles. Por ejemplo, el significado `$` se analizará como un inicio de variable y `${` o `{$` como un inicio de variable compleja.
<?php $nombre = "Joe Smith" ; $ocupación = "Programador" ; eco <<< EOFEsta es una sección heredoc. Para obtener más información, hable con $name, su $ocupación local.¡Gracias!EOF ;$imprimir = <<< EOFHola $nombre! ¡De hecho, puedes asignar la sección heredoc a una variable!EOF ; echo $imprimir ;?>Salidas
Esta es una sección heredoc. 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á 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 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 posteriores, al igual que Perl, es posible no interpolar variables encerrando la etiqueta entre comillas simples; esto se llama nowdoc : [11]
$x = <<<' END ' Estimado $destinatario,Deseo que te vayas de Sunnydale y nunca regreses.No del todo amor, $sender END ;En PHP 5.3+ también es posible rodear la etiqueta con comillas dobles, lo que al igual que Perl tiene el mismo efecto que no rodear la etiqueta con nada en absoluto.
El siguiente código Ruby muestra una lista de compras utilizando un documento aquí.
pone << GROCERY_LIST Lista de compras ---- 1. Mezcla de ensalada. 2. Fresas.* 3. Cereales. 4. Leche.* * Orgánica GROCERY_LIST El resultado:
$ ruby comestibles-list.rb Lista de compras ------------ 1. Mezcla de ensalada. 2. Fresas.* 3. Cereales. 4. Leche.* *Orgánica En <<un documento aquí 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 aquí implica usar <<dos veces, en diferentes sentidos:
Archivo :: abrir ( "lista de compras" , "w" ) hacer | f | f << << GROCERY_LIST Lista de compras ---- 1. Mezcla de ensalada. 2. Fresas.* 3. Cereales. 4. Leche.* * Fin de GROCERY_LIST orgánico 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 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 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:
puts << BEGIN + "<--- middle ---> \n " + << END Este es el comienzo: BEGIN ¡ Y ahora se acabó! FIN # esto es igual a esta expresión: pone "Este es el comienzo: \n <--- medio ---> \n ¡Y ahora se acabó!" Al igual que Perl, Ruby presenta archivos literales, es decir, el contenido del archivo que sigue __END__en una línea. Es accesible como objeto de archivo DATAy puede verse como una forma de segmento de datos .
Python admite cadenas de varias líneas como una cadena "textual". Pueden estar entre comillas simples (') o dobles ("), estas últimas se muestran en los ejemplos siguientes.
print ( """ Cliente: No es una gran tienda de quesos, ¿verdad? Tendero: La 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 hay mucha tienda de { shop_type . lower () }, ¿verdad? Tendero: { accolade . capitalize () } en el distrito, señor. "" " )Desde C++11 , C++ admite cadenas literales con delimitador personalizado ("my_delimiter" en este ejemplo):
#incluir <ostream> const char * str = R " my_delimiter ( Inicio de la cadena. Nueva barra diagonal \ quote " ' parens ) ( Fin de la cadena ) my_delimiter " ; std :: cout << str << std :: endl ; imprimirá
Inicio de cuerda. Nueva líneabarra diagonal \ cita " ' parens ) (Fin de la cadena
Desde la versión 2.0, D admite aquí cadenas de estilo documento que utilizan el carácter de prefijo 'q'. Estas cadenas comienzan con q"IDENTseguida inmediatamente de una nueva línea (para un identificador arbitrario IDENT) y terminan 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 sintaxis similar, con cadenas que 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 anterior y z/OS actual , 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 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 usa para especificar la cadena de texto que señala el final de los datos, que se puede usar si un flujo de datos contiene JCL (de nuevo, 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, 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 /* //* EL TRABAJO FINALIZA La declaración es el equivalente funcional de
Indicar que sigue el flujo de datos, terminado en .//SYSIN DD *<</*/*
Aquí las cadenas de Racket comienzan con #<<seguidas de caracteres que definen un terminador para 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 #<<y termina antes de una nueva línea seguida por el terminador.
#lang raqueta( displayln #<<HERESTRING Esta es una cadena aquí simple en Racket. * Uno * Dos * Tres HERESTRING ) Salidas:
Esta es una cadena simple aquí en Racket. * Uno , dos , tresNo se reconocen secuencias de escape entre las líneas inicial y final; todos los caracteres están incluidos en la cadena (y el terminador) literalmente.
#lang raqueta( displayln #<<A here string in Racket ☺ Esta cadena se extiende por varias líneas y puede contener cualquier símbolo Unicode. Entonces, cosas como λ, ☠, α, β, están todas bien. En la siguiente línea viene el terminador. También puede contener cualquier símbolo Unicode, ¡incluso espacios y emoticones! Una cuerda aquí en Racket ☺ ) Salidas:
Esta cadena abarca varias líneas y puede contener cualquier símbolo Unicode. Entonces cosas como λ, ☠, α, β están todas bien.En la siguiente línea viene el terminador. También puede contener cualquier símbolo Unicode, ¡incluso espacios y emoticones!Aquí las cadenas se pueden usar normalmente en contextos donde las cadenas normales lo harían:
#lang raqueta( printf #<<END Estimada ~a, Gracias por la interesante conversación ~a. ~unFIN "Isaac" "ayer" "Carl" ) Salidas:
Querido Isaac,Gracias por la reveladora conversación de ayer. carlosUna alternativa interesante es utilizar la extensión del idioma at-exppara escribir expresiones @. [13]
Se ven así:
#lang at-exp racket(displayln @string-append{Esta es una cuerda largamuy conveniente cuando unun trozo de texto largo 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 larga, muy conveniente cuando se necesita una gran cantidad de texto .No te preocupes por escapar de "comillas" o \escapes. También está bien tener λ, γ, θ, ...Código para insertar: 7Una 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 , aquí los documentos se denominan aquí-cadenas . Una cadena aquí es una cadena que comienza con un delimitador abierto ( @"o @') y termina con un delimitador cerrado ( "@o '@) en una línea sola, que termina la cadena. Todos los caracteres entre el delimitador de apertura y cierre se consideran literales de cadena. El uso de una cadena aquí con comillas dobles permite interpretar las variables , el uso de comillas simples no.La interpolación de variables se produce con variables simples (por ejemplo, $xpero NO $x.yo $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 una cadena aquí. La función ConvertTo-UpperCasese define de la siguiente manera:
PD> función Convertir a mayúsculas ( $cadena ) { $cadena . ToUpper () } PS > ConvertTo-UpperCase @ ' >> uno dos tres >> eins dos tres >> '@ 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 aquí con comillas dobles:
PD > $doc , $marty = 'Dr. Emmett Brown' , 'Marty McFly' PD > $time = [DateTime] 'Viernes, 25 de octubre de 1985 8:00:00 AM' PS > $diff = New-TimeSpan -Minutos 25 PS > @" >> $doc : ¿Son esos mis relojes los que escucho? >> $marty: ¡Sí! ¡Uh, son las $($time.Hour) en punto! >> $doc: ¡Perfecto! ¡Mi experimento funcionó! Todos son exactamente $($diff.Minutes) ) 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: ¿Esos 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: Espera un minuto. Espera un minuto. Doc... ¿Me está diciendo que son las 08:25? Dr. Emmett Brown: Precisamente. Marty McFly: ¡Maldita sea! ¡Llego tarde a la escuela!Usando una cadena aquí con comillas simples, el resultado se vería así:
PS > @ ' >> $doc: ¿Son esos mis relojes los 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á diciendo que es $(($time + $diff).ToShortTimeString())? >> $doc : Precisamente. >> $marty: ¡Maldita sea! ¡Llego tarde a la escuela! >> '@ $doc: ¿Son esos mis relojes los 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á 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 el símbolo $ se trata implícitamente como entrada para el comando anterior; todas las líneas que no comienzan 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, hacer referencia explícita a la entrada como SYS$INPUT:
$ TYPE SYS $INPUT Este texto se reflejará directamente en la pantalla mediante el comando TYPE. $ ! otros comandos ...produce:
Este texto se reflejará directamente en la pantalla mediante el comando TIPO.Además, el comando DECK, inicialmente destinado al soporte de tarjetas perforadas (de ahí su nombre: significaba el comienzo de una plataforma de datos ), se puede utilizar para proporcionar información al comando anterior. [14] La plataforma 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$ EODProduciría el siguiente resultado (suponiendo que ADD_SUMS se haya escrito para leer los valores y agregarlos):
$19.19Ejemplo 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 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 plegada:
--- título : "Ejemplo de funcionalidad de estilo heredoc usando YAML" fecha : "2007-06-01" ejemplo : > HTML entra en YAML sin mensaje de modificación : | <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> "no tiene un significado especial en un documento aquí y no es necesario utilizar un carácter de escape, a diferencia de una cadena entre comillas dobles; por lo demás son esencialmente idénticos.\EOFse usa, esto se cita, por lo que no se produce la interpolación de variables y termina con EOF, mientras que si \\EOFse usa, esto 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 citado original. \'como delimitador inicial y, por lo tanto, 'como delimitador final, que es similar a un literal de cadena multilínea pero elimina los saltos de línea inicial y final.