Здесь документ

В вычислительной технике документ здесь ( here-document , here-text , heredoc , hereis , here-string или here-script файла ) представляет собой литерал или литерал входного потока : это раздел файла исходного кода , который обрабатывается так, как будто это был отдельный файл . Этот термин также используется для обозначения многострочных строковых литералов , которые используют аналогичный синтаксис, сохраняя разрывы строк и другие пробелы (включая отступы) в тексте.

Здесь документы возникают в оболочке Unix , и находятся в оболочке Борна ( sh), оболочка C ( csh), ткш ( tcsh), КорнШелл ( ksh), Bourne Again Shell ( bash) и Z-оболочка ( zsh), среди других. Здесь строковые литералы в стиле документа встречаются в различных языках высокого уровня , в частности, в языке программирования Perl (синтаксис, вдохновленный оболочкой Unix) и в языках, находящихся под влиянием Perl, таких как PHP и Ruby . JavaScript также поддерживает эту функциональность через литералы шаблонов , функция, добавленная в его 6-й версии ( ES6 ). Другие языки высокого уровня, такие как Python , Julia и Tcl, имеют другие возможности для многострочных строк.

Здесь документы можно рассматривать как файлы или строки. Некоторые оболочки рассматривают их как литерал форматной строки , позволяя заменять переменные и подставлять команды внутри литерала.

Обзор

Наиболее распространенный синтаксис для документов здесь, происходящих из оболочек Unix, следующий: << за которым следует разделительный идентификатор (часто слово EOF или END), за которым, начиная со следующей строки, следует текст, который нужно заключить в кавычки, а затем он закрывается тем же идентификатором-разделителем в отдельной строке. Этот синтаксис обусловлен тем, что документы здесь формально являются потоковыми литералами, а содержимое документа часто перенаправляется на стандартный ввод (стандартный ввод) предыдущей команды или текущего сценария/исполняемого файла оболочки.

Синтаксис документа здесь аналогичен синтаксису оболочки для перенаправления ввода , который < за которым следует имя файла, который будет использоваться в качестве входных данных.

Другие языки часто используют по существу схожий синтаксис, но детали синтаксиса и фактическая функциональность могут значительно различаться. При использовании просто для строковых литералов << не указывает на косвенность, а является просто соглашением о начальном разделителе. В некоторых языках, например Ruby, << также используется для перенаправления ввода, что приводит к << используется дважды, если нужно перенаправить из строкового литерала здесь документа.

Файловые литералы

В узком смысле документы здесь представляют собой файловые литералы или потоковые литералы. Они берут свое начало в оболочке Unix, хотя аналогичные возможности доступны и в некоторых других языках.

оболочки Unix

Здесь документы доступны во многих оболочках Unix. В следующем примере текст передается в tr команда (транслитерация нижнего регистра в верхний регистр), используя документ здесь. Это может быть файл оболочки или введено в интерактивном режиме по запросу.

$ LANG=C tr a-z A-Z << END
> one two three
> four five six
> END
ONE TWO THREE
FOUR FIVE SIX

В этом случае END использовался в качестве разделительного идентификатора. Он указывает начало и конец документа здесь. Перенаправление и идентификатор-разделитель не нужно разделять пробелом: <<END или << END оба работают одинаково хорошо.

По умолчанию поведение во многом идентично содержимому двойных кавычек: имена переменных заменяются их значениями, оцениваются команды внутри обратных кавычек и т. д.

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

Это можно отключить, заключив в кавычки любую часть метки, которая затем заканчивается значением без кавычек; поведение по существу идентично тому, если бы содержимое было заключено в одинарные кавычки. Например, заключив его в одинарные кавычки:

$ cat << 'EOF'
> \$ Working dir "$PWD" `pwd`
> EOF
\$ Working dir "$PWD" `pwd`

Также можно использовать двойные кавычки, но это может привести к путанице, поскольку раскрытие действительно происходит в строке с двойными кавычками, но не происходит в документе с разделителем в двойных кавычках. Разделители в одинарных и двойных кавычках различаются в некоторых других языках, особенно в Perl (см. ниже), где поведение аналогично соответствующему заключению строк в кавычки.

В оболочке POSIX, но не в csh/tcsh, добавление знака минус к << (т.е. <<-) приводит к тому, что ведущие табуляции игнорируются. Это позволяет делать здесь отступы для документов в скриптах оболочки (в первую очередь для выравнивания с существующими отступами), не меняя их значения:

Скрипт, содержащий:

LANG=C tr a-z A-Z <<- END_TEXT
Here doc with <<-
 A single space character (i.e. 0x20 )  is at the beginning of this line
	This line begins with a single TAB character i.e 0x09  as does the next line
	END_TEXT

echo The intended end was before this line 
echo and these were not processed by tr
echo +++++++++++++++

LANG=C tr a-z A-Z << END_TEXT
Here doc with <<
 A single space character (i.e. 0x20 )  is at the beginning of this line
	This line begins with a single TAB character i.e 0x09 as does the next line
	END_TEXT

echo The intended end was before this line, 
echo but because the line with the delimiting Identifier began with a TAB it was NOT recognized and
echo the tr command continued processing.

производит:

HERE DOC WITH <<-
 A SINGLE SPACE CHARACTER (I.E. 0X20 )  IS AT THE BEGINNING OF THIS LINE
THIS LINE BEGINS WITH A SINGLE TAB CHARACTER I.E 0X09  AS DOES THE NEXT LINE
The intended end was before this line
and these were not processed by tr
+++++++++++++++
HERE DOC WITH <<
 A SINGLE SPACE CHARACTER (I.E. 0X20 )  IS AT THE BEGINNING OF THIS LINE
	THIS LINE BEGINS WITH A SINGLE TAB CHARACTER I.E 0X09 AS DOES THE NEXT LINE
	END_TEXT

ECHO THE INTENDED END WAS BEFORE THIS LINE, 
ECHO BUT BECAUSE THE LINE WITH THE DELIMITING IDENTIFIER BEGAN WITH A TAB IT WAS NOT RECOGNIZED AND
ECHO THE TR COMMAND CONTINUED PROCESSING.

Другое использование — вывод в файл:

$ cat << EOF > ~/testFile001
>   3 spaces precede this text.
>	A single tab character is at the beginning of this line.
>Nothing precedes this text
EOF

Здесь струны

Строка here (доступная в bash , ksh или zsh ) синтаксически аналогична и состоит из <<<и осуществляет перенаправление ввода из слова (последовательность, рассматриваемая оболочкой как единица, в этом контексте обычно строковый литерал). В этом случае для слова используется обычный синтаксис оболочки («синтаксис строки здесь»), причем единственным синтаксисом является перенаправление: строка здесь — это обычная строка, используемая для перенаправления ввода, а не особый тип строки.

Не нужно цитировать ни одного слова:

$ LANG=C tr a-z A-Z <<< one
ONE

Если строка содержит пробелы, ее необходимо заключить в кавычки:

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

Это также можно записать как:

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

Многострочные строки приемлемы, что дает:

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

Обратите внимание, что включаются ведущие и конечные символы новой строки, если они присутствуют:

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

ONE
TWO THREE

$

Ключевое отличие от документов здесь состоит в том, что в документах здесь разделители находятся на отдельных строках; ведущие и конечные символы новой строки удаляются. В отличие от документов здесь, строки здесь не используют разделители.

Здесь строки особенно полезны для команд, которые часто требуют короткого ввода, таких как калькулятор. bc:

$ bc <<< 2^10
1024

Обратите внимание, что здесь поведение строки также может быть реализовано (в обратном порядке) через конвейер и метод echo команда, например:

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

однако здесь строки особенно полезны, когда последняя команда должна быть запущена в текущем процессе, как в случае с read встроенный:

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

ничего не дает, а

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

Это происходит потому, что в предыдущем примере трубопровод вызывает read запускаться в подпроцессе и поэтому не может влиять на среду родительского процесса.

Microsoft НМАКЕ

В Microsoft NMAKE документы называются встроенными файлами . Встроенные файлы называются << или <<pathname: первая запись создает временный файл, вторая запись создает (или перезаписывает) файл с указанным путем. Встроенный файл завершается с помощью << в отдельной строке, за которой может следовать ключевое слово (без учета регистра) KEEP или NOKEEP чтобы указать, следует ли сохранить созданный файл.

target0: dependent0
    command0 <<
temporary inline file
...
<<

target1: dependent1
    command1 <<
temporary, but preserved inline file
...
<<KEEP

target2: dependent2
    command2 <<filename2
named, but discarded inline file
...
<<NOKEEP

target3: dependent3
    command3 <<filename3
named inline file
...
<<KEEP

Р

В R нет файловых литералов, но он обеспечивает эквивалентную функциональность, комбинируя строковые литералы с функцией преобразования строки в файл. R допускает произвольные пробелы, включая символы новой строки, в строках. Затем строку можно превратить в дескриптор файла с помощью textConnection() функция. Например, следующий код превращает таблицу данных, встроенную в исходный код, в переменную фрейма данных:

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)

Сегмент данных

Перл и Руби имеют форму файлового литерала, который можно рассматривать как форму сегмента данных . В этих языках, включая строку __DATA__ (Перл) или __END__ (Ruby, старый Perl) отмечает конец сегмента кода и начало сегмента данных. Выполняется только содержимое до этой строки, а содержимое исходного файла после этой строки доступно как файловый объект: PACKAGE::DATA в Perl (например, main::DATA) и DATA в Руби. Будучи встроенными файлами, они семантически аналогичны документам здесь, хотя в каждом скрипте может быть только один файл. Однако в этих языках термин «здесь документ» вместо этого относится к многострочным строковым литералам, как описано ниже.

Схема URI данных

Как далее поясняется в схеме URI данных , все основные веб-браузеры понимают URI, которые начинаются с данных: как здесь документ.

Многострочные строковые литералы

Термин «здесь документ» или «здесь строка» также используется для обозначения многострочных строковых литералов в различных языках программирования, особенно в Perl (синтаксис, на который влияет оболочка Unix), а также в языках, на которые влияет Perl, особенно PHP и Ruby. В стиле ракушки << синтаксис часто сохраняется, несмотря на то, что он не используется для перенаправления ввода.

Под влиянием Perl

Перл

В Perl существует несколько различных способов вызова документации. Разделители вокруг тега имеют в документе here тот же эффект, что и в обычном строковом литерале: например, использование двойных кавычек вокруг тега позволяет интерполировать переменные , а использование одинарных кавычек — нет, а использование тега без либо ведет себя как двойные кавычки. Использование обратных кавычек в качестве разделителей вокруг тега запускает содержимое heredoc как сценарий оболочки. Необходимо убедиться, что закрывающий тег находится в начале строки, иначе тег не будет распознан интерпретатором.

Обратите внимание, что документ здесь начинается не с тега, а со следующей строки. Таким образом, оператор, содержащий тег, продолжается после тега.

Вот пример с двойными кавычками:

my $sender = "Buffy the Vampire Slayer";
my $recipient = "Spike";

print <<"END";

Dear $recipient,

I wish you to leave Sunnydale and never return.

Not Quite Love,
$sender

END

Выход:

Dear Spike,

I wish you to leave Sunnydale and never return.

Not Quite Love,
Buffy the Vampire Slayer

Вот пример с одинарными кавычками:

print <<'END';
Dear $recipient,

I wish you to leave Sunnydale and never return.

Not Quite Love,
$sender
END

Выход:

Dear $recipient,

I wish you to leave Sunnydale and never return.

Not Quite Love,
$sender

И пример с обратными кавычками (может быть непереносимым):

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

Можно запустить несколько heredocs в одной строке:

say(<<BEGIN . "this is the middle\n" . <<END);
This is the beginning:
BEGIN
And now it is over!
END

# this is equivalent to:
say("This is the beginning:\nthis is the middle\nAnd now it is over!\n");

Сам тег может содержать пробелы, что позволяет использовать heredocs без нарушения отступов .

  say <<'  END';
Hello World
  END

Хотя начиная с версии Perl 5.26, heredocs может включать отступ:

        #prints "Hello there\n" with no leading whitespace.
        if (1) {
          print <<~EOF;
            Hello there
            EOF
        }

В дополнение к этим строкам в Perl также имеются файловые литералы, а именно содержимое файла, следующего за ним. __DATA__ (ранее __END__) на отдельной строке. Доступен как файловый объект PACKAGE::DATA такой как main::DATAи может рассматриваться как разновидность сегмента данных .

PHP

В PHP документы здесь называются heredocs . В PHP heredocs не являются строковыми литералами. Текст Heredoc ведет себя так же, как строка в двойных кавычках, но без двойных кавычек. Например, значение `$` будет анализироваться как начало переменной, а `${` или `{$` — как начало сложной переменной.

<?php
 
$name       = "Joe Smith";
$occupation = "Programmer";
echo <<<EOF

	This is a heredoc section.
	For more information talk to $name, your local $occupation.

	Thanks!

EOF;

$toprint = <<<EOF

	Hey $name! You can actually assign the heredoc section to a variable!

EOF;
echo $toprint;

?>

Выходы

This is a heredoc section.
For more information talk to Joe Smith, your local Programmer.

Thanks!

Hey Joe Smith! You can actually assign the heredoc section to a variable!

В версиях PHP до 7.3 строка, содержащая закрывающий идентификатор, не должна содержать никаких других символов, кроме необязательной завершающей точки с запятой. В противном случае он не будет считаться закрывающим идентификатором, и PHP продолжит его поиск. Если правильный закрывающий идентификатор не найден, в последней строке скрипта возникнет ошибка анализа. Однако, начиная с версии 7.3, больше не требуется, чтобы за закрывающим идентификатором следовала точка с запятой или новая строка. Кроме того, закрывающий идентификатор может иметь отступ, и в этом случае отступ будет удален из всех строк строки документа.

В PHP 5.3 и более поздних версиях, как и в Perl, можно не интерполировать переменные, заключая тег в одинарные кавычки; это называется nowdoc :

$x = <<<'END'
Dear $recipient,

I wish you to leave Sunnydale and never return.

Not Quite Love,
$sender
END;

В PHP 5.3+ также можно заключить тег в двойные кавычки, что, как и в Perl, имеет тот же эффект, что и отсутствие окружения тега чем-либо вообще.

Руби

Следующий код Ruby отображает список покупок с помощью документа здесь.

puts <<GROCERY_LIST
Grocery list
----
1. Salad mix.
2. Strawberries.*
3. Cereal.
4. Milk.*
 
* Organic
GROCERY_LIST

Результат:

$ ruby grocery-list.rb
Grocery list
------------
1. Salad mix.
2. Strawberries.*
3. Cereal.
4. Milk.*
 
* Organic

The << в документе here не указывается перенаправление ввода, но Ruby также использует << для перенаправления ввода, поэтому перенаправление в файл из документа здесь включает использование << дважды, в разных смыслах:

File::open("grocery-list", "w") do |f|
  f << <<GROCERY_LIST
Grocery list
----
1. Salad mix.
2. Strawberries.*
3. Cereal.
4. Milk.*
 
* Organic
GROCERY_LIST
end

Как и в оболочках Unix, Ruby также позволяет идентификатору-разделителю не начинаться с первого столбца строки, если начало документа здесь отмечено немного другим стартером. <<-. Кроме того, Ruby рассматривает здесь документы как строку в двойных кавычках, и поэтому можно использовать #{} конструкция для интерполяции кода. Следующий пример иллюстрирует обе эти функции:

now = Time.now
puts <<-EOF
  It's #{now.hour} o'clock John, where are your kids?
  EOF

Ruby расширяет эту возможность, предоставляя синтаксис «<<~» для исключения отступов в документе:

puts <<~EOF
  This line is indented two spaces.
    This line is indented four spaces.
      This line is indented six spaces.
  EOF

Во всех строках опущен общий отступ в два пробела:

$ ruby indented-heredoc.rb
This line is indented two spaces.
  This line is indented four spaces.
    This line is indented six spaces.

Как и Perl, Ruby позволяет начинать несколько документов здесь в одной строке:

puts <<BEGIN + "<--- middle --->\n" + <<END
This is the beginning:
BEGIN
And now it is over!
END

# this equals this expression:
puts "This is the beginning:\n<--- middle --->\nAnd now it is over!"

Как и в Perl, в Ruby есть файловые литералы, а именно содержимое файла, следующего за ним. __END__ на отдельной линии. Доступен как файловый объект DATA и может рассматриваться как разновидность сегмента данных .

Питон

Python поддерживает многострочные строки как «дословную» строку. Они могут быть заключены в три одинарные (') или двойные (”) кавычки, последние показаны в примерах ниже.

print("""
Customer: Not much of a cheese shop is it?
Shopkeeper: Finest in the district , sir.
""")

Начиная с Python 3.6, дословные f-строки поддерживают интерполяцию переменных и выражений.

shop_type = "CHEESE"
accolade = "finest"
print(f"""
Customer: Not much of a {shop_type.lower()} shop is it?
Shopkeeper: {accolade.capitalize()} in the district , sir.
""")

Ява

Текстовые блоки поддерживаются, начиная с Java 15, через JEP 378:

String html = """
    <html>
        <body>
            <p>Hello, world</p>
        </body>
    </html>
""";

С++

См. также: C++11 § Новые строковые литералы.

Начиная с C++11 , C++ поддерживает строковые литералы с настраиваемым разделителем («my_delimiter» в этом примере):

#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;

распечатаю

Start of string. New line
slash \ quote " ' parens ) ( End of string

Д

Начиная с версии 2.0, D поддерживает строки в стиле документа с использованием префиксного символа «q». Эти строки начинаются с q"IDENT сразу за которым следует новая строка (для произвольного идентификатора IDENT) и заканчивается IDENT" в начале строки.

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

D также поддерживает несколько разделителей в кавычках с аналогичным синтаксисом, причем такие строки начинаются с q"[ и заканчивая ]" или аналогично для другого символа-разделителя (любого из () <> {} или []).

ОС/JCL

IBM В языке управления заданиями (JCL), который использовался в более ранних версиях MVS и текущих операционных системах z/OS , данные, встроенные в поток заданий, могут быть идентифицированы знаком * в операторе DD, например: //SYSIN DD * или //SYSIN DD *,DLM=text В первом случае следуют строки текста, которые объединяются в псевдофайл с именем DD SYSIN. Все записи, следующие за командой, объединяются до тех пор, пока не появится другая команда OS/JCL (любая строка, начинающаяся с //), последовательность EOF по умолчанию ( /*) найден, или происходит физический конец данных. Во втором случае условия те же, за исключением того, что операнд DLM= используется для указания текстовой строки, сигнализирующей об окончании данных, которую можно использовать, если поток данных содержит JCL (опять же, любая строка, начинающаяся с //), или /* последовательность (например, комментарии в исходном коде C или C++). Следующее компилирует и выполняет программу на языке ассемблера, передаваемую ассемблеру в виде встроенных данных.

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

The //SYSIN DD * оператор является функциональным эквивалентом <</* Далее следует указывающий поток данных, завершающийся /*.

Ракетка

Racket Строки здесь начинаются с #<< за которыми следуют символы, определяющие терминатор строки. Содержимое строки включает все символы между #<< строка и строка, единственным содержимым которой является указанный терминатор. Точнее, содержимое строки начинается после новой строки, следующей за #<<и заканчивается перед новой строкой, за которой следует терминатор.

#lang racket

(displayln
 #<<HERESTRING
This is a simple here string in Racket.
  * One
  * Two
  * Three
HERESTRING
 )

Выходы:

This is a simple here string in Racket.
  * One
  * Two
  * Three

Между начальной и конечной строками не распознаются escape-последовательности; все символы включаются в строку (и терминатор) буквально.

#lang racket

(displayln
 #<<A here string in Racket ☺
This string spans for multiple lines
and can contain any Unicode symbol.
So things like λ, ☠, α, β, are all fine.

In the next line comes the terminator. It can contain any Unicode symbol as well, even spaces and smileys!
A here string in Racket ☺
 )

Выходы:

This string spans for multiple lines
and can contain any Unicode symbol.
So things like λ, ☠, α, β, are all fine.

In the next line comes the terminator. It can contain any Unicode symbol as well, even spaces and smileys!

Здесь строки могут обычно использоваться в контекстах, где обычные строки:

#lang racket

(printf #<<END
Dear ~a,

Thanks for the insightful conversation ~a.

                ~a

END
        "Isaac"
        "yesterday"
        "Carl")

Выходы:

Dear Isaac,

Thanks for the insightful conversation yesterday.

                Carl

Интересная альтернатива — использовать расширение языка at-exp писать @-выражения. Они выглядят так:

#lang at-exp racket

(displayln @string-append{
This is a long string,
very convenient when a
long chunk of text is
needed.

No worries about escaping
"quotes" or \escapes. It's
also okay to have λ, γ, θ, ...

Embed code: @(number->string (+ 3 4))
})

Выходы:

This is a long string,
very convenient when a
long chunk of text is
needed.

No worries about escaping
"quotes" or \escapes. It's
also okay to have λ, γ, θ, ...

Embed code: 7

@-выражение не является конкретным и не ограничивается строками. Это синтаксическая форма, которую можно составить из остальной части языка.

Windows PowerShell

В PowerShell документы здесь называются здесь-строками . Здесь строка — это строка, которая начинается с открытого разделителя ( @" или @') и заканчивается закрывающим разделителем ( "@ или '@) в отдельной строке, которая завершает строку. Все символы между открывающим и закрывающим разделителем считаются строковым литералом. Использование здесь строки с двойными кавычками позволяет интерпретировать переменные , а использование одинарных кавычек — нет. Интерполяция переменных происходит с простыми переменными (например, $x но НЕ $x.y или $x[0]). Вы можете выполнить набор операторов, поместив их в $() (например $($x.y) или $(Get-Process | Out-String)).

В следующем коде PowerShell текст передается функции с помощью здесь строки. Функция ConvertTo-UpperCase определяется следующим образом:

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

Вот пример, демонстрирующий интерполяцию переменных и выполнение операторов с использованием строки в двойных кавычках:

PS  > $doc, $marty = 'Dr. Emmett Brown', 'Marty McFly'
PS  > $time = [DateTime]'Friday, October 25, 1985 8:00:00 AM'
PS  > $diff = New-TimeSpan -Minutes 25
PS  > @"
>> $doc : Are those my clocks I hear?
>> $marty : Yeah! Uh, it's $($time.Hour) o'clock!
>> $doc : Perfect! My experiment worked! They're all exactly $($diff.Minutes) minutes slow.
>> $marty : Wait a minute. Wait a minute. Doc... Are you telling me that it's $(($time + $diff).ToShortTimeString())?
>> $doc : Precisely.
>> $marty : Damn! I'm late for school!
>> "@
Dr. Emmett Brown : Are those my clocks I hear?
Marty McFly : Yeah! Uh, it's 8 o'clock!
Dr. Emmett Brown : Perfect! My experiment worked! They're all exactly 25 minutes slow.
Marty McFly : Wait a minute. Wait a minute. Doc... Are you telling me that it's 08:25?
Dr. Emmett Brown : Precisely.
Marty McFly : Damn! I'm late for school!

Используя вместо этого строку с одинарными кавычками, результат будет выглядеть следующим образом:

PS  > @'
>> $doc : Are those my clocks I hear?
>> $marty : Yeah! Uh, it's $($time.Hour) o'clock!
>> $doc : Perfect! My experiment worked! They're all exactly $($diff.Minutes) minutes slow.
>> $marty : Wait a minute. Wait a minute. Doc... Are you telling me that it's $(($time + $diff).ToShortTimeString())?
>> $doc : Precisely.
>> $marty : Damn! I'm late for school!
>> '@
$doc : Are those my clocks I hear?
$marty : Yeah! Uh, it's $($time.Hour) o'clock!
$doc : Perfect! My experiment worked! They're all exactly $($diff.Minutes) minutes slow.
$marty : Wait a minute. Wait a minute. Doc... Are you telling me that it's $(($time + $diff).ToShortTimeString())?
$doc : Precisely.
$marty : Damn! I'm late for school!

ЦИФРОВОЙ командный язык (DCL)

В сценариях DCL любая строка ввода, которая не начинается с символа $, неявно обрабатывается как входные данные для предыдущей команды — все строки, которые не начинаются с $, являются здесь-документами. Входные данные либо передаются программе, либо на них можно явно ссылаться по логическому имени SYS$INPUT (аналогично концепции stdin в Unix ).

Например, явно ссылаясь на входные данные как SYS$INPUT:

$ TYPE SYS$INPUT
This text will be directly echoed
to the screen by the TYPE command.
$! other commands ...

производит:

This text will be directly echoed
to the screen by the TYPE command.

Кроме того, команда DECK, изначально предназначенная для поддержки перфокарт (отсюда и ее название: она обозначала начало колоды данных ), может использоваться для подачи входных данных для предыдущей команды. Входная колода завершается либо командой $ EOD, либо шаблоном символов, заданным параметром /DOLLARS для DECK.

Пример программы суммирования денежных значений:

$ RUN ADD_SUMS.EXE
$ DECK
$13.53
$3.33
$2.33
$ EOD

Выдаст следующий результат (предполагается, что ADD_SUMS был написан для чтения значений и их добавления):

$19.19

Пример использования DECK /DOLLARS для создания одного командного файла из другого:

$ COPY SYS$INPUT SYS$SCRATCH:TEMP.COM
$ DECK /DOLLARS=$$$$
$ TYPE SYS$INPUT
This is an example of using DECK to create
a command file from within a command file
$$$$
$! other commands follow ...

ЯМЛ

YAML в первую очередь полагается на отступы пробелов для структуры, что делает его устойчивым к столкновению разделителей и позволяет представлять многострочные строки со свернутыми строковыми литералами:

---
caption: "Example of heredoc-style functionality using YAML"
date:    "2007-06-01"
example: >
        HTML goes into YAML without modification
message: |

        <blockquote style="font: italic 12pt Times">
        <p>"Three is always greater than two,
           even for large values of two"</p>
        <p>--Author Unknown</p>
        </blockquote>

См. также

• CDATA
• Конвейер (Unix)

Примечания

Общий

• Справочное руководство Bash, заархивировано 14 июля 2018 г. на Wayback Machine.
  • 3.6.6 Здесь документы , заархивированные 14 июля 2018 г. на Wayback Machine
  • 3.6.7 Здесь строки , заархивированные 14 июля 2018 г. на Wayback Machine
• Расширенное руководство по написанию сценариев Bash. Архивировано 14 августа 2013 г. в Wayback Machine , Мендель Купер.
  • Глава 19. Здесь документы , заархивированные 28 августа 2013 г. на Wayback Machine.
  • 19.1. Здесь струны , заархивированные 7 февраля 2018 г. на Wayback Machine.

Внешние ссылки

• Вот документ . Ссылка на задачу Rosetta Code с примерами документов на более чем 15 языках.