- Перевод
Если вы уже освоились с основами терминала, возможно, вы уже готовы к тому, чтобы комбинировать изученные команды. Иногда выполнения команд оболочки по одной вполне достаточно для решения некоей задачи, но в некоторых случаях вводить команду за командой слишком утомительно и нерационально. В подобной ситуации нам пригодятся некоторые особые символы, вроде угловых скобок.
Для оболочки, интерпретатора команд Linux, эти дополнительные символы - не пустая трата места на экране. Они - мощные команды, которые могут связывать воедино различные фрагменты информации, разделять то, что было до этого цельным, и делать ещё много всего. Одна из самых простых, и, в то же время, мощных и широко используемых возможностей оболочки - это перенаправление стандартных потоков ввода/вывода.
Три стандартных потока ввода/вывода
Для того, чтобы понять то, о чём мы будем тут говорить, важно знать, откуда берутся данные, которые можно перенаправлять, и куда они идут. В Linux существует три стандартных потока ввода/вывода данных.Первый - это стандартный поток ввода (standard input). В системе это - поток №0 (так как в компьютерах счёт обычно начинается с нуля). Номера потоков ещё называют дескрипторами. Этот поток представляет собой некую информацию, передаваемую в терминал, в частности - инструкции, переданные в оболочку для выполнения. Обычно данные в этот поток попадают в ходе ввода их пользователем с клавиатуры.
Второй поток - это стандартный поток вывода (standard output), ему присвоен номер 1. Это поток данных, которые оболочка выводит после выполнения каких-то действий. Обычно эти данные попадают в то же окно терминала, где была введена команда, вызвавшая их появление.
И, наконец, третий поток - это стандартный поток ошибок (standard error), он имеет дескриптор 2. Этот поток похож на стандартный поток вывода, так как обычно то, что в него попадает, оказывается на экране терминала. Однако, он, по своей сути, отличается от стандартного вывода, как результат, этими потоками, при желании, можно управлять раздельно. Это полезно, например, в следующей ситуации. Есть команда, которая обрабатывает большой объём данных, выполняя сложную и подверженную ошибкам операцию. Нужно, чтобы полезные данные, которые генерирует эта команда, не смешивались с сообщениями об ошибках. Реализуется это благодаря раздельному перенаправлению потоков вывода и ошибок.
Как вы, вероятно, уже догадались, перенаправление ввода/вывода означает работу с вышеописанными потоками и перенаправление данных туда, куда нужно программисту. Делается это с использованием символов > и < в различных комбинациях, применение которых зависит от того, куда, в итоге, должны попасть перенаправляемые данные.
Перенаправление стандартного потока вывода
Предположим, вы хотите создать файл, в который будут записаны текущие дата и время. Дело упрощает то, что имеется команда, удачно названная date , которая возвращает то, что нам нужно. Обычно команды выводят данные в стандартный поток вывода. Для того, чтобы эти данные оказались в файле, нужно добавить символ > после команды, перед именем целевого файла. До и после > надо поставить пробел.При использовании перенаправления любой файл, указанный после > будет перезаписан. Если в файле нет ничего ценного и его содержимое можно потерять, в нашей конструкции допустимо использовать уже существующий файл. Обычно же лучше использовать в подобном случае имя файла, которого пока не существует. Этот файл будет создан после выполнения команды. Назовём его date.txt . Расширение файла после точки обычно особой роли не играет, но расширения помогают поддерживать порядок. Итак, вот наша команда:
$ date > date.txt
Нельзя сказать, что сама по себе эта команда невероятно полезна, однако, основываясь на ней, мы уже можем сделать что-то более интересное. Скажем, вы хотите узнать, как меняются маршруты вашего трафика, идущего через интернет к некоей конечной точке, ежедневно записывая соответствующие данные. В решении этой задачи поможет команда traceroute , которая сообщает подробности о маршруте трафика между нашим компьютером и конечной точкой, задаваемой при вызове команды в виде URL. Данные включают в себя сведения обо всех маршрутизаторах, через которые проходит трафик.
Так как файл с датой у нас уже есть, будет вполне оправдано просто присоединить к этому файлу данные, полученные от traceroute . Для того, чтобы это сделать, надо использовать два символа > , поставленные один за другим. В результате новая команда, перенаправляющая вывод в файл, но не перезаписывающая его, а добавляющая новые данные после старых, будет выглядеть так:
$ traceroute google.com >> date.txt
Теперь нам осталось лишь изменить имя файла на что-нибудь более осмысленное, используя команду mv , которой, в качестве первого аргумента, передаётся исходное имя файла, а в качестве второго - новое:
$ mv date.txt trace1.txt
Перенаправление стандартного потока ввода
Используя знак < вместо > мы можем перенаправить стандартный ввод, заменив его содержимым файла.Предположим, имеется два файла: list1.txt и list2.txt , каждый из которых содержит неотсортированный список строк. В каждом из списков имеются уникальные для него элементы, но некоторые из элементов список совпадают. Мы можем найти строки, которые имеются и в первом, и во втором списках, применив команду comm , но прежде чем её использовать, списки надо отсортировать.
Существует команда sort , которая возвращает отсортированный список в терминал, не сохраняя отсортированные данные в файл, из которого они были взяты. Можно отправить отсортированную версию каждого списка в новый файл, используя команду > , а затем воспользоваться командой comm . Однако, такой подход потребует как минимум двух команд, хотя то же самое можно сделать в одной строке, не создавая при этом ненужных файлов.
Итак, мы можем воспользоваться командой < для перенаправления отсортированной версии каждого файла команде comm . Вот что у нас получилось:
$ comm <(sort list1.txt) <(sort list2.txt)
Круглые скобки тут имеют тот же смысл, что и в математике. Оболочка сначала обрабатывает команды в скобках, а затем всё остальное. В нашем примере сначала производится сортировка строк из файлов, а потом то, что получилось, передаётся команде comm , которая затем выводит результат сравнения списков.
Перенаправление стандартного потока ошибок
И, наконец, поговорим о перенаправлении стандартного потока ошибок. Это может понадобиться, например, для создания лог-файлов с ошибками или объединения в одном файле сообщений об ошибках и возвращённых некоей командой данных.Например, что если надо провести поиск во всей системе сведений о беспроводных интерфейсах, которые доступны пользователям, у которых нет прав суперпользователя? Для того, чтобы это сделать, можно воспользоваться мощной командой find .
Обычно, когда обычный пользователь запускает команду find по всей системе, она выводит в терминал и полезные данные и ошибки. При этом, последних обычно больше, чем первых, что усложняет нахождение в выводе команды того, что нужно. Решить эту проблему довольно просто: достаточно перенаправить стандартный поток ошибок в файл, используя команду 2> (напомним, 2 - это дескриптор стандартного потока ошибок). В результате на экран попадёт только то, что команда отправляет в стандартный вывод:
$ find / -name wireless 2> denied.txt
Как быть, если нужно сохранить результаты работы команды в отдельный файл, не смешивая эти данные со сведениями об ошибках? Так как потоки можно перенаправлять независимо друг от друга, в конец нашей конструкции можно добавить команду перенаправления стандартного потока вывода в файл:
$ find / -name wireless 2> denied.txt > found.txt
Обратите внимание на то, что первая угловая скобка идёт с номером - 2> , а вторая без него. Это так из-за того, что стандартный вывод имеет дескриптор 1, и команда > подразумевает перенаправление стандартного вывода, если номер дескриптора не указан.
И, наконец, если нужно, чтобы всё, что выведет команда, попало в один файл, можно перенаправить оба потока в одно и то же место, воспользовавшись командой &> :
$ find / -name wireless &> results.txt
Итоги
Тут мы разобрали лишь основы механизма перенаправления потоков в интерпретаторе командной строки Linux, однако даже то немногое, что вы сегодня узнали, даёт вам практически неограниченные возможности. И, кстати, как и всё остальное, что касается работы в терминале, освоение перенаправления потоков требует практики. Поэтому рекомендуем вам приступить к собственным экспериментам с > и < .Уважаемые читатели! Знаете ли вы интересные примеры использования перенаправления потоков в Linux, которые помогут новичкам лучше освоиться с этим приёмом работы в терминале?
В системе по-умолчанию всегда открыты три "файла" — (клавиатура), (экран) и (вывод сообщений об ошибках на экран). Эти, и любые другие открытые файлы, могут быть перенапрвлены. В данном случае, термин "перенаправление" означает получить вывод из файла, команды, программы, сценария или даже отдельного блока в сценарии (см. Пример 3-1 и Пример 3-2) и передать его на вход в другой файл, команду, программу или сценарий.
С каждым открытым файлом связан дескриптор файла. Дескрипторы файлов, и — 0, 1 и 2, соответственно. При открытии дополнительных файлов, дескрипторы с 3 по 9 остаются незанятыми. Иногда дополнительные дескрипторы могут сослужить неплохую службу, временно сохраняя в себе ссылку на, или. Это упрощает возврат дескрипторов в нормальное состояние после сложных манипуляций с перенаправлением и перестановками (см. Пример 16-1).
COMMAND_OUTPUT > # Перенаправление stdout (вывода) в файл. # Если файл отсутствовал, то он создется, иначе — перезаписывается. ls -lR > dir-tree.list # Создает файл, содержащий список дерева каталогов. : > filename # Операция > усекает файл "filename" до нулевой длины. # Если до выполнения операции файла не существовало, # то создается новый файл с нулевой длиной (тот же эффект дает команда "touch"). # Символ: выступает здесь в роли местозаполнителя, не выводя ничего. > filename # Операция > усекает файл "filename" до нулевой длины. # Если до выполнения операции файла не существовало, # то создается новый файл с нулевой длиной (тот же эффект дает команда "touch"). # (тот же результат, что и выше — ": >", но этот вариант неработоспособен # в некоторых командных оболочках.) COMMAND_OUTPUT >> # Перенаправление stdout (вывода) в файл. # Создает новый файл, если он отсутствовал, иначе — дописывает в конец файла. # Однострочные команды перенаправления # (затрагивают только ту строку, в которой они встречаются): # ——————————————————————— 1>filename # Перенаправление вывода (stdout) в файл "filename". 1>>filename # Перенаправление вывода (stdout) в файл "filename", файл открывается в режиме добавления. 2>filename # Перенаправление stderr в файл "filename". 2>>filename # Перенаправление stderr в файл "filename", файл открывается в режиме добавления. &>filename # Перенаправление stdout и stderr в файл "filename". #============================================================================== # Перенаправление stdout, только для одной строки. LOGFILE=script.log echo "Эта строка будет записана в файл \"$LOGFILE\"." 1>$LOGFILE echo "Эта строка будет добавлена в конец файла \"$LOGFILE\"." 1>>$LOGFILE echo "Эта строка тоже будет добавлена в конец файла \"$LOGFILE\"." 1>>$LOGFILE echo "Эта строка будет выведена на экран и не попадет в файл \"$LOGFILE\"." # После каждой строки, сделанное перенаправление автоматически "сбрасывается". # Перенаправление stderr, только для одной строки. ERRORFILE=script.errors bad_command1 2>$ERRORFILE # Сообщение об ошибке запишется в $ERRORFILE. bad_command2 2>>$ERRORFILE # Сообщение об ошибке добавится в конец $ERRORFILE. bad_command3 # Сообщение об ошибке будет выведено на stderr, #+ и не попадет в $ERRORFILE. # После каждой строки, сделанное перенаправление также автоматически "сбрасывается". #============================================================================== 2>&1 # Перенаправляется stderr на stdout. # Сообщения об ошибках передаются туда же, куда и стандартный вывод. i> i
в j
. # Вывод в файл с дескриптором i
передается в файл с дескриптором j
. >&j # Перенаправляется файл с дескриптором 1
(stdout) в файл с дескриптором j
. # Вывод на stdout передается в файл с дескриптором j
. 0< FILENAME < FILENAME # Ввод из файла. # Парная команде ">", часто встречается в комбинации с ней. # # grep search-word
Операции перенаправления и/или конвейеры могут комбинироваться в одной командной строке.
command < input-file > output-file command1 | command2 | command3 > output-file См. Пример 12-23 и Пример A-17.
Допускается перенаправление нескольких потоков в один файл.
ls -yz >> command.log 2>&1 # Сообщение о неверной опции "yz" в команде "ls" будет записано в файл "command.log". # Поскольку stderr перенаправлен в файл.
Закрытие дескрипторов файлов
Закрыть дескриптор входного файла.
0<&-, <&-
Закрыть дескриптор выходного файла.
1>&-, >&-
Дочерние процессы наследуют дескрипторы открытых файлов. По этой причине и работают конвейеры. Чтобы предотвратить наследование дескрипторов — закройте их перед запуском дочернего процесса.
# В конвейер передается только stderr. exec 3>&1 # Сохранить текущее "состояние" stdout. ls -l 2>&1 >&3 3>&- | grep bad 3>&- # Закрыть дескр. 3 для "grep" (но не для "ls"). # ^^^^ ^^^^ exec 3>&- # Теперь закрыть его для оставшейся части сценария. # Спасибо S.C.
Дополнительные сведения о перенаправлении ввода/вывода вы найдете в Приложение D.
16.1. С помощью команды exec
Команда exec
Пример 16-1. Перенаправление с помощью exec
#!/bin/bash # Перенаправление stdin с помощью "exec". exec 6<&0 # Связать дескр. #6 со стандартным вводом (stdin). # Сохраняя stdin. exec < data-file # stdin заменяется файлом "data-file" read a1 # Читается первая строка из "data-file". read a2 # Читается вторая строка из "data-file." echo echo "Следующие строки были прочитаны из файла." echo "——————————————" echo $a1 echo $a2 echo; echo; echo exec 0<&6 6<&- # Восстанавливается stdin из дескр. #6, где он был предварительно сохранен, #+ и дескр. #6 закрывается (6<&-) освобождая его для других процессов. # # <&6 6<&- дает тот же результат. echo -n "Введите строку " read b1 # Теперь функция "read", как и следовало ожидать, принимает данные с обычного stdin. echo "Строка, принятая со stdin." echo "—————————" echo "b1 = $b1" echo exit 0
Аналогично, конструкция exec >filename перенаправляет вывод на в заданный файл. После этого, весь вывод от команд, который обычно направляется на, теперь выводится в этот файл.
Пример 16-2. Перенаправление с помощью exec
#!/bin/bash # reassign-stdout.sh LOGFILE=logfile.txt exec 6>&1 # Связать дескр. #6 со stdout. # Сохраняя stdout. exec > $LOGFILE # stdout замещается файлом "logfile.txt". # ———————————————————— # # Весь вывод от команд, в данном блоке, записывается в файл $LOGFILE. echo -n "Logfile: " date echo "————————————-" echo echo "Вывод команды \"ls -al\"" echo ls -al echo; echo echo "Вывод команды \"df\"" echo df # ———————————————————— # exec 1>&6 6>&- # Восстановить stdout и закрыть дескр. #6. echo echo "== stdout восстановлено в значение по-умолчанию == " echo ls -al echo exit 0
Пример 16-3. Одновременное перенаправление устройств, и, с помощью команды exec
#!/bin/bash # upperconv.sh # Преобразование символов во входном файле в верхний регистр. E_FILE_ACCESS=70 E_WRONG_ARGS=71 if [ ! -r "$1" ] # Файл доступен для чтения? then echo "Невозможно прочитать из заданного файла!" echo "Порядок использования: $0 input-file output-file" exit $E_FILE_ACCESS fi # В случае, если входной файл ($1) не задан #+ код завершения будет этим же. if [ -z "$2" ] then echo "Необходимо задать выходной файл." echo "Порядок использования: $0 input-file output-file" exit $E_WRONG_ARGS fi exec 4<&0 exec < $1 # Назначить ввод из входного файла. exec 7>&1 exec > $2 # Назначить вывод в выходной файл. # Предполагается, что выходной файл доступен для записи # (добавить проверку?). # ———————————————— cat — | tr a-z A-Z # Перевод в верхний регистр # ^^^^^ # Чтение со stdin. # ^^^^^^^^^^ # Запись в stdout. # Однако, и stdin и stdout были перенаправлены. # ———————————————— exec 1>&7 7>&- # Восстановить stdout. exec 0<&4 4<&- # Восстановить stdin. # После восстановления, следующая строка выводится на stdout, чего и следовало ожидать. echo "Символы из \"$1\" преобразованы в верхний регистр, результат записан в \"$2\"." exit 0
Next: Перенаправление ошибок в файл Up: Перенаправление ввода-вывода Previous: Перенаправление ввода из файла Contents Index
Перенаправление вывода в файл
Для перенаправления стандартного вывода в файл используйте оператор `>’.
Перенаправление ввода/вывода в Linux
Укажите после имени команды оператор >, а затем имя файла, который будет служить приемником вывода. Например, чтобы записать вывод результатов работы программы в файл, введите:
Если Вы перенаправите стандартный вывод в уже существующий файл, он будет перезаписан с начала. Чтобы добавить стандартный вывод к содержимому существующего файла, необходимо использовать оператор `»’. Например, для добавления результатов работы при повторном запуске программы в файл, введите:
Alex Otwagin 2002-12-16
Программа обычно ценна тем, что может обрабатывать данные: принимать одно, на выходе выдавать другое, причём в качестве данных может выступать практически что угодно: текст, числа, звук, видео… Потоки входных и выходных данных для команды называются ввод и вывод . Потоков ввода и вывода у каждой программы может быть и по несколько. В каждый процесс, при создании в обязательном порядке получает так называемые стандартный ввод (standard input, stdin) и стандартный вывод (standard output, stdout) и стандартный вывод ошибок (standard error, stderr).
Стандартные потоки ввода/вывода предназначены в первую очередь для обмена текстовой информацией. Тут даже не важно, кто общается с помощью текстов: человек с программой или программы междй собой - главное, чтобы у них был канал передачи данных и чтобы они говорили «на одном языке».
Текстовый принцип работы с машиной позволяет отвлечься от конкретных частей компьютера, вроде системной клавиатуры и видеокарты с монитором, рассматривая единое оконечное устройство , посредством которого пользователь вводит текст (команды) и передаёт его системе, а система выводит необходимые пользователю данные и сообщения (диагностику и ошибки). Такое устройство называется терминалом . В общем случае терминал - это точка входа пользователя в систему, обладающая способностью передавать текстовую информацию. Терминалом может быть отдельное внешнее устройство, подключаемое к компьютеру через порт последовательной передачи данных (в персональном компьютере он называется «COM port»). В роли терминала может работать (с некоторой поддержкой со стороны системы) и программа (например, xterm или ssh). Наконец, виртуальные консоли - тоже терминалы, только организованные программно с помощью подходящих устройств современного компьютера.
При работе с командной строкой, стандартный ввод командной оболочки связан с клавиатурой, а стандартный вывод и вывод ошибок - с экраном монитора (или окном эмулятора терминала). Покажем на примере простейшей команды - cat. Обычно команда cat читает данные из всех файлов, которые указаны в качестве её параметров, и посылает считанное непосредственно в стандартный вывод (stdout). Следовательно, команда
/home/larry/papers# cat history-final masters-thesis
выведет на экран сначала содержимое файла, а затем - файла.
Однако если имя файла не указано, программа cat читает входные данные из stdin и немедленно возвращает их в stdout (никак не изменяя). Данные проходят через cat , как через трубу. Приведём пример:
/home/larry/papers# cat Hello there. Hello there. Bye. Bye. Ctrl —D /home/larry/papers#
Каждую строчку, вводимую с клавиатуры, программа cat немедленно возвращает на экран. При вводе информации со стандартного ввода конец текста сигнализируется вводом специальной комбинации клавиш, как правило Ctrl —D .
Приведём другой пример. Команда sort читает строки вводимого текста (также из stdin, если не указано ни одного имени файла) и выдаёт набор этих строк в упорядоченном виде на stdout. Проверим её действие.
/home/larry/papers# sort bananas carrots apples Ctrl+D apples bananas carrots /home/larry/papers#
Как видно, после нажатия Ctrl —D , sort вывела строки упорядоченными в алфавитном порядке.
Стандартный ввод и стандартный вывод
Допустим, вы хотите направить вывод команды sort в некоторый файл, чтобы сохранить упорядоченный по алфавиту список на диске. Командная оболочка позволяет перенаправить стандартный вывод команды в файл, используя символ. Приведём пример:
/home/larry/papers# sort > shopping-list bananas carrots apples Ctrl —D /home/larry/papers#
Можно увидеть, что результат работы команды sort не выводится на экран, однако он сохраняется в файле с именем. Выведем на экран содержимое этого файла:
/home/larry/papers# cat shopping-list apples bananas carrots /home/larry/papers#
Пусть теперь исходный неупорядоченный список находится в файле. Этот список можно упорядочить с помощью команды sort , если указать ей, что она должна читать из данного файла, а не из своего стандартного ввода, и кроме того, перенаправить стандартный вывод в файл, как это делалось выше. Пример:
/home/larry/papers# sort items shopping-list /home/larry/papers# cat shopping-list apples bananas carrots /home/larry/papers#
Однако можно поступить иначе, перенаправив не только стандартный вывод, но и стандартный ввод утилиты из файла, используя для этого символ:
/home/larry/papers# sort < items apples bananas carrots /home/larry/papers#
Результат команды sort < items эквивалентен команде sort items , однако первая из них демонстрирует следующее: при выдаче команды sort < items система ведёт себя так, как если бы данные, которые содержатся в файле, были введены со стандартного ввода. Перенаправление осуществляется командной оболочкой. Команде sort не сообщалось имя файла: эта команда читала данные из своего стандартного ввода, как если бы мы вводили их с клавиатуры.
Введём понятие фильтра . Фильтром является программа, которая читает данные из стандартного ввода, некоторым образом их обрабатывает и результат направляет на стандартный вывод. Когда применяется перенаправление, в качестве стандартного ввода и вывода могут выступать файлы. Как указывалось выше, по умолчанию, stdin и stdout относятся к клавиатуре и к экрану соответственно. Программа sort является простым фильтром - она сортирует входные данные и посылает результат на стандартный вывод. Совсем простым фильтром является программа cat - она ничего не делает с входными данными, а просто пересылает их на выход.
Выше уже демонстрировалось, как использовать программу sort в качестве фильтра. В этих примерах предполагалось, что исходные данные находятся в некотором файле или что эти исходные данные будут введены с клавиатуры (стандартного ввода). Однако как поступить, если вы хотите отсортировать данные, которые являются результатом работы какой-либо другой команды, например, ls ?
Будем сортировать данные в обратном алфавитном порядке; это делается опцией команды sort . Если вы хотите перечислить файлы в текущем каталоге в обратном алфавитном порядке, один из способов сделать это будет таким.
Перенаправление ввода-вывода
Применим сначала команду ls :
/home/larry/papers# ls english-list history-final masters-thesis notes /home/larry/papers#
Теперь перенаправляем выход команды ls в файл с именем file-list
/home/larry/papers# ls > file-list /home/larry/papers# sort -r file-list notes masters-thesis history-final english-list /home/larry/papers#
Здесь выход команды ls сохранен в файле, а после этого этот файл был обработан командой sort . Однако этот путь является неизящным и требует использования временного файла для хранения выходных данных программы ls .
Решением в данной ситуации может служить создание состыкованных команд (pipelines). Стыковку осуществляет командная оболочка, которая stdout первой команды направляет на stdin второй команды. В данном случае мы хотим направить stdout команды ls на stdin команды sort . Для стыковки используется символ, как это показано в следующем примере:
/home/larry/papers# ls | sort -r notes masters-thesis history-final english-list /home/larry/papers#
Эта команда короче, чем совокупность команд, и её проще набирать.
Рассмотрим другой полезный пример. Команда
/home/larry/papers# ls /usr/bin
выдаёт длинный список файлов. Большая часть этого списка пролетает по экрану слишком быстро, чтобы содержимое этого списка можно было прочитать. Попробуем использовать команду more для того, чтобы выводить этот список частями:
/home/larry/papers# ls /usr/bin | more
Теперь можно этот список «перелистывать».
Можно пойти дальше и состыковать более двух команд. Рассмотрим команду head , которая является фильтром следующего свойства: она выводит первые строки из входного потока (в нашем случае на вход будет подан выход от нескольких состыкованных команд). Если мы хотим вывести на экран последнее по алфавиту имя файла в текущем каталоге, можно использовать следующую длинную команду:
/home/larry/papers# ls | sort -r | head -1 notes /home/larry/papers\#
где команда head выводит на экран первую строку получаемого ей входного потока строк (в нашем случае поток состоит из данных от команды ls ), отсортированных в обратном алфавитном порядке.
Использование состыкованных команд (конвейер)
Эффект от использования символа для перенаправления вывода файла является деструктивным; иными словами, команда
/home/larry/papers# ls > file-list
уничтожит содержимое файла, если этот файл ранее существовал, и создаст на его месте новый файл.
Если вместо этого перенаправление будет сделано с помощью символов, то вывод будет приписан в конец указанного файла, при этом исходное содержимое файла не будет уничтожено. Например, команда
/home/larry/papers# ls >> file-list
приписывает вывод команды ls в конец файла.
Следует иметь в виду, что перенаправление ввода и вывода и стыкование команд осуществляется командными оболочками, которые поддерживают использование символов, и. Сами команды не способны воспринимать и интерпретировать эти символы.
Недеструктивное перенаправление вывода
Что-то вроде этого должно делать то, что вам нужно?
Проверьте это: wintee
Нет необходимости в cygwin.
Однако я столкнулся и сообщил о некоторых проблемах.
Также вы можете проверить http://unxutils.sourceforge.net/ потому что он содержит tee (и не нужен cygwin), но будьте осторожны, что выходные EOL являются UNIX-подобными.
И последнее, но не менее важно, если у вас есть PowerShell, вы можете попробовать Tee-Object. Введите в консоли PowerShell для получения дополнительной информации.
Это работает, хотя это немного уродливо:
Это немного более гибко, чем некоторые другие решения, поскольку он работает по-своему, поэтому вы можете использовать его для добавления.
Я использую это довольно много в пакетных файлах для регистрации и отображения сообщений:
Да, вы могли бы просто повторить инструкцию ECHO (один раз для экрана и второй раз перенаправляясь на файл журнала), но это выглядит так же плохо, и это проблема обслуживания.
Перенаправление ввода и вывода
По крайней мере, таким образом вам не нужно вносить изменения в сообщения в двух местах.
Обратите внимание, что _ — это просто короткое имя файла, поэтому вам нужно будет удалить его в конце вашего пакетного файла (если вы используете пакетный файл).
Это создаст файл журнала с текущим временем и временем, и вы можете использовать линии консоли во время процесса
Если у вас есть cygwin в вашем пути к среде Windows, вы можете использовать:
Простое консольное приложение C # сделало бы трюк:
Чтобы использовать это, вы просто передаете исходную команду в программу и указываете путь к любым файлам, для которых вы хотите дублировать вывод. Например:
Будет отображать результаты поиска, а также сохранять результаты в файлах files1.txt и files2.txt.
Обратите внимание, что на пути обработки ошибок не так много (ничего!), И поддержка нескольких файлов может не потребоваться.
Я также искал одно и то же решение, после небольшой попытки, я смог успешно выполнить это в командной строке. Вот мое решение:
Он даже захватывает любую команду PAUSE.
Альтернативой является tee stdout для stderr в вашей программе:
Затем в вашем dos batchfile:
Stdout перейдет в файл журнала, и stderr (те же данные) отобразятся на консоли.
Как отобразить и перенаправить вывод в файл. Предположим, что если я использую команду dos, dir> test.txt, эта команда перенаправляет вывод в файл test.txt без отображения результатов. как написать команду для вывода вывода и перенаправления вывода в файл с помощью DOS, т. е. командной строки Windows, а не в UNIX / LINUX.
Вы можете найти эти команды в biterscripting (http://www.biterscripting.com) полезными.
Это вариант предыдущего answer MTS, однако он добавляет некоторые функции, которые могут быть полезны другим. Вот метод, который я использовал:
- Команда задается как переменная, которая может использоваться позже в коде, для вывода в командное окно и добавления в файл журнала с использованием
- команда избегает redirection с использованием символа моркови, чтобы команды не оценивались первоначально
- Временной файл создается с именем файла, аналогичным пакетному файлу с именем который использует синтаксис расширения параметра командной строки чтобы получить имя командного файла.
- Результат добавляется в отдельный файл журнала
Вот последовательность команд:
- Сообщения вывода и ошибки отправляются во временный файл
- Содержимое временного файла тогда равно:
- добавлен в файл журнала
- вывод в командное окно
- Временный файл с сообщением удаляется
Вот пример:
Таким образом, команда может быть просто добавлена после более поздних команд в пакетном файле, который выглядит намного чище:
Это может быть добавлено и в конце других команд. Насколько я могу судить, это будет работать, когда сообщения имеют несколько строк. Например, следующая команда выводит две строки, если есть сообщение об ошибке:
Я согласен с Брайаном Расмуссеном, порт unxutils — самый простой способ сделать это. В разделе « Пакетные файлы » его страниц Scripting Rob van der Woude предоставляет массу информации об использовании команд MS-DOS и CMD. Я подумал, что у него может быть собственное решение вашей проблемы, и после того, как я TEE.BAT там копаться, я нашел TEE.BAT , который, кажется, именно так, представляет собой пакетный языковой пакет MS-DOS. Это довольно сложный пакетный файл, и я бы склонен использовать порт unxutils.
Я устанавливаю perl на большинстве своих машин, поэтому ответ с помощью perl: tee.pl
dir | perl tee.pl или каталог | perl tee.pl dir.bat
сырой и непроверенный.
Операторы перенаправления команд используются для изменения местоположений потоков ввода и вывода команд, заданных по умолчанию, на какие-либо другие. Местоположение потоков ввода и вывода называется дескриптор.
В следующей таблице описаны операторы перенаправления потоков ввода и вывода команд.
| Оператор перенаправления | Описание |
|---|---|
| > | Записывает данные на выходе команды вместо командной строки в файл или на устройство, например, на принтер. |
| < | Читает поток входных данных команды из файла, а не с клавиатуры. |
| >> | Добавляет выходные данные команды в конец файла, не удаляя при этом существующей информации из файла. |
| >& | Считывает данные на выходе одного дескриптора как входные данные для другого дескриптора. |
| <& | Считывает входные данные одного дескриптора как выходные данные другого дескриптора. |
| | | Считывает выходные данные одной команды и записывает их на вход другой команды. Эта процедура известна под названием «канал». |
По умолчанию, входные данные команды (дескриптор STDIN) отсылаются с клавиатуры интерпретатору команд Cmd.exe, далее Cmd.exe отправляет выходные данные команды (дескриптор STDOUT) в окно командной строки.
В следующей таблице представлены доступные дескрипторы.
Номера от 0 до 9 представляют первые 10 дескрипторов. Для запуска программы и перенаправления любого из 10 дескрипторов используется интерпретатор команд Cmd.exe. Для задания требуемого дескриптора перед оператором перенаправления введите его номер. Если дескриптор не определен, то по умолчанию оператором перенаправления ввода «<» будет ноль (0), а оператором перенаправления вывода «>» будет единица (1). После ввода оператора «<» или «>» необходимо указать, откуда читать и куда записывать данные. Можно задать имя файла или любой из существующих дескрипторов.
Для задания перенаправления в существующие дескрипторы используется амперсанд (&), затем номер требуемого дескриптора (например, & номер_дескриптора ). Например, для перенаправления дескриптора 2 (STDERR) в дескриптор 1 (STDOUT) введите:
Дублирование дескрипторов
Оператор перенаправления «&» дублирует выходные или входные данные с одного заданного дескриптора на другой заданный дескриптор. Например, для отправки выводных данных команды dir в файл File.txt и отправки ошибки вывода в файл File.txt введите:
dir>c:\file.txt 2>&1
При дублировании дескриптора происходит копирование всех его исходных характеристик. Например, если дескриптор доступен только для записи, то все его дубликаты будут доступны только для записи. Нельзя продублировать дескриптор с доступом только для чтения в дескриптор с доступом только для записи.
Перенаправление ввода команд (<)
Для перенаправления ввода команд с цифровой клавиатуры на файл или на устройство используйте оператор «<». Например, для ввода команды sort из файла List.txt введите:
sort Содержимое файла File.txt появится в командной строке в виде списка в алфавитном порядке. Оператор «<» открывает заданное имя файла с доступом только для чтения. Поэтому с его
помощью нельзя записывать в файл. Например, при запуске программы с оператором <&2 все
попытки прочитать дескриптор 0 ни к чему не приведут, так как изначально он был открыт с
доступом только для записи. Примечание Выходные данные практически всех команд высвечиваются в окне командной строки. Даже команды,
выводящие данные на диск или принтер, выдают сообщения и запросы в окне командной строки. Для перенаправления вывода команд из окна командной строки в файл или на устройство
применяется оператор «>». Этот оператор используется с большинством команд. Например, для
перенаправления вывода команды dir в файл Dirlist.txt введите: dir>dirlist.txt Если файл Dirlist.txt не существует, интерпретатор команд Cmd.exe создаст его. Если файл
существует, Cmd.exe заменит информацию в файле на данные, полученные от команды dir
. Для запуска команды netsh routing dump
и последующей отправки результатов ее работы в
Route.cfg введите: netsh routing dump > c:\route.cfg Оператор «>» открывает заданный файл с доступом только для записи. Поэтому с помощью
данного оператора файл прочитать нельзя. Например, при запуске программы с оператором
перенаправления <&0 все попытки записать дескриптор 1 ни к чему не приведут, так как
изначально дескриптор 0 был открыт с доступом только для чтения. Примечание. Для использования оператора перенаправления ввода необходимо, чтобы задаваемый файл уже
существовал. Если файл для ввода существует, то интерпретатор команд Cmd.exe открывает его с
доступом только для чтения и его содержимое отправляет в команду так, как если бы это был
ввод с цифровой клавиатуры. При задании дескриптора интерпретатор команд Cmd.exe дублирует
его в дескриптор, существующий в системе. Например, для считывания файла File.txt на вход в дескриптор 0 (STDIN) введите: Для открытия файла File.txt, сортировки его содержимого и последующей отправки в окно
командной строки (STDOUT) введите: sort< file.txt Для того чтобы найти файл File.txt и перенаправить дескриптор 1 (STDOUT) и дескриптор 2
(STDERR) в Search.txt введите: findfile file.txt>search.txt 2<&1 Для дублирования определенного пользователем дескриптора 3 в качестве входной информации для
дескриптора 0 (STDIN) введите: При перенаправлении вывода в файл и задании существующего имени файла интерпретатор команд
Cmd.exe открывает файл с доступом только для записи и переписывает его содержимое. Если
дескриптор задан, интерпретатор команд Cmd.exe дублирует файл в существующий дескриптор. Для дублирования определенного пользователем дескриптора 3 в дескриптор 1 введите: Для перенаправления всех выходных данных, включая выходные данные дескриптора 2 (STDERR),
команды ipconfig
в дескриптор 1 (STDOUT) и последующего перенаправления выходных
данных в Output.log введите: ipconfig.exe>>output.log 2>&1 Для добавления выходных данных команды в конец файла без потери хранящейся в нем информации
используется двойной символ «больше» (>>). Например, следующая команда добавляет список
каталогов, созданный командой dir
, в файл Dirlist.txt: dir>>dirlist.txt Для добавления выходных данных команды netstat
в конец файла Tcpinfo.txt введите: netstat>>tcpinfo.txt Иногда удобнее записывать это следующим образом:
SET OutFile="%~n0.html"
> %OutFile% ECHO ^ Оператор канала «вертикальная линия» (|) забирает выходные данные одной команды (по умолчанию
STDOUT) и направляет их на вход другой команды (по умолчанию STDIN). Например, следующая
команда сортирует каталог: В данном примере обе команды запускаются одновременно, но команда sort
приостанавливает работу до получения выходных данных команды dir
. Команда sort
использует выходные данные команды dir
в качестве своих входных данных, а затем свои
выходные данные отправляет в дескриптор 1 (STDOUT). Комбинируя команды-фильтры с другими командами и именами файлов, можно создавать команды на
заказ. Например, для сохранения имен файлов, содержащих строку «LOG», используется следующая
команда: dir /b | find "LOG" > loglist.txt Выход команды dir
отсылается в команду-фильтр find
. Имена файлов, содержащие
строку «LOG», хранятся в файле Loglist.txt в виде списка (например, NetshConfig.log,
Logdat.svd и Mylog.bat). При использовании более одного фильтра в одной команде их необходимо отделять с помощью
канала (|). Например, следующая команда ищет в каждом каталоге диска C файлы, в названии
которых присутствует строка «Log», и выводит их постранично на экран: dir c:\ /s /b | find "LOG" | more Наличие канала (|) указывает cmd.exe ,
что выход команды DIR нужно отправить
команде-фильтру find
. Команда find
выбирает только те имена файлов, в которых
содержится строка «LOG». Команда more
выводит на экран имена файлов, полученные
командой find
с паузой после заполнения каждого экрана. Дополнительные сведения о
командах-фильтрах смотри в разделе 1403
Потоки вывода
Сообщения скриптов выводятся во вполне определенные потоки - потоки вывода. Таким образом то, что мы выводим через echo "Hello, world!" Не просто выводится на экран, а, с точки зрения системы, а конкретно - командных интерпретаторов sh и bash - выводится через определенный поток вывода. В случае echo - поток под номером 1 (stdout), с которым ассоциирован экран. Некоторые программы и скрипты так-же используют другой поток вывода - под номером 2 (stderr). В него они выводят сообщения об ошибках. Благодаря этому можно раздельно выхватывать из потоков обычные информационные сообщения и сообщения об ошибках и направлять и обрабатывать их раздельно. Например, Вы можете заблокировать вывод информационных сообщения, оставив только сообщения об ошибках. Или направить вывод сообщений об ошибках в отдельный файл для логирования. Что такое ">somefile"
Такой записью в Unix (в интерпретаторах bash и sh) указывается перенаправление потоков вывода. В следующем примере мы перенаправим все информационные (обычные) сообщения команды ls в файл myfile.txt, получив таким образом в этом файле просто список ls: $ ls > myfile.txt Однако давайте сделаем заведомо ошибочную операцию: $ ls /masdfasdf > myfile.txt Т.к. поток stderr (2) мы никуда не перенаправили - сообщение об ошибке появится на экране и НЕ появится в файле myfile.txt А теперь давайте выполним команду ls так, чтобы информационные данные записались в файл myfile.txt, а сообщения об ошибках - в файл myfile.err, при этом на экране во время выполнения не появится ничего: $ ls >myfile.txt 2>myfile.err Конечно, мы можем оба потока направить в один файл или в одно и то же устройство. 2>&1
Нередко в скриптах можно встретить такую запись. Она означает: "Поток с номером 2 перенаправить в поток с номером 1", или "Поток stderr - направить через поток stdout". Т.е. все сообщения об ошибках мы направляем через поток, через который обычно печатаются обычные, не ошибочные сообщения. $ ls /asfasdf 2>&1 $ ls /asfasdf >myfile.txt 2>&1 /dev/null
Однако иногда нам нужно просто скрыть все сообщения - не сохраняя их. Т.е. просто блокировать вывод. Для этого служит виртуальное устройство /dev/null. В следующем примере весь вывод обычных сообщений команды ls мы направим в /dev/null: $ ls > /dev/null $ ls > /dev/null 2>&1 $ ls >/dev/null 2>/dev/null $ ls 2>/dev/null Заметьте, что здесь уже нельзя указывать "2>&1", т.к. поток (1) не перенаправлен никуда и в таком случае сообщения об ошибках будут банально вывалены на экран. Что первее - яйцо или курица?
Я приведу Вам здесь 2 примера. Пример 1) $ ls >/dev/null 2>&1 $ ls 2>&1 >/dev/null Дело в том, что интерпретаторы читают и применяют перенаправления слева направо. И сейчас мы разберем оба примера. Пример 1 1) ">/dev/null" - мы направляем поток 1 (stdout) в /dev/null. Все сообщения, попадающие в поток (1) - будут направлены в /dev/null. 2) "2>&1" - мы перенаправляем поток 2 (stderr) в поток 1 (stdout). Но, т.к. поток 1 уже ассоциирован с /dev/null - все сообщения все-равно попадут в /dev/null. Результат: на экране - пусто. Пример 2 1) "2>&1" - мы перенаправляем поток ошибок stderr (2) в поток stdout (1). При этом, т.к. поток 1 по-умолчанию ассоциирован с терминалом - сообщения об ошибках мы успешно увидим на экране. 2) ">/dev/null" - а уже здесь мы перенаправляем поток 1 в /dev/null. И обычные сообщения мы не увидим. Результат: мы будем видеть сообщения об ошибках на экране, но не будет видеть обычные сообщения. Вывод: сначала перенаправьте поток, а потом на него ссылайтесь. Три направления ввода-вывода являются выделенными - стандартный ввод, вывод и поток ошибок (stdin, stdout, stderr
). По умолчанию, все три потока связаны (ассоциированы) с терминалом. При этом программа выводит все свои сообщения в том числе и об ошибках на терминал. Shell
позволяет перенаправить эти стандартные потоки, установить ввод-вывод и объединение потоков. Перенаправление потоков ввода-вывода. >file
Перенаправление стандартного потока вывода в файл file
>>file
-Перенаправление стандартного потока вывода в файл file
с добавлением в конец файла. prog1 | prog2
-Передача выходного потока программы prog1 во входной поток программы prog2.
n>file
file.
n>>file
-Перенаправление стандартного потока с дескриптором n в файл file
с добавлением в конец файла. n>&m
-Объединение потоков с дескрипторами n
и m
. $ prog1 >/dev/null 2>&1
/dev/null
- это псевдоустройство, которое уничтожает направленный в него поток. Передача потока вывода одной программы в поток ввода другой используется часто. Например: $ gzip -d archive.tar.gz | tar –xf
Здесь происходит разархивация файла archive.tar.gz
, запакованного двумя архиваторами. Выходной поток от утилиты gzip
передается во входной поток утилите tar
. Аналогично эту же операцию можно было выполнить и по другому: $ gzip -d archive.tar.gz
$ tar -xf archive.tar
Поскольку язык Bourne Shell
является процедурным языком программирования, в нем также как и в других подобных языках есть операторы, позволяющие управлять последовательностью выполнения команд. Необходимым оператором является проверка некоторого условия, в зависимости от выполнения которого определяется дальнейший ход программы. Таким оператором является команда test.
Эта команда проверяет выполнение некоторого условия. У команды test
существует два варианта вызова: test условие
[ условие ]
Следует отметить, что между скобкой и условием необходимо наличие пробелов, иначе Shell
не сможет опознать "[" как команду test
. При успешном завершении test
возвращает "0"
. Условия проверки файлов: -f file
Файл "file"
является обычным файлом. -d file
Файл "file"
является каталогом. -w file
Файл "file"
имеет разрешение на запись. -x file
Файл "file"
имеет разрешение на исполнение. -s file
Файл "file"
не пустой. Условия проверки строк: string1=string2
Строки string1
и string2
совпадают. string1!=string2
Строки string1
и string2
не совпадают. -n string1
Строка string1
существует. -z string1
Строка string1
не существует. Условия операций с целыми числами: x -eq y
x равно y x -ne y
x не равно y x -gt y
x больше y x -ge y
x больше или равно y x -lt y
x меньше y x -le y
x меньше или равно y В этом случае команда test
воспринимает строки именно как целые числа. Нулевому значению так же соответствует пустая строка. Логические операции в контексте test
! (not)
Логическое "НЕ" -o (or)
Логическое "ИЛИ" -a (and)
Логическое "И" Условный оператор "if
"
Общий вид использования условного оператора if представляется следующим образом: if <условие>
then <список команд>
[ elif <условие>
then <список> ]
Выражения, выделенные в квадратных скобках, являются необязательными. Т.е. можно представить наиболее употребительную "порезанную" модификацию условного оператора: if <условие>
then <список команд>
В этом случае если <условие>
выполнено (код завершения 0) то выполняется <список команд>.
В противном случае <список команд>
пропускается. Оператор выбора case
В общем случае синтаксис оператора case
выглядит следующим образом: case <строка> in
Шаблон 1)
........
Шаблон2)
........
........
Значение <строка>
сравнивается с шаблонами, по порядку. Если было найдено совпадение, тогда выполняются команды соответствующего раздела. Следует отметить, что шаблоны допускают использование масок. Если совпадения не было найдено, тогда выполняются команды из раздела с шаблоном "*" (аналогично default
селектора switch
в С
). Для примера приведем кусочек инициализационного скрипта BSD UNIX
. Здесь переменные (inetd_enable и inetd_flags
)
были получены из другого файла (rc.conf).
. /etc/rc.conf
case {$inetd_enable} in
)
if [ -x /usr/sbin/inetd ]; then
/usr/sbin/inetd $inetd_flags
fi Оператор цикла с перечислением for
Синтаксис оператора for
for <имя>
<список команд>
Фрагмент, выделенный в квадратные скобки, может отсутствовать. Оператор for
обеспечивает выполнение цикла столько раз, сколько слов в списке значений. При этом переменная <имя>
принимает последовательно значения слов из списка. Сам по себе список может формироваться из вывода других команд. Если же список отсутствует, тогда <имя>
принимает значения, переданные как позиционные параметры скрипта. Оператор цикла с истинным условием while
Синтаксис оператора while
в общем случае имеет следующую структуру: while <условие>
<список команд>
Оператор while
предпочтителен тогда, когда не известен заранее список значений параметров. Список команд будет выполняться в цикле до тех пор, пока сохраняется истинность условия. При первом входе в цикл условие должно выполняться. Оператор цикла с ложным условием until
Синтаксис оператора until
в общем случае имеет следующую структуру: until <условие>
<список команд>
Список команд будет выполняться в цикле до тех пор, пока сохраняется ложность условия. При первом входе в цикл условие не должно выполняться. Следует заметить, что условие цикла проверяется на ложность после каждого, в т.ч. и первой выполненной команды в цикле. Основные команды ОС UNIX
для работы с файлами
1. Команда pwd
.
Синтаксис: pwd
. Описание: команда выводит имя текущей директории для работающего командного интерпретатора. Задание 1.
Воспользуйтесь командой pwd для определения своей домашней директории.
Отразите команду и результат ее работы в отчете.
2. Команда man
.
Синтаксис: man
имя. Имя - это имя интересующей нас команды, утилиты, системного вызова, библиотечной функции, файла. Описание: UNIX MANUAL
- руководство по операционной системе UNIX.
Информация оттуда доступна в интерактивном режиме с помощью утилиты man
. Задание 2.
С помощью утилиты man посмотрите информацию о команде pwd.
Запишите кратко информацию о команде в отчет (на русском языке).
3. Команда cd
.
Синтаксис:cd
имя_директории. Описание: это команда смены текущей директории. Имя_директории - это полное или относительное имя директории, которую вы хотите сделать текущей. cd
без параметров текущей сделает вашу домашнюю директорию. Задание 3.
Сделайте текущей директорию на уровень выше. Проверьте это, затем вернитесь в свою домашнюю директорию. Проверьте смену директории.
Выполнение проделанных команд отразите в отчете.
4. Команда ls
.
Синтаксис: ls
имя_директории Описание: команда просмотра состава указанной директории. ls
без параметров распечатывает список файлов из текущей директории. В полученный список не войдут файлы, имена которых начинаются с символа “.
” - файлы, созданные различными системными программами в своих целях. Посмотреть полный список файлов можно, указав в команде ls
ключ “-a”, т.е. ls -aимя_директории Права доступа к файлам
С каждым файлом в ОС UNIX
связано 12-битное слово, называемое «правами доступа» к файлу. Младшие 9 бит этого слова объединены в три группы по три бита; каждая группа задает права доступа для владельца файла, для его группы и для всех остальных пользователей. Три бита в каждой группе отвечают за право на чтение, запрос и использование файла. Чтобы узнать права доступа к тому или иному файлу, можно воспользоваться командой , например:
> ls -l /bin/cat
Расположенная в начале строки группа символов -rwxr-xr-x
показывает тип файла (первый символ; минус означает, что мы имеем дело с обыкновенным файлом, буква d
означала бы каталог и т.п.) и права доступа, соответственно, для владельца (в данном случае rwx
, т.е. чтение, запись и исполнение), группы и всех остальных (в данном случае r-x
, т.е. права на запись отсутствуют). Таким образом, файл /bin/cat
доступен любому пользователю на чтение и исполнение, но модифицировать его может только пользователь root
(т.е. администратор). Можно записать слово прав доступа к файлу в виде восьмеричного числа (3 знака - восьмеричная цифра), трехзначного (владелец, группа, остальные пользователи) каждый знак в этом трехзначном восьмеричном числе формируется как сумма прав: 4- права на чтение, 2- права на запись, 1 - на использование (из двоичной триады): (111) 2 =2 0 +2 1 +2 2 =(1+2+4) 10 .
Например, 7 = 1 + 2 + 4 Þ права rwx
4 2 1
6 = 0 + 2+ 4 Þ права rw- -
4 2 0
В трехзначном числе задания прав: 744
для владельца определены все права, для группы - только чтение, для остальных пользователей - только на чтение. Для использования прав доступа к файлам используется команда chmod
, которая позволяет задать новые права доступа в виде восьмеричного числа, например: $ chmod 744 filel.c.
Задание 4.
а) Для получения полной информации о команде ls воспользуйтесь утилитой man. Перенаправьте вывод команды в какой-либо текстовый файл.
б) Посмотрите полное содержимое текущей директории и перенаправьте этот вывод также в текстовый файл.
в) С помощью команды
ls -l <имя_файла> выведите информацию о правах доступа к тому текстовому файлу, с которым вы работали в п. 4б, затем перенаправьте эту информацию в тот же текстовый файл. Объясните полученный вывод.
5. Команда cat
.
Перенаправление ввода/вывода. Для просмотра содержимого небольшого текстового файла на экране можно воспользоваться командой: сat
имя_файла Внимание!
Не пытайтесь просматривать таким образом содержимое директории и бинарных файлов. Большой тестовый файл удобно просматривать командой more
(описание использования найдите в UNIX MANUAL
). Почему здесь неудобна команда сat
? В команде сat
можно задавать несколько имен файлов: сat файл1 файл 2 … файл N
при этом содержимое всех файлов подряд будет выведено на экран. Можно перенаправить вывод в какой-нибудь файл: сat файл 1 файл 2 > файл_ результатов
Перенаправление вывода со стандартного потока вывода (экрана) в файл является стандартным для всех команд. Перенаправить стандартный ввод (с клавиатуры), например, брать данные для программы из файла, можно с помощью знака “<”. сat >
новый_файл - создаст новый текстовый файл с содержимым, вводимым вами с клавиатуры. Прервать процесс ввода данных-
Задание 5.
Создайте с помощью сat новый текстовый файл и просмотрите его содержимое. Перенаправьте вывод со стандартного потока в другой файл, имя которого введите с клавиатуры, и убедитесь в правильности проделанной операции.
6. Простейшие команды работы с файлами: cp, rm, mkdir, mv
Для создания новой директории используется команда: mkdir
имя_директории Для копирования содержимого одного файла в другой используется команда: cp
файл_источник файл_назначение. Команда
cp файл 1 файл 2 …. файл N директория назначения
служит для копирования файла или файлов в уже существующую директорию с именем директории_назначения под своими именами. Вместо имен копируемых файлов можно использовать их шаблоны. Шаблоны задаются с помощью метасимволов: * - соответствует всем цепочкам литер, включая пустую. Все одиночные литеры [ …] - соответствует любой литере, заключенной в скобки. Пара литер, разделенных минусом, задает диапазон литер. Команда
cp - r
дир_источник дир_назначение служит для рекурсивного копировария одной директории (дир_источник) в новую директориию (дир_назначение). Вместо имен в командах копирования могут использоваться их шаблоны. Команда
rm файл 1 файл 2 …. файл N
позволяет удалить 1 или несколько регулярных файлов из текущей директории. Вместо имен могут использоваться шаблоны. Если хотите удалить одну или несколько директорий вместе с их содержимым (рекурсивное удаление) в команде rm
используйте ключ -r
Rm-r дир 1 дир 2
Команда переименования: mv
имя_источника имя_назначения Файл с именем имя_источника переименовывает в файл с именем имя_назначения. При этом перед выполнением команды файла с именем имя_назначения существовать не должно. Задание 6.
Создайте новую директорию внутри своей домашней. Организуйте там небольшой тестовый файл с содержимым из двух строк:
«Изучаю работу в ОС UNIX
Организую скрипт».
Скопируйте содержимое этого файла в другой - с тем же именем, но в директории /home. Удалите первоначально созданный файл из вашей директории, если копирование прошло успешно. Проверьте содержимое использованных директориий и файлов.
Задание 7.
1). Когда вы освоили работу в интерактивном режиме с простейшими командами ОС UNIX, создайте с помощью редактора Kwriter скрипт со сценарием, соответствующим последовательному выполнению:
Задание 3,
Задание 4Б,4В,
Задание 5,
Задание 6.
В задании 6 не забудьте проверить программно успешно ли прошло копирование файла, с выдачей на экран дисплея текстовых сообщений и содержимого соответствующих директорий.
Необходимо, чтобы в командном файле была организована грамотная выдача запросов на ввод данных с клавиатуры с помощью команды: $ echo - n “текст запроса”.
2). Сохраните скрипт с именем Myscript1, запустите его на выполнение командой
sh Myscript1
введите запрашиваемые данные и проверьте полученные результаты.
3). Составьте отчет о выполненной лабораторной работе, в котором должна быть отражена и ваша работа в интерактивном режиме и со скриптом, включая текст скрипта (с комментариями) и полученные результаты на экране и в файлах.
Системные вызовы getuid и getpid
Узнать идентификатор пользователя, запустившего программу на выполнение,-UID
и идентификатор группы, к которой он относится,-GID
можно с помощью системных вызовов getuid() и getpid()
,применив их внутри этой программы. Прототипы системных вызовов: #include #include uid_t getuid(void);
gid_t getgid(void);
Задание 8.
Напишите, откомпилируйте и запустите программу, которая печатала бы идентификатор пользователя, запустившего программу, и идентификатор его группы.
Включите программу с результатами в отчет.
1. Понятие файла в ОС UNIX
. Что такое домашняя директория? 2. Какие существуют средства группирования команд Shell
-интерпретатора? приведите примеры использования. 3. Как осуществляется перенаправление ввода-вывода? 4. Что такое конвейер команд? приведите пример. 5. Как средствами Shell
выполнить арифметические действия над Shell
-переменной? 6. Каковы правила генерации имен файлов? 7. Как выполняется подстановка результатов выполнения команд? 8. Как интерпретировать строку cmd1 & cmd2 &
? 9. Как интерпретировать строку cmd1 && cmd2 &
? 10. Как интерпретировать строку cmd1 || cmd2 &
? 11. Как в UNIX
определены права доступа к файлу? Какой командой их можно посмотреть для конкретного файла? 12. Как определить идентификатор пользователя, запустившего программу и идентификатор его группы? Лабораторная работа № 3.
Процессы в операционной системе UNIX.
Цель работы
Научиться создавать процессы и освоить изменение пользовательского контекста процессов с помощью системных вызовов, применяемых в программах на языке С
, в ОС UNIX
.
1. Изучить организацию процессов в UNIX
: понятие процесса, контекст процесса, жизненный цикл процесса, идентификация процессов, иерархическая структура процессов. Написать на С
и отладить программу в соответствии с заданием 1. 2. Ознакомиться с созданием процесса в UNIX
, с организацией завершения процесса. Написать и отладить программу (язык С
) в соответствии с Заданием 2, включить ее в отчет. 3. Изучить параметры функции main()
в языке С
, переменные среды и аргументы командной строки. Написать программу на языке С
в соответствии с Заданием 3, отладить и включить ее в отчет вместе с результатами. 4. Изучить семейство функций для организации системного вызова exec().
5. Написать программу на языке С
в соответствии с вариантом Задания 4, выданного преподавателем, отладить программу и продемонстрировать полученные результаты преподавателю. Включить программу с результатами в отчет. 6. Защитить работу преподавателю, ответив на контрольные вопросы.Перенаправление вывода команд (>)
Использование оператора «<&» для перенаправления ввода и дублирования
Использование оператора «>&» для перенаправления ввода и дублирования
Использование оператора «>>» для добавления вывода
Использование оператора канала (|)
Комбинирование команд с операторами перенаправления
При этом после нажатия на Enter Вы не увидите ничего на экране, зато в файле myfile.txt будет находится все то, что должно было отобразиться на экране.
И что случится? Т.к. директории masdfasdf в корне файловой системы не существует (я так предполагаю - вдруг у Вас есть?), то команда ls сгенерирует ошибку. Однако вывалит эту ошибку она уже не через обычный поток stdout (1), а через поток ошибок stderr (2). А перенаправление задано лишь для stdout ("> myfile.txt").
Здесь нам встречается впервые указание номера потока в качестве перенаправления. Запись "2>myfile.err" указывает, что поток с номером 2 (stderr) нужно перенаправить в файл myfile.err.
А вот еще пример, в котором все сообщения перенаправляются в файл myfile.txt:
При этом все сообщения, как об ошибках, так и обычные, будут записаны в myfile.txt, т.к. поток stdout мы сначала перенаправлили в файл, а потом указали, что ошибки нужно вываливать в stdout - соответственно, в файл myfile.txt
На экране не будет отображено ничего, кроме сообщений об ошибках. А в следующем примере - и сообщения об ошибках будут блокированы:
Причем эта запись эквивалентна записи вида:
А в следующем примере мы заблокируем только сообщения об ошибках:
Пример 2)
С виду - от перестановки мест слогаемых сумма не меняется. Но порядок указателей перенаправления играет роль!
-c file
Файл "file"
является специальным файлом.
-r file
Файл "file"
имеет разрешение на чтение.
;;
esac