Что такое стандартный ввод Linux
Обновлено: 21.11.2024
Есть неплохая вероятность того, что если вы использовали операционные системы Linux, то могли столкнуться с тремя известными потоками данных, известными как stdin, stderr и stdout. Все они различны по своим функциям и имеют собственное применение, но у всех трех есть одна общая черта: они представляют собой потоки данных, которые создает bash.
Давайте узнаем больше о том, что на самом деле означают потоки данных и чем они полезны. С точки зрения вычислений поток данных — это то, что дает нам возможность передавать данные от источника к оттоку и наоборот. Источник и отток являются двумя конечными точками потока данных. Вам может быть интересно узнать, что какую бы команду вы ни запускали в своем терминале Linux, она будет либо в одной из этих конечных точек.
Теперь мы немного знаем о потоках данных, давайте узнаем больше о трех известных потоках данных.
stdin — обозначает стандартный ввод и используется для ввода текста в качестве ввода.
stdout — обозначает стандартный вывод и используется для вывода текста любой команды, которую вы вводите в терминал, а затем этот вывод сохраняется в потоке stdout.
stderr — стандартная ошибка. Он вызывается всякий раз, когда команда сталкивается с ошибкой, а затем это сообщение об ошибке сохраняется в этом потоке данных.
Следует отметить, что в Linux все эти потоки рассматриваются как файлы. Кроме того, Linux присваивает уникальные значения каждому из этих потоков данных.
Теперь давайте рассмотрим несколько примеров этих трех потоков данных.
В приведенном ниже примере показан типичный поток стандартного ввода.
Команда
Вывод
В приведенной выше команде мы вводим данные в поток, а инструмент чтения получает данные из стандартного ввода.
Теперь ниже показан пример стандартного вывода —
Команда
Вывод
Мы знаем, что используем команду ls с флагом -ltr для отображения списка всех файлов в определенной сортировке, где последний обновленный файл отображается внизу. Список отправляется в поток данных stdout, после чего терминал просто распечатывает его.
Теперь пример stderr показан ниже —
Команда
Приведенная выше команда недействительна, так как у меня нет каталога с именем printit, и она сгенерирует сообщение об ошибке, которое будет отправлено в stderr, а затем терминал напечатает его.
Стандартный ввод, часто обозначаемый аббревиатурой stdin, является источником входных данных для программ командной строки (т. е. программ, работающих в текстовом режиме). в Linux и других Unix-подобных операционных системах.
В таких операционных системах используется концепция стандартных потоков данных. Каждая команда и, следовательно, каждый процесс автоматически инициализируется (т. е. назначается) тремя потоками данных: одним входным потоком, называемым стандартным вводом, и два потока вывода, называемые стандартный вывод и стандартная ошибка. Эти потоки состоят из данных в форме простого текста (т. е. удобочитаемых буквенно-цифровых символов) и считаются особыми типами файлов.
Команда — это указание, данное пользователем, чтобы заставить компьютер что-то сделать, например запустить программу. Команды обычно выдаются путем ввода их в командной строке и последующего нажатия клавиши ENTER, которая передает их в оболочку. Оболочка — это программа, которая считывает команды, набранные на клавиатуре, а затем выполняет (т. е. запускает) их. Процесс — это экземпляр выполняемой программы.
Эта терминология может сбить с толку новых пользователей. Тем не менее, с ним полезно ознакомиться, потому что он обычно используется в документации для Unix-подобных операционных систем, включая онлайновые man (т. е. справочные) страницы, которые можно найти почти во всех таких системы.
Пользователи, знакомые с языком программирования C, на котором написано ядро Linux (т. е. ядро операционной системы) и многие его утилиты, должны знать, что он включает подпрограммы для выполнения основные операции со стандартным вводом и стандартным выводом. Примеры включают printf, который позволяет отправлять текст на стандартный вывод, и scanf, который позволяет программе читать со стандартного ввода.
Стандартным вводом по умолчанию является любой текст, вводимый с клавиатуры. Это аналог стандартного вывода и стандартной ошибки, которые по умолчанию являются монитором дисплея.
Стандартный ввод можно перенаправить с помощью аргументов и операторов перенаправления, чтобы он стал источником, отличным от клавиатуры (так же, как стандартный вывод и стандартная ошибка могут быть перенаправлены так, чтобы они направлялись в место назначения, отличное от монитора дисплея). Аргумент, также называемый аргументом командной строки, представляет собой имя файла или другие данные, которые предоставляются в качестве входных данных для команды.
Простым примером является команда wc, поведение которой по умолчанию заключается в подсчете количества строк, слов и символов в тексте.Ввод этой команды в командной строке и нажатие клавиши ENTER для начала новой строки позволяет любому тексту, введенному впоследствии с клавиатуры, стать стандартным вводом для wc. Когда затем команда выполняется (одновременным нажатием клавиш CONTROL и d на новой пустой строке), wc подсчитывает количество строк, слов и символов в набранном тексте и сообщает о результатах. на монитор (т. е. стандартный вывод), и программа завершается.
Если в качестве аргументов программе предоставляется один или несколько входных файлов, стандартный ввод автоматически перенаправляется на эти входные файлы, а не на клавиатуру. Таким образом, в следующем примере стандартным вводом становится file1, и wc напечатает (терминология UNIX для write) суммы строк, слов и символов. в файле1 на мониторе дисплея:
Стандартный ввод также можно перенаправить из любого текстового файла вместо клавиатуры с помощью оператора перенаправления ввода, который представлен угловой скобкой, указывающей влево ( wc
< /цитата>Результат такой же, как и в примере, где файл1 используется в качестве аргумента. Однако механизм другой. Это согласуется с принципом философии Unix (который также является основополагающим для Linux), согласно которому желательно, чтобы существовало более одного способа выполнения любой задачи.
Вместо ввода с клавиатуры или из файла программа может использовать вывод другой программы в качестве ввода. Это достигается с помощью вертикальной черты, которая представлена символом вертикальной черты. Например, команду head (которая по умолчанию считывает первые десять строк текста) можно использовать для чтения первых десяти строк файла file1 и передачи вывода в wc:
Таким образом, wc сообщит общее количество строк (которых, конечно, должно быть десять), слов и символов в первых десяти строках файла file1.
Как и в случае с другими командами, стандартным вводом для head по умолчанию является клавиатура. Таким образом, при отсутствии каких-либо аргументов (например, файл1) или перенаправлении от другой команды, head будет читать первые десять строк любого текста, набранного с клавиатуры, а затем отправлять их на стандартный вывод (т. е. повторять их на экране дисплея). ) при отсутствии какого-либо перенаправления вывода. В этом легко убедиться, введя следующую команду, а затем набрав более десяти строк текста, каждая из которых завершается нажатием клавиши ENTER (чтобы уведомить систему о начале новой строки):
Каждая строка стандартного ввода (т. е. введенная с клавиатуры) будет отображаться (т. е. повторяться на экране) до тех пор, пока не будет введено десять строк.
Создана 25 апреля 2005 г. Обновлена 19 декабря 2006 г.
Авторские права © 2005 - 2006 The Linux Information Project. Все права защищены.
Дэйв Маккей
Дэйв Маккей
Писатель
stdin , stdout и stderr – это три потока данных, которые создаются при запуске команды Linux. Вы можете использовать их, чтобы узнать, передаются ли ваши сценарии по конвейеру или перенаправляются. Мы покажем вам, как это сделать.
Потоки соединяются в двух точках
Как только вы начнете знакомиться с Linux и Unix-подобными операционными системами, вы столкнетесь с терминами stdin , stdout и stederr . Это три стандартных потока, которые устанавливаются при выполнении команды Linux. В вычислениях поток — это то, что может передавать данные. В случае этих потоков эти данные являются текстовыми.
Потоки данных, как и потоки воды, имеют два конца. У них есть исток и отток. Какую бы команду Linux вы ни использовали, она обеспечивает один конец каждого потока. Другой конец определяется оболочкой, запустившей команду. Этот конец будет подключен к окну терминала, подключен к каналу или перенаправлен к файлу или другой команде в соответствии с командной строкой, которая запустила команду.
Стандартные потоки Linux
В Linux стандартным входным потоком является стандартный ввод. Это принимает текст в качестве входных данных. Текстовый вывод из команды в оболочку доставляется через поток stdout (стандартный вывод). Сообщения об ошибках от команды отправляются через поток stderr (стандартная ошибка).
Итак, вы можете видеть, что есть два потока вывода, stdout и stderr , и один поток ввода, stdin . Поскольку сообщения об ошибках и обычный вывод имеют собственный канал для переноса в окно терминала, их можно обрабатывать независимо друг от друга.
Потоки обрабатываются как файлы
Потоки в Linux, как и почти все остальное, рассматриваются как файлы. Вы можете читать текст из файла и записывать текст в файл. Оба этих действия включают поток данных.Таким образом, концепция обработки потока данных в виде файла не так уж и натянута.
Каждому файлу, связанному с процессом, присваивается уникальный номер для его идентификации. Это известно как файловый дескриптор. Всякий раз, когда требуется выполнить действие над файлом, файловый дескриптор используется для идентификации файла.
Эти значения всегда используются для stdin , stdout и stderr :
Реакция на конвейеры и перенаправления
Чтобы упростить знакомство с предметом, обычно используется упрощенная версия темы. Например, в случае с грамматикой нам говорят, что действует правило «I перед E, кроме как после C». Но на самом деле исключений из этого правила больше, чем случаев, которые ему подчиняются.
Подобным образом, говоря о stdin , stdout и stderr , удобно изложить общепринятую аксиому, согласно которой процесс не знает и не заботится о том, где заканчиваются его три стандартных потока. Должен ли процесс заботиться о том, идет ли его вывод на терминал или перенаправляется в файл? Может ли он вообще определить, поступает ли его ввод с клавиатуры или передается из другого процесса?
На самом деле процесс знает — или, по крайней мере, может узнать, если решит проверить, — и может соответствующим образом изменить свое поведение, если автор программного обеспечения решит добавить эту функциональность.
Мы можем легко увидеть это изменение в поведении. Попробуйте эти две команды:
Команда ls ведет себя иначе, если ее выходные данные ( stdout ) передаются другой команде. Это ls переключается на вывод в один столбец, а не преобразование, выполняемое cat. И ls делает то же самое, если его вывод перенаправляется:
Перенаправление stdout и stderr
Есть преимущество в том, что сообщения об ошибках доставляются выделенным потоком. Это означает, что мы можем перенаправить вывод команды (stdout) в файл и по-прежнему видеть любые сообщения об ошибках (stderr) в окне терминала. При необходимости вы можете реагировать на ошибки по мере их возникновения. Это также не позволяет сообщениям об ошибках загрязнять файл, в который был перенаправлен stdout.
Введите следующий текст в редактор и сохраните его в файл с именем error.sh.
Сделайте скрипт исполняемым с помощью этой команды:
Первая строка скрипта выводит текст в окно терминала через поток stdout. Вторая строка пытается получить доступ к несуществующему файлу. Это создаст сообщение об ошибке, которое будет доставлено через stderr .
Запустите скрипт с помощью этой команды:
Мы видим, что оба потока вывода, stdout и stderr, отображаются в окнах терминала.
Попробуем перенаправить вывод в файл:
Сообщение об ошибке, доставляемое через stderr, по-прежнему отправляется в окно терминала. Мы можем проверить содержимое файла, чтобы увидеть, перешел ли вывод stdout в файл.
Вывод стандартного ввода был перенаправлен в файл, как и ожидалось.
Символ перенаправления > по умолчанию работает со стандартным выводом. Вы можете использовать один из числовых файловых дескрипторов, чтобы указать, какой стандартный поток вывода вы хотите перенаправить.
Чтобы явно перенаправить stdout , используйте эту инструкцию перенаправления:
Чтобы явно перенаправить stderr , используйте эту инструкцию перенаправления:
Давайте повторим наш тест, и на этот раз мы будем использовать 2> :
Сообщение об ошибке перенаправляется, и эхо-сообщение stdout отправляется в окно терминала:
Давайте посмотрим, что находится в файле capture.txt.
Сообщение stderr находится в файле capture.txt, как и ожидалось.
Перенаправление как stdout, так и stderr
Конечно, если мы можем перенаправить либо stdout, либо stderr в файл независимо друг от друга, мы должны иметь возможность перенаправить их оба одновременно, в два разных файла?
Да, можем. Эта команда направит stdout к файлу с именем Capture.txt, а stderr — к файлу с именем error.txt.
Поскольку оба потока вывода — стандартный вывод и стандартная ошибка — перенаправляются в файлы, вывод в окне терминала не отображается. Мы возвращаемся к приглашению командной строки, как будто ничего не произошло.
Давайте проверим содержимое каждого файла:
Перенаправление stdout и stderr в один и тот же файл
Отлично, каждый из стандартных выходных потоков направляется в отдельный файл. Единственной другой комбинацией, которую мы можем сделать, является отправка stdout и stderr в один и тот же файл.
Этого можно добиться с помощью следующей команды:
Давайте разберемся.
- ./error.sh: запускает файл сценария error.sh.
- >capture.txt: поток stdout перенаправляется в файл capture.txt. > является сокращением от 1> .
- 2>&1: используется инструкция перенаправления &>. Эта инструкция позволяет указать оболочке, что один поток должен попасть в тот же пункт назначения, что и другой поток. В этом случае мы говорим «перенаправить поток 2, stderr, в тот же пункт назначения, куда перенаправляется поток 1, stdout».
Нет видимых результатов. Это обнадеживает.
Давайте проверим файл Capture.txt и посмотрим, что в нем содержится.
Потоки stdout и stderr были перенаправлены в один целевой файл.
Чтобы выходные данные потока были перенаправлены и молча удалены, направьте вывод в /dev/null .
Обнаружение перенаправления внутри скрипта
Мы обсудили, как команда может определить, перенаправляется ли какой-либо из потоков, и может соответствующим образом изменить свое поведение. Можем ли мы сделать это в наших собственных сценариях? Да мы можем. И это очень простой метод для понимания и применения.
Введите следующий текст в редактор и сохраните его как input.sh.
Используйте следующую команду, чтобы сделать его исполняемым:
Умная часть — это проверка в квадратных скобках. Параметр -t (терминал) возвращает значение true (0), если файл, связанный с файловым дескриптором, завершается в окне терминала. Мы использовали файловый дескриптор 0 в качестве аргумента теста, который представляет стандартный ввод.
Если стандартный ввод подключен к окну терминала, тест будет верным. Если стандартный ввод подключен к файлу или каналу, тест завершится ошибкой.
Мы можем использовать любой удобный текстовый файл для создания входных данных для скрипта. Здесь мы используем файл с именем dummy.txt.
Выходные данные показывают, что скрипт распознает ввод данных не с клавиатуры, а из файла. При желании вы можете соответствующим образом изменить поведение своего скрипта.
Это было с перенаправлением файлов, давайте попробуем с каналом.
Сценарий распознает, что его входные данные передаются в него. Или, точнее, он еще раз распознает, что поток стандартного ввода не подключен к окну терминала.
Давайте запустим скрипт без каналов и перенаправлений.
Стандартный поток подключается к окну терминала, и скрипт сообщает об этом соответствующим образом.
Чтобы проверить то же самое с выходным потоком, нам нужен новый скрипт. Введите следующее в редактор и сохраните его как output.sh.
Используйте следующую команду, чтобы сделать его исполняемым:
Единственное существенное изменение в этом скрипте — тест в квадратных скобках. Мы используем цифру 1 для представления файлового дескриптора для stdout .
Давайте попробуем. Мы будем передавать вывод через cat .
Сценарий распознает, что его выходные данные не направляются непосредственно в окно терминала.
Мы также можем протестировать скрипт, перенаправив вывод в файл.
Выхода в окно терминала нет, нас молча возвращают в командную строку. Как и следовало ожидать.
Мы можем заглянуть в файл capture.txt, чтобы увидеть, что было захвачено. Для этого используйте следующую команду.
Опять же, простой тест в нашем скрипте обнаруживает, что поток stdout не отправляется напрямую в окно терминала.
Если мы запустим скрипт без каких-либо каналов или перенаправлений, он должен обнаружить, что стандартный вывод доставляется непосредственно в окно терминала.
И это именно то, что мы видим.
Потоки сознания
Знание того, как определить, подключены ли ваши скрипты к окну терминала, конвейеру или перенаправляются, позволит вам соответствующим образом настроить их поведение.
Вывод журнала и диагностики может быть более или менее подробным, в зависимости от того, идет ли он на экран или в файл. Сообщения об ошибках могут записываться в файл, отличный от обычного вывода программы.
Как это обычно бывает, чем больше знаний, тем больше возможностей.
| Команды Linux | |
| Файлы | tar · pv · cat · tac · chmod · grep · diff · sed · ar · man · pushd · popd · fsck · testdisk · seq · fd · pandoc · cd · $PATH · awk · join · jq · fold · uniq · journalctl · tail · stat · ls · fstab · echo · less · chgrp · chown · rev · look · strings · type · rename · zip · unzip · mount · umount · install · fdisk · mkfs · rm · rmdir · rsync · df · gpg · vi · nano · mkdir · du · ln · patch · convert · rclone · shred · srm |
| Процессы | alias · screen · top · nice · renice · прогресс · strace · systemd · tmux · chsh · история · at · пакетное · бесплатное · которое · dmesg · chfn · usermod · ps · chroot · xargs · tty · pinky · lsof · vmstat · timeout · стена · yes · kill · спать · sudo · su · время · groupadd · usermod · группы · lshw · выключение · перезагрузка · halt · poweroff · passwd · lscpu · crontab · date · bg · fg |
| Сеть | netstat · ping · traceroute · ip · ss · whois · fail2ban · bmon · копать · finger · nmap · ftp · curl · wget · who · whoami · w · iptables · ssh-keygen · ufw |
- › Как создать справочную страницу в Linux
- › Как использовать команду Echo в Linux
- › 15 специальных символов, которые нужно знать для Bash
- › Как использовать at и пакет в Linux для планирования команд
- › Как обрабатывать файл построчно в скрипте Linux Bash
- › Командные строки: почему люди до сих пор беспокоятся о них?
- › Что означает XD и как вы его используете?
- ›5 шрифтов, которые следует прекратить использовать (и лучшие альтернативы)
Всякий раз, когда выполняется какая-либо команда в терминале, stdin, stderr и stdout представляют собой три потока данных, которые создает bash. Если вы знакомы с командной строкой, возможно, вы уже воспользовались этими функциями. По сути, они позволяют передавать/перенаправлять данные от одной команды к другой.
Давайте посмотрим, как работают stdin, stderr и stdout и как их можно использовать.
стандартный ввод, стандартный вывод и стандартный вывод
В вычислительной технике термин "поток" относится к чему-то, что может передавать данные. Здесь все три потока несут текст в качестве данных.
Как и потоки воды, потоки данных также имеют две конечные точки. Есть исток и отток. Любая команда, которую вы запускаете в терминале, будет в любой точке потока. С помощью потока можно соединить два окна терминала, две разные команды и даже файлы!
Давайте кратко рассмотрим специальные потоки.
- stdin: стандартный ввод. В качестве входных данных используется текст.
- stdout: означает стандартный вывод. Текстовый вывод команды сохраняется в потоке stdout.
- stderr: стандартная ошибка. Всякий раз, когда команда сталкивается с ошибкой, сообщение об ошибке сохраняется в этом потоке.
В Linux почти все потоки рассматриваются как файлы. Точно так же, как вы можете читать/записывать файл, вы можете читать/записывать данные из этих потоков.
Легкий способ получить доступ к любому файлу — использовать связанный с ним уникальный номер файлового дескриптора. В случае с этими потоками каждому из них присваиваются уникальные значения.
stdin, stdout и stderr в действии
Давайте начнем с изучения этих потоков через действия, начнем со стандартного ввода.
Выполните следующую команду.
Команда потребует ввода с клавиатуры. Здесь инструмент чтения получает ввод со стандартного ввода. Теперь давайте посмотрим на стандартный вывод.
Сначала запустите команду.
Здесь команда ls выводит список файлов в текущем каталоге. Список отправляется на stdout, и терминал распечатывает его. Теперь давайте проверим stderr.
Ошибка может возникнуть по-разному. В этом примере отправка ls недопустимого аргумента приведет к ошибке.
Здесь нет файла с каким-либо именем. Вот почему возвращаемое ls сообщение отправляется в stderr.
Трубопровод
Это распространенный метод, в котором в полной мере используются потоки stdin и stdout. Поясним это на примере.
Здесь | знак отвечает за трубопровод. Выходные данные, создаваемые echo, записываются в поток stdout. Затем конвейер перенаправляет содержимое стандартного вывода на стандартный ввод для команды grep. Вот как grep узнает, над каким содержимым выполнять операцию.
Если вы хотите передать следующей команде и stderr, и stdout, используйте вместо этого «|&».
Перенаправление потоков
Теперь, когда мы знаем, как работают эти потоки, давайте посмотрим, как их можно перенаправить. Конвейер — это форма перенаправления. Однако это касается только stdin и stdout. Bash позволяет управлять всеми тремя потоками.
Чтобы перенаправить содержимое stdout в файл, добавьте угол «>», за которым следует имя целевого файла.
Здесь вывод команды echo будет сохранен в файле hello.txt.
Если файл уже существует, то приведенная выше команда перезапишет его. Чтобы этого избежать, убедитесь, что имя файла уникально. Если вы не хотите перезаписывать, вы можете вместо этого использовать «>>». Он добавляет вывод в конец целевого файла.
Целью стандартного ввода является работа с входными данными. Это также может быть перенаправлено. Например, вместо ввода с клавиатуры его можно загрузить из файла.
В этой команде cat будет получать данные непосредственно из файла hello.txt.
Давайте рассмотрим перенаправление на другом примере. На этот раз будет задействован скрипт Python.
Входные данные для скрипта находятся в файле hello.txt.
Давайте отправим файл в качестве входных данных для скрипта.
Интересно, что вы можете перенаправлять как stdin, так и stdout в одной и той же командной строке. Здесь следующая команда будет использовать hello.txt как stdin и отправить stdout команды в файл.
Перенаправление stderr похоже на stdout. Однако вам нужно указать идентификатор описания 2 для указания stderr. В противном случае будет использоваться стандартный вывод.
Здесь я буду перенаправлять содержимое stderr в текстовый файл.
Перенаправление Stdout и Stderr
Да, можно перенаправить их обоих одновременно. Все, что вам нужно, это указать идентификатор описания 1 и 2 перед перенаправлением.
Заключительные мысли
stdin, stdout и stderr — замечательные функции, предлагаемые bash по умолчанию. Если вы увлекаетесь сценариями bash, их использование может оказаться невероятно полезным в сложных ситуациях.
Хотите узнать больше о сценариях bash? Давайте начнем с этого руководства для начинающих по написанию сценариев bash!
Об авторе
Сидратул Мунтаха
Студент CSE. Я люблю Linux и играю с технологиями и гаджетами. Я использую как Ubuntu, так и Linux Mint.
Linux позволяет запускать инструкции из командной строки, используя переключатели для создания выходных данных.
Конечно, вопрос в том, как мы можем это использовать?
Один из способов использовать это — использовать три специальных файловых дескриптора — stdin, stdout и stderr.
В нормальных условиях каждая программа Linux при запуске открывает три потока; один для ввода; один на выход; и один для печати диагностических сообщений или сообщений об ошибках. Обычно они присоединяются к пользовательскому терминалу (см. man tty(4)), но вместо этого могут ссылаться на файлы или другие устройства, в зависимости от того, что родительский процесс выбрал для настройки.
Таблица 1.2. Стандартный ввод, стандартный вывод и стандартная ошибка
| Тип | Символ |
| стандартный ввод | 0 |
| стандартная ошибка | 2> |
стандартный ввод
Обычно стандартный ввод, называемый "stdin", осуществляется с клавиатуры.
Когда вы что-то вводите, вы вводите это на стандартный ввод (стандартный терминал ввода). Стандартное устройство ввода, которым обычно является клавиатура, но Linux также позволяет вам вводить стандартный ввод из файла.
Это укажет кошке вводить данные из файла myfirstscript, а не с клавиатуры (конечно, это то же самое, что и: cat myfirstscript ).
По сути, это сводится к тому, что ввод для этой команды (cat) больше не поступает оттуда, откуда он ожидался (с клавиатуры), а теперь поступает из файла.
Linux связывает файловый дескриптор 0 со стандартным вводом. Итак, мы могли бы сказать:
которая произвела бы то же самое, что и предыдущая команда.
Почему мы могли опустить 0?
Поскольку во время создания процесса с ним связан один стандартный ввод.
стандартный вывод
Стандартный вывод, созданный во время создания процесса, отправляется на консоль, ваш терминал или X-терминал. Точное место отправки выходных данных явно зависит от того, откуда был запущен процесс.
Наша консоль или терминал должны быть устройством, которое принимает выходные данные. Выполнение команды:
по умолчанию [кон]катенирует файл к нашему стандартному выводу, т. е. к нашей консоли или экрану терминала. (Где начался процесс.)
Мы можем изменить это и перенаправить вывод в файл.
Попробуйте следующее:
Это перенаправляет вывод не на экран, а в новый файл «длинный список». Процесс перенаправления с помощью '>' создаст файл 'longlisting', если его там не было. В качестве альтернативы, если файл «длинный список» существовал, он удалит его (конечно, удалив и содержимое) и поместит туда новый файл со списком каталогов «myfirstscript» внутри него.
Как мы увидим содержимое файла?
Это покажет размер, владельца, группу и имя файла myfirstscript внутри файла 'longlisting'.
В этом примере выходные данные команды ls передаются не на стандартный вывод (по умолчанию на экран), а в файл с названием «длинный список».
Linux имеет файловый дескриптор для стандартного вывода, равный 1 (аналогично 0 для стандартного входного файлового дескриптора).
Приведенный выше пример ls -la можно переписать так:
что сделало бы то же самое, что и без идентификатора файлового дескриптора и просто с использованием знака "больше".
Точно так же мы используем наш стандартный ввод как (или 1> ) для обозначения стандартного вывода.
Возвращаясь к приведенному выше примеру с котом, мы могли бы ввести данные в командной строке, которые будут отправлены непосредственно в файл. Если файла нет, он создаст его и вставит содержимое, которое мы набрали в командной строке, в файл. Это показано ниже:
Это не возвращает нас к подсказке. Почему? Чего он ждет?
Он ждет, пока мы действительно введем нашу строку в буфер. Вы должны начать вводить предложение, затем другое предложение, еще одно и т. д. Каждый раз, когда вы вводите символ, он добавляется в файл 'newfile'.
Когда вы закончите вводить то, что хотите, нажмите Ctrl-d. Символ Ctrl-d (^D) отправит кошке сигнал конца файла, тем самым вернув вас к подсказке.
Если вы перечисляете содержимое своего каталога, используя:
вы должны увидеть файл 'newfile'. Это файл, который вы только что создали в командной строке.
покажет вам содержимое 'newfile', отображаемое в стандартном выводе.
Почему все это сработало? Это сработало, потому что cat брал ввод со стандартного ввода и выводил свой вывод не в стандартный вывод, как обычно, а скорее перенаправлял вывод в файл 'newfile'.
При вводе команды и нажатии Enter вы не возвращаетесь к приглашению, так как консоль ожидает ввода со стандартного ввода; вы вводите строку за строкой стандартного ввода, а затем ^D. ^D остановил ввод, отправив в файл символ конца файла, поэтому создается файл «новый файл».
Вопрос: как вы думаете, что сделает tac > newFile?
Одновременное использование stdin и stdout
Если вы решите скопировать содержимое двух файлов в другой файл (вместо использования команды cp — в Linux есть несколько способов снять шкуру с кота), вы можете сделать следующее:
Кстати, это эквивалентно
Добавление к файлу
Ну, это прекрасно, но что произойдет, если мы не хотим удалять наш длинный список скриптов, а хотим добавить его в уже существующий файл.
Изначально мы набрали:
Если вы сделаете это во второй раз, первый длинный список файлов будет перезаписан. Как вы могли добавить к нему? Простое добавление двух знаков «больше», следующих друг за другом, как в приведенном ниже примере, добавит вывод в файл «longlisting»
Каждый раз, когда вы запускали эту команду, она не затирала (удаляла содержимое) файла длинного списка, а добавляла его к нему, в результате чего файл "длинного списка" увеличивался в размере.
И последнее замечание о стандартном выводе и стандартном вводе: перенаправление должно быть последней командой, которую вы выполняете в командной строке. Другими словами, вы не можете выполнить никакую другую команду после перенаправления. Мы поговорим об этом позже в разделе о каналах.
стдерр
Последний компонент в этом диалоговом окне файловых дескрипторов — стандартная ошибка.
Каждая команда может отправить свой вывод в одно из двух мест: а) это может быть действительный вывод или б) это может быть сообщение об ошибке.
Он делает то же самое с ошибками, что и со стандартным выводом; он отправляет их прямо на экран вашего терминала.
Если вы запускаете команду (как ваш пользователь):
вы обнаружите, что find найдет множество вещей, но также сообщит о множестве ошибок в виде «Отказано в доступе». . .'.
Возможно, нас не интересует сообщение «Отказано в доступе». ' - мы можем отказаться от этих сообщений (как root, сообщения об ошибках не возвращаются).
Если бы мы запустили команду, мы могли бы поместить стандартную ошибку в файл (помните, что стандартная ошибка по умолчанию отправляется на консоль; там же, где и стандартный вывод). В этом случае я собираюсь поместить его в специальный файл в системе Linux с именем /dev/null.
/dev/null похож на «Корзину» в Windows, за исключением того, что это корзина для бумаг с точкой невозврата — черная дыра Linux! Как только информация попадает в /dev/null, она исчезает навсегда.
Сначала я буду помещать все ошибки, сгенерированные командой find, в /dev/null, поскольку они меня не интересуют.
Мы видели, что стандартным вводом был файловый дескриптор 0, стандартным выводом был файловый дескриптор 1, так что никаких призов за предположение, что стандартная ошибка имеет файловый дескриптор 2.
Таким образом, команда
отбрасывает любые ошибки, созданные командой find. Они не собираются засорять нашу консоль всякой ерундой, которая нам неинтересна.
Обратите внимание, что между 2 и >
нет пробела.Это можно сделать с помощью любой команды, например:
Что бы перенаправить все сообщения об ошибках в файл с именем "myerror".
Подводя итог, мы можем использовать:
Не обязательно опускать цифру два (2). Если его оставить выключенным, стандартный вывод будет означать "myerror", включая 2 означает стандартную ошибку.
В случае листинга:
помещает все ошибки в файл с именем myerror.
Если бы мы хотели сохранить все эти сообщения об ошибках вместо использования одного знака больше, мы использовали бы два знака больше.
Использование одного знака "больше" приведет к затиранию файла "myerror", если он существует, что ничем не отличается от стандартного вывода. Используя знак двойного большего, он будет добавлен к содержимому файла с именем myerror.
Таким образом, содержимое 'myerror' не будет потеряно.
stdout, stderr и использование амперсанда (&)
С нашими новыми знаниями давайте попробуем сделать пару вещей с помощью команды find. Используя команду find, я хочу полностью игнорировать все сообщения об ошибках и сохранить все допустимые выходные данные в файле. Это можно сделать с помощью:
Это отбрасывает любые ошибки и сохраняет правильный вывод в файле "MyValidOutput". Порядок знаков перенаправления не важен. Независимо от того, будет ли сначала записан стандартный вывод или стандартная ошибка, команда выдаст правильные результаты.
Таким образом, мы могли бы переписать эту команду так:
Наконец-то я мог добавить вывод к существующим файлам с помощью:
Очевидно, что добавление к /dev/null не имеет смысла, но это служит иллюстрацией того, что выходные данные и ошибки могут быть добавлены к файлу.
Что произойдет, если мы захотим взять наш стандартный вывод и поместить его в тот же файл, что и стандартная ошибка? Что мы можем сделать, так это:
Это означает, что стандартная ошибка передается в файл с именем samefile, а стандартный вывод направляется в то же место, что и файловый дескриптор 2, то есть в файл с именем samefile.
Аналогично мы могли бы объединить вывод, выполнив:
Это захватывает вывод как стандартного вывода, так и стандартной ошибки в один и тот же файл.
Очевидно, что мы могли бы добавить к конкретному файлу вместо того, чтобы перезаписывать его.
Упражнения:
Используя простые сценарии из предыдущих упражнений, убедитесь, что все выходные данные команд df, du, vmstat, iostat записываются в файл для последующего использования.
Напишите сценарий для запуска команды vmstat каждые 10 секунд и записи вывода в файл /tmp/vmoutput. Убедитесь, что существующий файл никогда не затирается.
Добавить дату к началу выходного файла, созданного скриптом, указанным выше в вопросе 2. (поместите дату в начало или вверху файла)
Безымянные каналы
До сих пор мы видели, что можем запустить любую команду и перенаправить ее вывод в определенный файл, используя наши символы перенаправления (>, >, 2> или 2>>).
Было бы хорошо, если бы мы могли перенаправить вывод одной команды на ввод другой. Потенциально мы можем захотеть, чтобы вывод следующей команды стал вводом еще одной команды и так далее. Мы могли бы повторять этот процесс снова и снова, пока не достигнем желаемого результата.
В Linux на это влияет вертикальная черта (вертикальная черта '|'). Пример:
Это передаст вывод команды ls -al на ввод команды less.
Эффект будет заключаться в том, чтобы пролистывать ваш вывод по одной странице за раз, а не прокручивать его до стандартного вывода за один раз — слишком быстро, чтобы вы могли его прочитать, если, конечно, вы не Стив Остин!.< /p>
Что делает команду pipe мощной в Linux, так это то, что вы можете использовать ее снова и снова.
Вместо стандартного ввода grep из файла (или клавиатуры) теперь он поступает из команды ls. Команда grep ищет шаблон (не строку), соответствующий myfirstfile. Вывод команды grep становится вводом команды less. Less может вводить данные с клавиатуры или из файла, но в данном случае ввод осуществляется с помощью команды grep .
Сколько таких каналов может быть на одной линии? Сколько хотим! Мы увидим это и то, как это эффективно используется в сценариях оболочки, начиная со следующей главы.
Если бы каналы были недоступны, нам, возможно, пришлось бы заархивировать приведенную выше команду в два или более шагов. Однако с трубами эта задача упрощается (ускоряется).
Если мы сделаем шаг назад, чтобы запустить команду who:
Здесь не означает перенаправление!
Мы увидим только тех людей, которые вошли в систему как ваш пользователь (надеюсь, это только вы!!). Возможно, вы хотите видеть только людей, которые вошли в псевдо-терминалы, тогда:
что сообщит нам только имена пользователей, вошедших в псевдотерминалы.
В этих примерах мы используем выходные данные команды who в качестве входных данных для команды grep.
Кроме того, мы можем перенаправить вывод этой команды в файл с именем outfile:
Это создаст файл 'outfile', содержащий только тех пользователей, которые вошли в псевдо-терминалы. Это здорово.
Мы увидим, что это даст хороший эффект, когда мы начнем писать сценарии, создавая очень сложные фильтры, в которых мы используем выходные данные одной команды как входные данные для следующей, а выходные данные — как входные данные для следующей.< /p>
Читайте также: