Hier Dokument

In der Informatik ist ein Here-Dokument ( auch Here-Dokument , Here-Text , Heredoc , Hereis , Here-String oder Here-Skript genannt) ein Datei- oder Eingabestream- Literal: Es handelt sich um einen Abschnitt einer Quellcodedatei , der wie eine separate Datei behandelt wird . Der Begriff wird auch für mehrzeilige String-Literale verwendet , die eine ähnliche Syntax verwenden und Zeilenumbrüche sowie andere Leerzeichen (einschließlich Einrückungen) im Text beibehalten.

Dokumente haben ihren Ursprung in der Unix-Shell [ ^{1 ]} und sind seit 1979 in der Bourne-Shell und den meisten nachfolgenden Shells zu finden ^. Zeichenkettenliterale im Dokumentstil finden sich in verschiedenen höheren Programmiersprachen , insbesondere in Perl (dessen Syntax von der Unix-Shell inspiriert ist) und von Perl beeinflussten Sprachen wie PHP und Ruby . JavaScript unterstützt diese Funktionalität ebenfalls über Template-Literale , eine Funktion, die in der sechsten Version ( ES6 ) eingeführt wurde. Andere höhere Programmiersprachen wie Python , Julia und Tcl bieten andere Möglichkeiten zur Verarbeitung mehrzeiliger Zeichenketten.

Dokumente können hier entweder als Dateien oder als Zeichenketten behandelt werden. Einige Shells behandeln sie als Formatstring- Literal, was die Ersetzung von Variablen und Befehlen innerhalb des Literals ermöglicht.

Die gebräuchlichste Syntax für Here-Dokumente, die ihren Ursprung in Unix-Shells hat, sieht <<folgendermaßen aus: Nach einem Trennzeichen ( oft das Wort ` [2]` oder <sup>`[ 2 ]</sup> `) folgt in der nächsten Zeile der einzufügende Text, und schließlich schließt sich das Dokument mit demselben Trennzeichen in einer eigenen Zeile ab. Diese Syntax ist notwendig, da Here-Dokumente formal Stream-Literale sind und ihr Inhalt häufig an die Standardeingabe ( stdin ) des vorhergehenden Befehls oder des aktuellen Shell-Skripts/der aktuellen ausführbaren Datei umgeleitet wird. EOFEND

Die Syntax des Here-Dokuments ist analog zur Shell-Syntax für die Eingabeumleitung , auf die <der Name der als Eingabe zu verwendenden Datei folgt.

Andere Sprachen verwenden oft eine im Wesentlichen ähnliche Syntax, doch Details der Syntax und die tatsächliche Funktionalität können sich deutlich unterscheiden. Bei der Verwendung für Zeichenkettenliterale <<dient das `<h>` nicht der Indirektion, sondern ist lediglich eine Konvention für das Anfangstrennzeichen. In manchen Sprachen, wie beispielsweise Ruby, <<wird es auch zur Eingabeumleitung verwendet, was dazu führt, dass es <<zweimal benötigt wird, wenn man von einem Zeichenkettenliteral in einem Here-Dokument umleiten möchte.

Genau genommen handelt es sich bei Dokumenten hier um Datei- oder Streamliterale. Diese stammen aus der Unix-Shell, obwohl ähnliche Funktionen auch in einigen anderen Programmiersprachen verfügbar sind.

Here-Dokumente sind in vielen Unix-Shells verfügbar. ^{[ 1 ]} Im folgenden Beispiel wird Text trmithilfe eines Here-Dokuments an den Befehl übergeben (wobei Kleinbuchstaben in Großbuchstaben umgewandelt werden). Dies kann in einer Shell-Datei erfolgen oder interaktiv an der Eingabeaufforderung eingegeben werden.

$ LANG = C tr a-z A-Z << END > eins zwei drei > vier fünf sechs > END EINS ZWEI DREI VIER FÜNF SECHS 

In diesem Fall ENDwurde als Trennzeichen verwendet. Es legte den Anfang und das Ende des Here-Dokuments fest. Die Weiterleitung und das Trennzeichen müssen nicht durch ein Leerzeichen getrennt sein; <<ENDbeides << ENDfunktioniert gleichermaßen.

Standardmäßig verhält es sich weitgehend identisch mit dem Inhalt von doppelten Anführungszeichen: Variablennamen werden durch ihre Werte ersetzt, Befehle innerhalb von Backticks werden ausgewertet usw. ^{[ a ]}

$ cat << EOF > \$ Arbeitsverzeichnis "$PWD" `pwd` > EOF $ Arbeitsverzeichnis "/home/user" / home/user 

Dies kann deaktiviert werden, indem ein beliebiger Teil der Bezeichnung in Anführungszeichen gesetzt wird, woraufhin der nicht in Anführungszeichen stehende Wert folgt; ^{[ b ]} das Verhalten ist im Wesentlichen identisch mit dem, das sich ergibt, wenn der Inhalt in einfache Anführungszeichen eingeschlossen wäre. Zum Beispiel durch Setzen in einfache Anführungszeichen:

$ cat << 'EOF' > \$ Arbeitsverzeichnis "$PWD" `pwd` > EOF \$ Arbeitsverzeichnis "$PWD" `pwd`

Doppelte Anführungszeichen können zwar verwendet werden, dies kann jedoch zu Verwirrung führen, da die Expansion in einem doppelt angeführten String zwar erfolgt, nicht aber in einem Here-Dokument mit doppelt angeführten Begrenzern. ^{[ 4 ]} In einigen anderen Sprachen, insbesondere in Perl (siehe unten), wird zwischen einfachen und doppelten Anführungszeichen unterschieden , wobei das Verhalten dem der entsprechenden String-Quotierung entspricht.

In der POSIX-Shell , nicht aber in csh/tcsh, bewirkt das Anhängen eines Minuszeichens an den Befehl <<(d. h. ), dass führende Tabulatoren ignoriert werden. ^{[ 5 ]} Dies ermöglicht das Einrücken von Here-Dokumenten in Shell-Skripten (hauptsächlich zur Ausrichtung an bestehender Einrückung), ohne deren Wert zu ändern: ^{[ c ]}<<-

Ein Skript mit folgendem Inhalt:

LANG = C tr a-z A-Z <<- END_TEXT Hier doc mit <<- Ein einzelnes Leerzeichen (d. h. 0x20) befindet sich am Anfang dieser Zeile.  Diese Zeile beginnt mit einem einzelnen Tabulatorzeichen (d. h. 0x09), ebenso wie die nächste Zeile  . END_TEXTecho Das beabsichtigte Ende lag vor dieser Zeile echo und diese wurden von tr nicht verarbeitet echo +++++++++++++++LANG = C tr a-z A-Z << END_TEXT Hier doc mit << Ein einzelnes Leerzeichen (d. h. 0x20) befindet sich am Anfang dieser Zeile.  Diese Zeile beginnt mit einem einzelnen Tabulatorzeichen (d. h. 0x09), ebenso wie die nächste Zeile  . END_TEXTecho Das beabsichtigte Ende lag vor dieser Zeile, echo aber da die Zeile mit dem begrenzenden Bezeichner mit einem TAB begann , wurde sie NICHT erkannt und echo der tr- Befehl wurde weiter verarbeitet. 

produziert:

HIER DOC MIT <<- EIN EINZIGES LEERZEICHEN (0x20) BEFINDET SICH AM ANFANG DIESER ZEILE. DIESE ZEILE BEGINNT MIT EINEM EINZIGES TABELLOSEZEICHEN (0x09), SOWIE DIE NÄCHSTE ZEILE. Das beabsichtigte Ende lag vor dieser Zeile und wurde von tr nicht verarbeitet . +++++++++++++++ HIER DOC MIT << EIN EINZIGES LEERZEICHEN (0x20) BEFINDET SICH AM ANFANG DIESER ZEILE.  DIESE ZEILE BEGINNT MIT EINEM EINZIGES TABELLOSEZEICHEN (0x09), SOWIE DIE NÄCHSTE ZEILE.  END_TEXTECHO DAS GEWÜNSCHTE ENDE WAR VOR DIESER ZEILE, ECHO ABER WEIL DIE ZEILE MIT DEM TRENNUNGSZEICHEN MIT EINEM TAB BEGANN, WURDE SIE NICHT ERKANNT UND ECHO DER TR-BEFEHL WURDE FORTGESETZT.

Eine weitere Anwendungsmöglichkeit besteht darin, die Ausgabe in eine Datei zu schreiben:

$ cat << EOF > ~/testFile001 > Diesem Text gehen 3 Leerzeichen voraus. > Am Anfang dieser Zeile befindet sich ein einzelnes Tabulatorzeichen. > Diesem Text geht nichts voraus . EOF

Ein Here-String (verfügbar in bash , ksh oder zsh ) ist syntaktisch ähnlich und besteht aus einem Komma. <<<Er bewirkt die Umleitung der Eingabe von einem Wort (einer Sequenz, die von der Shell als Einheit behandelt wird, in diesem Kontext üblicherweise ein String-Literal). Dabei wird die übliche Shell-Syntax für das Wort verwendet (Here-String-Syntax), wobei die einzige Syntax die Umleitung ist: Ein Here-String ist ein gewöhnlicher String zur Eingabeumleitung, keine spezielle Art von String.

Ein einzelnes Wort muss nicht in Anführungszeichen gesetzt werden:

$ LANG = C tr a-z A-Z <<< eins EINS

