Вывод в файл: Перенаправление ввода/вывода в Linux

Содержание

Перенаправление ввода/вывода в Linux — Блог компании Селектел

Введение

Стандартные потоки ввода и вывода в Linux являются одним из наиболее распространенных средств для обмена информацией процессов, а перенаправление >, >> и | является одной из самых популярных конструкций командного интерпретатора.

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

Требования

Linux-система, например, Ubuntu 20.04

Потоки

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

Стандартный вывод и стандартная ошибка отображаются на дисплее терминала пользователя в виде текста.

Ввод и вывод распределяется между тремя стандартными потоками:

stdin — стандартный ввод (клавиатура),
stdout — стандартный вывод (экран),
stderr — стандартная ошибка (вывод ошибок на экран).

Потоки также пронумерованы:

stdin — 0,
stdout — 1,
stderr — 2.

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

< file — использовать файл как источник данных для стандартного потока ввода.
> file — направить стандартный поток вывода в файл. Если файл не существует, он будет создан, если существует — перезаписан сверху.
2> file — направить стандартный поток ошибок в файл. Если файл не существует, он будет создан, если существует — перезаписан сверху.
>>file — направить стандартный поток вывода в файл. Если файл не существует, он будет создан, если существует — данные будут дописаны к нему в конец.
2>>file — направить стандартный поток ошибок в файл. Если файл не существует, он будет создан, если существует — данные будут дописаны к нему в конец.
&>file или >&file — направить стандартный поток вывода и стандартный поток ошибок в файл. Другая форма записи: >file 2>&1.

Стандартный ввод

Стандартный входной поток обычно переносит данные от пользователя к программе. Программы, которые предполагают стандартный ввод, обычно получают входные данные от устройства типа клавиатура. Стандартный ввод прекращается по достижении EOF (конец файла), который указывает на то, что данных для чтения больше нет.

EOF вводится нажатием сочетания клавиш Ctrl+D.

Рассмотрим работу со стандартным выводом на примере команды cat (от CONCATENATE, в переводе «связать» или «объединить что-то»).

Cat обычно используется для объединения содержимого двух файлов.

Cat отправляет полученные входные данные на дисплей терминала в качестве стандартного вывода и останавливается после того как получает EOF.

Пример

cat

В открывшейся строке введите, например, 1 и нажмите клавишу Enter. На дисплей выводится 1. Введите a и нажмите клавишу Enter. На дисплей выводится a.

Дисплей терминала выглядит следующим образом:

test@111:~/stream$ cat
1
1
a
a

Для завершения ввода данных следует нажать сочетание клавиш Ctrl + D.

Стандартный вывод

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

При использовании без каких-либо дополнительных опций, команда echo выводит на экран любой аргумент, который передается ему в командной строке:

echo Пример

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

Пример

При выполнении echo без каких-либо аргументов, возвращается пустая строка.

Пример

Команда объединяет три файла: file1, file2 и file3 в один файл bigfile:

cat file1 file1 file1 > bigfile

Команда cat по очереди выводит содержимое файлов, перечисленных в качестве параметров на стандартный поток вывода. Стандартный поток вывода перенаправлен в файл bigfile.

Стандартная ошибка

Стандартная ошибка записывает ошибки, возникающие в ходе исполнения программы. Как и в случае стандартного вывода, по умолчанию этот поток выводится на терминал дисплея.

Пример

Рассмотрим пример стандартной ошибки с помощью команды ls, которая выводит список содержимого каталогов.

При запуске без аргументов ls выводит содержимое в пределах текущего каталога.

Введем команду ls с каталогом % в качестве аргумента:

ls %

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

ls: cannot access %: No such file or directory

Перенаправление потока

Linux включает в себя команды перенаправления для каждого потока.

Команды со знаками > или < означают перезапись существующего содержимого файла:

> — стандартный вывод,
< — стандартный ввод,
2> — стандартная ошибка.

Команды со знаками >> или << не перезаписывают существующее содержимое файла, а присоединяют данные к нему:

>> — стандартный вывод,
<< — стандартный ввод,
2>> — стандартная ошибка.

Пример

В приведенном примере команда cat используется для записи в файл file1, который создается в результате цикла:

cat > file1
a
b
c

Для завершения цикла нажмите сочетание клавиш Ctrl + D.

Если файла file1 не существует, то в текущем каталоге создается новый файл с таким именем.

Для просмотра содержимого файла file1 введите команду:

cat file1

В результате на дисплей терминала должно быть выведено следующее:

a
b
c

Для перезаписи содержимого файла введите следующее:

cat > file1
1
2
3

Для завершения цикла нажмите сочетание клавиш Ctrl + D.

В результате на дисплей терминала должно быть выведено следующее:

1
2
3

Предыдущего текста в текущем файле больше не существует, так как содержимое файла было переписано командой >.

Для добавления нового текста к уже существующему в файле с помощью двойных скобок >> выполните команду:

cat >> file1
a
b
c

Для завершения цикла нажмите сочетание клавиш Ctrl + D.

Откройте file1 снова и в результате на дисплее монитора должно быть отражено следующее:

1
2
3
a
b
c

Каналы

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

Пример

Введите команду:

ls | less

В результате каждый файл текущего каталога будет размещен на новой строке:

file1
file2
t1
t2

Перенаправлять данные с помощью каналов можно как из одной команды в другую, так и из одного файла к другому, а перенаправление с помощью

> и >> возможно только для перенаправления данных в файлах.

Пример

Для сохранения имен файлов, содержащих строку «LOG», используется следующая команда:

dir /catalog | find "LOG" > loglist

Вывод команды dir отсылается в команду-фильтр find. Имена файлов, содержащие строку «LOG», хранятся в файле loglist в виде списка (например, Config.log, Logdat.svd и Mylog.bat).

При использовании нескольких фильтров в одной команде рекомендуется разделять их с помощью знака канала |.

Фильтры

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

find — возвращает файлы с именами, которые соответствуют передаваемому аргументу.
grep — возвращает только строки, содержащие (или не содержащие) заданное регулярное выражение.
tee — перенаправляет стандартный ввод как стандартный вывод и один или несколько файлов.
tr — находит и заменяет одну строку другой.
wc — подсчитывает символы, линии и слова.

Как правило, все нижеприведенные команды работают как фильтры, если у них нет аргументов (опции могут быть):

cat — считывает данные со стандартного потока ввода и передает их на стандартный поток вывода. Без опций работает как простой повторитель. С опциями может фильтровать пустые строки, нумеровать строки и делать другую подобную работу.
head — показывает первые 10 строк (или другое заданное количество), считанных со стандартного потока ввода.
tail — показывает последние 10 строк (или другое заданное количество), считанные со стандартного потока ввода. Важный частный случай tail -f, который в режиме слежения показывает концовку файла. Это используется, в частности, для просмотра файлов журнальных сообщений.
cut — вырезает столбец (по символам или полям) из потока ввода и передает на поток вывода. В качестве разделителей полей могут использоваться любые символы.
sort — сортирует данные в соответствии с какими-либо критериями, например, арифметически по второму столбцу.
uniq — удаляет повторяющиеся строки. Или (с ключом -с) не просто удалить, а написать сколько таких строк было. Учитываются только подряд идущие одинаковые строки, поэтому часто данные сортируются перед тем как отправить их на вход программе.
bc — вычисляет каждую отдельную строку потока и записывает вместо нее результат вычисления.
hexdump — показывает шестнадцатеричное представление данных, поступающих на стандартный поток ввода.
strings — выделяет и показывает в стандартном потоке (или файле) то, что напоминает строки. Всё что не похоже на строковые последовательности, игнорируется. Команда полезна в сочетании с grep для поиска интересующих строковых последовательностей в бинарных файлах.
sed — обрабатывает текст в соответствии с заданным скриптом. Наиболее часто используется для замены текста в потоке: sed s/было/стало/g.
awk — обрабатывает текст в соответствии с заданным скриптом. Как правило, используется для обработки текстовых таблиц, например, вывод ps aux и т.д.
sh -s — текст, который передается на стандартный поток ввода sh -s. может интерпретироваться как последовательность команд shell. На выход передается результат их исполнения.
ssh — средство удаленного доступа ssh, может работать как фильтр, который подхватывает данные, переданные ему на стандартный поток ввода, затем передает их на удаленный хост и подает на вход процессу программы, имя которой было передано ему в качестве аргумента. Результат выполнения программы (то есть то, что она выдала на стандартный поток вывода) передается со стандартного вывода ssh.

Если в качестве аргумента передается файл, команда-фильтр считывает данные из этого файла, а не со стандартного потока ввода (есть исключения, например, команда tr, обрабатывающая данные, поступающие исключительно через стандартный поток ввода).

Пример

Команда tee, как правило, используется для просмотра выводимого содержимого при одновременном сохранении его в файл.

wc ~/stream | tee file2

Пример

Допускается перенаправление нескольких потоков в один файл:

ls -z >> file3 2>&1

В результате сообщение о неверной опции «z» в команде ls будет записано в файл t2, поскольку stderr перенаправлен в файл.

Для просмотра содержимого файла file3 введите команду cat:

cat file3

В результате на дисплее терминала отобразиться следующее:

ls: invalid option -- 'z'
Try 'ls --help' for more information.

Заключение

Мы рассмотрели возможности работы с перенаправлениями потоков >, >> и |, использование которых позволяет лучше работать с bash-скриптами.

Перенаправление ввода-вывода. Курс «Введение в Linux и Bash»

В Bash реализована возможность перенаправления потоков ввода и вывода.

Что это значит?

В стандартный поток ввода поступают данные, которые вводятся с клавиатуры. Стандартным потоком вывода является экран монитора. Другими словами, в командную строку Bash’а поступают данные, вводимые с клавиатуры. Если команда предполагает текстовый вывод, Bash выводит данные на экран.

Однако такое поведение по-умолчанию можно изменить. Данные могут поступать, например, из файла, а не с клавиатуры. Аналогично, они могут выводиться в файл, а не на экран.

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

В Bash знак больше «>» обозначает перенаправление стандартного потока вывода. В данном случае в файл. То есть cat по-умолчанию выводит данные на экран, но поскольку они были перенаправлены, то данные на экран выводиться не будут.

На экране видны только вводимые строки, выводимые оказываются в файле.

Пусть далее мы хотим добавить к заметке сегодняшнюю дату. Перенаправим вывод команды date в тот же файл.

Два знака больше «>>» – это тоже перенаправление вывода, но такое, когда данные добавляются в конец объекта (в данном случае файла), если он существует. Используй мы только один знак больше, файл был бы перезаписан.

На скрине выше командой cat note.txt файл читается. Так устроена команда cat, что если ей передается аргумент, то она не будет работать в интерактивном режиме, а возьмет данные из указанного файла и выведет их на экран. Поэтому это равносильно cat < note.txt, где знак меньше «<» обозначает перенаправление ввода.

Однако равносильно по результату – не значит равносильно по механизму реализации. При использовании знака именно командная оболочка, в данном случае Bash, занимается перенаправлением данных из файла. В то время как программа cat (или любая другая) работает в обычном режиме, «думая» что данные она получает со стандартного ввода.

Можно было бы ожидать, что если команде ls, которая выводит содержимое каталога, передать файл, содержащий адрес каталога, то она выведет объекты этого каталога. Однако это не так.

Такое перенаправление не работает. А там где «работает» можно обойтись и без него, то есть команда сама «знает», что если передается имя файла, или она употребима только с именем файла, то данные надо брать из него.

Здесь команда grep ищет первый аргумент во втором. Если находит, возвращает строку с ним. Программа wc считает количество строк, слов и символов в файле. С помощью sort строки сортируются.

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

С другой стороны, выводы в файл команд ls и других работают.

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

Канал – это способ соединения программ таким образом, чтобы вывод одной тут же передавался на вход другой. В результате создается программный конвейер, состоящий из двух и более программ. В командной оболочке для создания конвейера используется символ вертикальной черты – |.

Программные каналы позволяют избежать излишнего создания файлов с промежуточными данными. Рассмотрим пример. Команда wc считает количество строк, слов и символов в файле. С ключом -l – только количество слов. Пусть нам надо узнать общее количество файлов, содержащихся в каталоге.

В случае перенаправления ввода-вывода в файл, потребовалось бы сначала направить вывод программы ls в файл, после чего передать его программе wc. При этом был посчитан и этот файл (если он был сохранен в каталоге, который анализируется).

В случае же программного конвейера между ls и wc создается канал. В результате данные, отправляемые ls на стандартный вывод, то есть монитор, оболочка Bash «перехватывает» и отправляет в канал, из которого данные передаются оболочкой на ввод wc.

pl@comp:~$ ls | wc -l
13

Задание:

Имя команды cat – это сокращение от «catenate» (связывать, соединять). Если в качестве аргументов программе передать несколько файлов, то их содержимое будет соединено и выведено на экран.

Создайте два текстовых файла с какими-либо данными. С помощью программы cat объедините данные этих файлов в третьем файле.

Курс с ответами к заданиям и дополнительными уроками:
android-приложение, pdf-версия.

Перенаправление ввода/вывода в Linux (Ubuntu)

Введение

Одним из ключевых моментов философии UNIX было то, что все команды в командной строке (CLI) должны принимать текст в качестве ввода и выдавать текст в качестве вывода. Поскольку эта концепция была применена при разработке UNIX (и позже Linux), были разработаны команды для приема текста в качестве входных данных, выполнения какой-либо операции с текстом и последующего создания текста в качестве вывода. Команды, которые считывают текст в качестве входных данных, каким-либо образом изменяют этот текст, а затем создают текст в качестве выходных данных, иногда называют фильтрами.

Чтобы иметь возможность применять команды фильтрации и работать с текстовыми потоками, полезно понимать несколько форм перенаправления, которые можно использовать с большинством команд: конвейеры, стандартное перенаправление вывода, перенаправление вывода ошибок и перенаправление ввода.

Стандартный вывод

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

Стандартный вывод можно перенаправить из команды, чтобы он перешел к файлу, а не к терминалу. Стандартное перенаправление вывода достигается выполнением команды с символом больше > и конечным файлом. Например, команда ls ~ выведет список файлов в домашнем каталоге. Чтобы сохранить список файлов в домашнем каталоге, вы должны направить вывод в текстовый файл.

timeweb@localhost:~$ ls ~ > /tmp/home.txt

После чего содержимое файла home.txt будет иметь следующий вид:

timeweb@localhost:~$cat /tmp/home.txt
Desktop
Documents
Downloads
Music
Pictures
Public
Templates
Videos

Перенаправление вывода с использованием одного символа больше > создаст новый файл или перезапишет содержимое существующего файла с тем же именем. Перенаправление стандартного вывода с двумя символами больше >> также создаст новый файл, если он не существует. Разница в том, что при использовании символов >> вывод команды будет добавлен в конец файла, если он уже существует. Например, чтобы добавить в конец файла вывод команды date, выполните следующее:

timeweb@localhost:~$ date >> /tmp/home.txt     
timeweb@localhost:~$cat /tmp/home.
  txt
Desktop
Documents
Downloads
Music
Pictures
Public
Templates
Videos                                      	
Sun Jan  30 17:36:02 UTC 2022

Стандартная ошибка

Когда команда обнаруживает ошибку, она выдает вывод, известный как стандартная ошибка, также называемая stderr или STDERR. Как и стандартный вывод, стандартный вывод ошибок обычно отправляется на тот же терминал, где в данный момент выполняется команда. Число, связанное со стандартным дескриптором файла ошибок, равно 2.

Если вы попытаетесь выполнить команду ls /junk, то эта команда выдаст стандартные сообщения об ошибках, поскольку каталога /junk не существует.

timeweb@localhost:~$ ls /junk
ls: cannot access /junk: No such file or directory

Поскольку этот вывод переходит в стандартную ошибку, один только символ больше > не будет успешно перенаправлять его, и вывод команды все равно будет отправлен на терминал:

timeweb@localhost:~$ ls /junk > output
ls: cannot access /junk: No such file or directory

Чтобы перенаправить эти сообщения об ошибках, вы должны использовать правильный дескриптор файла, который для стандартной ошибки имеет номер 2. Выполните следующее, и ошибка будет перенаправлена в файл /tmp/ls.err:

timeweb@localhost:~$ ls /junk 2> /tmp/ls.err

Как и при стандартном выводе, использование одного символа > для перенаправления либо создаст файл, если он не существует, либо уничтожит (перезапишет) содержимое существующего файла. Чтобы предотвратить стирание существующего файла при перенаправлении стандартной ошибки, вместо этого используйте двойные символы >> после числа 2 для добавления:

timeweb@localhost:~$ ls /junk 2>> /tmp/ls.err

Некоторые команды будут выводить как stdout, так и stderr:

timeweb@localhost:~$ find /etc -name passwd
/etc/pam.d/passwd
/etc/passwd
find: '/etc/ssl/private': Permission denied

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

timeweb@localhost:~$ find /etc -name passwd > /tmp/output.txt 2> /tmp/error.txt

Команду cat можно использовать для проверки успешности перенаправления выше:

timeweb@localhost:~$ cat /tmp/output. txt
/etc/pam.d/passwd
/etc/passwd
timeweb@localhost:~$ cat /tmp/error.txt
find: '/etc/ssl/private': Permission denied

Иногда бесполезно отображать сообщения об ошибках в терминале или сохранять их в файле. Чтобы не сохранять эти сообщения об ошибках, используйте файл /dev/null.

Файл /dev/null похож на мусорное ведро, где все отправленное в него исчезает из системы; его иногда называют черной дырой. Любой тип вывода может быть перенаправлен в файл /dev/null; чаще всего пользователи перенаправляют стандартную ошибку в этот файл, а не в стандартный вывод.

Синтаксис использования файла /dev/null такой же, как и для перенаправления на обычный файл:

timeweb@localhost:~$ find /etc -name passw 2> /dev/null
/etc/pam.d/passwd
/etc/passwd

Что, если вы хотите, чтобы весь вывод (стандартная ошибка и стандартный вывод) отправлялся в один файл? Существует два метода перенаправления как стандартных ошибок, так и стандартных выходов:

timeweb@localhost:~$ ls > /tmp/ls. all 2>&1
timeweb@localhost:~$ ls &> /tmp/ls.all

Обе предыдущие командные строки создадут файл с именем /tmp/ls.all, содержащий все стандартные выходные данные и стандартные ошибки. Первая команда перенаправляет стандартный вывод на /tmp/ls.all, а выражение 2>&1 означает «отправлять stderr туда, куда направляется stdout». Во втором примере выражение &> означает «перенаправить весь вывод».

Стандартный ввод

Стандартный ввод, также называемый stdin или STDIN, обычно поступает с клавиатуры, ввод осуществляется пользователем, выполняющим команду. Хотя большинство команд могут считывать ввод из файлов, некоторые ожидают, что пользователь введет их с помощью клавиатуры.

Одним из распространенных способов использования текстовых файлов в качестве стандартного ввода для команд является создание файлов сценариев. Скрипты представляют собой простые текстовые файлы, которые интерпретируются оболочкой при наличии соответствующих разрешений и начинаются с #!/bin/sh в первой строке, что указывает оболочке интерпретировать сценарий как стандартный ввод:

timeweb@localhost:~$ cat examplescriptfile. sh
#!/bin/sh
echo HelloWorld

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

timeweb@localhost:~$ ./examplescriptfile.sh
HelloWorld

В некоторых случаях полезно перенаправить стандартный ввод, чтобы он поступал из файла, а не с клавиатуры. Хорошим примером того, когда желательно перенаправление ввода, является команда tr. Команда tr переводит символы, считывая данные со стандартного ввода; перевод одного набора символов в другой набор символов, а затем запись измененного текста в стандартный вывод.

Например, следующая команда tr будет принимать данные от пользователя (через клавиатуру), чтобы выполнить преобразование всех символов нижнего регистра в символы верхнего регистра. Выполните следующую команду, введите текст и нажмите Enter, чтобы увидеть перевод:

timeweb@localhost:~$ tr 'a-z' 'A-Z'
hello
HELLO

Команда tr не прекращает чтение из стандартного ввода, если только она не завершена. Это можно сделать, нажав комбинацию клавиш Ctrl+D.

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

timeweb@localhost:~$ cat Documents/animals.txt
1 retriever
2 badger
3 bat
4 wolf
5 eagle
timeweb@localhost:~$ tr 'a-z' 'A-Z' < Documents/animals.txt
1 RETRIEVER
2 BADGER
3 BAT
4 WOLF
5 EAGLE

Конвейеры команд

Конвейеры команд часто используются для эффективного использования команд фильтрации. В командном конвейере выходные данные одной команды отправляются другой команде в качестве входных данных. В Linux и большинстве операционных систем вертикальная черта | используется между двумя командами для представления конвейера команд.

Например, представьте, что вывод команды history очень велик. Чтобы отправить этот вывод команде less, которая отображает одну страницу данных за раз, можно использовать следующий конвейер команд:

timeweb@localhost:~$ history | less

Еще лучше пример, взять вывод команды history и отфильтровать вывод с помощью команды grep. В следующем примере текст, выводимый командой history, перенаправляется в команду grep в качестве входных данных. Команда grep сопоставляет строки ls и отправляет вывод на стандартный вывод:

timeweb@localhost:~$ history | grep "ls"
1  ls ~ > /tmp/home.txt
5  ls l> /tmp/ls.txt
6  ls 1> /tmp/ls.txt
7  date 1>> /tmp/ls.txt
    8  ls /junk
9  ls /junk > output
   10  ls /junk 2> /tmp/ls.err
   11  ls /junk 2>> /tmp/ls.err
   14  ls > /tmp/ls.all 2>&1
   15  ls &> /tmp/ls.all
   16  ls /etc/au* >> /tmp/ls. all 2>&1
   17  ls /etc/au* &>> /tmp.ls.all
   20  history | grep "ls"

Командные конвейеры становятся действительно мощными, когда объединяются в три или более команд. Например, просмотрите содержимое файла os.csv в каталоге Documents:

timeweb@localhost:~$ cat Documents/os.csv
1970,Unix,Richie
1987,Minix,Tanenbaum
1970,Unix,Thompson
1991,Linux,Torvalds

Следующая командная строка извлечет некоторые поля из файла os.csv с помощью команды cut, затем отсортирует эти строки с помощью команды sort и, наконец, удалит повторяющиеся строки с помощью команды uniq:

timeweb@localhost:~$ cut -f1 -d',' Documents/os.csv | sort -n | uniq
1970
1987
1991

Команда tee

Администратор сервера работает как сантехник, используя «трубы» и иногда команду tee. Команда tee разбивает вывод команды на два потока: один направляется на стандартный вывод, который отображается в терминале, а другой — в файл.

Команда tee может быть очень полезна для создания журнала команды или сценария. Например, чтобы записать время выполнения процесса, начните с команды date и скопируйте вывод в файл timer.txt:

timeweb@localhost:~$ date | tee timer.txt
Mon Jan  1 02:21:24 UTC 2022

Файл timer.txt теперь содержит копию даты, тот же вывод, что и в предыдущем примере:

timeweb@localhost:~$ cat timer.txt
Mon Jan  1 02:21:24 UTC 2022

Чтобы добавить время в конец файла timer.txt, используйте параметр -a:

timeweb@localhost:~$ date | tee -a timer.txt
Mon Jan  1 02:28:43 UTC 2022

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

timeweb@localhost:~$ date | tee timer.txt; sleep 15; date | tee -a timer.txt
Mon Jan  1 02:35:47 UTC 2022
Mon Jan  1 02:36:02 UTC 2022

Приведенная выше команда отобразит и запишет первый вывод команды date, сделает паузу на 15 секунд, затем отобразит и запишет вывод второй команды date. Файл timer.txt теперь содержит постоянный журнал среды выполнения.

Команда xargs

Опции и параметры команды обычно указываются в командной строке, как аргументы командной строки. В качестве альтернативы мы можем использовать команду xargs для сбора аргументов из другого источника ввода (например, файла или стандартного ввода), а затем передать эти аргументы команде. Команду xargs можно вызывать напрямую, и она примет любой ввод:

timeweb@localhost:~$ xargs
Hello
There

Чтобы выйти из команды xargs, нажмите Ctrl+C.

По умолчанию команда xargs передает ввод команде echo, когда за ней явно не следует другая команда. После нажатия Ctrl+D команда xargs отправит ввод в команду echo:

Важно знать: Нажатие Ctrl+D после выхода из команды xargs с помощью Ctrl+C приведет к выходу из текущей оболочки. Чтобы отправить ввод команды xargs в команду echo без выхода из оболочки, нажмите Ctrl+D во время выполнения команды xargs.

Команда xargs наиболее полезна, когда она вызывается в канале. В следующем примере с помощью команды touch будут созданы четыре файла. Файлы будут называться 1a, 1b, 1c и 1d на основе вывода команды echo.

timeweb@localhost:~$ echo '1a 1b 1c 1d' | xargs touch
timeweb@localhost:~$ ls
1a  1c  Desktop Downloads  Pictures  Templates  timer.txt
1b  1d  Documents  Music   Public Videos

Заключение

Мы рассмотрели перенаправление потоков ввода-вывода в Linux: стандартное перенаправление вывода, перенаправление вывода ошибок, перенаправление ввода и конвейеры. Понимание их возможностей упростит работу с bash-скриптами и позволит удобнее администрировать серверы cloud.timeweb.com с операционными системами семейства Linux.

Перенаправление ввода и вывода | Linux: Введение

Для того, чтобы записать данные в файл или прочитать их оттуда, процессу необходимо сначала открыть этот файл (при открытии на запись, возможно, придётся предварительно создать его). При этом процесс получает дескриптор (описатель) открытого файла — уникальное для этого процесса число, которое он и будет использовать во всех операциях записи. Первый открытый файл получит дескриптор 0, второй — 1 и так далее. Закончив работу с файлом, процесс закрывает его, при этом дескриптор освобождается и может быть использован повторно. Если процесс завершается, не закрыв файлы, за него это делает система. Строго говоря, только в операции открытия дескриптора указывается, какой именно файл будет использоваться. В качестве «файла» используются и обычные файлы, и файлы-дырки (чаще всего — терминалы), и

каналы, описанные в разделе Pipeline..Конвейер. Дальнейшие операции — чтение, запись и закрытие, работают с дескриптором, как с потоком данных, а куда именно ведёт этот поток, неважно.

Каждый процесс Linux получает при старте три «файла», открытых для него системой. Первый из них (дескриптор 0) открыт на чтение, это стандартный ввод процесса. Именно со стандартным вводом работают все операции чтения, если в них не указан дескриптор файла. Второй (дескриптор 1) — открыт на запись, это стандартный вывод процесса. С ним работают все операции записи, если дескриптор файла не указан в них явно. Наконец, третий поток данных (дескриптор 2) предназначается для вывода диагностических сообщений, он называется стандартный вывод ошибок. Поскольку эти три дескриптора уже открыты к моменту запуска процесса, первый файл, открытый самим процессом, будет, скорее всего, иметь дескриптор 3.

дескриптор: Описатель потока данных, открытого процессом. Дескрипторы нумеруются начиная с 0. При открытии нового потока данных его дескриптор получает наименьший из неиспользуемых в этот момент номеров. Три заранее открытых дескриптора: стандартный ввод (0), стандартный вывод (1) и стандартный вывод ошибок (2) процессу выдаются при запуске.

Механизм копирования окружения, описанный в лекции Доступ процессов к файлам и каталогам, подразумевает, в числе прочего, копирование всех открытых дескрипторов родительского процесса дочернему. В результате, и родительский, и дочерний процесс имеют под одинаковыми дескрипторами одни и те же потоки данных. Когда запускается стартовый командный интерпретатор, все три заранее открытых дескриптора связаны у него с терминалом (точнее, с соответствующим файлом-дыркой типа tty): пользователь вводит команды с клавиатуры и видит сообщения на экране. Следовательно, любая команда, запускаемая из командной оболочки, будет выводить на тот же терминал, а любая команда, запущенная интерактивно (не в фоне) — вводить оттуда.

Стандартный вывод

Мефодий уже сталкивался с тем, что некоторые программы умеют выводить не только на терминал, но и в файл, например, info при указании параметрического ключа «-o» с именем файла выведет текст руководства в файл, вместо того, чтобы отображать его на мониторе. D [methody@localhost methody]$ ls -l textfile -rw-r—r— 1 methody methody 23 Ноя 15 16:06 textfile

Пример 2. Перенаправление стандартного вывода в файл

От использования символа «>» возможности самой утилиты cat, конечно, не расширились. Более того, cat в этом примере не получила от командной оболочки никаких параметров: ни знака «>», ни последующего имени файла. В этом случае cat работала как обычно, не зная (и даже не интересуясь!), куда попадут выведенные данные: на экран монитора, в файл или куда-нибудь ещё. Вместо того, чтобы самой обеспечивать доставку вывода до конечного адресата (будь то человек или файл), cat отправляет все данные на стандартный вывод (сокращённо — stdout).

Подмена стандартного вывода — задача командной оболочки (shell). В данном примере shell создаёт пустой файл, имя которого указано после знака «>», и дескриптор этого файла передаётся программе cat под номером 1 (стандартный вывод). D [methody@localhost methody]$ cat textfile Это файл для примеров. Пример 1. [methody@localhost methody]$

Пример 3. Недеструктивное перенаправление стандартного вывода

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

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

Стандартный ввод

Аналогичным образом для передачи данных на вход программе может быть использован стандартный ввод (сокращённо — stdin). При работе с командной строкой стандартный ввод — это символы, вводимые пользователем с клавиатуры. Стандартный ввод можно перенаправить при помощи командной оболочки, подав на него данные из некоторого файла. Символ «<» служит для перенаправления содержимого файла на стандартный ввод программе. Например, если вызвать утилиту sort без параметра, она будет читать строки со стандартного ввода. Команда «sort < имя_файла» подаст на ввод sort данные из файла.

[methody@localhost methody]$ sort < textfile 
 Пример 1.
 Это файл для примеров.
[methody@localhost methody]$

Пример 4. Перенаправление стандартного ввода из файла

Результат действия этой команды совершенно аналогичен команде sort textfile, разница в том, что когда используется «<», sort получает данные со стандартного ввода, ничего не зная о файле «textfile», откуда они поступают. Механизм работы shell в данном случае тот же, что и при перенаправлении вывода: shell читает данные из файла «textfile», запускает утилиту sort и передаёт ей на стандартный ввод содержимое файла.

Стоит помнить, что операция «>» деструктивна: она всегда создаёт файл нулевой длины. Поэтому для, допустим, сортировки данных в файле надо применять последовательно sort < файл > новый_файл и mv новый_файл файл. Команда вида команда < файл > тот_же_файл просто урежет его до нулевой длины!

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

Стандартный вывод ошибок

В качестве первого примера и упражнения на перенаправление Мефодий решил записать руководство по cat в свой файл cat.info:

[methody@localhost methody]$ info cat > cat.info
 info: Запись ноды (coreutils.info.bz2)cat invocation...
 info: Завершено.
[methody@localhost methody]$ head -1 cat.info 
 File: coreutils.info,  Node: cat invocation,  Next: tac invocation,  Up: Output of entire files
[methody@localhost methody]$

Пример 5. Стандартный вывод ошибок

Удивлённый Мефодий обнаружил, что вопреки его указанию отправляться в файл две строки, выведенные командой info, всё равно проникли на терминал. Очевидно, эти строки не попали на стандартный вывод потому, что не относятся непосредственно к руководству, которое должна вывести программа, они информируют пользователя о ходе выполнения работы: записи руководства в файл. Для такого рода диагностических сообщений, а также для сообщений об ошибках, возникших в ходе выполнения программы, в Linux предусмотрен стандартный вывод ошибок (сокращённо — stderr).

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

Использование стандартного вывода ошибок наряду со стандартным выводом позволяет отделить собственно результат работы программы от разнообразной сопровождающей информации, например, направив их в разные файлы. Стандартный вывод ошибок может быть перенаправлен так же, как и стандартный ввод/вывод, для этого используется комбинация символов «2».

[methody@localhost methody]$ info cat > cat.info 2> cat.stderr
[methody@localhost methody]$ cat cat.stderr 
 info: Запись ноды (coreutils.info.bz2)cat invocation...
 info: Завершено.
[methody@localhost methody]$

Пример 6. Перенаправление стандартного вывода ошибок

В этот раз на терминал уже ничего не попало, стандартный вывод отправился в файл cat.info, стандартный вывод ошибок — в cat.stderr. Вместо «>» и «2» Мефодий мог бы написать «1>» и «2>». Цифры в данном случае обозначают номера дескрипторов открываемых файлов. Если некая утилита ожидает получить открытый дескриптор с номером, допустим, 4, то чтобы её запустить обязательно потребуется использовать сочетание «4>».

Иногда, однако, требуется объединить стандартный вывод и страндартный вывод ошибок в одном файле, а не разделять их. В командной оболочке bash для этого имеется специальная последовательность «2>&1». Это означает «направить стандартный вывод ошибок туда же, куда и стандартный вывод»:

[methody@localhost methody]$ info cat > cat.info 2>&1
[methody@localhost methody]$ head -3 cat.info 
 info: Запись ноды (coreutils.info.bz2)cat invocation...
 info: Завершено.
 File: coreutils.info,  Node: cat invocation,  Next: tac invocation,  Up: Output of entire files
[methody@localhost methody]$

Пример 7. Объединение стандартного вывода и стандартного вывода ошибок

В этом примере важен порядок перенаправлений: в командной строке Мефодий сначала указал, куда перенаправить стандартный вывод («> cat.info») и только потом велел направить туда же стандартный вывод ошибок. Сделай он наоборот («2>&1 > cat.info»), результат получился бы неожиданный: в файл попал бы только стандартный вывод, а диагностические сообщения появились бы на терминале. Однако логика здесь железная: на момент выполнения операции «2>&1» стандартный вывод был связан с терминалом, значит, после её выполнения стандартный вывод ошибок тоже будет связан с терминалом. А последующее перенаправление стандартного вывода в файл, конечно, никак не отразится на стандартном выводе ошибок. Номер в конструкции «&номер» — это номер открытого дескриптора. Если бы упомянутая выше утилита, записывающая в четвёртый дескриптор, была написана на shell, в ней бы использовались перенаправления вида «>&4». Чтобы не набирать громоздкую конструкцию «> файл 2>&1» в bash используются сокращения: «&> файл» или, что то же самое, «>& файл».

Перенаправление в никуда

Иногда заведомо известно, что какие-то данные, выведенные программой, не понадобятся. Например, предупреждения со стандартного вывода ошибок. В этом случае можно перенаправить стандартный вывод ошибок в файл-дырку, специально предназначенный для уничтожения данных — /dev/null. Всё, что записывается в этот файл, просто будет выброшено и нигде не сохранится.

[methody@localhost methody]$ info cat > cat. info 2> /dev/null
[methody@localhost methody]$

Пример 8. Перенаправление в /dev/null

Точно таким же образом можно избавиться и от стандартного вывода, отправив его в /dev/null.

Перенаправление стандартного ввода и вывода на файл — КиберПедия

Навигация:

Главная Случайная страница Обратная связь ТОП Интересно знать Избранные

Топ:

Техника безопасности при работе на пароконвектомате: К обслуживанию пароконвектомата допускаются лица, прошедшие технический минимум по эксплуатации оборудования…

Эволюция кровеносной системы позвоночных животных: Биологическая эволюция – необратимый процесс исторического развития живой природы…

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

Интересное:

Что нужно делать при лейкемии: Прежде всего, необходимо выяснить, не страдаете ли вы каким-либо душевным недугом. ..

Финансовый рынок и его значение в управлении денежными потоками на современном этапе: любому предприятию для расширения производства и увеличения прибыли нужны…

Берегоукрепление оползневых склонов: На прибрежных склонах основной причиной развития оползневых процессов является подмыв водами рек естественных склонов…

Дисциплины:

Автоматизация Антропология Археология Архитектура Аудит Биология Бухгалтерия Военная наука Генетика География Геология Демография Журналистика Зоология Иностранные языки Информатика Искусство История Кинематография Компьютеризация Кораблестроение Кулинария Культура Лексикология Лингвистика Литература Логика Маркетинг Математика Машиностроение Медицина Менеджмент Металлургия Метрология Механика Музыкология Науковедение Образование Охрана Труда Педагогика Политология Правоотношение Предпринимательство Приборостроение Программирование Производство Промышленность Психология Радиосвязь Религия Риторика Социология Спорт Стандартизация Статистика Строительство Теология Технологии Торговля Транспорт Фармакология Физика Физиология Философия Финансы Химия Хозяйство Черчение Экология Экономика Электроника Энергетика Юриспруденция

⇐ ПредыдущаяСтр 18 из 45Следующая ⇒

Операционная система позволяет направить стандартный ввод на файл вместо клавиатуры, а стандартный вывод на файл вместо экрана. Для такого перенаправления ввода и вывода программу следует запустить из командной строки, в которой указать входной и выходной файлы. Как это сделать, разберем это на примере программы 13 о подсчете выручки.

Исходный файл программы 13 называется Receipt.cpp, а исполняемый файл – Receipt.exe. Программа ожидает ввода с клавиатуры и выводит результаты на экран. Подготовим файл с исходными данными для этой программы. Это можно сделать с помощью любого текстового редактора, например, встроенного текстового редактора системы разработки. В среде TC выполним команду File, New, будет создан новый пустой файл, в его окне введем следующие данные о продажах четырех товаров по трем магазинам в виде:

543.50 764.45 456.70 1003.50

604.17 710.33 550.20 1221.80

804.0 765 480.34 1100

Сохраним набранные данные в файле Dtreceip.cpp.

Запустим программу 13 командной строкой:

D:\AUser\Programs>Receipt.exe < Dtreceip.cpp

Программа прочитает входные данные из указанного файла Dtreceip. cpp, а результаты выведет на экран.

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

D:\AUser\Programs>Receipt.exe < Dtreceip.cpp > Rez.txt

Здесь Rez.txt – имя файла, в который будет производиться вывод. Если выходной файл не существовал, он будет создан операционной системой.

Можно ввод производить со стандартного устройства (клавиатуры), а вывод осуществлять в файл, для этого следует использовать командную строку:

D:\AUser\Programs>Receipt.exe > Rez.txt

Содержимое файла Rez.txt можно вывести на экран командной строкой

D:\AUser\Programs>type Rez.txt

или открыть его в редакторе TC. В нем будет:

Введите выручку от чая, сахара, крупы, колбасы

Магазин 1: Магазин 2: Магазин 3: Выручка по магазинам:

2768.15

3086.5

3149.34

Выручка по товарам:

1951.67, 2239.78, 1487.24, 3325.3,

Всего продано за день на: 9003. 99

Работая в Windows, можно запускать программы с перенаправлением ввода и вывода на файл, используя ярлык на Рабочем столе, рис.26, задавая на вкладке Программы окна Свойства ярлыка нужную командную строку. Имена входного Dtreceip.cpp и выходного result.txt файлов указаны кратко, они отыскиваются в Рабочей папке.

Рис.26. Свойства ярлыка для запуска программы

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

Доступ к командной строке имеется также у файловых менеджеров типа Far или Windows Commander.

Перенаправить на файл можно только стандартный ввод и вывод. Если в программе используется, например, функция getch, которая не относится к стандартному вводу, то программа, запущенная подобной командной строкой, работать не будет (зависает).

Аргументы командной строки

При запуске программы на выполнение функция main может получить из операционной среды два аргумента. Для доступа к ним main должна быть объявлена с двумя формальными аргументами в виде:

void main(int argc, char* argv[])

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

Второй аргумент argv является массивом указателей на char. Эти указатели содержат адреса строк, в которые помещаются слова из командной строки. Аргументы в командной строке отделяются друг от друга пробелами или табуляциями.

Рис.27. Размещение в памяти аргументов командной строки

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

…>Echo.exe Hello, World!

программа напечатает:

Hello, World!

Первым аргументом argv[0] является имя программы, поэтому всегда argc >= 1. Если argc == 1, то в командной строке после имени программы никаких аргументов нет. В нашем примере argc == 3 и, соответственно, argv[0], argv[1]. argv[2] – это указатели на строки ”Echo.exe”, ”Hello,”, ”World!”. Согласно стандарту argv[argc] == 0, то есть является пустым указателем. Схема памяти показана на рис.27. Внутри main имеется только указатель argv, в котором хранится адрес нулевого элемента из массива указателей, расположенного вне main. А уже в этом внешнем по отношению к main массиве указателей хранятся адреса строк с аргументами командной строки.

⇐ Предыдущая13141516171819202122Следующая ⇒

Механическое удерживание земляных масс: Механическое удерживание земляных масс на склоне обеспечивают контрфорсными сооружениями различных конструкций…

Кормораздатчик мобильный электрифицированный: схема и процесс работы устройства…

Опора деревянной одностоечной и способы укрепление угловых опор: Опоры ВЛ — конструкции, предназначенные для поддерживания проводов на необходимой высоте над землей, водой…

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

ввод и вывод / Хабр

Bash-скрипты: начало
Bash-скрипты, часть 2: циклы
Bash-скрипты, часть 3: параметры и ключи командной строки
Bash-скрипты, часть 4: ввод и вывод
Bash-скрипты, часть 5: сигналы, фоновые задачи, управление сценариями
Bash-скрипты, часть 6: функции и разработка библиотек
Bash-скрипты, часть 7: sed и обработка текстов
Bash-скрипты, часть 8: язык обработки данных awk
Bash-скрипты, часть 9: регулярные выражения
Bash-скрипты, часть 10: практические примеры
Bash-скрипты, часть 11: expect и автоматизация интерактивных утилит

В прошлый раз, в третьей части этой серии материалов по bash-скриптам, мы говорили о параметрах командной строки и ключах. Наша сегодняшняя тема — ввод, вывод, и всё, что с этим связано.

Вы уже знакомы с двумя методами работы с тем, что выводят сценарии командной строки:

Отображение выводимых данных на экране.
Перенаправление вывода в файл.

Иногда что-то надо показать на экране, а что-то — записать в файл, поэтому нужно разобраться с тем, как в Linux обрабатывается ввод и вывод, а значит — научиться отправлять результаты работы сценариев туда, куда нужно. Начнём с разговора о стандартных дескрипторах файлов.

Стандартные дескрипторы файлов

Всё в Linux — это файлы, в том числе — ввод и вывод. Операционная система идентифицирует файлы с использованием дескрипторов.

Каждому процессу позволено иметь до девяти открытых дескрипторов файлов. Оболочка bash резервирует первые три дескриптора с идентификаторами 0, 1 и 2. Вот что они означают.

0, STDIN — стандартный поток ввода.
1, STDOUT — стандартный поток вывода.
2, STDERR — стандартный поток ошибок.

Эти три специальных дескриптора обрабатывают ввод и вывод данных в сценарии.
Вам нужно как следует разобраться в стандартных потоках. Их можно сравнить с фундаментом, на котором строится взаимодействие скриптов с внешним миром. Рассмотрим подробности о них.

STDIN

STDIN — это стандартный поток ввода оболочки. Для терминала стандартный ввод — это клавиатура. Когда в сценариях используют символ перенаправления ввода — <, Linux заменяет дескриптор файла стандартного ввода на тот, который указан в команде. Система читает файл и обрабатывает данные так, будто они введены с клавиатуры.

Многие команды bash принимают ввод из STDIN, если в командной строке не указан файл, из которого надо брать данные. Например, это справедливо для команды cat.

Когда вы вводите команду cat в командной строке, не задавая параметров, она принимает ввод из STDIN. После того, как вы вводите очередную строку, cat просто выводит её на экран.

STDOUT

STDOUT — стандартный поток вывода оболочки. По умолчанию это — экран. Большинство bash-команд выводят данные в STDOUT, что приводит к их появлению в консоли. Данные можно перенаправить в файл, присоединяя их к его содержимому, для этого служит команда >>.

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

pwd >> myfile

То, что выведет pwd, будет добавлено к файлу myfile, при этом уже имеющиеся в нём данные никуда не денутся.

Перенаправление вывода команды в файл

Пока всё хорошо, но что если попытаться выполнить что-то вроде показанного ниже, обратившись к несуществующему файлу xfile, задумывая всё это для того, чтобы в файл myfile попало сообщение об ошибке.

ls –l xfile > myfile

После выполнения этой команды мы увидим сообщения об ошибках на экране.

Попытка обращения к несуществующему файлу

При попытке обращения к несуществующему файлу генерируется ошибка, но оболочка не перенаправила сообщения об ошибках в файл, выведя их на экран. Но мы-то хотели, чтобы сообщения об ошибках попали в файл. Что делать? Ответ прост — воспользоваться третьим стандартным дескриптором.

STDERR

STDERR представляет собой стандартный поток ошибок оболочки. По умолчанию этот дескриптор указывает на то же самое, на что указывает STDOUT, именно поэтому при возникновении ошибки мы видим сообщение на экране.

Итак, предположим, что надо перенаправить сообщения об ошибках, скажем, в лог-файл, или куда-нибудь ещё, вместо того, чтобы выводить их на экран.

▍Перенаправление потока ошибок

Как вы уже знаете, дескриптор файла STDERR — 2. Мы можем перенаправить ошибки, разместив этот дескриптор перед командой перенаправления:

ls -l xfile 2>myfile
cat . /myfile

Сообщение об ошибке теперь попадёт в файл myfile.

Перенаправление сообщения об ошибке в файл

▍Перенаправление потоков ошибок и вывода

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

ls –l myfile xfile anotherfile 2> errorcontent 1> correctcontent

Перенаправление ошибок и стандартного вывода

Оболочка перенаправит то, что команда ls обычно отправляет в STDOUT, в файл correctcontent благодаря конструкции 1>. Сообщения об ошибках, которые попали бы в STDERR, оказываются в файле errorcontent из-за команды перенаправления 2>.

Если надо, и STDERR, и STDOUT можно перенаправить в один и тот же файл, воспользовавшись командой &>:

Перенаправление STDERR и STDOUT в один и тот же файл

После выполнения команды то, что предназначено для STDERR и STDOUT, оказывается в файле content.

Перенаправление вывода в скриптах

Существует два метода перенаправления вывода в сценариях командной строки:

Временное перенаправление, или перенаправление вывода одной строки.
Постоянное перенаправление, или перенаправление всего вывода в скрипте либо в какой-то его части.

▍Временное перенаправление вывода

В скрипте можно перенаправить вывод отдельной строки в STDERR. Для того, чтобы это сделать, достаточно использовать команду перенаправления, указав дескриптор STDERR, при этом перед номером дескриптора надо поставить символ амперсанда (&):

#!/bin/bash
echo "This is an error" >&2
echo "This is normal output"

Если запустить скрипт, обе строки попадут на экран, так как, как вы уже знаете, по умолчанию ошибки выводятся туда же, куда и обычные данные.

Временное перенаправление

Запустим скрипт так, чтобы вывод STDERR попадал в файл.

./myscript 2> myfile

Как видно, теперь обычный вывод делается в консоль, а сообщения об ошибках попадают в файл.

Сообщения об ошибках записываются в файл

▍Постоянное перенаправление вывода

Если в скрипте нужно перенаправлять много выводимых на экран данных, добавлять соответствующую команду к каждому вызову echo неудобно. Вместо этого можно задать перенаправление вывода в определённый дескриптор на время выполнения скрипта, воспользовавшись командой exec:

#!/bin/bash
exec 1>outfile
echo "This is a test of redirecting all output"
echo "from a shell script to another file."
echo "without having to redirect every line"

Запустим скрипт.

Перенаправление всего вывода в файл

Если просмотреть файл, указанный в команде перенаправления вывода, окажется, что всё, что выводилось командами echo, попало в этот файл.

Команду exec можно использовать не только в начале скрипта, но и в других местах:

#!/bin/bash
exec 2>myerror
echo "This is the start of the script"
echo "now redirecting all output to another location"
exec 1>myfile
echo "This should go to the myfile file"
echo "and this should go to the myerror file" >&2

Вот что получится после запуска скрипта и просмотра файлов, в которые мы перенаправляли вывод.

Перенаправление вывода в разные файлы

Сначала команда exec задаёт перенаправление вывода из STDERR в файл myerror. Затем вывод нескольких команд echo отправляется в STDOUT и выводится на экран. После этого команда exec задаёт отправку того, что попадает в STDOUT, в файл myfile, и, наконец, мы пользуемся командой перенаправления в STDERR в команде echo, что приводит к записи соответствующей строки в файл myerror.

Освоив это, вы сможете перенаправлять вывод туда, куда нужно. Теперь поговорим о перенаправлении ввода.

Перенаправление ввода в скриптах

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

exec 0< myfile

Эта команда указывает оболочке на то, что источником вводимых данных должен стать файл myfile, а не обычный STDIN. Посмотрим на перенаправление ввода в действии:

#!/bin/bash
exec 0< testfile
count=1
while read line
do
echo "Line #$count: $line"
count=$(( $count + 1 ))
done

Вот что появится на экране после запуска скрипта.

Перенаправление ввода

В одном из предыдущих материалов вы узнали о том, как использовать команду read для чтения данных, вводимых пользователем с клавиатуры. Если перенаправить ввод, сделав источником данных файл, то команда read, при попытке прочитать данные из STDIN, будет читать их из файла, а не с клавиатуры.

Некоторые администраторы Linux используют этот подход для чтения и последующей обработки лог-файлов.

Создание собственного перенаправления вывода

Перенаправляя ввод и вывод в сценариях, вы не ограничены тремя стандартными дескрипторами файлов. Как уже говорилось, можно иметь до девяти открытых дескрипторов. Остальные шесть, с номерами от 3 до 8, можно использовать для перенаправления ввода или вывода. Любой из них можно назначить файлу и использовать в коде скрипта.

Назначить дескриптор для вывода данных можно, используя команду exec:

#!/bin/bash
exec 3>myfile
echo "This should display on the screen"
echo "and this should be stored in the file" >&3
echo "And this should be back on the screen"

После запуска скрипта часть вывода попадёт на экран, часть — в файл с дескриптором 3.

Перенаправление вывода, используя собственный дескриптор

Создание дескрипторов файлов для ввода данных

Перенаправить ввод в скрипте можно точно так же, как и вывод. Сохраните STDIN в другом дескрипторе, прежде чем перенаправлять ввод данных.

После окончания чтения файла можно восстановить STDIN и пользоваться им как обычно:

#!/bin/bash
exec 6<&0
exec 0< myfile
count=1
while read line
do
echo "Line #$count: $line"
count=$(( $count + 1 ))
done
exec 0<&6
read -p "Are you done now? " answer
case $answer in
y) echo "Goodbye";;
n) echo "Sorry, this is the end.";;
esac

Испытаем сценарий.

Перенаправление ввода

В этом примере дескриптор файла 6 использовался для хранения ссылки на STDIN. Затем было сделано перенаправление ввода, источником данных для STDIN стал файл. После этого входные данные для команды read поступали из перенаправленного STDIN, то есть из файла.

После чтения файла мы возвращаем STDIN в исходное состояние, перенаправляя его в дескриптор 6. Теперь, для того, чтобы проверить, что всё работает правильно, скрипт задаёт пользователю вопрос, ожидает ввода с клавиатуры и обрабатывает то, что введено.

Закрытие дескрипторов файлов

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

#!/bin/bash
exec 3> myfile
echo "This is a test line of data" >&3
exec 3>&-
echo "This won't work" >&3

После исполнения скрипта мы получим сообщение об ошибке.

Попытка обращения к закрытому дескриптору файла

Всё дело в том, что мы попытались обратиться к несуществующему дескриптору.

Будьте внимательны, закрывая дескрипторы файлов в сценариях. Если вы отправляли данные в файл, потом закрыли дескриптор, потом — открыли снова, оболочка заменит существующий файл новым. То есть всё то, что было записано в этот файл ранее, будет утеряно.

Получение сведений об открытых дескрипторах

Для того, чтобы получить список всех открытых в Linux дескрипторов, можно воспользоваться командой lsof. Во многих дистрибутивах, вроде Fedora, утилита lsof находится в /usr/sbin. Эта команда весьма полезна, так как она выводит сведения о каждом дескрипторе, открытом в системе. Сюда входит и то, что открыли процессы, выполняемые в фоне, и то, что открыто пользователями, вошедшими в систему.

У этой команды есть множество ключей, рассмотрим самые важные.

-p Позволяет указать ID процесса.
-d Позволяет указать номер дескриптора, о котором надо получить сведения.

Для того, чтобы узнать PID текущего процесса, можно использовать специальную переменную окружения $$, в которую оболочка записывает текущий PID.

Ключ -a используется для выполнения операции логического И над результатами, возвращёнными благодаря использованию двух других ключей:

lsof -a -p $$ -d 0,1,2

Вывод сведений об открытых дескрипторах

Тип файлов, связанных с STDIN, STDOUT и STDERR — CHR (character mode, символьный режим). Так как все они указывают на терминал, имя файла соответствует имени устройства, назначенного терминалу. Все три стандартных файла доступны и для чтения, и для записи.

Посмотрим на вызов команды lsof из скрипта, в котором открыты, в дополнение к стандартным, другие дескрипторы:

#!/bin/bash
exec 3> myfile1
exec 6> myfile2
exec 7< myfile3
lsof -a -p $$ -d 0,1,2,3,6,7

Вот что получится, если этот скрипт запустить.

Просмотр дескрипторов файлов, открытых скриптом

Скрипт открыл два дескриптора для вывода (3 и 6) и один — для ввода (7). Тут же показаны и пути к файлам, использованных для настройки дескрипторов.

Подавление вывода

Иногда надо сделать так, чтобы команды в скрипте, который, например, может исполняться как фоновый процесс, ничего не выводили на экран. Для этого можно перенаправить вывод в /dev/null. Это — что-то вроде «чёрной дыры».

Вот, например, как подавить вывод сообщений об ошибках:

ls -al badfile anotherfile 2> /dev/null

Тот же подход используется, если, например, надо очистить файл, не удаляя его:

cat /dev/null > myfile

Итоги

Сегодня вы узнали о том, как в сценариях командной строки работают ввод и вывод. Теперь вы умеете обращаться с дескрипторами файлов, создавать, просматривать и закрывать их, знаете о перенаправлении потоков ввода, вывода и ошибок. Всё это очень важно в деле разработки bash-скриптов.

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

Уважаемые читатели! В этом материале даны основы работы с потоками ввода, вывода и ошибок. Уверены, среди вас есть профессионалы, которые могут рассказать обо всём этом то, что приходит лишь с опытом. Если так — передаём слово вам.

Командная строка

— Как сохранить вывод терминала в файл?

Спросил 8 лет, 7 месяцев назад

Изменено 8 месяцев назад

Просмотрено 3,3 млн раз

Как сохранить вывод команды в файл?

Есть ли способ без использования каких-либо программ? Я хотел бы знать, как.

командная строка

Да, можно, просто перенаправьте вывод (AKA stdout ) в файл:

 SomeCommand > SomeFile.txt

Или, если вы хотите добавить данные:

 SomeCommand >> SomeFile.txt

Если вы хотите stderr , используйте это:

 SomeCommand &> SomeFile.txt

или добавить сюда:

 SomeCommand &>> SomeFile.txt

, если вы хотите, чтобы stderr и вывод отображались на консоли и в файле используйте это:

 SomeCommand 2>&1 | тройник SomeFile.txt

(Если вам нужен только вывод, отбросьте 2 выше)

Для записи вывода команды в файл существует 10 основных способов.

Обзор:

_{Обратите внимание, что н.п. в столбце синтаксиса означает «не существует».
Способ есть, но он слишком сложен, чтобы вписаться в колонку. Вы можете найти полезную ссылку в разделе Список об этом.}

 || виден в терминале || виден в файле || существующий
  Синтаксис || Стандартный выход | Стандартная ошибка || Стандартный выход | Стандартная ошибка || файл
==========++==========+==========++==========+==== ======++===========
    > || нет | да || да | нет || перезаписывать
    >> || нет | да || да | нет || добавить
          || | || | ||
   2> || да | нет || нет | да || перезаписывать
   2>> || да | нет || нет | да || добавить
          || | || | ||
   &> || нет | нет || да | да || перезаписывать
   &>> || нет | нет || да | да || добавить
          || | || | ||
 | тройник || да | да || да | нет || перезаписывать
 | тройник -а || да | да || да | нет || добавить
          || | || | ||
 н.э. (*) || да | да || нет | да || перезаписывать
 н.э. (*) || да | да || нет | да || добавить
          || | || | ||
|& тройник || да | да || да | да || перезаписывать
|& тройник -а || да | да || да | да || добавить

Список:

команда > output. txt
Стандартный поток вывода будет перенаправлен только в файл, он не будет виден в терминале. Если файл уже существует, он перезаписывается.
команда >> output.txt
Стандартный поток вывода будет перенаправлен только в файл, он не будет виден в терминале. Если файл уже существует, новые данные будут добавлены в конец файла.
команда 2> output.txt
Стандартный поток ошибок будет перенаправлен только в файл, его не будет видно в терминале. Если файл уже существует, он перезаписывается.
команда 2>> output.txt
Стандартный поток ошибок будет перенаправлен только в файл, его не будет видно в терминале. Если файл уже существует, новые данные будут добавлены в конец файла.
команда &> output.txt
И стандартный вывод, и стандартный поток ошибок будут перенаправлены только в файл, в терминале ничего не будет видно. Если файл уже существует, он перезаписывается.
команда &>> output.txt
И стандартный вывод, и стандартный поток ошибок будут перенаправлены только в файл, в терминале ничего не будет видно. Если файл уже существует, новые данные будут добавлены в конец файла..
команда | тройник output.txt
Стандартный поток вывода будет скопирован в файл, он все равно будет виден в терминале. Если файл уже существует, он перезаписывается.
команда | тройник -a output.txt
Стандартный поток вывода будет скопирован в файл, он все равно будет виден в терминале. Если файл уже существует, новые данные будут добавлены в конец файла.
(*)
Bash не имеет сокращенного синтаксиса, который позволяет передавать только StdErr во вторую команду, которая потребуется здесь в сочетании с tee снова для завершения таблицы. Если вам действительно нужно что-то подобное, посмотрите «Как передать stderr, а не stdout?» о переполнении стека, чтобы узнать, как это можно сделать, например. путем замены потоков или использования подстановки процессов.
команда |& tee output.txt
И стандартный поток вывода, и стандартный поток ошибок будут скопированы в файл, оставаясь при этом видимыми в терминале. Если файл уже существует, он перезаписывается.
команда |& tee -a output.txt
И стандартный поток вывода, и стандартный поток ошибок будут скопированы в файл, оставаясь при этом видимыми в терминале. Если файл уже существует, новые данные будут добавлены в конец файла.

Вы также можете использовать tee для отправки вывода в файл:

 команда | тройник ~/outputfile.txt

Небольшая модификация также будет ловить stderr:

 команда 2>&1 | тройник ~/outputfile.txt

или чуть короче и проще:

 command |& tee ~/outputfile.txt

tee полезен, если вы хотите иметь возможность захватывать выходные данные команды, а также просматривать их в реальном времени .

Вы можете перенаправить вывод команды в файл:

 ваша_команда >/путь/к/файлу

Чтобы добавить вывод команды в файл вместо его перезаписи, используйте:

 ваша_команда >>/путь/к/файлу

Улучшение, которое следует принять во внимание —

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

Чтобы исправить это, вы можете использовать программу sed для удаления этих кодов. Пример:

 команда 2>&1 | sed -r 's/'$(echo -e "\033")'\[[0-9]{1,2}(;([0-9]{1,2})?)?[mK] //г' | тройник ~/outputfile.txt

Здесь два разных вопроса. Первый в названии:

Как сохранить вывод терминала в файл?

Второй вопрос в теле:

Как сохранить вывод команды в файл?

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

Сохранить весь вывод терминала в файл

В этом ответе используется малоизвестная команда под названием script , которая сохраняет весь вывод вашей оболочки в текстовый файл, пока вы не наберете exit . Вывод команды по-прежнему отображается на вашем экране, но также появляется в текстовом файле .

Процесс прост. Использование:

 $ скрипт ~/outputfile.txt
Скрипт запущен, файл /home/rick/outputfile.txt
$ команда1
$ команда2
$ команда3
$ выход
выход
Скрипт готов, файл /home/rick/outputfile.txt

Затем посмотрите на записанный вывод команд 1, 2 и 3 с помощью:

 cat ~/outputfile.txt

Это похоже на предыдущий ответ:

 command |& tee ~/outputfile.txt

Но вам не обязательно использовать |& tee ~/outputfile.txt после каждой команды .
Команда script имеет дополнительное преимущество (или недостаток) перезагрузки ~/.bashrc при запуске.
Скрипт 9Команда 0022 показывает командную строку ( $PS1 ), за которой следуют введенные вами команды.
Команда сценария записывает все детали в полном цвете.

Много раз мы хотим, чтобы вывод попал в буфер обмена, чтобы мы могли вставить его позже. Из этого ответа вы можете использовать:

 cat ~/.bashrc | xclip - выбор буфера обмена

Теперь вы можете использовать Ctrl + V практически в любом приложении для вставки вывода терминала в документ. Чтобы вставить вывод терминала из буфера обмена обратно в терминал, используйте Ctrl + Shift + V вместо .

6

некоторая_команда | tee command.log и some_command > command.log имеют проблему, заключающуюся в том, что они не сохраняют вывод команды в файл command.log в режиме реального времени.

Чтобы избежать этой проблемы и сохранить вывод команды в режиме реального времени, вы можете добавить unbuffer , который поставляется с пакетом expect .

Пример:

 ожидается установка sudo apt-get
разбуферить some_command | тройник command. log
unbuffer some_command > command.log

Предполагая, что log.py содержит:

 время импорта
печать('тестирование')
time.sleep(100) # сон на 100 секунд

вы можете запустить unbuffer python log.py | tee command.log или unbuffer python log.py > command.log

Дополнительная информация: Как сохранить вывод команды в файл в режиме реального времени?

3

Для заданий cron , и т. д. следует избегать расширений Bash. Эквивалентными операторами перенаправления POSIX sh являются

 Bash POSIX.
------------ --------------
foo &> bar foo > bar 2>&1
foo &>> бар foo >> бар 2>&1
foo |& bar foo 2>&1 | бар

Вы заметите, что средства POSIX в некотором смысле проще и понятнее. Синтаксис &> был заимствован из csh , что уже должно убедить вас в том, что это плохая идея.

Если вы хотите выводить данные в файл во время выполнения команды:

 script -c . /path/to/executable.bash -f log.txt

Еще не упомянутый вариант, который также может сохранять цвета/цвета, заключается в использовании консольной программы, такой как Konsole (эмулятор терминала KDE/Plasma по умолчанию) для сохранения вывода.

`Konsole`

 Konsole имеет:
Файл > Сохранить вывод как...

ярлык Ctrl + Shift + S ; он позволяет сохранить вывод в виде текстового файла или в виде HTML, включая цвета! Я точно не знаю, сколько это сэкономит, но в моем тесте он включал только ~ 1000, всю прокрутку терминала (вы можете увеличить буфер, создав новый профиль, Профиль > Новый..., а затем изменить Прокрутите настройки, чтобы захватить больше; версия Konsole 4:21.08.1).

`gnome-terminal`

gnome-terminal также имеет «вывод копии как HTML», что позволяет вставлять HTML в документ; он сохраняет цвет, но копирует только содержимое вывода, отображаемого в данный момент на экране AFAICT.

`вообще`

Конечно, вы можете сделать прямое перетаскивание (удерживая левую кнопку мыши при перетаскивании), а затем скопировать ( ctrl + c , Edit > Copy или щелкнуть правой кнопкой мыши и выбрать копию ).

`другие?`

Не стесняйтесь изменить этот ответ, включив в него другие популярные терминальные приложения. Мой любимый, Yakuake , похоже, не имеет этой функции, как и большинство популярных терминалов, которые я рассмотрел, включая terminal.app и Hyper.

`Прямой вывод команды в файл, включая исходную команду, И печать в терминале`

Запрошено 4 года, 10 месяцев назад

Изменено 3 года, 6 месяцев назад

Просмотрено 25 тыс. раз

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

Запустите команду, которую мне нужно запустить
Перенаправить весь вывод команды в указанный файл
Включить исходную команду в указанный файл
Распечатать вывод исходной команды в терминале

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

Кто-то предложил это:

 echo "ls -l" | xargs -I{} bash -c "echo >> output.file; eval {} >> output.file"

Но это не выводит вывод в терминал и не включает исходную команду в файл.

Буду признателен за любые идеи.

командная строка

3

Это тройник , который вы ищете.

 лс -л | тройник

печатает вывод ls -l на стандартный вывод (т.е. на терминал) и одновременно сохраняет его в файле outfile . Но : имя команды не записывается ни в стандартный вывод, ни в файл. Для этого просто введите echo имя команды перед запуском команды и направьте оба вывода на tee :

 ( echo "ls -l" && ls -l ) | тройник

Это громоздко набирать, так почему бы не определить функцию?

 оба(){ ( эхо "$@" && "$@" ) | выходной файл ;}

После этого вы можете просто запустить

 оба ls -l

, чтобы получить желаемый результат. Поместите функцию в свой ~/.bashrc , чтобы она определялась в каждом новом терминале.

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

, оба вывода ls -l

вместо этого сделайте это:

 Both(){ ( echo "${@:2}" && "${@:2}" ) | тройник "$1" ;}

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

0

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

 $ скрипт my_output
Скрипт запущен вторник, 28 ноября 2017 г., 09:46:15 UTC.
$ кто
аджеферисс
$ выход
Сценарий выполнен вторник, 28 ноября 2017 г., 09:46:27 UTC.

Тогда если я cat my_output Я получаю тот же вывод:

 $ cat my_output
Скрипт запущен вторник, 28 ноября 2017 г. , 09:46:15 UTC.
$ кто
аджеферисс
$ выход
выход
Сценарий выполнен вторник, 28 ноября 2017 г., 09:46:27 UTC.

Вы можете использовать функцию отладки оболочки вместе с tee :

 (set -x; аргументы команды1...; аргументы команды2) 2>&1 | тройник output.log

( ... ) запускает подоболочку, которая позволяет вам «собирать» выходные потоки всех команд, выполняемых внутри подоболочки. Он также содержит эффект установите команду ниже для этой подоболочки.
set -x включает параметр оболочки x , который выводит все команды, выполняемые оболочкой, в стандартный поток ошибок перед их выполнением.
2>&1 перенаправляет поток 2 (стандартная ошибка) в поток 1 (стандартный вывод).
| перенаправляет стандартный поток вывода левой команды на стандартный поток ввода правой команды.
tee ФАЙЛ копирует стандартный входной поток в файл ФАЙЛ и на стандартный вывод.

Если ваша последовательность команд уже находится в файле сценария, имеет смысл запустить ее следующим образом:

 bash -x /path/to/script args... 2>&1 | тройник output.log

`Твой ответ`

`Зарегистрируйтесь или войдите в систему`

Зарегистрируйтесь с помощью Google

Зарегистрироваться через Facebook

Зарегистрируйтесь, используя адрес электронной почты и пароль

`Опубликовать как гость`

Электронная почта

Требуется, но не отображается

`Опубликовать как гость`

Электронная почта

Требуется, но не отображается

Нажимая «Опубликовать свой ответ», вы соглашаетесь с нашими условиями обслуживания, политикой конфиденциальности и политикой использования файлов cookie

. Out-File (Microsoft.PowerShell.Utility) — PowerShell | Microsoft Learn 
 Справочник
 Модуль:
 Microsoft.PowerShell.Утилита
 Отправляет вывод в файл.
 Синтаксис 
 Вне файла
   [-FilePath] <строка>
   [[-Кодировка] <Кодировка>]
   [-Добавить]
   [-Сила]
   [-NoClobber]
   [-Ширина <число>]
   [-NoNewline]
   [-InputObject ]
   [-Что если]
   [-Подтверждать]
   [<Общие параметры>] 
 Вне файла
   [[-Кодировка] <Кодировка>]
   -LiteralPath <строка>
   [-Добавить]
   [-Сила]
   [-NoClobber]
   [-Ширина <число>]
   [-NoNewline]
   [-InputObject ]
   [-Что если]
   [-Подтверждать]
   [] 
 Описание 
 Командлет  Out-File  отправляет выходные данные в файл. Он неявно использует систему форматирования PowerShell для
записать в файл. Файл получает то же представление на дисплее, что и терминал. Это означает
что вывод может быть не идеальным для программной обработки, если только все входные объекты не являются строками.
Когда вам нужно указать параметры для вывода, используйте  Out-File  вместо перенаправления
оператор (  >  ). Дополнительные сведения о перенаправлении см.
about_Redirection.
 Примеры 
 Пример 1. Отправка выходных данных и создание файла 
 В этом примере показано, как отправить список процессов локального компьютера в файл. Если файл делает
не существует,  Out-File  создает файл по указанному пути.
 Процесс получения | Out-File -FilePath .\Process.txt
Get-Content -Путь .\Process.txt
NPM(K) PM(M) WS(M) CPU(s) Id SI ProcessName
 ------ ----- ----- ------ -- -- -----------
     2922,39 35,40 10,98 42764 9 Применение
     53 99,04 113,96 0,00 32664 0 CcmExec
     27 96.62 112.43 113.00 17720 9 Код 
 Командлет  Get-Process  получает список процессов, запущенных на локальном компьютере. Процесс   объекты отправляются по конвейеру в командлет  Out-File .  Out-File  использует  FilePath  параметр и создает файл в текущем каталоге с именем  Process.txt  .  Get-Content  Команда получает содержимое из файла и отображает его в консоли PowerShell.
 Пример 2. Предотвращение перезаписи существующего файла 
 В этом примере предотвращается перезапись существующего файла. По умолчанию  Out-File  перезаписывает
существующие файлы.
 Процесс получения | Out-File -FilePath .\Process.txt -NoClobber
Out-File: файл «C:\Test\Process.txt» уже существует.
В строке:1 символ:15
+ Получить-Процесс | Out-File -FilePath .\Process.txt -NoClobber
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
 Командлет  Get-Process  получает список процессов, запущенных на локальном компьютере. Процесс   объекты отправляются по конвейеру в командлет  Out-File .  Out-File  использует  FilePath  параметр и пытается записать в файл в текущем каталоге с именем  Process.txt  .  Параметр NoClobber  предотвращает перезапись файла и отображает сообщение о том, что
Файл уже существует.
 Пример 3: Отправка вывода в файл в формате ASCII 
 В этом примере показано, как закодировать вывод с помощью определенного типа кодирования.
 $Procs = Get-Process
Out-File -FilePath .\Process.txt -InputObject $Procs -Encoding ASCII -Width 50 
 Командлет  Get-Process  получает список процессов, запущенных на локальном компьютере. Процесс   объекты хранятся в переменной  $Procs  .  Out-File  использует параметр  FilePath  и создает
файл в текущем каталоге с именем  Процесс.txt  . Параметр  InputObject  передает
обрабатывать объекты в  $Procs  в файл  Process. txt  . Параметр  Encoding  преобразует
вывод в формате  ASCII . Параметр  Width  ограничивает длину каждой строки в файле 50 символами, поэтому
некоторые данные могут быть усечены.
 Пример 4. Использование поставщика и отправка вывода в файл 
 В этом примере показано, как использовать командлет  Out-File , когда вы не находитесь в0044 Поставщик файловой системы  водить машину. Используйте командлет  Get-PSProvider  для просмотра поставщиков на локальном компьютере. Для большего
информацию см. в разделе about_Providers.
 PS> Set-Location-Псевдоним пути:
PS> Получить-местоположение
Дорожка
----
Псевдоним:\
PS> Получить-ChildItem | Out-File - FilePath C:\TestDir\AliasNames.txt
PS> Get-Content -Path C:\TestDir\AliasNames.txt
Имя типа команды
----------- ----
Псевдоним % -> ForEach-Object
Псевдоним? -> Где-Объект
Псевдоним ac -> Добавить контент
Псевдоним cat -> Get-Content 
 Команда  Set-Location  использует параметр  Path  для установки текущего местоположения в реестр. провайдер  Псевдоним:  . Командлет  Get-Location  отображает полный путь для  Alias:  .  Get-ChildItem  отправляет объекты по конвейеру в командлет  Out-File .  Out-File  использует  Параметр FilePath  для указания полного пути и имени выходного файла,  C:\TestDir\AliasNames.txt  . Командлет  Get-Content  использует параметр  Path  и отображает
содержимое файла в консоли PowerShell.
 Пример 5: Установка ширины выходного файла для всей области 
 В этом примере используется  $PSDefaultParameterValues  для установки параметра  Ширина  для всех вызовов  Out-File  и операторы перенаправления (  >  и  >>  ) на 2000. Это гарантирует, что везде
в текущей области, в которой вы выводите данные в формате таблицы в файл, PowerShell использует ширину строки
2000 вместо ширины линии, определяемой шириной консоли хоста PowerShell.
 функция DemoDefaultOutFileWidth() {
    пытаться {
        $PSDefaultParameterValues['out-file:width'] = 2000
        $logFile = "$pwd\logfile.txt"
        Get-ChildItem Env:\ > $logFile
        Get-Service -ErrorAction Игнорировать | Формат-Таблица-Авторазмер | Выходной файл $logFile -Append
        Get-процесс | Идентификатор таблицы форматов, SI, имя, путь, MainWindowTitle >> $logFile
    }
    в конце концов {
        $PSDefaultParameterValues.Remove('out-file:width')
    }
}
DemoDefaultOutFileWidth 
 Дополнительные сведения о  $PSDefaultParameterValues  , см.
about_Preference_Variables.
 Parameters 
 -Append 
 -Confirm 
 -Encoding 
 -FilePath 
 -Force 
 -InputObject 
 -LiteralPath 
 -NoClobber 
 -NoNewline 
 -WhatIf 
 -Width 
 Inputs 
  PSObject 
 Вы можете направить любой объект на  Out-File  .
 Выходы 
  Нет 
  Out-File  не генерирует никаких выходных данных.
 Примечания 
 Объекты ввода автоматически форматируются так же, как в терминале, но вы можете использовать  Format-* Командлет  для явного управления форматированием вывода в файл. Например,  Дата получения | Список форматов | Out-File out.txt 
 Чтобы отправить выходные данные команды PowerShell в командлет  Out-File , используйте конвейер. В качестве альтернативы вы
может хранить данные в переменной и использовать  Параметр InputObject  для передачи данных в  Out-File  командлет.
  Out-File  сохраняет данные в файл, но не создает никаких выходных объектов для конвейера.
 В PowerShell 7.2 добавлена возможность управления визуализацией управляющих последовательностей ANSI. ANSI-украшенный
вывод, который передается в  Out-File , может быть изменен в зависимости от настройки  Свойство $PSStyle. OutputRendering . Для получения дополнительной информации см.
about_ANSI_терминалы.
 about_Providers
 about_Quoting_Rules
 Вне значения по умолчанию
 Внешний хост
 Out-Null
 Внешняя струна
 Тройник Объект
 Как сохранить вывод командной строки в файл в Windows, Mac и Linux 
 Когда вы запускаете команду в окне терминала, вывод команды обычно выводится в терминал или на экран, чтобы вы могли его прочитать немедленно. Вы также можете распечатать вывод команды в файл, если хотите его сохранить.
 Сохранение вывода команды в файл полезно, если вы пытаетесь диагностировать проблему. Чтобы получить помощь от службы технической поддержки, вам, возможно, придется выполнить определенные команды на своем компьютере и отправить результаты в службу поддержки. Это легко сделать с помощью перенаправления вывода в командной строке.
 Сегодня мы рассмотрим, как отправить вывод команды в текстовый файл в оболочке bash в Windows, Mac и Linux.
  Примечание:  В нашем примере мы будем использовать терминал Mac, но он работает одинаково в оболочке bash в Linux и в новой оболочке bash в Windows 10.
 Перенаправить вывод только в файл 
 Есть два оператора для перенаправления вывода команды в файл вместо экрана.
 Символ  >  создает новый файл, если он отсутствует, или перезаписывает файл, если он уже существует.  >>  также создает новый файл, если он отсутствует, но добавляет текст в конец файла, если он уже существует, а не перезаписывает файл.
 Чтобы перенаправить вывод команды в файл, введите команду, укажите  >  или оператор  >> , а затем укажите путь к файлу, на который вы хотите перенаправить вывод. Например, команда ls выводит список файлов и папок в текущем каталоге. При выполнении следующей команды список файлов и папок будет записан в файл  ls_output.txt  в папке  TerminalOutput .
 Замените  /path/to/file  полным путем к файлу, который вы хотите использовать.
 лс > /путь/к/файлу 
 Это команда для нашего примера.
 лс > /Users/lorikaufman/TerminalOutput/ls_output.txt 
 Чтобы просмотреть содержимое файла в окне терминала, используйте команду  cat , как показано в следующей команде. Снова замените  /path/to/file  на полный путь к файлу, который вы хотите просмотреть.
 кот /путь/к/файлу 
 Оператор  >  заменяет содержимое существующего файла каждый раз, когда вы используете его для перенаправления вывода. Если вы хотите сохранить вывод нескольких команд в один файл, используйте 9Вместо оператора 0044 >> . Это добавляет вывод команды в конец указанного файла, если он уже существует. Если файл не существует, он создает новый.
 Например, мы добавим системную информацию в конец созданного выше файла. Итак, в следующей строке  uname -a  — это команда, за которой следует оператор перенаправления  >> . Затем полный путь к файлу, к которому мы хотим добавить вывод команды  uname .
 Параметр  -a  в команде  uname  выводит всю доступную системную информацию.
 uname -a >> /Users/lorikaufman/TerminalOutput/ls_output.txt 
 Чтобы просмотреть файл с добавленной информацией в окне терминала, введите следующую команду, указав полный путь к вашему файлу.
 кот /Users/lorikaufman/TerminalOutput/ls_output.txt 
 Повторите этот процесс столько раз, сколько вам нужно, чтобы продолжать добавлять выходные данные команды в конец файла.
 Вот еще один пример отправки вывода команды  ls  в виде дерева каталогов с рекурсивным перечислением подкаталогов (параметр  R ) и одним файлом в строке (параметр  1 ).
 ls -1R > /Users/lorikaufman/TerminalOutput/dir_tree.txt 
 
 Затем мы используем команду  cat , как упоминалось ранее, для просмотра содержимого файла в окне терминала.
 кот /Users/lorikaufman/TerminalOutput/dir_tree.txt 
 Распечатать вывод на экран и перенаправить его в файл 
 Операторы  >  и  >>  не отображают вывод команды на экран. Вывод отправляется только в файл.
 Если вы хотите отправить вывод в файл и увидеть его на экране, используйте команду  tee  вместо операторов  >  и  >> .
 Чтобы использовать команду  tee , вы должны направить вывод выполняемой команды, например  ls  , на команду  tee  , с помощью оператора трубы вертикальный стержень (  |  ). Например, следующая команда берет выходные данные команды  ls  и передает их команде  tee . Затем команда  tee  отправляет эти выходные данные на экран и в файл, который вы указываете, используя полный путь к файлу.
 лс | тройник /Пользователи/lorikaufman/TerminalOutput/ls_output. txt 
 Приведенная выше команда заменяет все содержимое в файле или создает новый, если он не существует, точно так же, как  >  оператор. Мы использовали следующую команду  cat  для просмотра содержимого нашего файла в окне терминала.
 кот /Users/lorikaufman/TerminalOutput/ls_output.txt 
 Чтобы использовать команду  tee  для вывода вывода на экран и добавления его в конец файла, введите следующую команду. Здесь мы добавляем полную информацию о системе в конец файла с помощью команды  uname -a , точно так же, как мы делали это с оператором  >> , но также отправляем вывод на экран.
 имя-а | tee -a /Users/lorikaufman/TerminalOutput/ls_output.txt 
 Следующая команда представляет собой версию  tee  для рекурсивной печати дерева каталогов в файл и на экран, по одному файлу в каждой строке, точно так же, как мы делали с оператором  > .
 лс-1Р | тройник /Пользователи/lorikaufman/TerminalOutput/dir_tree.txt 
 Затем мы снова используем команду  cat  для просмотра содержимого файла.
 кот /Users/lorikaufman/TerminalOutput/dir_tree.txt 
 Но подождите, есть еще 
 Существует множество других способов перенаправить вывод, включая ошибки, в файл. Вы можете прочитать о различных операторах и командах, используемых для перенаправления вывода, в главе «Перенаправление ввода-вывода» Advanced Bash Scripting Guide.
 Пользователи Mac также должны добавить в закладки нашу памятку по командам Mac Terminal.
 Как сохранить вывод терминала в файл в Linux 
 Терминал является сердцем системы Linux. Каждая программа, работающая в Linux, работает в командной строке терминала. Это включает в себя массивные программы, такие как веб-браузеры, и даже простые, такие как текстовые редакторы. Таким образом, умение правильно использовать терминал является важным шагом, если вы хотите понять, как работает операционная система.
 При этом, работая на терминале Linux, вы можете захотеть сохранить вывод терминала команды в файл. Этот файл можно использовать как информацию для другой операции или просто для регистрации активности терминала. В этой статье рассказывается о пяти способах сохранения вывода терминала в файл.
 Содержимое 
 1. Использовать определенные терминалы
 2. Перенаправление вывода
 3. Тройник
 4. Сценарий
 5. Захват терминала фреймбуфера
 Часто задаваемые вопросы
 1. Используйте определенные терминалы 
 Первый способ решения этой проблемы — использование терминала, поддерживающего сохранение вывода в файл. Например, терминал Konsole, который поставляется со стандартной установкой KDE, включает возможность записи вывода в файл.
 Для этого нажмите кнопку «Файл» в строке меню и выберите «Сохранить вывод как…».
 Откроется диалоговое окно, в котором можно сохранить вывод терминала. Оттуда вы можете выбрать, где вы хотите сохранить файл.
 Вы также можете сохранить вывод команды в терминале GNOME. Просто щелкните правой кнопкой мыши терминал и нажмите «Копировать вывод как HTML». Это загрузит текст терминала в буфер обмена. Оттуда вы можете вставить его в любой текстовый редактор.
 2. Перенаправление вывода 
 Другим способом решения этой проблемы является использование встроенных операторов оболочки UNIX. Это функции по умолчанию в Linux, которые могут перенаправлять текстовый вывод программы в файл. Есть три оператора, которые могут это сделать:
 Оператор  >  создаст или заменит содержимое файла выводом вашей программы. Это полезно, если вы хотите сбросить и просмотреть текущий результат вашей программы в тот же файл.
 Оператор  >>  также создаст файл с выводом вашей программы. Однако этот оператор только добавит вывод, а не заменит его. Это полезно, если вы хотите постоянно сбрасывать результат своей программы в один файл.
 Наконец, оператор  2>  — это оператор особого типа, который печатает ошибки, о которых будет сообщено. Это очень полезно во время отладки, так как показывает проблему, с которой столкнулась программа перед сбоем.
 Зная это, вы можете использовать эти операторы, добавляя их в конец вашей программы. Рассмотрим следующий пример:
 echo "сделать проще" > hello.txt 
 Я дал указание программе  echo  вывести слово "сделать проще", затем добавил  >  оператор, а также имя файла. Это указывало оболочке UNIX записывать вывод в файл «hello.txt», а не печатать его на экране.
 3. Tee 
 Помимо перенаправления вывода, вы также можете сохранить вывод команды терминала с помощью программы под названием  tee  . Это программа GNU, которая позволяет вам читать и писать в стандартный ввод. Используйте эту программу с каналами UNIX для записи вывода команды в файл.
 Рассмотрим следующий пример:
 эхо "упростить" | tee hello. txt 
 Здесь вместо перенаправления вывода я перенаправил (  |  ) вывод на  tee  .
  Примечание  : Конвейер принимает выходные данные одной программы и передает их на вход другой. Это позволяет вам склеивать вместе несколько программ, если все они используют стандартные входы и выходы.
 4. Скрипт 
 Другой способ получения вывода из терминала через скрипт   , встроенная программа Linux, которая записывает все, что вы вводите в терминале, а также его вывод.
 Вы можете использовать сценарий для записи журнала сеанса терминала в текстовом формате, который можно синтаксически анализировать. Это очень полезно, если вы хотите отправить журнал ошибок онлайн, чтобы получить поддержку от других людей.
 Чтобы использовать его, выполните следующую команду:
 имя_файла_сценария.txt 
 Это запустит среду сценариев, в которой вы сможете просто запускать команды. Однако важно отметить, что сценарий фиксирует все, что вы делаете в этом сеансе. Рассмотрим следующий пример:
 Сценарий запущен 27 марта 2022 г. 18:02:29+08:00 [TERM="rxvt-unicode-256color" TTY="/dev/pts/2" COLUMNS="77" LINES="22"]
