Что такое shell и зачем он нужен

Командная оболочка в любых unix-подобных системах, к которым относится и GNU/Linux, является обычной программой, запускаемой как в текстовой консоли (которая используется всё реже), так и в графической среде – в окне эмулятора терминала, доступного в любой Linux-системе.

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

Почти во всех дистрибутивах Linux для пользователей по умолчанию назначается командная оболочка bash (Bourne Again SHell – ещё одна командная оболочка Бурна; Стив Бурн – автор первой командной оболочки в Unix – sh). Фактически она стала неофициальным стандартом, и усовершенствование ее функциональных возможностей продолжается непрерывно. Существуют и другие командные оболочки – tcsh (версия C-shell), ksh (Korn Shell), zsh и т.д. – у каждой есть свои достоинства и недостатки, а также свои группы поклонников. Тем не менее, bash более привычна широким массам пользователей с различными уровнями подготовки, потому я и остановил свой выбор на ней. Стоит также отметить, что какими бы возможностями ни обладали различные оболочки, все они совместимы со своим идеологическим прародителем – Bourn Shell (sh). Иными словами, скрипт, написанный для sh, будет корректно работать в любой современной оболочке (обратно, вообще говоря, неверно).

Преимущества командной строки

Может возникнуть вопрос: зачем возиться с командной строкой, если существуют удобные и красивые графические интерфейсы? Тому есть множество причин. Во-первых, далеко не все операции удобнее и быстрее выполнять с помощью графического интерфейса. Во-вторых, каждая программа следует основополагающему принципу Unix-систем: делать чётко определённую работу и делать её хорошо. Иными словами, вы всегда понимаете, что происходит при запуске той или иной утилиты (если что-то не вполне понятно, то следует обратиться к man-руководству). В-третьих, осваивая команды, пробуя их сочетания и комбинации их параметров, пользователь изучает систему, приобретая ценный практический опыт. Вы получаете доступ к таким эффективным инструментам, как конвейеры, позволяющие организовать цепочку команд для обработки данных, средства перенаправления ввода/вывода, а кроме того, можете программировать непосредственно в командной оболочке. Пожалуй, на программировании стоит остановиться подробнее, тем более что многие системные сценарии в Linux (например, скрипты запуска системных сервисов) написаны для shell.

Командная оболочка в качестве языка программирования

Итак, командную оболочку можно рассматривать как язык программирования и как программную среду выполнения одновременно. Разумеется, этот язык не компилируемый, а интерпретируемый. Он допускает использование переменных: системных или собственных. Последовательность выполнения команд программы изменяется с помощью конструкций проверки условия и выбора соответствующего варианта: if-then-else и case. Циклы while, until и for позволяют автоматизировать многократно повторяющиеся действия. Имеется возможность объединять группы команд в логические блоки. Вы можете даже писать настоящие функции с передачей в них параметров. Таким образом, налицо все признаки и характеристики полноценного языка программирования. Попробуем извлечь из этого двойную пользу – наряду с изучением основ программирования автоматизируем свою повседневную работу.

Hello, World! Простая система резервного копирования

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

#!/bin/bash # # Резервное копирование каталогов и файлов из домашнего каталога # Этот командный скрипт можно автоматически запускать при помощи cron # cd $HOME if [ ! -d archives ] then mkdir archives fi cur_date=`date +%Y%m%d%H%M` if [ $# -eq 0 ] ; then tar czf archive${cur_date}.tar.gz projects bin else tar czf archive${cur_date}.tar.gz $* fi if [ $? = 0 ] ; then mv archive${cur_date}.tar.gz $HOME/archives echo "$cur_date – Резервное копирование успешно завершено." else echo "$cur_date – ОШИБКА во время резервного копирования." fi

Любой командный сценарий (script – скрипт, так называются программы командной оболочки) начинается со строки идентификатора, в которой явно задаётся интерпретатор команд с указанием полного пути к нему. Полный путь – последовательное перечисление всех каталогов, начиная с корневого, в которые надо войти, чтобы добраться до целевого файла, и, разумеется, имя этого файла. Запись полного пути чрезвычайно важна для однозначной идентификации каждого файла в иерархии файловой системы.

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

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

Наконец-то мы добрались до первой «настоящей» команды. Она позволяет сменить каталог (Change Directory), т.е. перейти из текущего каталога в другой, переданный команде как аргумент. В большинстве случаев целевой каталог задаётся в явной форме, например, cd /tmp или cd projects, но в нашем случае используется предопределённая системная переменная HOME – в ней содержится полный путь к домашнему каталогу текущего пользователя, от имени которого выполняется командный сценарий. Тем самым мы избавляемся от необходимости вносить изменения в код всякий раз при смене пользователя, потому что команда возвращает любого в его личный каталог. Знак доллара "$" перед именем переменной означает, что необходимо извлечь значение, содержащееся в этой переменной, и подставить его в командную строку вместо её имени. Особо следует отметить, что в командном языке оболочки регистров букв имеют важное значение, т.е. HOME, Home и home – это три различные переменные. По соглашению, буквами верхнего регистра обозначаются имена системных переменных: HOME, PATH, EDITOR и т.д. Это соглашение не запрещает пользователям создавать свои переменные с именами из заглавных букв, но зачем усложнять себе жизнь, нарушая общепринятые нормы и правила? Не рекомендуется также изменять значения системных переменных без крайней необходимости. В общем, соблюдаем простое правило: системные переменные используем только для чтения, а если потребовалась собственная, то её имя записываем буквами нижнего регистра.

Нашу первую команду можно было бы записать более кратко:

cd ~

Здесь символ "~" также означает домашний каталог текущего пользователя. Ветераны командной строки выражаются ещё лаконичнее:

cd

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

На очереди классическая программная конструкция проверки условия и принятия соответствующего решения. Общая схема такова:

if <условие> then <одна или несколько команд> fi

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

Для проверки условия, как правило, применяется команда test или её альтернативная форма записи в квадратных скобках. Иначе говоря, записи

if [ ! -d archives ] if test ! -d archives

абсолютно равнозначны. Я предпочитаю квадратные скобки, поскольку они более наглядно определяют границы проверяемого условия. И правая, и левая скобка должны быть обязательно отделены от условия пробелами.

Критерии проверки условия определяются разнообразными флагами. Команда test распознаёт очень большой их список. В нашем примере использован флаг -d, позволяющий проверить, соответствует ли заданное после флага имя реально существующему каталогу (directory). Наиболее часто при работе с файлами применяются следующие флаги:

F – существует ли обычный файл с заданным именем;

R – установлено ли для заданного файла право на чтение из него;

W – установлено ли для заданного файла право на запись в него;

X – установлено ли для заданного файла право на его выполнение;

S – имеет ли заданный файл ненулевой размер.

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

if [ ! -d archives ] Если не существует каталог archives (в текущем каталоге), then то начать выполнение блока команд: mkdir archives создать каталог archives (в текущем каталоге) fi завершить выполнение блока команд.

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

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

ten=10 string="Это строка текста"

Но в нашем примере применяется небольшая хитрость. Обратите внимание, что после знака равенства – символа присваивания – записана команда в обратных кавычках. Такая форма записи позволяет присвоить переменной не саму строку, а результат её выполнения. Здесь это вывод команды date, которая возвращает текущую дату и время в формате, определяемом списком параметров:

%Y – текущий год в полной форме, т.е. из четырёх цифр (например, 2009);

%m – номер текущего месяца (например, 09 – для сентября);

%d – номер текущего дня;

%H – текущий час в 24-часовом формате;

%M – текущая минута.

Таким образом, если выполнить команду

cur_date=`date +%Y%m%d%H%M`

десятого сентября 2009 года в 22:45, то переменной cur_date будет присвоено строковое значение "200909102245". Цель этого ухищрения – сформировать уникальное, не повторяющееся имя архивного файла. Если вы намерены запустить несколько экземпляров программы в течение одной минуты, то можете улучшить уникальность имён, добавляя ещё и текущие секунды. Как? Изучите руководство утилиты date (man date) – в этом нет ничего сложного.

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

if [ $# -eq 0 ] ; then

Проверка условия «если число переданных параметров равно нулю», то выполнить следующую команду. Отметим, что ключевое слово then можно записать в строке условия, отделив его от условного выражения точкой с запятой.

tar czf archive${cur_date}.tar.gz projects bin

Команда создания архивного файла и сжатия этого файла. Сама утилита tar не выполняет сжатие, а только лишь собирает все заданные файлы и каталоги в единый tar-файл. Для этого предназначен первый флаг - c (create – создать). Сжатие выполняет внешняя программа – здесь это gzip, вызываемый вторым флагом - z. Если в вашей системе установлена более эффективная программа сжатия bzip2, то вы можете воспользоваться ею, изменив команду следующим образом:

tar cjf archive${cur_date}.tar.bz2 projects bin

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

Ключевое слово else открывает альтернативную ветвь выполнения. Команды этого блока начинают работать, если проверка условия даёт результат «ложь» (в нашем примере: «число переданных параметров ненулевое», т.е. пользователь задал имена каталогов). В этом случае команда будет выглядеть так:

tar czf archive${cur_date}.tar.gz $*

Здесь каталоги по умолчанию заменены строкой имён каталогов, принятой извне. Имеется возможность принимать и обрабатывать каждый внешний параметр по отдельности, но нам удобнее передать строку целиком.

В конце программы выполняется ещё одна проверка. В unix-средах все команды возвращают код статуса завершения своей работы. Если команда отработала успешно, то она возвращает код 0, в противном случае код завершения будет ненулевым. Чтобы проверить успешность выполнения предыдущей команды архивации, воспользуемся ещё одной специальной переменной $?, в которой всегда содержится значение кода завершения самой последней команды. Если в переменной $? содержится 0, т.е. файл резервной копии был успешно создан, то мы перемещаем его в каталог архивов:

mv archive${cur_date}.tar.gz $HOME/archives

и выдаём соответствующее сообщение:

echo "$cur_date – Резервное копирование успешно завершено."

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

echo "$cur_date – ОШИБКА во время резервного копирования."

На этом работа нашего командного сценария завершается.

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

chmod 750 bckp

и запустить:

./bckp

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

./bckp docs progs works

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

Можно поместить файл bckp в один из каталогов, указанных в системной переменной PATH. Наиболее предпочтительными местами размещения являются /usr/local/bin или $HOME/bin, если таковые у вас имеются. После этого вы можете запускать bckp как системную команду.

Как автоматизировать операции резервного копирования «по расписанию»

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

crontab -e

Инструкции записываются в строго определённом формате (поля разделяются пробелами):

минуты часы день_месяца месяц день_недели команда

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

30 23 10,20,30 * * /usr/local/bin/bckp

Это означает, что сценарий резервного копирования (следует указать полный путь к этому файлу) будет выполняться в 23:30 10-го, 20-го и 30-го числа каждого месяца независимо от дня недели. (Звёздочки обозначают весь допустимый диапазон значений, в данном случае: каждый месяц – в 4-м поле, любой день недели – в 5-м поле)

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

0 5 * * 3,5 /usr/local/bin/bckp

Здесь резервные копии будут создаваться в 5:00 по средам и пятницам в каждом месяце (звёздочка в 4-м поле), независимо от числа (звёздочка в 3-м поле).

Обо всех тонкостях составления расписания можно прочитать в руководстве man 5 crontab.

Итоги и выводы

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

Ресурсы для скачивания

static.content.url=http://www.сайт/developerworks/js/artrating/

ArticleID=458335

ArticleTitle=Основы программирования в командной оболочке shell

• Tutorial

Зачем и для кого статья?

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

Здесь не будет пересказа манов (документации), и статья никак не отменяет и не заменяет их чтение. Вместо этого я расскажу о главных вещах (командах, приемах и принципах), которые надо осознать с самого начала работы в unix shell-е, чтобы работа происходила эффективно и приятно.

Статья касается полноценных unix-подобных окружений, с полнофункциональным шеллом (предпочтительно zsh или bash)и достаточно широким набором стандартных программ.

Что такое шелл

Shell (шелл, он же «командная строка», он же CLI, он же «консоль», он же «терминал», он же «черное окошко с белыми буковками») -- это текстовый интерфейс общения с операционной системой (ну, строго говря, это программа , которая таковой интерфейс обеспечивает, но сейчас это различие несущественно).

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

Типичный вид шелла:

Шелл - это основной способ для взаимодействия со всеми Unix-подобными серверными системами.

Где встречаются системы с командной строкой?

Где вас может поджидать unix-овый шелл, популярные варианты:

• MacOS (bash);
• удаленный доступ на сервер по работе или для личного веб-проекта;
• домашний файл-сервер с удаленным доступом;
• Ubuntu, PC-BSD на ноутбуке/десктопе - unix-подобные системы сегодня просты в установке и использовании.

Какие задачи разумно решать шеллом?

Естественные задачи, для которых шелл пригоден, полезен и незаменим:

• интерактивная работа в терминале:
  • выполнение компиляции, запуск заданий через make;
  • сравнение текстовых файлов;
  • быстрый ad-hoc анализ данных (количество уникальных ip в логе, распределение записей по часам/минутам и т.п.);
  • разовые массовые действия (прибить много процессов; если работаете с системой контроля версий - ревертнуть или зарезолвить кучу файлов);
  • диагностика происходящего в системе (семафоры, локи, процессы, дескрипторы, место на диске и т.п.);
• скриптование:
  • установочные скрипты, для выполнения которых нельзя рассчитывать на наличие других интерпретаторов - это не для новичков;
  • функции для кастомизации интерактивного шелла (влияющие на приглашение, меняющие каталог, устанавливающие переменные окружения) - тоже не совсем для новичков;
  • одноразовые скрипты типа массового перекодирования файлов;
  • makefile-ы.

Абсолютно первые шаги

Начинаем работу: войти и выйти

Убедитесь, что точно знаете, как запустить шелл и как из него выйти.

Если вы работаете за машиной, на которой установлена Ubuntu, вам надо запустить программу Terminal. По окончании работы можно просто закрыть окно.

На MacOS - тоже запустить Terminal.

Для доступа к удаленному серверу - воспользоваться ssh (если локально у вас MacOS, Ubuntu или другая unix-like система) или putty (если у вас Windows).

Кто я, где я?

Выполните следующие команды:

• hostname - выводит имя машины (сервера), на которой вы сейчас находитесь;
• whoami - выводит ваш логин (ваше имя в системе);
• tree -d / |less - псевдографическое изображение дерева каталогов на машине; выход из пролистывания - q ;
• pwd - выводит каталог, в котором вы сейчас находитесь; в командной строке вы не можете быть «просто так», вы обязательно находитесь в каком-то каталоге (=текущий каталог, рабочий каталог). Вероятно, текущий рабочий каталог выводится у вас в приглашении (prompt).
• ls - список файлов в текущем каталоге; ls /home - список файлов в указанном каталоге;

История команд (history)

Важное свойство полноценной командной строки - история команд.

Выполните несколько команд: hostname , ls , pwd , whoami . Теперь нажмите клавишу «вверх». В строке ввода появилась предыдущая команда. Клавишами «вверх» и «вниз» можно перемещаться вперед и назад по истории. Когда долистаете до hostname , нажмите Enter - команда выполнится еще раз.

Команды из истории можно не просто выполнять повторно, а еще и редактировать. Долистайте историю до команды ls , добавьте к ней ключ -l (получилось ls -l , перед минусом пробел есть, а после - нет). Нажмите Enter - выполнится модифицированная команда.

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

Copy-paste

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

Прекрасной особенностью текста является то, что его можно копировать и вставлять, это верно и для командной строки.

Попробуйте выполнить команду date +"%y-%m-%d, %A"
Вводили ли вы ее целиком руками или скопировали из статьи? Убедитесь, что вы можете ее скопировать, вставить в терминал и выполнить.

После того, как научитесь пользоваться man "ом, убедитесь, что можете скопировать и выполнить примеры команд из справки. Для проверки найдите в справке по программе date раздел EXAMPLES , скопируйте и выполните первый приведенный пример (на всякий случай: знак доллара не является частью команды, это условное изображение приглашения к вводу).

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

Ключи и опции

При исследовании истории команд вы уже столкнулись с тем, что у команды ls есть по крайней мере два варианта. Если вызвать ее просто так, она выводит простой список:

Akira@latitude-e7240: ~/shell-survival-quide> ls Makefile shell-first-steps.md shell-first-steps.pdf shell-survival-quide.md shell-survival-quide.pdf
Если же добавить ключ -l , к каждому файлу выводится подробная информация:

Akira@latitude-e7240: ~/shell-survival-quide> ls -l total 332 -rw-rw-r-- 1 akira akira 198 Feb 13 11:48 Makefile -rw-rw-r-- 1 akira akira 15107 Feb 14 22:26 shell-first-steps.md -rw-rw-r-- 1 akira akira 146226 Feb 13 11:49 shell-first-steps.pdf -rw-rw-r-- 1 akira akira 16626 Feb 13 11:45 shell-survival-quide.md -rw-rw-r-- 1 akira akira 146203 Feb 13 11:35 shell-survival-quide.pdf
Это очень типичная ситуация: если к вызову команды добавлять специальные модификаторы (ключи, опции, параметры), поведение команды меняется. Сравните: tree / и tree -d / , hostname и hostname -f .

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

Ls -ld /home ls -l /home grep root /etc/passwd

man

man - справка по командам и программам, доступным на вашей машине, а также по системным вызовам и стандартной библиотеке C.

Попробуйте: man grep , man atoi , man chdir , man man .

Пролистывание вперед и назад делается кнопками «вверх», «вниз», «PageUp», «PageDown», выход из просмотра справки - кнопкой q . Поиск определенного текста в справочной статье: нажимите / (прямой слеш), введите текст для поиска, нажимите Enter. Перемещение к следующим вхождениям - клавиша n .

Все справочные статьи делятся на категории. Самые важные:

• 1 - исполняемые программы и шелльные команды (wc , ls , pwd и т.п.);
• 2 - системные вызовы (fork , dup2 и т.п.)
• 3 - библиотечные функции (printf , scanf , cos , exec).

Указывать, из какой именно категории надо показать справку, нужно в случаях совпадений имен. Например, man 3 printf описывает функцию из стандартной библиотеки C, а man 1 printf - консольную программу с таким же именем.

Посмотреть список всех доступных на машине справочных статей можно с помощью команды man -k . (точка - тоже часть комады).

less

Когда в небольшом окне терминала надо просмотреть очень длинный текст (содержимое какого-то файла, длинный man и т.п.), используют специальные программы-«пейджеры» (от слова page/страница, то есть постраничные листатели). Самый популярный листатель - less , и именно он обеспечивает вам пролистывание, когда вы читаете man-ы.

Попробуйте и сравните поведение:

Cat /etc/bash.bashrc cat /etc/bash.bashrc |less

Можно передать файл в пролистыватель сразу в параметрах:

Less /etc/bash.bashrc

Пролистывание вверхи и вниз - кнопки «вверх», «вниз», «PageUp», «PageDown», выход - кнопка q . Поиск определенного текста: нажимите / (прямой слеш), введите текст для поиска, нажимите Enter. Перемещение к следующим вхождениям - клавиша n . (Узнаете инструкцию про man ? Ничего удивительного, для вывода справки тоже используется less .)

Права

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

Посмотреть права на файл можно с помощью ls -l . Например:

> ls -l Makefile -rw-r--r-- 1 akira students 198 Feb 13 11:48 Makefile
Этот вывод означает, что владельцу (akira) можно читать и писать файл, группе (students) - только читать, всем прочим пользователя - тоже только читать.

Если при работе вы получаете сообщение permission denied , это значит, что у вас недостаточно правна объект, с которым вы хотели работать.

Подробнее читайте в man chmod .

STDIN, STDOUT, конвейеры (пайпы)

С каждой исполняющейся программой связаны 3 стандартных потока данных: поток входных данных STDIN , поток выходных данных STDOUT , поток для вывода ошибок STDERR .

Запустите программу wc , введите текст Good day today , нажмите Enter, введтие текст good day , нажмите Enter, нажмите Ctrl+d. Программа wc покажет статистику по количеству букв, слов и строк в вашем тексте и завершится:

> wc good day today good day 2 5 24
В данном случае вы подали в STDIN программы двухстрочный текст, а в STDOUT получили три числа.

Теперь запустите команду head -n3 /etc/passwd , должно получиться примерно так:

> head -n3 /etc/passwd root:x:0:0:root:/root:/bin/bash daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin bin:x:2:2:bin:/bin:/usr/sbin/nologin
В этом случае программа head ничего не читала из STDIN , а в STDOUT написала три строки.

Можно представить себе так: программа - это труба, в которую втекает STDIN , а вытекает STDOUT .

Важнейшее свойство юниксовой командной строки состоит в том, что программы-«трубы» можно соединять между собой: выход (STDOUT) одной программы передавать в качестве входных данных (STDIN) другой программе.

Такая конструкция из соединенных программ называется по-английски pipe (труба), по-русски - конвейер или пайп.

Объединение программ в конвейер делается символом | (вертикальная черта)

Выполните команду head -n3 /etc/passwd |wc , получится примерно следующее:

> head -n3 /etc/passwd |wc 3 3 117
Произошло вот что: программа head выдала в STDOUT три строки текста, которые сразу же попали на вход программе wc , которая в свою очередь подсчитала количество символов, слов и строк в полученном тексте.

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

> head -n3 /etc/passwd |wc |wc 1 3 24

Составление конвейеров (пайпов) - очень частое дело при работе в командной строке. Пример того, как это делается на практике, читайте в разделе «Составление конвейера-однострочника».

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

Вывод (STDOUT) програмы можно не только передать другой программе по конвейеру, но и просто записать в файл. Такое перенаправление делается с помощью > (знак «больше»):

Date > /tmp/today.txt
В результате выполнения этой команды на диске появится файл /tmp/today.txt . Посмотрите его содержимое с помощью cat /tmp/today.txt

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

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

Date >> /tmp/today.txt
Проверьте, что теперь записано в файле.

Кроме того, программе можно вместо STDIN передать любой файл. Попробуйте:

Wc

Что делать, когда что-то непонятно

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

• насколько возможно четко сформулируйте вопрос или задачу - нет ничего сложнее, чем решать «то, не знаю что»;
• вспомните, сталкивались ли вы уже с такой же или подобной проблемой - в этом случае стоит попробовать решение, которое сработало в прошлый раз;
• почитайте подходящие man-ы (если понимаете, какие man-ы подходят в вашем случае) - возможно, вы найдете подходящие примеры использования команд, нужные опции или ссылки на другие команды;
• подумайте: нельзя ли немного поменять задачу? - возможно, чуть-чуть изменив условия, вы получите задачу, которую уже умеете решать;
• задайте свой четко сформулированный вопрос в поисковой системе - возможно, ответ найдется на Stack Overflow или других сайтах;

Если ничего из перечисленного не помогло - обратитесь за советом к преподавателю, опытному коллеге или товарищу. И не бойтесь задавать «глупые» вопросы - не стыдно не знать, стыдно не спрашивать.

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

Методы работы

Скопировать-и-вставить - из man-ов, из статей на StackOverflow и т.п.Командная строка состоит из текста, пользуйтесь этим: копируйте и используйте примеры команд,записывайте удачные находки на память, публикуйте их в твиттерах и блогах.

Вытащить из истории предыдущую команду, добавить в конвейер еще одну команду, запустить, повторить .См. также раздел «Составление конвейера-однострочника».

Базовые команды

• переход в другой каталог: cd ;
• просмотр содержимого файлов: саt , less , head , tail ;
• манипуляции с файлами: cp , mv , rm ;
• просмотр содержимого каталогов: ls , ls -l , ls -lS ;
• структура каталогов: tree , tree -d (можно передать в качестве параметра каталог);
• поиск файлов: find . -name ... ;

Аналитика

• wc , wc -l ;
• sort -k - сортировка по указанному полю;
• sort -n - числовая соритровка;
• diff - сравнение файлов;
• grep , grep -v , grep -w , grep "\" , grep -E - поиск текста;
• uniq , uniq -c - уникализация строк;
• awk - в варианте awk "{print $1}" , чтобы оставить только первое поле из каждой строки, $1 можно менять на $2 , $3 и т.д.;

Диагностика системы

• ps axuww - информация о процессах (запущенных программах), работающих на машине;
• top - интерактивный просмотр самых ресурсоемких процессов;
• df - занятое и свободное место на диске;
• du - суммарный размер файлов в каталоге (рекурсивно с подкаталогами);
• strace , ktrace - какие системные вызовы выполняет процесс;
• lsof - какие файлы использует процесс;
• netstat -na , netstat -nap - какие порты и сокеты открыты в системе.

Некоторых программ у вас может не быть, их надо установить дополнительно. Кроме того, некоторые опции этих программ доступны только привилегированным пользователям (root "у).

Массовое и полуавтоматическое выполнение

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

• test - проврека условий;
• while read - цикл по строчкам STDIN ;
• xargs - подстановка строк из STDIN в параметры указанной программе;
• seq - генерация последовательностей натуральных чисел;
• () - объединить вывод нескольких команд;
• ; - выполнить одно за другим;
• && - выполнить при условии успешного завершения первой команды;
• || - выполнить при условии неудачного завершения первой команды;
• tee - продублировать вывод программы в STDOUT и в файл на диске.

Разное

• date - текущая дата;
• curl - скачивает документ по указаному url и пишет результат на STDOUT ;
• touch - обновить дату модификации файла;
• kill - послать процессу сигнал;
• true - ничего не делает, возвращает истину, полезна для организации вечных циклов;
• sudo - выполнить команду от имени root "а.

Составление конвейера-однострочника

Давайте рассмотрим пример реальной задачи: требуется прибить все процессы task-6-server , запущенные от имени текущего пользователя.

Шаг 1.
Понять, какая программа выдает примерно нужные данные, хотя бы и не в чистом виде. Для нашей задачи стоит получить список всех процессов в системе: ps axuww . Запустить.

Шаг 2.
Посмотреть на полученные данные глазами, придумать фильтр, который выкинет часть ненужных данных. Часто это grep или grep -v . Клавишей «Вверх» вытащить из истории предыдущую команду, приписать к ней придуманный фильтр, запустить.

Ps axuww |grep `whoami`
- только процессы текущего пользователя.

Шаг 3.
Повторять пункт 2, пока не получатся чистые нужные данные.

"
- все процессы с нужным именем (плюс, может быть, лишние вроде vim task-6-server.c и т.п.),

Ps axuww |grep `whoami` | grep "\" | grep -v vim ps axuww |grep `whoami` | grep "\" | grep -v vim |grep -v less
- только процессы с нужным именем

Ps axuww |grep `whoami` | grep "\" | grep -v vim |grep -v less |awk "{print $2}"

Pid-ы нужных процессов, п. 3 выполнен

Шаг 4.
Применить подходящий финальный обработчик. Клавишей «Вверх» вытаскиваем из истории предыдущую команду и добавляем обработку, которая завершит решение задачи:

• |wc -l чтобы посчитать количество процессов;
• >pids чтобы записать pid-ы в файл;
• |xargs kill -9 убить процессы.

Задания для тренировки

Хотите попрактиковаться в новых умениях? Попробуйте выполнить следующие задания:

• получите список всех файлов и каталогов в вашем домашнем каталоге;
• получите список всех man -статей из категории 2 (системные вызовы);
• посчитайте, сколько раз в man-е по программе grep встречается слово grep;
• посчитайте, сколько процессов запущено в данный момент от имени пользователя root ;
• найдите, какая команда встречается в максимальном количестве категорий справки (man);
• подсчитайте, сколько раз встречается слово var на странице ya.ru .

Подсказка: вам понадобится find , grep -o , awk "{print $1}" , регулярные выражения в grep , curl -s .

Что изучать дальше?

Если командная строка начинает вам нравиться, не останавливайтесь, продолжайте совершенствовать свои навыки.

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

• find со сложными опциями
• apropos
• locate
• telnet
• netcat
• tcpdump
• rsync
• screen
• zgrep , zless
• visudo
• crontab -e
• sendmail

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

Кому это надо?

А стоит ли вообще изучать сегодня командную строку и шелльный скриптинг? Определенно стоит. Приведу только несколько примеров из требований Facebook к кандидатам, которые хотят поступить на работу в FB.

МОСКВА 2007

Лабораторный практикум по курсу: “Операционная система Red Hat Linux ”

Лабораторная работа №5

Программирование в SHELL

Цель работы : на основе ранее полученных навыков работы с командным интерпретатором BASH овладеть начальными навыками программирования в командном интерпретаторе BASH для создания файлов сценария – SHELL скриптов.

Теоретические сведения

Выполнение отдельных команд в командном интерпретаторе не всегда является эффективным средством работы с SHELL оболочкой. Довольно часто требуется выполнять одни и те же последовательности действий при работе с операционной системой Linux каждый месяц, каждую неделю, каждый день и иногда и несколько раз в день. Например, предположим, вы работаете на фирме тестером программного обеспечения (Test Manager). Каждый день вам требуется в командной оболочке Linux выполнять один тот набор действий, а именно: монтирование устройства CD-ROM; копирование всей информации с него в папку, скажем, /opt/program на жестком диске; демонтирование CD-ROM; чтение файла readme из этой папки; установка программы с жесткого диска из папки /opt/program; создания нового файла отчета в директории /home/user/report_program удаление всего содержимого дистрибутива с жесткого диска. И это притом, что основная ваша работа заключается в тестировании программного обеспечения на предмет выявления недоработок (bags). Задача на первый взгляд простая, но выполнять подобные действия по несколько раз в день, притом, что вы занимаетесь и другими делами, неудобно. Или, например, вы работаете в фирме системным администратором и обслуживаете около 50 компьютеров. Каждый день вам требуется раскопировать на все компьютеры один и тот же файл с инструкциями на текущий день директора фирмы для всех подчиненных. Кроме того, в ваши задачи также входит в конце рабочего дня сохранить все данные каждого пользователя на общем сервере фирмы с персональных компьютеров подчиненных. Задача также на первый взгляд простая, но работа по набору команд в командном интерпретаторе для 50 компьютеров займет много времени. А если к тому же вы при наборе будите ошибаться, например, от усталости? Данные для директора и их владельца очень важны, и потерять их Вам никак нельзя. Но это еще простые действия. А представьте, что названия файлов отчетов, название папок с данными, имена компьютеров каждый раз будут меняться? Что тогда делать? Выход один – написать файл-сценария , т.е. создать текстовый файл, в котором требуется описать всю последовательность команд с путями, опциями, аргументами, выражениями, действиями и так далее для выполнения определенного сценария. Например, резервирования данных. После ввода команд в текстовый файл-сценария, данный файл делают исполняемым или выполняют его специальных операторов выполнения командного интерпретатора. Использование файлов сценария является особенно эффективным, если вам очень часто требуется выполнять последовательность из большого числа команд. Также является эффективным средством, если в зависимости от результатов выполнения предыдущих команд зависит выполнение следующих. С помощью файлов-сценариев можно также использовать арифметические и логические выражения, создавать циклы, обеспечивающие многократное выполнение группы команд Linux.

Создание файлов-сценария. Создания сценариев представляет собой последовательный набор команд, операторов командного интерпретатора и некоторых других символов в текстовом файле. Файлы-сценария также называют скриптами, а командные интерпретаторы латинским названием SHELL. В связи с тем, что на сегодняшний день существуют разные командные интерпретаторы, написание файла-сценария с использованием дополнительных символов, например, метасимволов, совместно с командами не должно противоречить правилам синтаксиса выбранного командного интерпретатора, в котором предполагается выполнять данный скрипт. Процесс написания таких файлов называют SHELL программированием. Рассмотрим процесс программирования на примере интерпретатора BASH. Таким образом, скрипты и правила написания скриптов в данной лабораторной работе могут быть не переносимы на другие интерпретаторы, например, такие как С Shell или TC Shell.

Последовательность #!. Написание любого скрипта начинается с принадлежности его к одному из командных интерпретаторов. В первой строке скрипта обычно пишут последовательность #! , которая указывает системе, какой интерпретатор должен выполнить команды из данного сценария. Если первый символ пробел, считается, что сценарий написан для BASH или PDKSH. Если сценарий начинается только с символа # , то для его выполнения необходим TC Shell. Если же за символом # следует символ!, ядро запустит интерпретатор, путь которого указан далее в этой строке. Например, для BASH будет следующая запись: #!/bin/sh . Пробела или одиночного символа # в начале сценария достаточно для интерпретаторов BASH Shell и TC Shell только при условии, что они будут считывать свой сценарий. Чтобы один интерпретатор распознал сценарии другого, необходимо включать в сценарий символы #! , после чего указывается путь интерпретирующей программы. Тогда при вызове сценария будет прекращена работа текущего интерпретатора, вместо него будет загружен сценарий другого типа, а затем выполнен сценарий. Рекомендуется всегда начинать все сценарии с последовательности #! . Также строки, начинающиеся с символа # можно использовать для комментариев действий пользователя в скрипте. Встретив символ #, интерпретатор shell игнорирует эту строку. Каждый комментарий должен завершаться символом окончания строки. Использование комментариев является признаком хорошего тона.

Расширение и запуск скриптов. Обычно файлы-сценариев имеют не только имена, но также и расширения. Чаще всего в качестве расширений используют комбинацию букв sh от латинского слова shell. По такому расширению, не открывая файл, сразу понятно, что это shell скрипт, так как нам опять же понятно, что файл с расширением . c скорее всего является входным файлом языков высокого уровня С и С++. После набора содержимого файла, файл сохраняется. Запустить файл можно двумя способами либо сделать его исполняемым с помощью команды chmod, либо запускать его с помощью специальных операторов командного интерпретатора: sh и. Обычно пользователи задают для файл-сценария восьмеричные значения 750 или 550. В следующем примере сделаем скрипт script.sh выполняемым с помощью команды chmod и запустим его на выполнение из текущей директории в фоновом режиме.

chmod u+x script.sh

./ script.sh &

Теперь вернем файлу предыдущие атрибуты и запустим его на выполнение с помощью оператора BASH.

chmod u-x script.sh

sh script.sh&

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

echo “Добрый день!”

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

echo “Введите ваше имя: ”

read your _ name

echo “ Добрый день ,” your_name “!”

Данный скрипт усложнен по отношению к предыдущему. Здесь используется переменная your_name , значение которой потом применяется совместно с текстом.

Использование переменных. Как и языках программирования, в shell Вы также можете использовать переменные, присваивать значения переменным можно через оператор присваивания равно «=». Сначала вводится имя переменной, потом без пробела знак «=», затем без пробела значение переменной. Имя переменной может состоять из любого количества буквенных символов, включая символ подчеркивания. Имя может содержать и цифры, однако не должно начинаться с цифры. Все остальные символы (в частности, восклицательный знак, амперсанд и пробел) в имя входить не должны. Такие символы зарезервированы интерпретатором для специальных целей. Как следствие, имя может состоять только из одного слова, поскольку при синтаксическом анализе команд интерпретатор рассматривает пробел как разделитель имен команд и аргументов. Значение переменной может состоять из любой последовательности символов. В следующем примере присвоим переменной «ppp» значение «www123yyy».

ppp =” www 123 yyy ”

Если вы используете в качестве значения переменной строковое значение, используйте двойные кавычки. После присвоения значения вы можете пользоваться именем переменной для ссылки на это значение, например использовать его в качестве аргумента команд сценария. На значение переменной можно ссылаться посредством ее имени, которое предваряется оператором $. Знак доллара - это специальный оператор, который использует имя переменной для ссылки на ее значение, то есть фактически для ее вычисления. Теперь с помощью уже знакомой команды echo и переменной «ppp» можно отображать значение этой переменной.

echo $ppp

www123yyy

Аргументы командной строки. В сценарии, как и в командах Linux, можно использовать аргументы. Аргумент в сценарии обозначается оператором $ с указанием номера позиции в командной строке. Нумерация параметров начинается с единицы, а заканчивается девятью. Первый параметр задается переменной $1, второй - $2 и т. д. Аргумент $0 резерви­руется для имени shell-сценария, в качестве которого выступает первое слово, находя­щееся в командной строке. По умолчанию имеется возможность устанавливать 9 переменных с $1 до $9 . Если вво­дится несколько аргументов, можно отдельно обращаться к каждому из них по его номеру. В следующем примере в командной строке вводятся три аргумента. Предварительно создадим скрипт arguments с аргументами, а потом его выполним.

Обращаем ваше внимание, если вам требуется использовать аргумент(ы) из нескольких слов, вы должны в командной строке взять его (их) в двойные кавычки. Иногда требуется задать в сценарии точное количество аргументов, это можно выполнить с помощью аргумента $# . Параметр $* позволяет указать все аргументы в командной строке.

Переменная export. Иногда для разных файлов-сценария требуется воспользоваться определенной переменной, которая уже была определена. Переменные, которые вы определяете в интерпретаторе shell, являются локальными для него. В некотором смысле такая пе­ременная принадлежит своему интерпретатору. Непосредственно определить переменную для другого интерпретатора нельзя, однако можно экспортировать определение переменной из одного интерпретатора в другой с помощью команды export. Команда export содержит инструкцию для системы, в соответствии с которой для каждого вновь образованного shell будет определяться копия этой переменной. Каждый новый интерпретатор shell будет иметь собственную копию экспортированной переменной. В следующем примере определим переменную «rrr» и экспортируем ее для других интерпретаторов с помощью команды export.

Арифметические операции – команда let . Команда let - это команда интерпретатора BASH shell, обеспечивающая выпол­нение операций над арифметическими величинами. С помощью этой команды можно сравнивать числовые значения или выполнять над ними арифметические операции, такие как сложение или умножение. Формат команды: let значение1 оператор значение2. Приведем пример.

$ let 2*5

10

В арифметические выражения, использующие оператор let, можно включать и опе­раторы присваивания. В следующем примере результат умножения двух чисел присваи­вается переменной total.

$ let “total=2*5”

$ echo $total

10

$

Операторы сравнения часто используются для сравнения числовых значений в управ­ляющих конструкциях, таких как циклы и условные переходы. В следующем примере команды сценария file1 четырежды выводят на экран слово "Привет!". В данном случае для управления выходом из цикла используется оператор let "ttt <= 4", а для увеличения переменной цикла again на единицу - оператор let "ttt = ttt + 1". Обратите внимание на то, что при изменении переменной again ее вычислять не требуется.

File1

ttt=l

while let "ttt<= 4"

do

echo $ttt Привет!

let "ttt = ttt + 1"

done

Выполнение скрипта:

$ file1

Привет!

Привет!

Привет!

Кроме того, вы также можете использовать и другие арифметические операторы. В таблице 1 приведены арифметические операторы и операторы сравнения Bash Shell.

Таблица 1 - Операторы BASH shell

Арифметические операторы	Функции
	Умножение
	Сложение
	Вычитание
	Деление с остатком
Операторы сравнения	Функции
	Больше чем
	Меньше чем
	Больше либо равно
	Меньше либо равно
	Равенство в выражениях
	Равенство в команде let
	Не равно
	Логическое И
	Логическое ИЛИ
	Логическое НЕ

Управляющие конструкции. Управляющие конструкции предназначены для управления ходом выполнения команд shell-сценария. Эти конструкции позволяют организовать повторное выполнение определенной последовательности команд или выбирать для выполнения команды, необходимые в конкретной ситуации. Управляющая конструкция состоит из двух основ­ных компонентов: операции проверки и команд. В результате выполнения сравнения (проверки условия) возвращается значение «истина» или «ложь», а затем на основании полученного результата выполняются определенные команды. Существует два вида управляющих конструкций: циклические (циклы) и условные (ус ловия). Циклическая конструкция используется для повторного выполнения команд, тогда как условная - для выполнения последовательности команд., которая удовлетво­ряет определенным условиям. В интерпретаторе BASH shell можно использовать три циклические конструкции, while, for и for-in, и две условные - if и case.

Управляющие конструкции while и if - это конструкции общего назначения, которые обычно используются при решении таких задач, как итерационные вычисления и проверка различных условий. Управляющие конструкции case и for ориентированы на более узкий круг задач. Конструкция case является многовариантным оператором и представляет собой частный случай условного оператора if. Эта конструкция часто используется при создании меню. Конструкция for представляет собой цикл, однократно обрабатывающий всю информацию для каждого значения, включенного в список, до тех пор, пока не встретится окончание списка.

Кроме сравнения значений или переменных, управляющие конструкции if и while можно применять для проверки того, успешно или неудачно была выполнена системная команда Linux. Напомним, что в Linux каждая выполняемая команда возвращает код завершения. Если выполнение команды было успешным, ее код завершения равен 0. Если по какой-либо причине команда не была выполнена успешно, кодом завершения будет некоторое положительное значение, указывающее тип ошибки. Управляющие кон­струкции if и while позволяют проверить, чему был равен код завершения: 0 или некоторому другому значению. Если код завершения равен нулю, значит, выполнение команды было успешным и управляющая конструкция if или while будет завершена.

Команда test . Сравнивать значения можно не только с помощью условных управляющих конструкций, но также с помощью команды test. При сравнении двух значений test возвращает 0 в том случае, если сравнение будет успешным. Команда test позволяет сравнивать целые числа, строки и даже выполнять логи­ческие операции. Совместно с командой test применяют опции, которые задают тип сравнения. Полный перечень опций приведен в таблице 2.

Таблица 2. Операции, выполняемые командой test интерпретатора BASH shell

Сравнение целых чисел	Функция
	Больше чем
	Меньше чем
	Больше чем либо равно
	Меньше чем либо равно
	Не равно
Сравнение строк	Функция
	Проверка на наличие пустой строки
	Проверка на наличие строкового значения
	Проверка строк на равенство
	Прооверка строк на неравенство
	Проверка на наличие строки, состоящей из нулей
Логические операции	Функция
	Логическое И
	Логическое ИЛИ
	Логическое НЕ
Проверка файлов	Функция
	Установка факта существования файла и его регулярности
	Проверяется, не является ли файл пустым
	Проверка возможности считывания из файла
	Проверка возможности записи в файл, а также его изменения
	Проверяется, является ли файл исполнимым
	Проверяется, является ли имя файла именем каталога
	Проверяется, является ли имя файла символической ссылкой
	Проверяется, обозначает ли имя файла байт-ориентированное устройство
	Проверяется, обозначает ли имя блок-ориентированное устройство

Команда test имеет следующий синтаксис:

test значение -опция значение

test строка = строка

В следующем примере покажем пример использования команды test. Сравним целочисленных значения, для этого используем опцию равенства –eq. Для проверки результата выполнения операции сравнения используем код завершения последней выполненной командыtest, который храниться в переменной $? интерпретатораshell.

$ tot = 4

$ test $ tot -eq 7

$ echo $?

1

Также команда test $tot –eq 7 может быть записана и в другом виде:

$ [ $tot –eq 7 ]

Условные конструкции: if, if-else, elif, case . Интерпретатор BASH shell включает несколько условных управляющих конструкций (табл. 3), которые позволяют выбирать для выполнения определенные команды Linux. Многие из этих конструкций напоминают условные управляющие конструкции в языках программирования, но имеются и некоторые отличия.

Таблица 3 – Управляющие конструкции интерпретаторов bash Shell

Условные управляющие конструкции	Функция
if команда then команда fi	Конструкция if вызывает выполнение действия в случае, если результат проверки истинен
if команда then команда else команда fi	Конструкция if-else вызывает выполнение действия в случае, если код завершения проверяемой команды paвен значению «истина», в противном случае выполняется действие else
if команда then команда elif команда then команда else команда fi	Конструкция elif дает возможность вкладывать конструкции if, что позволяет выбрать один из многих вариантов; если истинно условие, проверяемое первой конструкцией if, выполняются предусмотренные в ней команды и следующей конструкции elif управление не передается
case строка in шаблон) команда;; еsас	Конструкция case сравнивает строковое значение с одним из нескольких шаблонов (образцов). При обнаружении совпадения выполняются команды, соответствующие этому шаблону
команда && команда	Логическая операция И возвращает значение 0 («истина»), если обе команды возвращают значение 0; если же одна из команд возвращает ненулевое значение, резуль­тат операции И равен «ложь» и данная операция воз­вращает ненулевое значение
команда | | команда	Логическая операция ИЛИ, возвращающая значение 0 («истина») в случае, если одна или обе команды возвра­щают значение 0 («истина»); если обе команды возвра­щают ненулевое значение, то результат операции ИЛИ - «ложь» и операция возвращает ненулевое значение
Команда	Логическая операция НЕ, инвертирует код завершения команды
while команда do команды done	Конструкция while выполняет действие до тех пор, пока команда проверки возвращает значение «истина»
until команда do команды done	Конструкция until выполняет действие до тех пор, пока команда проверки возвращает значение «ложь»
Циклические управляющие конструкции	Функция while, until, for, for-in, select
for переменная in список-значений do команды done	Конструкция for-in предназначена для обработки списка значений. Переменной последовательно присваиваются значения из списка
for переменная do команды done	Конструкция for предназначена для последовательной обработки аргументов сценария. Переменной последовательно присваивается значение каждого аргумента
select строка in перечень-элементов do команды done	Конструкция select создает меню на основе элементов заданного списка, а затем выполняется указанная команда (обычно это команда case)

Условная конструкция if - then . Условная конструкция if ставит условие на выполнение команды. Этим условием является код завершения какой-то конкретной команды Linux. Если команда выполнена успешно (то есть код завершения равен 0), то команды внутри конструкции if выполняются. Если код завершения отличен от 0, то команды внутри конструкции if выполняться не будут. Иногда требуется выбрать один из двух вариантов, в зависимости от того как была выполнены команда Linux. Ключевое слово else конструкции if позволяет выбрать один из двух вариантов. Приведем синтаксис команды if-then-else.

Как уже говорилось выше, для построения произвольных алгоритмов необходимо иметь операторы проверки условий. Оболочка bash поддерживает операторы выбора if … then … else и case , а также операторы организации циклов for , while , until , благодаря чему она превращается в мощный язык программирования.

5.8.1 Операторы if и test (или )

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

if list1 then list2 else list3 fi

где list1 , list2 и list3 — это последовательности команд, разделенные запятыми и оканчивающиеся точкой с запятой или символом новой строки. Кроме того, эти последовательности могут быть заключены в фигурные скобки: {list} .

Оператор if проверяет значение, возвращаемое командами из list1 . Если в этом списке несколько команд, то проверяется значение, возвращаемое последней командой списка. Если это значение равно 0, то будут выполняться команды из list2 ; если это значение не нулевое, будут выполнены команды из list3 . Значение, возвращаемой таким составным оператором if , совпадает со значением, выдаваемым последней командой выполняемой последовательности.

Полный формат команды if имеет вид:

if list then list [ elif list then list ] ... [ else list ] fi

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

В качестве выражения, которое стоит сразу после if или elif , часто используется команда test , которая может обозначаться также квадратными скобками . Команда test выполняет вычисление некоторого выражения и возвращает значение 0, если выражение истинно, и 1 в противном случае. Выражение передается программе test как аргумент. Вместо того, чтобы писать

test expression,

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

[ expression ].

Заметьте, что test и [ — это два имени одной и той же программы, а не какое-то магическое преобразование, выполняемое оболочкой bash (только синтаксис [ требует, чтобы была поставлена закрывающая скобка). Заметьте также, что вместо test в конструкции if может быть использована любая программа.

В заключение приведем пример использования оператора if :

if [ -e textmode2.htm ] ; then

ls textmode*

else

pwd

Об операторе test (или […]) надо бы поговорить особо.

5.8.2 Оператор test и условные выражения

Условные выражения, используемые в операторе test , строятся на основе проверки файловых атрибутов, сравнения строк и обычных арифметических сравнений. Сложные выражения строятся из следующих унарных или бинарных операций ("элементарных кирпичиков"):

A file

Верно, если файл с именем file существует.

B file

Верно, если file существует и является специальным файлом блочного устройства.

C file

Верно, если file существует и является специальным файлом символьного устройства.

D file

Верно, если file существует и является каталогом.

E file

Верно, если файл с именем file существует.

F file

Верно, если файл с именем file существуети является обычным файлом.

G file

Верно, если файл с именем file существуети для него установлен бит смены группы.

H file или -L file

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

K file

Верно, если файл с именем file существуети для него установлен "sticky"" bit.

P file

Верно, если файл с именем file существуети является именованным каналом (FIFO).

R file

Верно, если файл с именем file существуети для него установлено право на чтение

S file

Верно, если файл с именем file существуети его размер больше нуля .

T fd

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

U file

Верно, если файл с именем file существуети для него установлен бит смены пользователя.

W file

Верно, если файл с именем file существуети для него установлено право на запись.

X file

Верно, если файл с именем file существуети является исполняемым .

O file

Верно, если файл с именем file существуети его владельцем является пользователь, на которого указывает эффективный идентификатор пользователя.

G file

Верно, если файл с именем file существуети принадлежит группе, определяемой эффективным идентификатором группы.

S file

Верно, если файл с именем file существуети является сокетом.

N file

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

file1 -nt file2

Верно, если файлfile1 имеет более позднее время модификации, чем file2 .

file1 -ot file2

Верно, если файлfile1 старше , чем file2 .

file1 -ef file2

Верно, если файлыfile1 и file2 имеют одинаковые номера устройств и индексных дескрипторов (inode).

O optname

Верно, если задействована опция оболочки optname . Пояснения см. на странице man bash.

Z string

Верно, если длина строки равна нулю.

N string

Верно, если длина строки не равна нулю.

string1 == string2

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

string1 !== string2

Верно, если строки не совпадают.

string1 < string2

Верно, если строка string1 лексикографически предшествует строке string2 (для текущей локали).

string1 > string2

Верно, если строка string1 лексикографически стоит после строки string2 (для текущей локали).

arg1 OP arg2

Здесь OP — это одна из операций арифметического сравнения: -eq (равно), -ne (не равно), -lt (меньше чем), -le (меньше или равно), -gt (больше), -ge (больше или равно). В качестве аргументов могут использоваться положительные или отрицательные целые.

Из этих элементарных условных выражений можно строить сколь угодно сложные с помощью обычных логических операций ОТРИЦАНИЯ, И и ИЛИ:

!(expression)

Булевский оператор отрицания.

expression1 -a expression2

Булевский оператор AND (И). Верен, если верны оба выражения.

expression1 -o expression2

Булевский оператор OR (ИЛИ). Верен, если верно любое из двух выражений.

Такие же условные выражения используются и в операторах while и until , которые мы рассмотрим чуть ниже.

5.8.3 Оператор case

Формат оператора case таков:

case word in [ [(] pattern [ | pattern ] ...) list ;; ] ... esac

Команда case вначале производит раскрытие слова word , и пытается сопоставить результат с каждым из образцов pattern поочередно. После нахождения первого совпадения дальнейшие проверки не производятся, выполняется список команд, стоящий после того образца, с которым обнаружено совпадение. Значение, возвращаемое оператором, равно 0, если совпадений с образцами не обнаружено. В противном случае возвращается значение, выдаваемое последней командой из соответствующего списка.

Следующий пример использования оператора case заимствован из системного скрипта /etc/rc.d/rc.sysinit.

case "$UTC" in

yes|true)

CLOCKFLAGS="$CLOCKFLAGS -u";

CLOCKDEF="$CLOCKDEF (utc)";

no|false)

CLOCKFLAGS="$CLOCKFLAGS --localtime";

CLOCKDEF="$CLOCKDEF (localtime)";

esac

Если переменная принимает значение yes или true, то будет выполнена первая пара команд, а если ее значение равно no или false - вторая пара.

5.8.4 Оператор select

Оператор select позволяет организовать интерактивное взаимодействие с пользователем. Он имеет следующий формат:

select name [ in word; ] do list ; done

Вначале из шаблона word формируется список слов, соответствующих шаблону. Этот набор слов выводится в стандартный поток ошибок, причем каждое слово сопровождается порядковым номером. Если шаблон word пропущен, таким же образом выводятся позиционные параметры. После этого выдается стандартное приглашение PS3, и оболочка ожидает ввода строки на стандартном вводе. Если введенная строка содержит число, соответствующее одному из отображенных слов, то переменной name присваивается значение, равное этому слову. Если введена пустая строка, то номера и соответствующие слова выводятся заново. Если введено любое другое значение, переменной name присваивается нулевое значение. Введенная пользователем строка запоминается в переменой REPLY . Список команд list выполняется с выбранным значением переменной name .

Вот небольшой скрипт:

#!/bin/sh

echo "Какую ОС Вы предпочитаете?"

select var in "Linux" "Gnu Hurd" "Free BSD" "Other"; do

break

done

echo "Вы бы выбрали $var"

Какую ОС Вы предпочитаете?
1) Linux
2) Gnu Hurd
3) Free BSD
4) Other
#?

Нажмите любую из 4 предложенных цифр (1,2,3,4). Если вы, например, введете 1, то увидите собщение:

“Вы бы выбрали Linux”

5.8.5 Оператор for

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

for name in words do list done.

Правила построения списков команд (list ) такие же, как и в операторе if .

Пример. Следующий скрипт создает файлы foo_1, foo_2 и foo_3:

for a in 1 2 3 ; do

touch foo_$a

done

В общем случае оператор for имеет формат:

for name [ in word; ] do list ; done

Вначале производится раскрытие слова word в соответствии с правилами раскрытия выражений, приведенными выше. Затем переменной name поочередно присваиваются полученные значения, и каждый раз выполняется список команд list . Если "in word " пропущено, то список команд list выполняется один раз для каждого позиционного параметра, который задан.

В Linux имеется программа seq , которая воспринимает в качестве аргументов два числа и выдает последовательность всех чисел, расположенных между заданными. С помощью этой команды можно заставить for в bash работать точно так же, как аналогичный оператор работает в обычных языках программирования. Для этого достаточно записать цикл for следующим образом:

for a in $(seq 1 10) ; do

cat file_$a

done

Эта команда выводит на экран содержимое 10-ти файлов: " file_1", ..., "file_10".

5.8.6 Операторы while и until