Im Falle einer Zeichenkette mit Leerzeichen muss diese in Anführungszeichen gesetzt werden:

$ LANG = C tr a-z A-Z <<< 'one two three' ONE TWO THREE

Dies könnte auch so geschrieben werden:

$ foo = 'one two three' $ LANG = C tr a-z A-Z <<< " $foo " ONE TWO THREE

Mehrzeilige Zeichenketten sind zulässig und ergeben Folgendes:

$ LANG = C tr a-z A-Z <<< ' one > two three' ONE TWO THREE

Beachten Sie, dass führende und nachfolgende Zeilenumbrüche, sofern vorhanden, mit einbezogen werden:

$ LANG = C tr a-z A-Z <<< ' > eins > zwei drei > 'EINS ZWEI DREI$

Der Hauptunterschied zu Here-Dokumenten besteht darin, dass in Here-Dokumenten die Trennzeichen in separaten Zeilen stehen; führende und nachfolgende Zeilenumbrüche werden entfernt. Im Gegensatz zu Here-Dokumenten verwenden Here-Strings keine Trennzeichen.

Hier sind Zeichenketten besonders nützlich für Befehle, die oft kurze Eingaben erfordern, wie zum Beispiel der Taschenrechner bc:

$ bc <<< 2 ^10 1024

echoBeachten Sie, dass das String-Verhalten hier auch (Umkehrung der Reihenfolge) durch Piping und den Befehl erreicht werden kann , wie in:

$ echo 'one two three' | LANG = C tr a-z A-Z ONE TWO THREE

Allerdings sind Zeichenketten hier besonders nützlich, wenn der letzte Befehl im aktuellen Prozess ausgeführt werden muss, wie es bei der readeingebauten Funktion der Fall ist:

$ echo 'one two three' | read -r a b c $ echo " $a $b $c "

bringt nichts ein, während

$ read -r a b c <<< 'eins zwei drei' $ echo " $a $b $c " eins zwei drei

Dies geschieht, weil im vorherigen Beispiel die Weiterleitung dazu führt, readdass der Code in einem Unterprozess ausgeführt wird und somit die Umgebung des übergeordneten Prozesses nicht beeinflussen kann .

In Microsoft NMAKE werden Dokumente hier als Inline-Dateien bezeichnet . Inline-Dateien werden mit ` <inline.h>` <<oder `<inline.h>` referenziert <<pathname: Die erste Schreibweise erstellt eine temporäre Datei , die zweite erstellt (oder überschreibt) die Datei mit dem angegebenen Pfadnamen. Eine Inline-Datei wird mit `< <<inline.h>` in einer eigenen Zeile abgeschlossen, optional gefolgt vom Schlüsselwort `--` (Groß-/Kleinschreibung wird nicht beachtet) KEEPoder NOKEEP`--`, um anzugeben, ob die erstellte Datei beibehalten werden soll.

Ziel0 : abhängig 0 Befehl0 << temporäre Inline- Datei ... <<Ziel1 : abhängiger Befehl 1 << temporäre, aber beibehaltene Inline- Datei ... <<BEHALTEN Ziel2 : abhängiger Befehl 2 << Dateiname2 benannte, aber verworfene Inline- Datei ... <<NICHTBEHALTEN Ziel3 : abhängiger Befehl 3 << Dateiname3 benannte Inline- Datei ... <<BEHALTEN

R kennt keine Dateiliterale, bietet aber eine äquivalente Funktionalität durch die Kombination von Zeichenkettenliteralen mit einer Funktion zur Umwandlung von Zeichenketten in Dateien. R erlaubt beliebige Leerzeichen, einschließlich Zeilenumbrüche, in Zeichenketten. Eine Zeichenkette kann dann mithilfe der Funktion in einen DateideskriptortextConnection() umgewandelt werden . Beispielsweise wandelt der folgende Code eine im Quellcode eingebettete Datentabelle in eine Dataframe-Variable um:

str <- "State Population Income Illiteracy Life.Exp Murder 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 )

Perl ^{[ 6 ]} und Ruby ^{[ 7 ]} kennen Dateiliterale, die als Datensegmente betrachtet werden können . In diesen Sprachen markiert die Zeile `<code> __DATA__` (Perl) bzw. `<code>(Ruby, älteres Perl)` (Ruby) das Ende des Codesegments und den Beginn des Datensegments. Nur der Inhalt vor dieser Zeile wird ausgeführt; der Inhalt der Quelldatei nach dieser Zeile ist als Dateiobjekt verfügbar: in Perl (z. B. `<code>.file.xml` ) und in Ruby. Als Inline-Dateien ähneln sie semantisch Here-Dokumenten, wobei pro Skript nur eines vorhanden sein kann. In diesen Sprachen bezeichnet der Begriff „Here-Dokument“ jedoch mehrzeilige Zeichenkettenliterale, wie weiter unten erläutert. __END__PACKAGE::DATAmain::DATADATA