[?2004h[[1;31m balaraw:[1;35m~ [0m]$ ls
[?2004l
[0m[01;34mDesktop[0m [01;34mЗагрузки[0m [01;34mmail[0m [01;34mНовости][0m [01;34mpods[0m [01;34mdocuments][0m [00;32mhello.txt[0m [01;34mMail] [0m [01;34mppics[0m [01;34mtmp[0m [01;34mvids[0m
[?2004h[[1;31m balaraw:[1;35m~ [0m]$ выход
[?2004l
выход
 
Скрипт выполнен 27.03.2022 18:03:19+08:00 [COMMAND_EXIT_CODE="0"] 
 Сценарий включает все нажатия клавиш и управляющие символы, которые вы нажимаете. В моем случае это включало все «невидимые» клавиши, которые я нажимал, в том числе  Tab  и  Backspace  нажатия клавиш.
 После завершения сеанса введите  exit  . Это завершит программу Script и запишет весь журнал в указанный вами файл.
 5. Захват терминала фреймбуфера 
 Наконец, вы также можете получить вывод терминала, извлекая данные из фреймбуфера Linux. Это полезно, если вы работаете непосредственно с телетайпом и хотите зафиксировать вывод программы.
 Чтобы захватить устройство фреймбуфера, выполните следующую команду, находясь в телетайпе:
 cat /dev/fb0 > capture.raw 
 Важно отметить, что захват устройства фреймбуфера таким образом означает, что вы сбрасываете сырой байт фреймбуфера в файл. Чтобы просмотреть этот файл, вам нужно загрузить его в редактор изображений и вручную настроить цвет и глубину цвета. Мало того, что этот процесс занимает много времени, так еще и легко сделать это неправильно.
 Таким образом, одним из способов решения этой проблемы является использование сторонней программы, такой как fbgrab. Это захватит текущий экран телетайпа из устройства буфера кадра и выгрузит его в файл PPM или PNG.
 Установка fbgrab также относительно проста. В дистрибутивах на основе Debian и Ubuntu вы можете использовать apt:
 sudo apt install fbgrab 
 Для Arch Linux запустите pacman:
 sudo pacman -S fbgrab 
 Использование fbgrab для захвата вывода терминала 
 После установки перейдите к телетайп, нажав  Control  +  Shift  +  Alt  +  F3  , затем запустите  fbcat  или  fbgrab  .
 Fbcat — это более простая программа, которая захватывает текущий экран буфера кадра и сохраняет его в изображение PPM. Это низкоуровневый необработанный формат изображения, который вы можете загрузить в редактор изображений для преобразования в PNG. Fbcat в первую очередь полезен, если вы пытаетесь захватить дисплей с более низкой битовой глубиной, для правильного захвата которого требуется необработанный формат изображения.
 Чтобы выполнить захват с помощью программы fbcat, выполните следующую команду:
 fbcat > Capture.ppm 
 Это захватит отображаемый в данный момент экран и выгрузит содержимое в файл Capture.ppm.
 Fbgrab, с другой стороны, является более сложной программой, предназначенной для захвата изображений с более высокой битовой глубиной. По большей части вы будете использовать его для захвата экрана телетайпа. Он поддерживает сохранение в PNG по умолчанию и имеет возможность выбрать другой телетайп для захвата.
 Для захвата с помощью программы fbgrab выполните следующую команду:
 sudo fbgrab -c 3 capture. png 
 Это захватит третий экран телетайпа и сохранит его в файле capture.png.
 Если вы ищете дополнительные руководства для терминала Linux, ознакомьтесь с тем, что обсуждает отправку электронной почты из командной строки.
 Часто задаваемые вопросы 
 1. Помогите! Fbgrab не работает; изображение просто черное или пустое. 
 Вероятно, это связано с тем, что fbgrab использует другое устройство кадрового буфера для захвата вывода терминала. Проверьте текущее устройство кадрового буфера, используемое системой, указав папку «/dev».
 ls /dev 
 Оттуда найдите устройство «/dev/fbX». Обычно Linux использует «/dev/fb0» для своего фреймбуфера. Однако, если ваша система использует другой фреймбуфер, например «/dev/fb1», вы можете передать следующую команду, чтобы заставить fbgrab вместо этого извлекать данные из этого фреймбуфера:0005
 fbgrab -d 1 capture.png 
 2. Можно ли получить содержимое файла, который я написал в качестве входных данных для программы? 
 Да! Помимо трех операторов, описанных выше, вы также можете использовать оператор  <  для извлечения данных из файла. Затем оболочка будет рассматривать это как ввод для программы.
 Такой способ также избавляет от необходимости полагаться на другие программы для печати текста. Рассмотрим следующие примеры:
 [1] cat test.txt | программа
[2] программа < test.txt 
 В первом примере вызывается программа cat для загрузки текста, затем загружается оператор конвейера с выводом cat и передается вашей программе.
 С другой стороны, второй пример немедленно вызывает вашу программу, затем выбирает оператор  < , который обрабатывает следующий аргумент как входные данные.
 3. Есть ли способ заставить сценарий записывать только вывод команды? 
 Да, сценарий можно использовать только для одной команды. Это очень полезно при устранении неполадок, когда вы просто хотите зафиксировать вывод одной программы. Сделайте это, выполнив следующую команду:
 script -c "ваша-команда" test.txt 
 Флаг  -c  указывает программе-скрипту запускать только программу: ваша-команда. Оттуда он запишет свой вывод в текстовый файл с именем test.txt.
  Изображение предоставлено: Unsplash 
 Полезна ли эта статья?
 Подпишитесь на нашу рассылку!
 Наши последние учебные пособия доставляются прямо на ваш почтовый ящик
 Подпишитесь на все информационные бюллетени.
  Регистрируясь, вы соглашаетесь с нашей Политикой конфиденциальности, а европейские пользователи соглашаются с политикой передачи данных. Мы не будем передавать ваши данные, и вы можете отказаться от подписки в любое время. 
 Facebook
 Твитнуть
 Как выполнить вывод в файл с помощью PowerShell Out-File — LazyAdmin 
 Вывод команд PowerShell по умолчанию отображается в терминале. Но в некоторых ситуациях полезнее перенаправить вывод в файл в PowerShell. Для этого воспользуемся командлетом Out-File.
 Существуют различные способы вывода результатов сценария или команды PowerShell в файл. Можно даже показать вывод в терминале и одновременно экспортировать его в файл. А знаете ли вы, что вы также можете экспортировать только результаты успеха, предупреждения или ошибки?
 В этой статье
 1
 В этой статье мы рассмотрим, как записать вывод в файл в PowerShell. Я также объясню, как вы можете добавить к существующему файлу или как вы можете создать файл журнала.
 Запись вывода Powershell в файл

Существует несколько способов записи вывода PowerShell в файл. Наиболее распространенными способами являются использование командлета Out-File или оператора перенаправления > . Другие варианты - использовать 9Командлет 0021 Set-Content и Add-Content . Мы собираемся сосредоточиться на первых двух, но я кратко упомяну альтернативу, если она уместна.

Командлет Out-File и оператор перенаправления > позволяют записывать и добавлять ( >> ) выходные данные PowerShell в файл. Разница между ними в том, что первый принимает параметры, а второй нет.

С командлетом Out-File мы можем использовать следующие параметры:

Parameter Description

-Filepath Set the location and name of the file

-Append Append the output to the existing content of the file

- Принудительно Перезаписать файл только для чтения

-NoClobber Предотвратить перезапись файла

-NoNewLine Символ новой строки не будет записан.

-Width Ограничение количества символов на каждой строке (по умолчанию 80)

-Whatif

Оператор.

однако не имеет никаких параметров. Но у него есть преимущество по сравнению с Out-File. При использовании командлета Out-File экспортируются только успешные результаты, поэтому предупреждения или ошибки не будут записаны в файл.

При использовании оператора перенаправления, когда можно указать, какой поток мы хотим экспортировать:

44 7 4>9161246 Verbose only

Оператор	Описание / Поток	Согласованность

97467469746746979797979797
2>	Только ошибка	Ошибка записи
3>	Только предупреждение	Предупреждение записи
Write-Verbose
5>	Debug only	Write-Debug
6>	Information only	Write-Information
*>	All

Оператор перенаправления PowerShell

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

Чтобы записать вывод в файл, все, что вам нужно сделать, это передать Out- Файл командлета позади вашего скрипта или команды и укажите путь. Если файл не существует, то он будет создан командлетом:

 Get-Process -Name explorer | Out-File -FilePath c:\temp\process.txt
# Такой же как:
Get-Process -Имя проводника > c:\temp\process.txt
# Результаты, достижения
 Get-Content C:\temp\process.txt
 NPM(K) PM(M) WS(M) CPU(s) Id SI ProcessName
 ------ ----- ----- ------ -- -- -----------
    132 94,56 158,22 131,45 123364 1 исследователь
PS С:\>

Как видите, результаты выполнения командлета Get-Process сохраняются в файле process.txt:

Powershell Output to File

оператор перезапишет любой существующий файл по умолчанию. Мы можем предотвратить это, добавив параметр -NoClobber в командлет

 Get-Process -Name explorer | Out-File c:\temp\process. txt -NoClobber

Обратите внимание, что вы не можете предотвратить перезапись с помощью оператора перенаправления

Если файл уже существует, то будет выдано сообщение об ошибке:

Не перезаписывать существующие файлы

Если вы хотите выводить в файл внутри скрипта, я рекомендую сначала использовать командлет Test-Path для определить, существует ли уже файл. Таким образом, вы можете написать лучшее решение, например добавить дату к имени файла, вместо того, чтобы просто пытаться писать в него:

 $exportPath = "C:\temp\process.txt"
Если (тестовый путь $exportPath) {
    # Показать предупреждение или изменить имя файла здесь
    Пишет-Предупреждение "Файл уже существует"
    $exportPath = "C:\temp\process-1.txt" # создайте что-нибудь красивое с указанием даты или времени
}еще{
    Проводник Get-Process -Name | Выходной файл $exportPath -NoClobber
}

PowerShell Добавить в файл

Вместо перезаписи мы также можем добавить вывод к существующему содержимому файла. Для этого мы можем либо использовать параметр -append , либо использовать оператор перенаправления >>. В обоих случаях содержимое вывода будет добавлено в существующий файл.

Вы также можете добавить к несуществующему файлу, оба метода создадут новый файл, если указанный файл не существует.

 # Добавление с помощью командлета Out-File
'Яблоко' | Out-File -FilePath C:\temp\fruits.txt -Append
Get-Content -Путь c:\temp\fruits.txt
# Результат
Яблоко
# Добавляем оператор перенаправления
'Груша' >> C:\temp\fruits.txt
Get-Content -Путь c:\temp\fruits.txt
# Результат
Яблоко
Груша

При добавлении вывода к существующему файлу содержимое будет помещено в новую строку. Если вы хотите разместить содержимое в одной строке, создав одну длинную строку, вам потребуется использовать командлет Out-File с параметром -NoNewLine .

Символ новой строки помещается после значения, которое вы добавили в файл. Поэтому важно также добавить параметр -NoNewLine в первый вывод.

 # Обратите внимание, что вам нужно будет указать NoNewLine и для первой записи
'Черника;' | Out-File -FilePath C:\temp\fruits.txt -NoNewline
# Добавляем больше ягод
'Клубника;' | Out-File -FilePath C:\temp\fruits.txt -Append -NoNewline
'Ежевика;' | Out-File -FilePath C:\temp\fruits.txt -Append -NoNewline
'Малина;' | Out-File -FilePath C:\temp\fruits.txt -Append -NoNewline
'Клюква;' | Out-File -FilePath C:\temp\fruits.txt -Append -NoNewline

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

Добавить в файл без новой строки

Использование PowerShell Add-Content

Другой способ добавить содержимое в файл — использовать командлет Add-Content. Одним из самых больших преимуществ командлета Add-Content является то, что он позволяет добавлять содержимое сразу в несколько файлов.

Как и в случае с командлетом Out-File и оператором перенаправления, командлет Add-Content создает новый файл, если файл не существует.

Таким образом, чтобы просто добавить содержимое в файл, мы можем использовать следующую команду:

 Add-Content -Path c:\temp\file.txt -Value «Новая строка для добавления»

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

В приведенном ниже примере текущая дата будет добавлена ко всем файлам TXT по пути c:\temp\files, кроме файла с readme в имени файла:

 Add-Content -Path C:\temp\files\*. txt -Value (Get-Date) -Exclude "readme*"

Все файлы, кроме файлов readme, обновлены:

PowerShell Add-Content

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

Если мы возьмем приведенный выше пример, мы также можем использовать параметр фильтра для выбора только файлов, содержащих слово log:

 Add-Content -Path C:\temp\files\* -Value (Get-Date) -Фильтр "*лог*"

Записывать в файл только ошибки, предупреждения или успех

Командлет out-file записывает в файл только успешный результат вашей команды или сценария. Но иногда вы также хотите, чтобы выводились предупреждения или ошибки.

Для этого мы можем использовать оператор перенаправления. Это позволяет вам указать, какой поток вы хотите вывести в файл.

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

 Функция Get-ProcessCpu {
    параметр(
        [Параметр(обязательный = $true)]$имя
    )
    Get-Process -Name $имя | выберите процессор
}
Get-ProcessCpu -name "explorer2" | Исходящий файл C:\temp\process.txt

Процесс Explorer2 не существует, поэтому командлет Get-Process выдаст ошибку. Если мы запустим скрипт таким образом, то файл process.txt будет полностью пуст.

Однако, если мы используем оператор перенаправления, мы можем указать, какой поток мы хотим вывести.

 # Записать все результаты в файл:
Get-ProcessCpu -name "explorer2" *> C:\temp\process. txt
# Записать в файл только ошибку:
Get-ProcessCpu -name "explorer2" 2> C:\temp\process-error-log.txt
# Записывать в файл только предупреждения:
Get-ProcessCpu -name "explorer2" 3> C:\temp\process-error-log.txt

Как видите, ошибка записывается в текстовый файл с помощью оператора перенаправления:

Powershell Write to Log File

Наилучший вариант для записи в log файл — использовать Start-Transcript командлет, но мы также можем написать собственную функцию журнала, используя командлет Add-Content или оператор перенаправления.

Использование оператора перенаправления ограничит ваши возможности, но это отличный способ, если вы хотите записывать только ошибки сценария в файл журнала:

 Функция Get-ProcessCpu {
    параметр(
        [Параметр(обязательный = $true)]$имя
    )
    Get-Process -Name $имя | выберите процессор
}
# Записывать в лог-файл только ошибки
Get-ProcessCpu -name "explorer2" 2>> "C:\temp\files\$env:computername-process. log"

Но когда вы записываете сообщения в лог-файл, вы, вероятно, хотите иметь немного больше контроля. С файлами журнала важно, чтобы мы могли видеть, когда произошло событие и серьезность события. Итак, что мы хотим сделать, это добавить метку времени и уровень события в сообщение журнала.

Таким образом, мы можем легко прочитать файл журнала и идентифицировать любые возникшие ошибки.

 # Установить путь к файлу журнала
$logFile = "C:\temp\files\$env:имя_компьютера-процесс.log"
Функция записи в журнал {
 параметр(
 [Параметр(обязательный = $true)][строка] $сообщение,
 [Параметр (обязательный = $false)]
 [ValidateSet("ИНФО","ПРЕДУПРЕЖДЕНИЕ","ОШИБКА")]
 [строка] $level = "ИНФОРМАЦИЯ"
 )
 # Создать временную метку
 $timestamp = (Get-Date).
Навигация по записям
Список устройств usb linux: Как посмотреть USB устройства Linux
Обзор nikon 1 s1: Проще некуда. Обзор системной камеры Nikon 1 S1 — Ferra.ru
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Комментарий *
Имя * 
Email * 
Сайт 
  
  Найти:   
Рубрики
1С
1С Обучение
Access
Adobe
Coreldraw
Delphi
Excel
Mathcad
Microsoft Access
Microsoft Excel
Microsoft Word
Sql
Word
Без рубрики
Изучение Delphi
Разное
Советы и лайфхаки
Уроки по Adobe
Уроки по CorelDRAW
Уроки по Mathcad
Уроки по Sql
Фотошкола
2019 © Все права защищены. Карта сайта