Оператор while работает подобно if , только выполнение операторов из списка list2 циклически продолжается до тех пор, пока верно условие, и прерывается, если условие не верно. Конструкция выглядит следующим образом:

while list1 do list2 done.

while [ -d mydirectory ] ; do

ls -l mydirectory >> logfile

echo -- SEPARATOR -- >> logfile

sleep 60

done

Такая программа будет протоколировать содержание каталога "mydirectory" ежеминутно до тех пор, пока директория существует.

Оператор until аналогичен оператору while :

until list1 do list2 done.

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

5.8.7 Функции

Синтаксис

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

function name () { list }

Причем слово function не обязательно, name определяет имя функции, по которому к ней можно обращаться, а тело функции состоит из списка команд list , находящегося между { и }. Этот список команд выполняется каждый раз, когда имя name задано как имя вызываемой команды. Отметим, что функции могут задаваться рекурсивно, так что разрешено вызывать функцию, которую мы задаем, внутри нее самой.

Функции выполняются в контексте текущей оболочки: для интерпретации функции новый процесс не запускается (в отличие от выполнения скриптов оболочки).

Аргументы

Когда функция вызывается на выполнение, аргументы функции становятся позиционными параметрами (positional parameters) на время выполнения функции. Они именуются как $n , где n — номер аргумента, к которому мы хотим получить доступ. Нумерация аргументов начинается с 1, так что $1 — это первый аргумент. Мы можем также получить все аргументы сразу с помощью $* , и число аргументов с помощью $# . Позиционный параметр 0 не изменяется.

Если в теле функции встречается встроенная команда return , выполнение функции прерывается и управление передается команде, стоящей после вызова функции. Когда выполнение функции завершается, позиционным параметрам и специальному параметру # возвращаются те значения, которые они имели до начала выполнения функции.

Локальные переменные (local)

Если мы хотим создать локальный параметр, можно использовать ключевое слово local . Синтаксис ее задания точно такой же, как и для обычных параметров, только определению предшествует ключевое слово local: local name=value .

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

seq()

local I=$1;

while [ $2 != $I ]; do

echo -n "$I ";

I=$(($I + 1))

done;

echo $2

Обратите внимание на опцию -n оператора echo , она отменяет переход на новую строку. Хотя это и несущественно для тех целей, которые мы здесь имеем в виду, это может оказаться полезным для использования функции в других целях.

Функция вычисления факториала fact

Еще один пример:

fact()

if [ $1 = 0 ]; then

echo 1;

else

echo $(($1 * $(fact $(($1 — 1)))))

Это функция факториала, пример рекурсивной функции. Обратите внимание на арифметическое расширение и подстановку команд.

В. Костромин (kos at rus-linux dot net) - 5.8. Shell как язык программирования