Wie im Data-URI-Schema näher erläutert , verstehen alle gängigen Webbrowser URIs, die mit data beginnen: wie hier document.

Die Begriffe „Here-Dokument“ oder „Here-String“ werden auch für mehrzeilige Stringliterale in verschiedenen Programmiersprachen verwendet , insbesondere in Perl (dessen Syntax von der Unix-Shell beeinflusst ist) und in von Perl beeinflussten Sprachen wie PHP und Ruby. Die Shell-ähnliche <<Syntax wird oft beibehalten, obwohl sie nicht zur Eingabeumleitung verwendet wird.

In Perl gibt es verschiedene Möglichkeiten, Here-Dokumente aufzurufen. ^{[ 8 ]} Die Begrenzer um das `<here>`-Tag haben innerhalb des Here-Dokuments dieselbe Wirkung wie in einem regulären String-Literal: Beispielsweise ermöglicht die Verwendung von doppelten Anführungszeichen um das Tag die Interpolation von Variablen , während die Verwendung von einfachen Anführungszeichen dies nicht ermöglicht. Ohne Anführungszeichen verhält sich das Tag wie mit doppelten Anführungszeichen. Die Verwendung von Backticks als Begrenzer um das Tag führt den Inhalt des Here-Dokuments als Shell-Skript aus. Es ist wichtig, dass das `<here>`-Tag am Zeilenanfang steht, da es sonst vom Interpreter nicht erkannt wird.

Beachten Sie, dass das Here-Dokument nicht beim Tag beginnt, sondern in der nächsten Zeile. Die Anweisung, die den Tag enthält, wird also nach dem Tag fortgesetzt.

Hier ein Beispiel mit doppelten Anführungszeichen:

my $sender = "Buffy the Vampire Slayer" ; my $recipient = "Spike" ;print <<" END ";Sehr geehrter Empfänger,Ich wünsche dir, dass du Sunnydale verlässt und nie wieder zurückkehrst.Nicht ganz Liebe, AbsenderENDE

Ausgabe:

Lieber Spike,Ich wünsche dir, dass du Sunnydale verlässt und nie wieder zurückkehrst.Nicht ganz Liebe, Buffy – Im Bann der Dämonen

Hier ein Beispiel mit einfachen Anführungszeichen:

print <<' END '; Sehr geehrter $recipient,Ich wünsche dir, dass du Sunnydale verlässt und nie wieder zurückkehrst.Nicht ganz Liebe, Absender ENDE

Ausgabe:

Sehr geehrter Empfänger,Ich wünsche dir, dass du Sunnydale verlässt und nie wieder zurückkehrst.Nicht ganz Liebe, Absender

Und ein Beispiel mit Backticks (möglicherweise nicht portabel):

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

Es ist möglich, mehrere Heredocs in derselben Zeile zu beginnen:

say ( << BEGIN . "Dies ist die Mitte\n" . << END ); Dies ist der Anfang: BEGIN Und nun ist es vorbei ! END# Dies entspricht: sagen wir ( "Dies ist der Anfang:\nDies ist die Mitte\nUnd jetzt ist es vorbei!\n" );

Das Tag selbst kann Leerzeichen enthalten, wodurch Heredocs verwendet werden können, ohne die Einrückung zu beeinträchtigen .

say << ' END' ; Hello World END

Obwohl seit Perl Version 5.26 ^{[ 9 ]} Heredocs Einrückungen enthalten können:

#Gibt "Hallo\n" ohne führende Leerzeichen aus. if ( 1 ) { print << ~ EOF ; Hallo EOF }

Zusätzlich zu diesen Zeichenketten kennt Perl auch Dateiliterale, also den Inhalt der Datei, der __DATA__(früher __END__) in einer eigenen Zeile steht. Dieser Inhalt ist über das Dateiobjekt zugänglich , PACKAGE::DATAbeispielsweise `file.json` main::DATA, und kann als eine Art Datensegment betrachtet werden .

In PHP werden Here-Dokumente als Heredocs bezeichnet . Heredocs sind in PHP keine String-Literale. Der Text eines Heredocs verhält sich wie ein String in doppelten Anführungszeichen, jedoch ohne diese. Beispielsweise wird `$` als Variablenanfang und `${` oder `{$` als Beginn einer komplexen Variablen interpretiert.

<?php$name = "Joe Smith" ; $occupation = "Programmierer" ; echo <<< EOF Dies ist ein Heredoc-Abschnitt.  Für weitere Informationen wenden Sie sich bitte an $name, Ihren lokalen $occupation. Danke!EOF ;$toprint = <<< EOF Hey $name! Du kannst den Heredoc-Abschnitt tatsächlich einer Variablen zuweisen!EOF ; echo $toprint ;?>

Ausgaben

Dies ist ein Heredoc-Abschnitt. Für weitere Informationen wenden Sie sich bitte an Joe Smith, Ihren lokalen Programmierer.Danke!Hey Joe Smith! Man kann den Heredoc-Abschnitt tatsächlich einer Variablen zuweisen!

In PHP-Versionen vor 7.3 durfte die Zeile mit dem schließenden Bezeichner außer einem optionalen Semikolon keine weiteren Zeichen enthalten. Andernfalls wurde sie nicht als schließender Bezeichner erkannt, und PHP suchte weiter. Wurde kein gültiger schließender Bezeichner gefunden, führte dies zu einem Syntaxfehler in der letzten Zeile des Skripts. Ab Version 7.3 ist es jedoch nicht mehr erforderlich, dass dem schließenden Bezeichner ein Semikolon oder ein Zeilenumbruch folgt. Der schließende Bezeichner kann außerdem eingerückt sein; in diesem Fall wird die Einrückung aus allen Zeilen des Docstrings entfernt. ^{[ 10 ]}

In PHP 5.3 und späteren Versionen ist es wie in Perl möglich, die Interpolation von Variablen zu verhindern, indem man das Tag in einfache Anführungszeichen setzt; dies wird als nowdoc bezeichnet : ^{[ 11 ]}

$x = <<<' END ' Sehr geehrter $recipient,Ich wünsche dir, dass du Sunnydale verlässt und nie wieder zurückkehrst.Nicht ganz Liebe, $sender ENDE ;

In PHP 5.3+ ist es auch möglich, das Tag in doppelte Anführungszeichen zu setzen, was, genau wie bei Perl, den gleichen Effekt hat, als würde man das Tag gar nicht umschließen.

Der folgende Ruby-Code zeigt eine Einkaufsliste mithilfe eines Here-Dokuments an.

puts << LOCEYRY_LIST Einkaufsliste ---- 1. Salatmischung. 2. Erdbeeren.* 3. Müsli. 4. Milch.* * Bio LOCEY_LIST

Das Ergebnis:

$ ruby ​​grocery-list.rb Einkaufsliste ------------ 1. Salatmischung. 2. Erdbeeren.* 3. Müsli. 4. Milch.* * Bio

Das ` <<<h1>` in einem Here-Dokument signalisiert keine Eingabeumleitung, aber Ruby verwendet `<h1>` auch <<für die Eingabeumleitung, sodass die Umleitung in eine Datei von einem Here-Dokument aus die <<zweimalige Verwendung von `<h1>` in unterschiedlicher Bedeutung erfordert:

Datei :: öffnen ( "Einkaufsliste" , "w" ) do | f | f << << EINKAUFSLIST Einkaufsliste ---- 1. Salatmischung. 2. Erdbeeren.* 3. Müsli. 4. Milch.* * Bio EINKAUFSLIST Ende

Wie bei Unix-Shells erlaubt auch Ruby, dass der Trennbezeichner nicht in der ersten Spalte einer Zeile beginnt, wenn der Beginn des Here-Dokuments mit einem leicht abweichenden Startzeichen markiert ist <<-. Darüber hinaus behandelt Ruby Here-Dokumente als doppelt angeführte Zeichenketten, wodurch es möglich ist, #{}Code mithilfe dieser Konstruktion zu interpolieren. Das folgende Beispiel veranschaulicht diese beiden Funktionen:

jetzt = Zeit . jetzt setzt <<- EOF  Es ist #{jetzt.stunde} Uhr John, wo sind deine Kinder?  EOF

Ruby erweitert dies durch die Syntax "<<~", die das Weglassen der Einrückung im Here-Dokument ermöglicht:

puts <<~ EOF  Diese Zeile ist um zwei Leerzeichen eingerückt.  Diese Zeile ist um vier Leerzeichen eingerückt.  Diese Zeile ist um sechs Leerzeichen eingerückt.  EOF

Der übliche Einzug von zwei Leerzeichen wird in allen Zeilen weggelassen:

$ ruby ​​indented-heredoc.rb Diese Zeile ist um zwei Leerzeichen eingerückt.  Diese Zeile ist um vier Leerzeichen eingerückt.  Diese Zeile ist um sechs Leerzeichen eingerückt.

Wie Perl erlaubt auch Ruby das Starten mehrerer Here-Dokumente in einer Zeile:

puts << BEGIN + "<--- Mitte ---> \n " + << END Dies ist der Anfang: BEGIN Und nun ist es vorbei! END# Dies entspricht diesem Ausdruck: puts "Dies ist der Anfang: \n <--- Mitte ---> \n Und nun ist es vorbei!"

Wie Perl kennt auch Ruby Dateiliterale, also den Inhalt der Datei, der __END__in einer eigenen Zeile steht. Dieser ist über das Dateiobjekt zugänglich DATAund kann als eine Art Datensegment betrachtet werden .

Python unterstützt mehrzeilige Zeichenketten als „wörtliche“ Zeichenketten. Diese können in drei einfache (') oder doppelte (") Anführungszeichen eingeschlossen werden; letztere werden in den folgenden Beispielen gezeigt.

print ( """ Kunde: Ist das nicht gerade ein Käseladen? Ladenbesitzer: Der beste im ganzen Bezirk, mein Herr. """ )

Ab Python 3.6 unterstützen wörtliche f-Strings die Interpolation von Variablen und Ausdrücken.

shop_type = "CHEESE" accolade = "finest" print ( f """ Kunde: Nicht gerade ein { shop_type . lower () } Laden, oder? Ladenbesitzer: { accolade . capitalize () } im Bezirk, mein Herr. """ )

Textblöcke werden ab Java 15 über JEP 378 unterstützt: ^{[ 12 ] [ 13 ]}

String html = """  <html>  <body>  <p>Hallo Welt</p>  </body>  </html> """ ;

Seit C++11 unterstützt C++ Stringliterale mit benutzerdefiniertem Trennzeichen ("my_delimiter" in diesem Beispiel):

#include <ostream>const char * str = R " my_delimiter( Start of string. New line slash \ quote " ' parens ) ( End of string )my_delimiter " ; std :: cout << str << std :: endl ;

wird ausgedruckt

Zeichenkettenanfang. Neue Zeile slash \ quote " ' parens ) ( Ende der Zeichenkette 

Seit Version 2.0 unterstützt D Zeichenketten im Here-Dokumentstil mit dem Präfix 'q'. Diese Zeichenketten beginnen mit einem 'q q"IDENT', gefolgt von einem Zeilenumbruch (für einen beliebigen Bezeichner IDENT), und enden mit einem 'q' IDENT"am Zeilenanfang.

int main () { string list = q "IDENT 1. Item One 2. Item Two 3. Item Three IDENT" ; writef ( list ); }

D unterstützt auch einige Anführungszeichen, mit ähnlicher Syntax, wobei solche Zeichenketten mit einem beginnen q"[und mit einem enden ]"oder ähnlich für andere Trennzeichen (eines der Zeichen () <> {} oder []).

In der Job Control Language (JCL) von IBM, die in den früheren MVS- und den aktuellen z/OS -Betriebssystemen verwendet wird, lassen sich Daten, die sich innerhalb eines Jobstreams befinden , durch ein * in einer DD-Anweisung kennzeichnen, z. B. `DD` oder `DD` . Im ersten Fall folgen die Textzeilen und werden zu einer Pseudodatei mit dem DD-Namen SYSIN kombiniert. Alle Datensätze nach dem Befehl werden kombiniert, bis entweder ein weiterer OS/JCL-Befehl ausgeführt wird (eine beliebige Zeile, die mit `DD` beginnt ), die Standard -EOF- Sequenz (`\ n`) gefunden wird oder das physische Datenende erreicht ist. Im zweiten Fall gelten dieselben Bedingungen, nur dass der Operand `DLM=` verwendet wird, um die Textzeichenfolge anzugeben, die das Datenende signalisiert. Diese kann verwendet werden, wenn ein Datenstrom JCL enthält (wiederum eine beliebige Zeile, die mit `DD` beginnt ) oder die Sequenz `\n` (z. B. Kommentare in C- oder C++-Quellcode). Das folgende Beispiel kompiliert und führt ein Assemblerprogramm aus , das dem Assembler als Inline-Daten übergeben wird. //SYSIN DD *//SYSIN DD *,DLM=text///*///*

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

Die Aussage ist das funktionale Äquivalent von: Es folgt ein Datenstrom, der durch . beendet wird . //SYSIN DD *<</*/*

Rackets Here-Strings beginnen mit #<<einem Komma, gefolgt von Zeichen, die das Ende des Strings definieren. ^{[ 14 ]} Der Inhalt des Strings umfasst alle Zeichen zwischen der #<<ersten Zeile und einer Zeile, deren einziger Inhalt das angegebene Ende ist. Genauer gesagt: Der Inhalt des Strings beginnt nach einem Zeilenumbruch nach dem Komma #<<und endet vor einem Zeilenumbruch, dem das Ende folgt.

#lang racket( displayln #<<HERESTRING Dies ist ein einfacher Here-String in Racket.  * Eins  * Zwei  * Drei HERESTRING )

Ausgaben:

Dies ist eine einfache Here-String-Kombination im Racket-Spiel.  * Eins  * Zwei  * Drei

Zwischen der Start- und der Endzeile werden keine Escape-Sequenzen erkannt; alle Zeichen werden wörtlich in die Zeichenkette (einschließlich des Abschlusszeichens) aufgenommen.

#lang racket( displayln #<<Ein Here-String in Racket ☺ Dieser String erstreckt sich über mehrere Zeilen und kann beliebige Unicode-Symbole enthalten. Daher sind Zeichen wie λ, ☠, α, β alle zulässig.In der nächsten Zeile folgt der Terminator. Er kann beliebige Unicode-Symbole enthalten, sogar Leerzeichen und Smileys! Ein Here-String in Racket ☺ )

Ausgaben:

Diese Zeichenkette erstreckt sich über mehrere Zeilen und kann beliebige Unicode-Symbole enthalten. Daher sind beispielsweise λ, ☠, α und β zulässig.In der nächsten Zeile folgt das Abschlusszeichen. Es kann jedes beliebige Unicode-Symbol enthalten, sogar Leerzeichen und Smileys!

Hier können Zeichenketten in Kontexten, in denen normale Zeichenketten verwendet würden, auch normal verwendet werden:

#lang racket( printf #<<END Lieber ~a,Danke für das aufschlussreiche Gespräch ~a. ~aENDE "Isaac" "gestern" "Carl" )

Ausgaben:

Lieber Isaac,Vielen Dank für das aufschlussreiche Gespräch gestern. Carl

Eine interessante Alternative ist die Verwendung der Spracherweiterung at-expzum Schreiben von @-Ausdrücken. ^{[ 15 ]} Diese sehen folgendermaßen aus:

#lang at-expracket (displayln @string-append{ Das ist eine lange Zeichenkette. sehr praktisch, wenn ein langer Textabschnitt ist benötigt. Keine Sorge, dass Sie entkommen können "Anführungszeichen" oder Escape-Sequenzen. Es ist Es ist auch in Ordnung, λ, γ, θ, ... zu haben. Einbettungscode:@(number->string(+34)) }) 

Ausgaben:

Dies ist eine lange Zeichenkette, die sich sehr eignet, wenn ein langer Textabschnitt benötigt wird.Sie brauchen sich keine Sorgen um die Maskierung von Anführungszeichen oder Escape-Sequenzen zu machen. Auch die Verwendung von λ, γ, θ, ... ist in Ordnung.Einbettungscode: 7

Ein @-Ausdruck ist weder spezifisch noch auf Zeichenketten beschränkt; er ist eine Syntaxform, die mit dem Rest der Sprache kombiniert werden kann.

In PowerShell werden Here-Dokumente als Here-Strings bezeichnet . Ein Here-String ist eine Zeichenkette, die mit einem öffnenden Trennzeichen (`` @"oder `` @')`) beginnt und mit einem schließenden Trennzeichen (`` "@oder `` '@)`) in einer eigenen Zeile endet. Alle Zeichen zwischen dem öffnenden und dem schließenden Trennzeichen werden als Zeichenkettenliteral interpretiert. Die Verwendung von doppelten Anführungszeichen in einem Here-String ermöglicht die Interpretation von Variablen , die Verwendung von einfachen Anführungszeichen hingegen nicht. Variableninterpolation$x ist bei einfachen Variablen möglich (z. B. `int` , aber nicht bei `int` $x.yoder ` $x[0]string`). Sie können eine Reihe von Anweisungen ausführen, indem Sie diese in einen Here-String einfügen ( $()z. B. `` $($x.y)oder ` $(Get-Process | Out-String)`).

Im folgenden PowerShell-Code wird Text mithilfe einer Here-Zeichenkette an eine Funktion übergeben. Die Funktion ConvertTo-UpperCaseist wie folgt definiert:

PS > function ConvertTo-UpperCase ( $string ) { $string . ToUpper () } PS > ConvertTo-UpperCase @ ' >> one two three >> eins zwei drei >> '@ ONE TWO THREE EINS ZWEI DREI

Hier ist ein Beispiel, das die Variableninterpolation und die Ausführung von Anweisungen mithilfe eines Here-Strings mit doppelten Anführungszeichen demonstriert:

PS > $doc , $marty = 'Dr. Emmett Brown' , 'Marty McFly' PS > $time = [DateTime] 'Freitag, 25. Oktober 1985 8:00:00 Uhr' PS > $diff = New-TimeSpan -Minutes 25 PS > @" >> $doc : Sind das meine Uhren, die ich da höre? >> $marty : Ja! Äh, es ist $($time.Hour) Uhr! >> $doc : Perfekt! Mein Experiment hat funktioniert! Sie gehen alle genau $($diff.Minutes) Minuten nach. >> $marty : Moment mal. Moment mal. Doc... Wollen Sie mir etwa sagen, dass es $(($time + $diff).ToShortTimeString()) ist? >> $doc : Genau. >> $marty : Verdammt! Ich komme zu spät zur Schule! >> "@ Dr. Emmett Brown : Sind das meine Uhren, die ich da höre? Marty McFly: Ja! Äh, es ist 8 Uhr! Dr. Emmett Brown: Perfekt! Mein Experiment hat funktioniert! Sie gehen alle genau 25 Minuten nach. Marty McFly: Moment mal. Moment mal. Doc... Wollen Sie mir etwa sagen, dass es 8:25 Uhr ist? Dr. Emmett Brown: Genau. Marty McFly: Mist! Ich komme zu spät zur Schule!

Verwendet man stattdessen einen Here-String mit einfachen Anführungszeichen, sähe die Ausgabe folgendermaßen aus:

PS > @ ' >> $doc : Sind das meine Uhren, die ich da höre? >> $marty : Ja! Äh, es ist $($time.Hour) Uhr! >> $doc : Perfekt! Mein Experiment hat funktioniert! Sie gehen alle genau $($diff.Minutes) Minuten nach. >> $marty : Moment mal. Moment mal. Doc... Willst du mir etwa sagen, dass es $(($time + $diff).ToShortTimeString()) ist? >> $doc : Genau. >> $marty : Mist! Ich bin zu spät zur Schule! >> '@ $doc : Sind das meine Uhren, die ich da höre? $marty : Ja! Äh, es ist $($time.Hour) Uhr! $doc : Perfekt! Mein Experiment hat funktioniert! Sie gehen alle genau $($diff.Minutes) Minuten nach. $marty : Moment mal. Moment mal. Doc... Meinst du, es ist $(($time + $diff).ToShortTimeString())? $doc: Genau. $marty: Mist! Ich komme zu spät zur Schule!

In DCL-Skripten wird jede Eingabezeile, die nicht mit einem Dollarzeichen ($) beginnt, implizit als Eingabe für den vorhergehenden Befehl behandelt – alle Zeilen, die nicht mit $ beginnen, sind Here-Dokumente. Die Eingabe wird entweder an das Programm übergeben oder kann explizit über den logischen Namen SYS$INPUT referenziert werden (analog zum Unix-Konzept stdin ).

Zum Beispiel durch explizites Verweisen auf die Eingabe als SYS$INPUT:

$ TYPE SYS $INPUT Dieser Text wird vom Befehl TYPE direkt auf dem Bildschirm ausgegeben. $ ! andere Befehle ... 

produziert:

Dieser Text wird vom Befehl TYPE direkt auf dem Bildschirm ausgegeben.

Zusätzlich kann der Befehl DECK, ursprünglich für die Unterstützung von Lochkarten gedacht (daher der Name: er kennzeichnete den Beginn eines Datenstapels ), zur Eingabe für den vorhergehenden Befehl verwendet werden. ^{[ 16 ]} Der Datenstapel wird entweder durch den Befehl $EOD oder durch das im Parameter /DOLLARS des Befehls DECK angegebene Zeichenmuster beendet.

Beispiel eines Programms zur Ermittlung der Geldwerte:

$ RUN ADD_SUMS.EXE $ DECK 13,53 € 3,33 € 2,33 $ $ EOD 

Dies würde folgende Ausgabe erzeugen (vorausgesetzt, ADD_SUMS wurde geschrieben, um die Werte zu lesen und zu addieren):

19,19 €

Beispiel für die Verwendung von DECK /DOLLARS zum Erstellen einer Befehlsdatei aus einer anderen:

$ COPY SYS $INPUT SYS $SCRATCH :TEMP.COM $ DECK /DOLLARS = $$$$ $ TYPE SYS $INPUT Dies ist ein Beispiel für die Verwendung von DECK zum Erstellen einer Befehlsdatei innerhalb einer Befehlsdatei. $ $$ $ $ ! Weitere Befehle folgen ... 

YAML verwendet primär Leerzeichen zur Strukturierung, wodurch es resistent gegen Trennzeichenkollisionen ist und mehrzeilige Zeichenketten mit gefalteten Zeichenkettenliteralen darstellen kann:

--- Bildunterschrift : "Beispiel für die Funktionalität im Heredoc-Stil mit YAML" Datum : "2007-06-01" Beispiel : > HTML wird ohne Änderungen in YAML umgewandelt Nachricht : |<blockquote style="font: italic 12pt Times"> <p>„Drei ist immer größer als zwei, selbst für große Werte von zwei.“</p> <p>– Autor unbekannt</p> </blockquote>

• CDATA
• Pipeline (Unix)

• Hier ist das Dokument . Link zur Rosetta Code- Aufgabe mit Beispielen für Here-Dokumente in über 15 Sprachen.