Eof linux что это
Обновлено: 04.07.2024
Мне нужно было написать скрипт для ввода многострочного ввода в программу ( psql ).
После небольшого поиска я нашел следующий синтаксис:
Это правильно создает многострочную строку (от BEGIN; до END; , включительно) и передает ее в качестве входных данных psql .
Но я понятия не имею, как / почему это работает, может кто-нибудь объяснить, пожалуйста?
Я имею в виду cat << EOF , я знаю, > вывод в файл, >> добавляет в файл, < читает входные данные из файла.
Что << именно делает?
И есть ли справочная страница для этого?
Я удивлен, что это работает с кошкой, но не с эхом. cat должен ожидать имя файла как stdin, а не как строку символов. PSQL << EOF звучит логично, но не иначе. Работает с кошкой, но не с эхом. Странное поведение. Есть какие-нибудь подсказки по этому поводу? Отвечаю себе: cat без параметров выполняет и реплицирует на вывод все, что отправляет через ввод (stdin), следовательно, используя свой вывод для заполнения файла через>. На самом деле имя файла, считываемое как параметр, не является потоком стандартного ввода. @Alex echo просто печатает свои аргументы командной строки, в то время как cat читает stding (при передаче по нему) или читает файл, который соответствует его аргументам командной строкиЗдесь документы
Этот тип перенаправления инструктирует оболочку читать входные данные из текущего источника, пока не появится строка, содержащая только слово (без завершающих пробелов).
Все строки, считанные до этой точки, затем используются в качестве стандартного ввода для команды.
Формат здесь-документов:
Для слова не выполняется расширение параметров, подстановка команд, арифметическое расширение или расширение имени пути . Если какие-либо символы в слове заключены в кавычки, разделитель является результатом удаления кавычки в слове , а строки в документе здесь не раскрываются. Если слово не заключено в кавычки, все строки здесь-документа подвергаются расширению параметров, подстановке команд и арифметическому расширению. В последнем случае последовательность символов \<newline> игнорируется и \ должна использоваться для цитирования символов \ , $ и ` .
Если оператор перенаправления имеет значение <<- , то все начальные символы табуляции удаляются из строк ввода и строки, содержащей разделитель . Это позволяет естественным образом сдвигать документы в скриптах оболочки.
Мне было труднее всего отключить расширение переменных / параметров. Все, что мне нужно было сделать, это использовать «двойные кавычки», и это исправило это! Спасибо за информацию! Что касается, <<- пожалуйста, обратите внимание, что удаляются только начальные символы вкладки, а не символы программной вкладки. Это один из тех редких случаев, когда вам действительно нужен символ табуляции. Если в остальной части документа используются мягкие вкладки, убедитесь, что отображаются невидимые символы и (например) скопируйте и вставьте символ вкладки. Если вы все сделаете правильно, ваша подсветка синтаксиса должна правильно поймать конечный разделитель. Я не вижу, как этот ответ более полезен, чем приведенные ниже. Он просто срыгивает информацию, которую можно найти в других местах (которые, вероятно, уже были проверены) @ BrDaHa, возможно это не так. Почему вопрос? из-за голосов? это был единственный за несколько лет. это видно по сравнению дат.cat <<EOF Синтаксис очень полезен при работе с многострочным текстом в Bash, например. при назначении многострочной строки переменной оболочки, файлу или каналу.
1. Присвойте многострочную строку переменной оболочки
$sql Переменная теперь держит символы новой строки тоже. Вы можете проверить с помощью echo -e "$sql" .
2. Передать многострочную строку в файл в Bash
print.sh Файл теперь содержит:
3. Передайте многострочную строку в трубу в Bash.
b.txt Файл содержит bar и baz строки. Тот же вывод выводится на stdout .
1. 1 и 3 можно сделать без кота; 2. Пример 1 можно выполнить с помощью простой многострочной строкиВ вашем случае, «EOF» известен как «Здесь тег». В основном <<Here говорит оболочке, что вы собираетесь вводить многострочную строку до появления «тега» Here . Вы можете назвать этот тег, как вы хотите, это часто EOF или STOP .
- Тэг может быть любой строкой, прописными или строчными, хотя большинство людей используют прописные буквы по соглашению.
- Тег не будет считаться тегом Here, если в этой строке есть другие слова. В этом случае он будет считаться только частью строки. Тег должен быть отдельно в отдельной строке, чтобы считаться тегом.
- У тега не должно быть начальных или конечных пробелов в этой строке, чтобы он считался тегом. В противном случае он будет считаться частью строки.
POSIX 7
Операторы перенаправления «<<» и «<< -» позволяют перенаправлять строки, содержащиеся во входном файле оболочки, называемом «здесь-документ», на ввод команды.
Здесь-документ должен рассматриваться как одно слово, которое начинается после следующего и продолжается до тех пор, пока не появится строка, содержащая только разделитель и a, без символов между ними. Затем начинается следующий документ, если он есть. Формат следующий:
где необязательный n представляет номер дескриптора файла. Если число опущено, то здесь документ ссылается на стандартный ввод (дескриптор файла 0).
Если какой-либо символ в слове заключен в кавычки, разделитель должен быть сформирован путем выполнения удаления слова в кавычках, а строки документа здесь не должны расширяться. В противном случае разделителем должно быть само слово.
Если никакие символы в слове не заключены в кавычки, все строки здесь-документа должны быть раскрыты для раскрытия параметров, подстановки команд и арифметического раскрытия. В этом случае входные данные ведут себя как внутренние двойные кавычки (см. Двойные кавычки). Однако символ двойной кавычки ('"') не должен обрабатываться специально в документе здесь, за исключением случаев, когда двойная кавычка появляется внутри" $ () "," `` "или" $ <> ".
Если символ перенаправления "<< -", все ведущие <tab> символы должны быть удалены из строк ввода и строки, содержащей конечный разделитель. Если в строке указано более одного оператора «<<» или «<< -», то здесь документ-документ, связанный с первым оператором, должен быть сначала предоставлен приложением и сначала должен быть прочитан оболочкой.
Когда здесь документ считывается из оконечного устройства и оболочка является интерактивной, он должен записать содержимое переменной PS2, обработанной, как описано в разделе «Переменные оболочки», в стандартную ошибку перед чтением каждой строки ввода, пока разделитель не будет распознан.
Примеры
Некоторые примеры еще не приведены.
Кавычки препятствуют расширению параметров
или (некрасиво, но верно):
Дефис удаляет ведущие вкладки
где <tab> буквенная вкладка, и может быть вставлен с Ctrl + V <tab>
Конечно, это существует, так что вы можете сделать отступ, cat как и окружающий код, который легче читать и поддерживать. Например:
К сожалению, это не работает с пробелами: здесь POSIX поддерживает tab отступы. Хлоп.
Рассмотрим операторы перенаправления вывода Bash и похожие по функции операторы и конструкции. Я собрал следующий список, если что-то пропустил, то пишите в комментариях:
- |
- >
- > /dev/null
- >>
- 2>
- 2>&1
- &>
- &>>
- <
- <<
- <<<
- Почему << (here document) и <<< (here string) нельзя использовать с переменными
- В чём различие << (here document) и <<< (here string)
- <(КОМАНДА)
- >(КОМАНДА)
- < <(КОМАНДА АРГУМЕНТЫ)
- 2> >(КОМАНДА) > /dev/null
- cat > ФАЙЛ <<_EOF_
- cat >> ФАЙЛ <<_EOF_
- cat <<_EOF_ > ФАЙЛ
- cat <<_EOF_ >> ФАЙЛ
Этот оператор на английском называется pipe, и на русском его называют труба или конвейер. Используется очень часто для перенаправления вывода из одной команды в другую, которая может принимать стандартный вывод. Например:
Символ > используется для перенаправления вывода в файл, например:
В этом примере вывод команды ls -l будет записан в файл dir.txt.
То есть оператор | используется когда вывод передаётся в другую команду, а оператор > используется когда вывод записывается в файл.
Ещё один пример использования сразу обоих операторов:
Результат работы этой последовательности команд будет сохранён в файл num.txt.
Если файл не существует, то он будет создан. Если файл существует, то оператор > полностью удалит его содержимое и запишет новым.
> /dev/null
Это частный случай перенаправления, когда всё из стандартного вывода перенаправляется в псевдоустройство /dev/null. Это означает уничтожение данные. То есть ничего не будет выводиться в стандартный вывод.
Функция оператора >> похожа на > с тем отличием, что оператор >> не удаляет содержимое файла, а дописывает новые данные к уже существующим.
Если файл не существует, то оператор >> создаст его и запишет в него переданные данные.
Оператор 2> перенаправляет стандартный вывод ошибок — standard error (stderr).
Результат выполнения команд и возникшие ошибки выводятся на консоль и может показаться, что это одно и то же. Но на самом деле, это разные типы вывода.
К примеру попытаемся сохранить в файл текст ошибки, возникшей в результате выполнения команды:
Текст ошибки будет выведен на экран, но файл ls-error.txt окажется пустым.
В данном случае ошибка не будет выведена на экран, а будет сохранена в файл ls-error.txt.
Файловый дескриптор «2» помещается непосредственно перед оператором перенаправления, чтобы выполнить перенаправление стандартной ошибки в файл ls-error.txt.
Конструкция 2>&1 предназначена для перенаправления стандартного вывода и стандартного вывода ошибок в один файл.
Используя этот метод, мы выполняем два перенаправления. Сначала мы перенаправляем стандартный вывод в файл ls-output.txt, а затем перенаправляем дескриптор файла 2 (стандартная вывод ошибок) на дескриптор файла один (стандартный вывод), используя обозначения 2>&1.
Обратите внимание, что порядок перенаправлений является значимым. Перенаправление стандартной ошибки всегда должно происходить после перенаправления стандартного вывода, иначе оно не работает. В приведённом выше примере
перенаправляет стандартную ошибку в файл ls-output.txt, но при изменении порядка на
стандартная ошибка направлена на экран.
Последние версии bash предоставляют второй, более упрощённый метод для выполнения комбинированного перенаправления 2>&1:
В этом примере мы используем одинарную запись &> для перенаправления как стандартного вывода, так и стандартной ошибки в файл ls-output.txt.
Вы также можете добавить стандартные выходные данные и стандартные потоки ошибок в один файл, например так:
Итак, &> является аналогом 2>&1, а &>> это то же самое, но с перенаправлением вывода в файл.
Как мы уже рассмотрели выше, символ > является перенаправлением вывода. Что касается символа <, то он перенаправляет ввод. Используется следующим образом:
В этом случае КОМАНДА1 будет выполнена с ФАЙЛ1 в качестве источника ввода вместо клавиатуры, которая является обычным источником стандартного ввода.
Оператор < соответствует использованию | для передачи в программу стандартного ввода. Например, следующие команды являются идентичными:
Ещё один пример, содержимое файла math.txt:
Тогда следующие команды идентичны:
Оператор << называется here document. С его помощью можно ввести строку состоящую из нескольких строк или присвоить переменной многострочное значение.
Если в консоль ввести
и нажать Enter, то переменной a будет присвоено значение «строка» и вновь станет доступно приглашение командной строки, потому что Enter по умолчанию является разделителем, символом новой строки. Из-за этого не получится ввести многострочное значение.
Оператор << (here document) меняет это правило — обозначением для новой строки становится другая последовательность символов. В качестве такого обозначения можно выбрать любой набор символов, единственное условие — этот набор не должен встречаться в водимых данных.
Данная запись означает, что запущена команда cat, после неё идёт оператор << и последовательность символов _EOF_. Эти символы (_EOF_) + Enter означают, что _EOF_ - становится обозначением начала и конца для многострочных данных. То есть Enter больше не будет означать окончание ввода данных, в качестве обозначения окончания ввода данных будет выступать _EOF_. Вместо этих символов можно выбрать что угодно.
Второй ввод _EOF_ + Enter означает конец многострочных данных. После этого будет выполнена команда, то есть будут выведены введённые цифры:
Если вы хотите переменной присвоить многострочное значение, то это можно сделать примерно так:
Выведем значение переменной:
Here document это весьма полезная конструкция, к примеру, с её помощью можно делать шаблоны текста, меню, выводимых данных:
Оператор <<< называется here string. Он передаёт с правой стороны стандартный ввод. Чтобы было понятно, следующие команды эквивалентны:
Почему << (here document) и <<< (here string) нельзя использовать с переменными
Если мы захотим присвоить переменной значение с помощью рассмотренных операторов и попробуем выполнить:
то будет получена ошибка:
Причина в том, что нельзя присвоить значение переменным передав данные в стандартном вводе. Например команда
вызовет точно такую же ошибку.
А операторы << (here document) и <<< (here string) передают данные командам в стандартном вводе.
В чём различие << (here document) и <<< (here string)
Различие между этими операторами в том, что << передаёт многострочные данные, которые обрамляются указанной последовательностью символов, а <<< передаёт только строку.
<(КОМАНДА)
Конструкция <(КОМАНДА) называется «подстановка процессов» (Process Substitution). В качестве КОМАНДА может быть одна или более команд с аргументами. Конструкция
вернёт имя специального файла, прочитав который можно получить вывод КОМАНДЫ.
Применение данного способа записи и чтения в и из команды показано далее.
>(КОМАНДА)
Это ещё одна форма «подстановки процессов» (Process Substitution):
Если используется эта форма, то вместо записи в файл, данные будут переданы на ввод для КОМАНДЫ.
< <(КОМАНДА АРГУМЕНТЫ)
Данная конструкция состоит из двух уже рассмотренных ранее элементов языка Bash:
Как мы только что узнали, <(КОМАНДА АРГУМЕНТЫ) возвращает имя файла из которого нужно считывать результат выполнения КОМАНДЫ. А оператор < передаёт ввод с файла (указанного справа от него) команде на стандартный ввод (указанной слева).
Следующие две команды являются аналогами друг друга:
2> >(КОМАНДА) > /dev/null
Эка комбинация, включающая в себя 3 уже рассмотренных элемента:
- 2> означает перенаправление стандартного вывода ошибок (stderr)
- >(КОМАНДА) означает подстановку процессов, в результате стандартный вывод ошибок будет передан для обработки в КОМАНДУ
- > /dev/null означает перенаправления стандартного вывода в /dev/null, то есть фактическое уничтожение стандартного вывода
Пример практического использования:
cat > ФАЙЛ <<_EOF_
Эта конструкция может показаться очень замысловатой, но она состоит из двух уже рассмотренных элементов:
- > (перенаправление вывода в файл)
- << (here document, то есть многострочный ввод)
В результате выполнения этого кода, в ФАЙЛ будут записаны строки
Причём если ФАЙЛ уже существует, то он будет стёрт и заменён указанным содержимым.
То есть это один из способов сохранения в файл многострочного вывода.
cat >> ФАЙЛ <<_EOF_
Эта конструкция похожа на предыдущую, в ней используются
- >> (перенаправление вывода в файл с дописыванием данных)
- << (here document, то есть многострочный ввод)
В результате выполнения следующего кода:
В ФАЙЛ будут сохранены строки:
Причём если ФАЙЛ уже существует, то он будет дописан.
cat <<_EOF_ > ФАЙЛ
Данная конструкция получает многострочный ввод по стандартному вводу и сохраняет его в файл. То есть это аналог
Недавно я читал книгу «Компьютерные системы: архитектура и программирование. Взгляд программиста». Там, в главе про систему ввода-вывода Unix, авторы упомянули о том, что в конце файла нет особого символа EOF .
Если вы читали о системе ввода-вывода Unix/Linux, или экспериментировали с ней, если писали программы на C, которые читают данные из файлов, то это заявление вам, вероятно, покажется совершенно очевидным. Но давайте поближе присмотримся к следующим двум утверждениям, относящимся к тому, что я нашёл в книге:
- EOF — это не символ.
- В конце файлов нет некоего особого символа.
EOF — это не символ
Почему кто-то говорит или думает, что EOF — это символ? Полагаю, это может быть так из-за того, что в некоторых программах, написанных на C, можно найти код, в котором используется явная проверка на EOF с использованием функций getchar() и getc() .
Это может выглядеть так:
Если заглянуть в справку по getchar() или getc() , можно узнать, что обе функции считывают следующий символ из потока ввода. Вероятно — именно это является причиной возникновения заблуждения о природе EOF . Но это — лишь мои предположения. Вернёмся к мысли о том, что EOF — это не символ.
А что такое, вообще, символ? Символ — это самый маленький компонент текста. «A», «a», «B», «b» — всё это — разные символы. У символа есть числовой код, который в стандарте Unicode называют кодовой точкой. Например — латинская буква «A» имеет, в десятичном представлении, код 65. Это можно быстро проверить, воспользовавшись командной строкой интерпретатора Python:
Или можно взглянуть на таблицу ASCII в Unix/Linux:
Выясним, какой код соответствует EOF , написав небольшую программу на C. В ANSI C константа EOF определена в stdio.h , она является частью стандартной библиотеки. Обычно в эту константу записано -1 . Можете сохранить следующий код в файле printeof.c , скомпилировать его и запустить:
Скомпилируем и запустим программу:
У меня эта программа, проверенная на Mac OS и на Ubuntu, сообщает о том, что EOF равняется -1 . Есть ли какой-нибудь символ с таким кодом? Тут, опять же, можно проверить коды символов в таблице ASCII, можно взглянуть на таблицу Unicode и узнать о том, в каком диапазоне могут находиться коды символов. Мы же поступим иначе: запустим интерпретатор Python и воспользуемся стандартной функцией chr() для того, чтобы она дала бы нам символ, соответствующий коду -1 :
Как и ожидалось, символа с кодом -1 не существует. Значит, в итоге, EOF , и правда, символом не является. Переходим теперь ко второму рассматриваемому утверждению.
В конце файлов нет некоего особого символа
Может, EOF — это особенный символ, который можно обнаружить в конце файла? Полагаю, сейчас вы уже знаете ответ. Но давайте тщательно проверим наше предположение.
Возьмём простой текстовый файл, helloworld.txt, и выведем его содержимое в шестнадцатеричном представлении. Для этого можно воспользоваться командой xxd :
Как видите, последний символ файла имеет код 0a . Из таблицы ASCII можно узнать о том, что этот код соответствует символу nl , то есть — символу новой строки. Это можно выяснить и воспользовавшись Python:
Так. EOF — это не символ, а в конце файлов нет некоего особого символа. Что же такое EOF ?
Что такое EOF?
EOF (end-of-file) — это состояние, которое может быть обнаружено приложением в ситуации, когда операция чтения файла доходит до его конца.
Взглянем на то, как можно обнаруживать состояние EOF в разных языках программирования при чтении текстового файла с использованием высокоуровневых средств ввода-вывода, предоставляемых этими языками. Для этого напишем очень простую версию cat , которая будет называться mcat . Она побайтно (посимвольно) читает ASCII-текст и в явном виде выполняет проверку на EOF . Программу напишем на следующих языках:
- ANSI C
- Python 3
- Go
- JavaScript (Node.js)
ANSI C
Начнём с почтенного C. Представленная здесь программа является модифицированной версией cat из книги «Язык программирования C».
Вот некоторые пояснения, касающиеся вышеприведённого кода:
- Программа открывает файл, переданный ей в виде аргумента командной строки.
- В цикле while осуществляется копирование данных из файла в стандартный поток вывода. Данные копируются побайтово, происходит это до тех пор, пока не будет достигнут конец файла.
- Когда программа доходит до EOF , она закрывает файл и завершает работу.
Python 3
В Python нет механизма явной проверки на EOF , похожего на тот, который имеется в ANSI C. Но если посимвольно читать файл, то можно выявить состояние EOF в том случае, если в переменной, хранящей очередной прочитанный символ, будет пусто:
Запустим программу и взглянём на возвращаемые ей результаты:
Вот более короткая версия этого же примера, написанная на Python 3.8+. Здесь используется оператор := (его называют «оператор walrus» или «моржовый оператор»):
Запустим этот код:
В Go можно явным образом проверить ошибку, возвращённую Read(), на предмет того, не указывает ли она на то, что мы добрались до конца файла:
JavaScript (Node.js)
В среде Node.js нет механизма для явной проверки на EOF . Но, когда при достижении конца файла делается попытка ещё что-то прочитать, вызывается событие потока end.
Низкоуровневые системные механизмы
Как высокоуровневые механизмы ввода-вывода, использованные в вышеприведённых примерах, определяют достижение конца файла? В Linux эти механизмы прямо или косвенно используют системный вызов read(), предоставляемый ядром. Функция (или макрос) getc() из C, например, использует системный вызов read() и возвращает EOF в том случае, если read() указывает на возникновение состояния достижения конца файла. В этом случае read() возвращает 0 . Если изобразить всё это в виде схемы, то получится следующее:
Получается, что функция getc() основана на read() .
Напишем версию cat , названную syscat , используя только системные вызовы Unix. Сделаем мы это не только из интереса, но и из-за того, что это вполне может принести нам какую-то пользу.
Вот эта программа, написанная на C:
В этом коде используется тот факт, что функция read() , указывая на достижение конца файла, возвращает 0 .
Когда я собираю его в Ubuntu, он начинает получать символы, но я не знаю, как завершить программу, так как он не заканчивается вводом ENTER или возврата каретки.
Что означает EOF? Как я могу вызвать это?
Этот источник также есть в книге Денниса Ритчи:
3 ответа
Как правило, вы можете "запустить EOF" в программе, работающей в терминале с помощью нажатия клавиш CTRL + D сразу после последнего сброса ввода.
Что означает EOF? Как я могу вызвать это?
EOF означает конец файла.
"Запуск EOF" в этом случае примерно означает "информирование программы о том, что ввод больше не будет отправлен".
В этом случае, так как getchar() вернет отрицательное число, если ни один символ не прочитан, выполнение прекращается.
Но это относится не только к вашей конкретной программе, это относится ко многим различным инструментам.
В общем, "запуск EOF" может быть выполнен нажатием комбинации клавиш CTRL + D сразу после последнего сброса ввода (т. Е. Путем отправки пустого ввода).
Когда вы нажимаете CTRL + D, то происходит то, что ввод, введенный с момента последнего сброса ввода, сбрасывается; когда это случается пустой вход read() системный вызов вызван возвратом STDIN программы 0 , getchar() возвращает отрицательное число ( -1 в библиотеке GNU C), и это, в свою очередь, интерпретируется как EOF 1 .
TL; DR: EOF - это не символ, это макрос, используемый для оценки отрицательного возврата функции чтения ввода. Для отправки можно использовать Ctrl + D EOT символ, который заставит функцию вернуться -1
Каждый программист должен RTFM
Давайте обратимся к "Справочному руководству C A" Harbison and Steele, 4-е изд. с 1995 г., стр. 317:
Отрицательное целое число EOF - это значение, которое не является кодировкой "реального символа" . Например, fget (раздел 15.6) возвращает EOF в конце файла, потому что нет "реального символа" для чтения.
по существу EOF не символ, а целочисленное значение, реализованное в stdio.h представлять -1 , Таким образом, ответ Коса является правильным, но речь идет не о получении "пустого" ввода. Важно отметить, что здесь EOF служит возвращаемым значением (из getchar() ) сравнение, а не для обозначения фактического характера. man getchar поддерживает это:
ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
fgetc(), getc() и getchar() возвращают символ, прочитанный как символ без знака, приведенный к типу int или EOF в конце файла или ошибки.
get () и fgets() возвращают s в случае успеха и NULL в случае ошибки или когда происходит конец файла, когда символы не были прочитаны.
ungetc () возвращает c в случае успеха или EOF в случае ошибки.
Рассмотрим while цикл - его основная цель - повторить действие, если условие в скобках верно. Посмотри снова:
Это в основном говорит продолжать делать вещи, если c = getchar() возвращает успешный код ( 0 или выше; кстати, это обычное дело, попробуйте запустить успешную команду, затем echo $? а потом не удалось echo $? и увидеть числа, которые они возвращают). Поэтому, если мы успешно получим символ и добавим C, возвращенный код состояния будет равен 0, а ошибка - -1. EOF определяется как -1 , Поэтому, когда условие -1 == -1 происходит, петли прекращаются. И когда это произойдет? Когда нет больше персонажа, чтобы получить, когда c = getchar() выходит из строя. Вы могли бы написать while ((c = getchar ()) != -1) и все равно будет работать
Кроме того, давайте вернемся к фактическому коду, вот выдержка из stdio.h
Коды ASCII и EOT
Хотя символ EOF не является действительным символом, существует EOT Символ (конец передачи), который имеет десятичное значение ASCII 04; он связан с сочетанием клавиш Ctrl + D (представлен также как метасимвол ^D ). Характер окончания передачи использовался для обозначения закрытия потока данных в обратном направлении, когда компьютеры использовались для управления телефонными соединениями, отсюда и название "конец передачи" .
Таким образом, мы можем сказать, что он существует, но это не для печати
Примечание
Мы часто забываем, что в прошлом компьютеры не были такими универсальными - дизайнеры должны использовать каждую доступную клавиатуру. Таким образом, отправка EOT символ с CtrlD по-прежнему "отправляет символ", в отличие от ввода заглавной буквы A, ShiftA, вы все равно заставляете компьютер вводить данные с помощью доступных клавиш. Таким образом, EOT - это реальный символ в том смысле, что он исходит от пользователя, он читается компьютером (хотя не для печати, не виден людьми), он существует в компьютерной памяти
Комментарий Byte Commander
Если вы попытаетесь прочитать из /dev/null, это также должно вернуть EOF, верно? Или что я получу там?
Да, совершенно верно, потому что в /dev/null нет фактического символа для чтения, следовательно, он c = getchar() вернусь -1 код, и программа выйдет сразу. Снова команда не возвращает EOF. EOF - это просто постоянная переменная, равная -1, которую мы используем для сравнения кода возврата функции getchar. EOF не существует как символ, это просто статическое значение внутри stdio.h ,
Еще один гвоздь в гробу
Иногда пытаются доказать, что EOF - это символ с кодом, подобным этому:
Проблема в том, что тип данных char может иметь значение со знаком или без знака. Кроме того, они являются наименьшим адресуемым типом данных, что делает их очень полезными в микроконтроллерах, где память ограничена. Так что вместо того, чтобы объявить int foo = 25; это часто встречается в микроконтроллерах с небольшой памятью char foo = 25; или что-то подобное. Кроме того, символы могут быть подписаны или не подписаны.
Можно проверить, что размер в байтах с программой, как это:
Какой именно смысл? Дело в том, что EOF определяется как -1, но тип данных char может печатать целочисленные значения.
ХОРОШО. то, что если мы попытаемся напечатать char как строку?
Очевидно, ошибка, но, тем не менее, ошибка скажет нам кое-что интересное:
skolodya @ ubuntu: $ gcc EOF.c -o EOF
EOF.c: В функции 'main': EOF.c:4:5: warning: format '%s' ожидает аргумент типа 'char *', но аргумент 2 имеет тип 'int' [-Wformat=] printf("%s", EOF);
Шестнадцатеричные значения
Еще одна любопытная вещь происходит со следующим кодом:
Если нажать Shift + A , мы получим шестнадцатеричное значение 41, очевидно такое же, как в таблице ASCII. Но для Ctrl + D мы имеем ffffffff опять же - возвращаемое значение getchar() Хранится в c ,
Обратитесь к другим языкам
Обратите внимание, что другие языки избегают этой путаницы, потому что они работают с оценкой состояния выхода из функции, а не сравнивают ее с макросом. Как читать файл в Java?
Главное меню » Linux » Mint » Что такое Cat EOF в Bash Script?
Обычно он используется либо для печати текста файла в терминале, либо для копирования содержимого файла в другое указанное место. Команда cat, за которой следует имя файла, позволяет просматривать содержимое любого файла в терминале Linux. Однако вместо того, чтобы выполнять этот шаг для просмотра содержимого файла, мы можем просто включить этот шаг в наш сценарий bash для той же цели. В этой статье показано использование оператора Cat EOF в сценарии bash в Linux Mint 20 с примерами.
Два случая использования Cat EOF в Bash Script в Linux Mint 20
Чтобы объяснить использование оператора Cat EOF в сценарии bash, мы разработали два простых примера сценария использования этого оператора в Linux Mint 20. Мы рассмотрим эти сценарии один за другим.
Случай №1: Печать содержимого файла в терминале
В этом сценарии мы покажем вам, как использовать оператор EOF для печати содержимого файла в терминале. Для этого мы сначала создадим сценарий bash, который будет содержать образец текста. Когда этот сценарий bash выполняется, он будет отображать текст, заключенный в нашем сценарии bash, в терминале. Следуйте инструкциям ниже, чтобы распечатать содержимое любого заданного файла в вашем терминале.
Шаг 1. Создайте сценарий Bash
Сначала мы создадим файл с именем EOF.sh в нашем домашнем каталоге. Вы можете выбрать любое другое имя для этого файла bash. Кроме того, вы можете создать этот файл bash в любом каталоге по вашему выбору; однако всегда удобно создавать файлы в домашнем каталоге в демонстрационных целях. Это избавляет нас от необходимости указывать путь к файлу каждый раз, когда мы хотим получить к нему доступ.
После создания этого файла мы откроем его в текстовом редакторе Linux Mint 20. Затем мы введем в этот файл сценарий, показанный на следующем изображении. Этот сценарий использует блок cat << EOF-EOF для печати содержимого этого блока в терминале. Мы написали случайный текст в этом блоке, который будет напечатан в терминале.
Шаг 2: выполнение сценария Bash
Когда наш bash-скрипт будет готов, мы выполним его с помощью следующей команды:
Шаг 3: проанализируйте вывод Bash Script
После выполнения команды на шаге 2 вы увидите содержимое, заключенное в блок cat << EOF-EOF в вашем сценарии bash в терминале.
Случай № 2: Печать содержимого файла в другой файл
В этом сценарии мы покажем вам, как распечатать содержимое одного файла в другом файле. Для этого мы изменим сценарий bash, который мы создали в предыдущем сценарии, случай № 1. Этот сценарий bash также будет содержать образец текста.
Когда этот сценарий bash выполняется, он сохранит текст, заключенный в нашем сценарии bash, в указанном файле. Если файл с указанным именем уже существует, то наш сценарий bash просто скопирует наш образец текста в этот файл. В противном случае сценарий сначала создаст файл по указанному пути, а затем скопирует содержимое во вновь созданный файл. После выполнения этого сценария bash вы можете перейти по указанному пути и проверить содержимое файла. Следуйте инструкциям ниже, чтобы распечатать содержимое любого файла в другой файл с помощью сценария bash.
Шаг 1. Измените сценарий Bash, созданный в случае № 1
На этом этапе мы просто откроем файл bash, созданный для демонстрации нашего первого сценария. В этом сценарии bash мы создали переменную с именем «var» и уравняли ее с путем к файлу, то есть именем и путем к файлу, в который мы хотим скопировать содержимое. Затем мы будем использовать блок cat < $var-EOF, чтобы заключить образец содержимого.
Шаг 2: выполнение сценария Bash
Когда наш сценарий bash был изменен, пришло время выполнить его с той же командой, что и в случае № 1. Однако на этот раз вы не сможете ничего увидеть на терминале.
Шаг 3. Проанализируйте содержимое файла, в который был скопирован образец текста
Чтобы проверить, успешно ли была выполнена желаемая операция, сначала мы перейдем в наш домашний каталог. В домашнем каталоге мы попытаемся найти файл, в который мы хотели скопировать содержимое нашего сценария bash. Как только файл будет найден (в нашем случае имя файла было «temp.txt»), вы можете просто открыть его, чтобы просмотреть его содержимое. Содержимое нашего файла является точной копией содержимого, заключенного в нашем сценарии bash.
Заключение
Пройдя два сценария, представленных в этой статье, вы должны быть в состоянии сказать, что понимаете базовое использование Cat EOF в сценарии bash в Linux Mint 20. Эти сценарии предоставляют вам два разных способа использования этого оператора в Linux Mint 20. для печати содержимого файла или копирования содержимого одного файла в другой.
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.
Читайте также: