Här dokument
I datoranvändning är ett här-dokument ( här-dokument , här-text , härdok , här , här-sträng eller här-skript ) en fil- literal eller ingångsström -literal: det är en del av en källkodsfil som behandlas som om det var en separat fil . Termen används också för en form av flerradiga strängliteraler som använder liknande syntax, bevarar radbrytningar och andra blanksteg (inklusive indrag) i texten.
Här har dokument sitt ursprung i Unix-skalet , och finns i Bourne-skalet ( sh ), C-skalet ( csh ), tcsh ( tcsh ), KornShell ( ksh ), Bourne Again Shell ( bash ) och Z-skalet ( zsh ), bland annat andra. Här finns strängliteraler i dokumentstil i olika högnivåspråk , särskilt programmeringsspråket Perl (syntax inspirerad av Unix-skal) och språk påverkade av Perl, som PHP och Ruby . JavaScript stöder även denna funktion via mallliterals , en funktion som lades till i sin sjätte version ( ES6 ). Andra högnivåspråk som Python , Julia och Tcl har andra faciliteter för flerradiga strängar.
Här kan dokument behandlas antingen som filer eller strängar. Vissa skal behandlar dem som en formatsträng literal, vilket tillåter variabel substitution och kommandosubstitution inuti literal.
Den vanligaste syntaxen för här dokument, med ursprung i Unix-skal, är << följt av en avgränsande identifierare (ofta ordet EOF eller END ), följt, med början på nästa rad, av texten som ska citeras, och sedan avslutas av samma avgränsande identifierare på sin egen rad. Denna syntax beror på att dokument här formellt är strömlitterala, och innehållet i dokumentet omdirigeras till stdin (standardinmatning) för föregående kommando; dokumentsyntaxen här är analogt med syntaxen för ingångsomdirigering , som är < "ta input från följande fil".
Andra språk använder ofta väsentligen liknande syntax, men detaljer om syntax och faktisk funktionalitet kan variera avsevärt. När det bara används för strängliteraler << inte inriktning, utan är helt enkelt en startavgränsningskonvention. På vissa språk, som Ruby, << också för indataomdirigering, vilket resulterar i att << används två gånger om man vill omdirigera från en här dokumentsträng literal.
Fil bokstavliga
Snävt sett är dokument här filliteraler eller streamliteraler. Dessa har sitt ursprung i Unix-skalet, även om liknande faciliteter finns tillgängliga på några andra språk.
Unix-skal
Här finns dokument tillgängliga i många Unix-skal. I följande exempel skickas text till tr- kommandot (translitterera små bokstäver till versaler) med hjälp av ett here-dokument. Detta kan vara i en skalfil eller inmatas interaktivt vid en prompt.
$ LANG = C tr az AZ << SLUT > en två tre > fyra fem sex > SLUT EN TVÅ TRE FYRA FEM SEX
END användes som avgränsande identifierare. Det specificerade början och slutet av här dokumentet. Omdirigeringen och den avgränsande identifieraren behöver inte separeras med ett mellanslag: <<END eller << END fungerar båda lika bra.
Som standard är beteendet i stort sett identiskt med innehållet i dubbla citattecken: variabelnamn ersätts med deras värden, kommandon inom backticks utvärderas, etc.
$ cat << EOF > \$ Working dir "$PWD" `pwd` > EOF $ Working dir "/home/user" /home/user Detta kan inaktiveras genom att citera valfri del av etiketten, som sedan avslutas med det icke-citerade värdet; beteendet är i huvudsak identiskt med det om innehållet var inneslutet i enstaka citattecken. Så till exempel genom att sätta det i enstaka citattecken:
$ cat << 'EOF' > \$ Working dir "$PWD" `pwd` > EOF \$ Working dir "$PWD" `pwd`
Dubbla citattecken kan också användas, men detta är föremål för förvirring, eftersom expansion sker i en sträng med dubbla citattecken, men inte i ett här dokument med dubbla citattecken. Enkel- och dubbelciterade avgränsare urskiljs på vissa andra språk, särskilt Perl (se nedan), där beteendet är parallellt med motsvarande strängcitat.
I POSIX-skalet, men inte csh/tcsh, har ett minustecken till << (dvs. <<- ) effekten att ledande flikar ignoreras. Detta tillåter indrag här dokument i skalskript (i första hand för anpassning till befintliga indrag) utan att ändra deras värde:
Ett skript som innehåller:
LANG = C tr az AZ <<- END_TEXT Här dokument med <<- Ett enstaka mellanslag (dvs. 0x20 ) är i början av denna rad. Denna rad börjar med ett enda TAB-tecken dvs 0x09 liksom nästa rad END_TEXT echo slutet var före detta radeko och dessa behandlades inte av tr echo ++++++++++++++++ LANG = C tr az AZ << END_TEXT Här dokument med << Ett enstaka mellanslag (dvs. 0x20 ) är i början av denna rad. Den här raden börjar med ett enda TAB-tecken dvs 0x09 liksom nästa rad END_TEXT echo Det avsedda slutet var före denna rad, echo men eftersom raden med den avgränsande identifieraren började med en TAB kändes den INTE igen och eka tr -kommandot fortsatt bearbetning. producerar:
HÄR ÄR DOKUMENT MED <<- EN ENKEL MELLANSLAGSTECKEN (Dvs. 0X20 ) I BÖRJAN AV DENNA RAD DENNA RAD BÖRJAR MED EN ENKEL TABBTECKET IE 0X09 SOM GÖR NÄSTA RAD Det avsedda slutet var före denna rad och dessa behandlades inte av tr +++++++++++++++ HÄR DOKUMENT MED << EN ENKEL MELLANSLAGSTEcken (Dvs. 0X20 ) ÄR I BÖRJAN AV DEN HÄR RADEN DEN HÄR RADEN BÖRJAR MED EN ENKEL TABB-TECKEN Dvs. 0X09 SOM NÄSTA RAD. END_TEXT EKHO DET AVSEENDE SLUTTET VAR FÖRE DEN HÄR RADEN, EKHO MEN FÖR ATT LINJEN MED DET AVGRÄNSANDE IDENTIFIERN BÖRJADE MED EN FLIK KÄNDES DEN INTE IGEN OCH EKOTAR TR-KOMMANDOET.En annan användning är att mata ut till en fil:
$ cat << EOF > ~/testFile001 > 3 blanksteg före denna text. > Ett enskilt tabbtecken finns i början av denna rad. >Inget föregår denna text EOF
Här strängar
En here-sträng (tillgänglig i bash , ksh , eller zsh ) är syntaktiskt lik och består av <<< , och påverkar indataomdirigering från ett ord (en sekvens som behandlas som en enhet av skalet, i det här sammanhanget vanligtvis en bokstavlig sträng). I det här fallet används den vanliga skalsyntaxen för ordet ("här strängsyntax"), där den enda syntaxen är omdirigeringen: en här-sträng är en vanlig sträng som används för inmatningsomdirigering, inte en speciell typ av sträng.
Ett enda ord behöver inte citeras:
$ LANG = C tr az AZ <<< en EN
Vid en sträng med mellanslag måste den citeras:
$ LANG = C tr az AZ <<< 'en två tre' EN TVÅ TRE
Detta kan också skrivas som:
$ foo = 'en två tre' $ LANG = C tr az AZ <<< " $foo " EN TVÅ TRE
Flerlinjesträngar är acceptabla, vilket ger:
$ LANG = C tr az AZ <<< ' en > två tre' EN TVÅ TRE
Observera att ledande och efterföljande nyrader, om sådana finns, ingår:
$ LANG = C tr az AZ <<< ' > en > två tre > ' EN TVÅ TRE $
Den viktigaste skillnaden från dokumenten här är att i dokumenten är avgränsningarna på separata rader; de ledande och efterföljande nylinjerna tas bort. Till skillnad från här dokument, här använder inte strängar avgränsare.
Här är strängar särskilt användbara för kommandon som ofta tar kort inmatning, till exempel kalkylatorn bc :
$ bc <<< 2 ^10 1024
Observera att strängbeteende här också kan åstadkommas (omvänd ordning) via rörledning och ekokommandot, som i:
$ echo 'ett två tre' | LANG = C tr az AZ ETT TVÅ TRE
Men här är strängar särskilt användbara när det sista kommandot måste köras i den aktuella processen, vilket är fallet med inbyggd läs :
$ echo 'ett två tre' | läs -rabc $ echo " $a $b $c "
ger ingenting, medan
$ read -rabc <<< 'en två tre' $ echo " $a $b $c " en två tre
Detta händer eftersom rörledningar i det föregående exemplet gör att läsning körs i en underprocess, och som sådan inte kan påverka miljön för den överordnade processen.
Microsoft NMAKE
I Microsoft NMAKE hänvisas här till dokument som inline-filer . Inline-filer refereras till som << eller <<sökvägsnamn : den första notationen skapar en temporär fil, den andra notationen skapar (eller skriver över) filen med det angivna sökvägsnamnet. En inbäddad fil avslutas med << på en rad för sig själv, eventuellt följt av nyckelordet (skiftlägeskänsligt) KEEP eller NOKEEP för att indikera om den skapade filen ska behållas.
target0 : dependent 0 command0 << temporary inline file ... << target1 : dependent 1 command1 << temporary, but beserved inline file ... <<KEEP
target2 : dependent 2 command2 <<filnamn2 namngiven, men kasserad inline fil .. <<NOKEEP
mål3 : beroende 3 kommando3 <<filnamn3 namngiven inline fil ... << KEEP
R
R har inte filliteraler, men ger motsvarande funktionalitet genom att kombinera strängliterals med en sträng-till-fil-funktion. R tillåter godtyckliga blanksteg, inklusive nyrader, i strängar. En sträng kan sedan omvandlas till en filbeskrivning med hjälp av textConnection() -funktionen. Till exempel gör följande en datatabell inbäddad i källkoden till en dataramvariabel:
str <- "Statens Befolkning Inkomst Analfabetism Liv.Exp Mord 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 212 5 Arizona. 7 212 54 Arizona. 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 )
Datasegment
Perl och Ruby har en form av fil literal, som kan betraktas som en form av datasegment . I dessa språk, inklusive raden __DATA__ (Perl) eller __END__ (Ruby, gamla Perl) markerar slutet på kodsegmentet och början på datasegmentet. Endast innehållet före denna rad exekveras, och innehållet i källfilen efter denna rad är tillgängligt som ett filobjekt: PACKAGE::DATA i Perl (t.ex. main::DATA ) och DATA i Ruby. Som en inline-fil liknar dessa semantiskt dokument här, även om det bara kan finnas en per skript. Men på dessa språk hänvisar termen "här dokument" istället till flerradssträngar, som diskuteras nedan.
Data URI-schema
Som ytterligare förklaras i Data URI-schema förstår alla större webbläsare URI:er som börjar med data: som här dokument.
Flerradiga strängar
Termen "här dokument" eller "här sträng" används också för flerradssträngar i olika programmeringsspråk, särskilt Perl (syntax påverkad av Unix-skal) och språk påverkade av Perl, särskilt PHP och Ruby. Skal-stilen <<- syntaxen behålls ofta, trots att den inte används för indataomdirigering.
Perl-influerad
Perl
I Perl finns det flera olika sätt att åberopa här docs. Avgränsningstecken runt taggen har samma effekt inom here-dokumentet som de skulle ha i en vanlig strängliteral: Om du till exempel använder dubbla citattecken runt taggen kan variabler interpoleras , men att använda enkla citattecken gör det inte, och att använda taggen utan antingen beter sig som dubbla citattecken. Genom att använda backticks som avgränsare runt taggen körs innehållet i heredoc som ett skalskript. Det är nödvändigt att se till att sluttaggen är i början av raden, annars kommer taggen inte att kännas igen av tolken.
Observera att här-dokumentet inte börjar vid taggen utan snarare börjar på nästa rad. Så uttalandet som innehåller taggen fortsätter efter taggen.
Här är ett exempel med dubbla citattecken:
min $sender = "Buffy the Vampire Slayer" ; min $recipient = "Spike" ; skriv ut <<" END "; Kära $mottagare, jag önskar att du lämnar Sunnydale och aldrig kommer tillbaka. Not Quite Love, $sender END
Produktion:
Kära Spike, jag önskar att du lämnar Sunnydale och aldrig kommer tillbaka. Not Quite Love, Buffy the Vampire Slayer
Här är ett exempel med enstaka citattecken:
skriv ut <<' END '; Kära $mottagare, jag önskar att du lämnar Sunnydale och aldrig kommer tillbaka. Not Quite Love, $sender END
Produktion:
Kära $mottagare, jag önskar att du lämnar Sunnydale och aldrig kommer tillbaka. Not Quite Love, $sender
Och ett exempel med backticks (kanske inte är portabel):
min $shell_script_stdout = << `SLUT` ; echo foo echo bar END
Det är möjligt att starta flera heredocs på samma rad:
säga ( << BEGIN . "detta är mitten\n" . << END ); Detta är början : BÖRJA Och nu är det över ! END # detta motsvarar: säg ( "Detta är början:\ndet här är mitten\nOch nu är det över!\n" ) ;
Själva taggen kan innehålla blanksteg, vilket kan göra att heredocs kan användas utan att bryta indrag .
säg << 'SLUT' ; Hej världen END
Även sedan Perl version 5.26 kan heredocs inkludera indrag:
#prints "Hej där\n" utan inledande blanksteg. if ( 1 ) { print <<~ EOF ; Hej där EOF }
Utöver dessa strängar har Perl också fil-literals, nämligen innehållet i filen som följer __DATA__ (tidigare __END__ ) på en rad för sig. Detta är tillgängligt som filobjektet PACKAGE::DATA såsom main::DATA , och kan ses som en form av datasegment .
PHP
I PHP kallas här dokument för heredocs . I PHP är heredocs inte bokstavliga strängar. Heredoc-text beter sig precis som en sträng med dubbla citattecken, men utan dubbla citattecken. Till exempel, betyder `$` kommer att tolkas som en variabel start, och `${` eller `{$` som en komplex variabel start.
<?php $name = "Joe Smith" ; $occupation = "Programmerare" ; echo <<< EOF Detta är en heredoc-sektion. För mer information prata med $name, din lokala $ockupation. Tack! EOF ; $toprint = <<< EOF Hej $namn! Du kan faktiskt tilldela heredoc-sektionen till en variabel! EOF ; echo $toprint ; ?>
Utgångar
Detta är ett heredoc-avsnitt. För mer information prata med Joe Smith, din lokala programmerare. Tack! Hej Joe Smith! Du kan faktiskt tilldela heredoc-sektionen till en variabel!
I PHP-versioner före 7.3 får raden som innehåller den avslutande identifieraren inte innehålla några andra tecken, förutom ett valfritt slutsemikolon. Annars kommer det inte att anses vara en avslutande identifierare, och PHP kommer att fortsätta leta efter en. Om en korrekt stängningsidentifierare inte hittas, kommer ett analysfel att resultera på den sista raden i skriptet. Men från version 7.3 krävs det inte längre att den avslutande identifieraren följs av semikolon eller nyrad. Dessutom kan den avslutande identifieraren dras in, i vilket fall indraget tas bort från alla rader i dokumentsträngen.
I PHP 5.3 och senare, liksom Perl, är det möjligt att inte interpolera variabler genom att omge taggen med enstaka citattecken; detta kallas nudoc :
$x = <<<' END ' Kära $mottagare, jag önskar att du lämnar Sunnydale och aldrig kommer tillbaka. Not Quite Love, $sender END ;
I PHP 5.3+ är det också möjligt att omge taggen med dubbla citattecken, vilket liksom Perl har samma effekt som att inte omge taggen med någonting alls.
Rubin
Följande Ruby-kod visar en inköpslista genom att använda ett här-dokument.
sätter << GROCERY_LIST Inköpslista ---- 1. Salladsmix. 2. Jordgubbar.* 3. Spannmål. 4. Mjölk.* * Ekologisk LISTA
Resultatet:
$ ruby grocery-list.rb Inköpslista ------------ 1. Salladsmix. 2. Jordgubbar.* 3. Spannmål. 4. Mjölk.* * Ekologisk
<< i ett här-dokument indikerar inte omdirigering av inmatning, men Ruby använder också << för omdirigering av indata , så att omdirigera till en fil från ett här-dokument innebär att << används två gånger, i olika betydelser:
File :: öppna ( "grocery-list" , "w" ) gör | f | f << << GROCERY_LIST Inköpslista ---- 1. Salladsmix. 2. Jordgubbar.* 3. Spannmål. 4. Mjölk.* * Ekologisk GROCERY_LIST slut
Precis som med Unix-skal tillåter Ruby också att den avgränsande identifieraren inte startar på den första kolumnen på en rad, om början av här-dokumentet är markerad med den något annorlunda startpunkten << - . Dessutom behandlar Ruby här dokument som en sträng med dubbla citat, och som sådan är det möjligt att använda #{}- konstruktionen för att interpolera kod. Följande exempel illustrerar båda dessa funktioner:
nu = Tid . nu sätter <<- EOF Det är #{now.hour} klockan John, var är dina barn? EOF
Ruby utökar detta genom att tillhandahålla "<<~"-syntaxen för att utelämna indrag i här-dokumentet:
sätter <<~ EOF Denna rad är indragen två blanksteg. Denna rad är indragen fyra blanksteg. Denna rad är indragen sex mellanslag. EOF
Den gemensamma indragningen av två mellanslag utelämnas från alla rader:
$ ruby indented-heredoc.rb Den här raden är indragen två blanksteg. Denna rad är indragen fyra blanksteg. Denna rad är indragen sex mellanslag.
Precis som Perl tillåter Ruby att starta flera här dokument på en rad:
sätter << BEGIN + "<--- mitten ---> \n " + << END Detta är början: BEGIN Och nu är det över! END # detta motsvarar detta uttryck: sätter "Detta är början: \n <--- mitten ---> \n Och nu är det över!"
Precis som med Perl har Ruby filbokstavar, nämligen innehållet i filen som följer __END__ på en rad för sig. Detta är tillgängligt som filobjektet DATA och kan ses som en form av datasegment .
Pytonorm
Python stöder flerradiga strängar som en "ordagrant" sträng. De kan omges av 3 enkla (') eller dubbla (") citattecken, det senare visas i exemplen nedan.
print ( """ Kund: Inte mycket av en ostaffär är det? Handlare: Finast i distriktet, sir. "" " )
Från Python 3.6 och framåt stöder ordagrant f-strängar variabel- och uttrycksinterpolation.
shop_type = "OST" utmärkelse = "finaste" tryck ( f """ Kund: Inte mycket av en { shop_type . lägre () } butik är det? Handlare: { utmärkelse . kapitalisera () } i distriktet, sir. "" " )
C++
Eftersom C++11 stöder C++ strängliteraler med anpassad avgränsare ("my_delimiter" i det här exemplet):
#include <ostream> const char * str = R " my_delimiter( Start av sträng. Ny rad snedstreck \ quote " ' parens ) ( End of string )my_delimiter " ; std :: cout << str << std :: endl ;
kommer att skriva ut
Start av sträng. Ny rad snedstreck \ quote " ' parens ) ( Slut på sträng
D
Sedan version 2.0 har D stöd för här dokumentliknande strängar som använder prefixet 'q'. Dessa strängar börjar med q"IDENT följt omedelbart av en ny rad (för en godtycklig identifierare IDENT), och slutar med IDENT" i början av en rad.
int main () { string list = q "IDENT 1. Item One 2. Item Two 3. Item Three IDENT" ; writef ( lista ); }
D stöder också några citerande avgränsare, med liknande syntax, med sådana strängar som börjar med q"[ och slutar med ]" eller liknande för andra avgränsare (någon av () <> {} eller []).
OS/JCL
På IBM:s Job Control Language (JCL) som används på dess tidigare MVS och nuvarande z/OS operativsystem, kan data som är inline i en jobbström identifieras med en * på en DD-sats, som // SYSIN DD * eller // SYSIN DD * , DLM = text I det första fallet följer textraderna och kombineras till en pseudofil med DD-namnet SYSIN. Alla poster som följer kommandot kombineras tills antingen ett annat OS/JCL-kommando inträffar (valfri rad som börjar med // ), standard EOF- sekvensen ( /* ) hittas eller det fysiska slutet av data inträffar. I det andra fallet är villkoren desamma, förutom att DLM=-operanden används för att ange textsträngens signaleringsslut på data, som kan användas om en dataström innehåller JCL (återigen, vilken rad som helst som börjar med // ) , eller /*- sekvensen (som kommentarer i C eller C++ källkod). Följande kompilerar och exekverar ett assemblerspråksprogram, som tillhandahålls som in-line-data till assemblern.
// AHAR JOBB ( 'ALEX HARRIS' ) // EXEC ASMLG // SYSIN DD * APROG START XR 15,15 BR 14 END /* //* JOBB SLUTAR
// SYSIN DD * -satsen är den funktionella motsvarigheten till <</* Indikerar s ström av data följer, avslutad av /* .
Racket
Rackets här strängar börjar med #<< följt av tecken som definierar en terminator för strängen. Innehållet i strängen inkluderar alla tecken mellan #<<- raden och en rad vars enda innehåll är den angivna terminatorn. Närmare bestämt börjar innehållet i strängen efter en ny rad efter #<< , och den slutar före en ny rad som följs av terminatorn.
#lang racket ( displayln #<<HERESTRING Detta är en enkel här sträng i Racket. * En * Två * Tre HERESTRING )
Utgångar:
Detta är en enkel här sträng i Racket. * Ett två tre
Inga flyktsekvenser känns igen mellan start- och slutlinjerna; alla tecken ingår i strängen (och terminatorn) bokstavligen.
#lang racket ( displayln #<<En här sträng i Racket ☺ Denna sträng sträcker sig över flera rader och kan innehålla vilken Unicode-symbol som helst. Så saker som λ, ☠, α, β, är alla bra. På nästa rad kommer terminatorn. Den kan också innehålla vilken Unicode-symbol som helst, även mellanslag och smileys! En här sträng i Racket ☺ )
Utgångar:
Denna sträng sträcker sig över flera rader och kan innehålla vilken Unicode-symbol som helst. Så saker som λ, ☠, α, β är alla bra. På nästa rad kommer terminatorn. Den kan också innehålla vilken Unicode-symbol som helst, även mellanslag och smileys!
Här kan strängar användas normalt i sammanhang där normala strängar skulle:
#lang racket ( printf #<<END Bästa ~a, Tack för det insiktsfulla samtalet ~a. ~a SLUT "Isaac" " igår" "Carl" )
Utgångar:
Kära Isaac, Tack för det insiktsfulla samtalet igår. Carl
Ett intressant alternativ är att använda språktillägget at-exp för att skriva @-uttryck. De ser ut så här:
#lang at-exp racket(displayln @string-append{ Detta är en lång sträng, mycket bekvämt när en lång bit text behövs. Inga bekymmer om att undkomma "citattecken" eller \escapes. Det är också okej att ha λ, γ, θ, ... Bädda in kod:@ ( nummer->sträng ( + 3 4 ))})
Utgångar:
Detta är en lång sträng, mycket bekvämt när en lång bit text behövs. Inga bekymmer om att undkomma "citat" eller \escapes. Det är också okej att ha λ, γ, θ, ... Bädda in kod: 7
Ett @-uttryck är inte specifikt eller begränsat till strängar, det är en syntaxform som kan komponeras med resten av språket.
Windows PowerShell
I PowerShell hänvisas här till dokument som här-strängar . En här-sträng är en sträng som börjar med en öppen avgränsare ( @" eller @' ) och slutar med en nära avgränsare ( "@ eller '@ ) på en rad för sig, som avslutar strängen. Alla tecken mellan öppna och stängda avgränsare anses vara strängen bokstavlig. Att använda en här-sträng med dubbla citattecken tillåter att variabler tolkas , att använda enkla citattecken gör det inte. Variabelinterpolation sker med enkla variabler (t.ex. $x men INTE $xy eller $x[0] ) . Du kan köra en uppsättning satser genom att lägga dem i $() (t.ex. $($xy) eller $(Get-Process | Out-String) ) .
I följande PowerShell-kod skickas text till en funktion med hjälp av en här-sträng. Funktionen Konvertera till versaler definieras enligt följande:
PS > funktion Konvertera till versaler ( $string ) { $string . ToUpper () } PS > KonverteraTill versaler @ ' >> en två tre >> eins zwei drei >> '@ EN TVÅ TRE EINS ZWEI DREI
Här är ett exempel som visar variabel interpolation och satsexekvering med hjälp av en here-sträng med dubbla citattecken:
PS > $doc , $marty = 'Dr. Emmett Brown' , 'Marty McFly' PS > $time = [DateTime] 'Freday, October 25, 1985 8:00:00 AM' PS > $diff = New-TimeSpan -Minutes 25 PS > @" >> $doc : Är det mina klockor jag hör? >> $marty : Ja! Äh, klockan är $($time.Hour)! >> $doc : Perfekt! Mitt experiment fungerade! De är alla exakt $($diff.Minutes ) minuter långsamt. >> $marty : Vänta en minut. Vänta en minut. Doc... Säger du mig att det är $(($time + $diff).ToShortTimeString())? >> $doc : Exakt . > > $marty: Fan! Jag är sen till skolan! >> "@ Dr. Emmett Brown: Är det mina klockor jag hör? Marty McFly: Ja! Äh, klockan är 8! Dr. Emmett Brown: Perfekt! Mitt experiment fungerade! De är alla exakt 25 minuter långsamma. Marty McFly: Vänta lite. Vänta en minut. Doc... Säger du mig att klockan är 08:25? Dr Emmett Brown: Precis. Marty McFly: Fan! Jag är sen till skolan!
Om du använder en här-sträng med enkla citattecken istället, skulle utdata se ut så här:
PS > @ ' >> $doc : Är det mina klockor jag hör? >> $marty: Ja! Äh, klockan är $($time.Hour)! >> $doc : Perfekt! Mitt experiment fungerade! De är alla exakt $($diff.Minutes) minuter långsamma. >> $marty : Vänta lite. Vänta en minut. Doc... Säger du mig att det är $(($time + $diff).ToShortTimeString())? >> $doc : Precis. >> $marty: Fan! Jag är sen till skolan! >> '@ $doc : Är det mina klockor jag hör? $marty: Ja! Äh, klockan är $($time.Hour)! $doc: Perfekt! Mitt experiment fungerade! De är alla exakt $($diff.Minutes) minuter långsamma. $marty: Vänta lite. Vänta en minut. Doc... Säger du mig att det är $(($time + $diff).ToShortTimeString())? $doc: Precis. $marty: Fan! Jag är sen till skolan!
DIGITAL Command Language (DCL)
I DCL-skript behandlas alla inmatningsrader som inte börjar med en $-symbol implicit som indata till föregående kommando - alla rader som inte börjar med $ är här-dokument. Indata skickas antingen till programmet eller kan uttryckligen refereras till med det logiska namnet SYS$INPUT (analogt med Unix-konceptet stdin ).
Om du till exempel uttryckligen hänvisar till ingången som SYS$INPUT:
$ TYPE SYS $INPUT Denna text kommer att ekas direkt till skärmen av kommandot TYPE. $ ! andra kommandon... producerar:
Denna text kommer att ekas direkt till skärmen av kommandot TYPE.Dessutom kan kommandot DECK, som ursprungligen var avsett för stöd för hålkort (därav dess namn: det betecknade början på ett datakort ) användas för att ge indata till föregående kommando. Inmatningsdäcket avslutas antingen med kommandot $ EOD eller teckenmönstret som specificeras av parametern /DOLLARS till DECK.
Exempel på ett program som summerar pengar:
$ RUN ADD_SUMS.EXE $ DECK $13.53 $3.33 $2.33 $ EODSkulle producera följande utdata (förutsatt att ADD_SUMS skrevs för att läsa värdena och lägga till dem):
19,19 USDExempel på att använda DECK /DOLLARS för att skapa en kommandofil från en annan:
$ COPY SYS $INPUT SYS $SCRATCH :TEMP.COM $ DECK /DOLLARS = $$$$ $ TYP SYS $INPUT Detta är ett exempel på hur du använder DECK för att skapa en kommandofil inifrån en kommandofil $ $$ $ $ ! andra kommandon följer ... YAML
YAML förlitar sig i första hand på blankstegsindragning för struktur, vilket gör den motståndskraftig mot kollision med avgränsare och kan representera flerradiga strängar med vikta strängar:
--- caption : "Exempel på heredoc-liknande funktionalitet med YAML" date : "2007-06-01" exempel : > HTML går in i YAML utan ändringsmeddelande : | <blockquote style="font: italic 12pt Times"> <p>"Tre är alltid större än två, även för stora värden på två"</p> <p>--Okänd författare</p> </blockquote>
Se även
Allmän
externa länkar
- Här dokument . Länk till Rosetta Code med exempel på dokument här på över 15 språk.