PID (Process IDentificator), перечисленные в первой колонке, это неповторяющиеся числа приписанные всем идущим процессам.
Последний столбец (COMMAND) дает имя выполняемой команды. Здесь мы видим только процессы, которые инициировал Larry. (В системе выполняется и много других
процессов. Команда "ps -aux" может выдать перечень всех происходящих в данный момент процессов).
В выведенном перечне указаны bash (это оболочка, используемая Larry) и сама команда ps. Как вы видите, bash выполняется параллельно с командой ps. bash выполнит ps, когда Larry введет команду. После окончания ps (после того, как выдана таблица процессов), управление возвращается к процессу bash, который выдаст на экран подсказок готовности к приему новых команд.
Выполняемый процесс известен shell как работа. Термины процесс и работа взаимозаменяемы. Однако процесс обычно воспринимается, как "работа", когда речь идет об управлении работами (job control)- свойстве shell, позволяющем уделять внимание нескольким независимым работам.
В большинстве случаев пользователи выполняют в каждый момент времени одну работу, ту которая соответствует последней переданной shell команде. Однако, используя управление работами, вы можете одновременно выполнять несколько работ, по необходимости переключаясь с одной на другую. Какая от этого польза? Давайте предположим, что вы редактируете текстовый файл и неожиданно хотите прерваться и сделать что-то другое. С помощью управления работами вы можете отложить редактирование и, вернувшись к подсказке shell, начать какую-то другую работу. После этого вы можете вернуться к редактированию, именно к тому месту, где вы прервали редактирование. Это всего один пример. Управление работами очень полезно на практике.
3.2 Выполнение работ на переднем плане и в фоне
Работы могут выполняться как на переднем плане, так и в фоне. На переднем плане в каждый момент может быть только одна работа. Работа переднего плана, это работа, с которой вы взаимодействуете, она получает информацию с клавиатуры и посылает результаты на ваш экран. С другой стороны, фоновые работы не получают информации с терминала, в общем случае
они тихо (в смысле - мирно) выполняются, не испытывая потребности в общении с пользователем.
Некоторые работы требуют очень большого времени для своего завершения и не свершают ничего внешне интересного в процессе этой работы. Компиляция программ - одна из таких работ, как и компрессия больших файлов. Нет вразумительных причин, почему вы должны при этом сидеть рядом и мучительно ждать, когда эти работы закончатся. Вы можете просто запустить их в фоне. Пока они там выполняются, вы можете заняться другими программами.
Работы могут быть также отложены. Отложенная работа - это работа, которая в данный момент не выполняется и временно остановлена. После того, как вы остановили работу, в дальнейшем вы можете ее продолжить как на переднем плане, так и в фоне. Возобновление приостановленной работы не изменит ее состояния - при возобновлении она начнется с того места, на котором была приостановлена.
Имейте в виду, что приостановка работы, это не прерывание работы. Когда вы прерываете идущий процесс (нажимая клавиши прерывания, обычно это ctrl-C), то убиваете процесс насовсем. (Клавиши прерывания можно переустанавливать командой stty. По умолчанию прерывание находится под ctrl-C, но мы не можем это гарантировать для всех систем). Если работа убита, то уж убита, и нет другого способа возобновить ее, как вновь запустить сначала, используя прежнюю команду. Заметим также, что некоторые программы могут перехватывать прерывания, тогда нажатие ctrl-C не приведет к немедленному прекращению работы. Это позволит программе выполнить необходимые операции аккуратного завершения. Некоторые программы вообще не позволят вам их прервать.
3.3 Работа в фоне и ликвидация работ
Давайте начнем с простого примера. Команда yes - вроде бы бесполезная команда, посылающая бесконечный поток "у" на стандартный выход. (Но это очень полезно. Если вы направите
через конвейер эти "у" на вход другой команды, которая требует ответов yes и "по" на вопросы, поток "у" даст подтверждение на все вопросы). Попробуйте.
/home/larry# yes
У
У
У
У
У
Это закончится в бесконечности. Вы можете убить процесс, нажав клавиши прерывания; обычно это ctrl-C. Чтобы нас больше не раздражал поток нескончаемых "у", перенаправим его в /dev/null. Как вы помните, /dev/null выступает в качестве "черной дыры" для данных. В ней исчезают бесследно любые данные.
/home/larry# yes > /dev/null
Ох, теперь намного лучше. Ничего не печатается, но и подсказка shell не появляется. Это потому, что программа продолжает работать, посылать "у" в /dev/null. Снова нажмите клавиши прерывания, чтобы прекратить это.
Давайте предположим, что мы хотим, чтобы команда yes продолжала работать, но также хотим получить обратно подсказку shell, чтобы выполнять другие работы. Мы можем перевести команду yes в фоновый режим, что позволит ей выполняться, но без выхода на взаимодействие с пользователем.
Чтобы переместить процесс в фоновый режим, необходимо после команды символ "&".
/home/larry# yes > /dev/null &;
[1]. 164
/home/larry#
Вы видите, что мы вновь получили подсказку. Но что значит "1 164"? И выполняется ли команда yes на самом деле?
"1" представляет номер работы для программы yes. Shell приписывает номер каждой выполняемой работе. Поскольку "yes" - одна единственная работа, которая в данный момент выполняется, ей присвоен номер 1. "164" - идентификатор процесса (PID); это номер, присвоенный системой работе. Любой
из этих номеров можно использовать при обращении к работе, как это будет показано в дальнейшем.
Теперь мы имеем выполняемый процесс yes в фоновом режиме, непрерывно посылающий поток "у"-ков в /dev/null. Чтобы проверить состояние этого процесса, используйте внутреннюю команду shell -jobs.
/home/larryfl jobs
[1]+ Running yes >/dev/null &
/home/larry#
Ясно, что она выполняется. Вы можете также воспользоваться командой ps, показанной ранее, для проверки статуса работ.
Для завершения работы используйте команду kill. Эта команда может брать в качестве аргумента как номер работы, так и идентификатор процесса. Это была работа номер 1, так что используя команду
/home/larry# kill %1
мы ликвидируем работу. При идентификации работы по номеру необходимо впереди ставить символ процента ("%").
Теперь, после ликвидации, мы можем снова использовать jobs для проверки:
/home/larry# jobs
[1]+ Terminated yes >/dev/null
/home/larry#
Работа действительно мертва, и если мы снова* воспользуемся командой jobs, ничего не будет выведено на экран. Вы можете также убить работу, используя номер идентификатора процесса (PID), который выводится наряду с работой, когда вы начинаете работу (в фоновом режиме). В нашем пример PID равен 164, так что команда /home/larry# kill 164
эквивалентна /home/larry# kill %1
??????? работе по номеру идентификатора процесса. 3.4 Остановка и возобновление работы
Есть другой способ перевести работу в фоновый режим. Вы можете начать работу нормально (в режиме переднего плана), остановить работу и продолжить в фоновом режиме. Сначала начнем работу "нормально":
/home/larry# yes > /dev/null
Поскольку опять работа выполняется на переднем плане, вы не получите обратно на экран подсказку shell.
Теперь, вместо того, чтобы прерывать работу с помощью ctrl-C, мы остановим работу. Приостановка работы не убивает ее. Чтобы осуществить приостановку работы, надо нажать соответствующие клавиши, обычно это ctrl-Z. /home/larry# yes > /dev/null [ctrl-Z]
[1]+ Stopped . yes >/dev/null /home/larry#
. Пока работа остановлена, она просто не выполняется. На нее не тратится время процессора. Но вы всегда можете возобновить работу, и она продолжится как ни в чем не бывало.
Для возобновления работы в режиме переднего плана используйте команду fg ("foreground" - передний план). /home/larry# fg yes >/dev/null
Shell снова выдаст на экран имя команды, чтобы вы могли проконтролировать, какую работу вы активизировали в режиме переднего плана. Вновь остановите работу с помощью ctrl-Z. В этот раз используйте команду bg ("background" - задний план, фоновый режим), чтобы перевести работу в фоновый режим. Эффект будет аналогичен тому, как если бы вы набрали после команды "&".
/home/larry# bg
[1]+ yes >/dev/null &
/home/larry#
????мы. получили назад подсказку. Команда jobs сообщит, что команда yes действительно выполняется, и мы можем снова ее убить с помощью команды kill, как мы это уже делали.
Как теперь остановить работу? Использование ctrl-Z не поможет, поскольку работа находится в фоновом режиме. Ответ - переместить работу на передний план, а затем остановить. Вы можете использовать fg как для остановленных работ, так и для работ, находящихся в фоне.
Существует большая разница между фоновой работой и остановленной. Остановленная работа не выполняется и не использует время процессора, да и никакой работы, честно говоря, в этот момент не делает (но занимает память, хотя по воле своппинга может оказаться на диске). Работа в фоновом режиме и выполняется, и занимает память. Она может даже выводить что-то на экран, хотя это может раздражать вас, когда вы работаете над чем-то другим. Например, если вы использовали команду:
/home/larry# yes &
без перенаправления stdout в /dev/null, поток "у" будет выводиться на экран без возможности прервать это (вы не сможете использовать ctrl-C для прерывания работ фонового режима). Чтобы остановить эту бесконечную выдачу, вам следует использовать команду fg для перевода работы в режим переднего плана, а затем использовать ctrl-C, чтобы ее убить.
Еще одно замечание. Команды fg и bg обычно переводят на передний план или в фоновый режим работы, которые были остановлены последними (что определяется символом "+" после номера работы, это когда вы используете команду jobs). Если вы выполняете много работ одновременно, вы можете перевести на передний план или, наоборот, в фоновый режим конкретную работу заданием идентификатора работы в качестве аргумента команд fg или bg, как в
/home/larry# fg %2
(перевод на передний план работы номер 2) или /home/larry# bg %3
(перевод в фон работы номер 3).
Для этих команд нельзя использовать идентификаторы процессов. Кроме того, использование только номеров работ, как
в
/home/larry# %2
эквивалентно
/home/larry# fg %2
Помните, что управление работами, это свойство shell. Команды fg, bg и jobs - внутренние команды shell. Если по какой- то причине вы используете shell, который не поддерживает управление работами, там вы не найдете этих команд.
4. Порядок выполнения работы
Внимательно ознакомившись с приведенным в главах 1-3 материалах проделать следующее:
1) С данными, созданными во 2-ой лабораторной работе, последовательно изменять права доступа и информацию об измененных правах записывать в log-файл. Необходимо перебрать все возможные варианты прав доступа, для группы, создателя и пользователей.
2) Пользуясь командами SHELLa, для всех своих данных создать символические и/или жесткие связи и создать log- файлы с содержанием индексов для жестких связей, и ссылок для символических.
3) Запустить любые 5 процессов и перевести их в режим фона и показать в log-файле, что данный процесс работает в фоновом режиме.
4) Удалить эти процессы используя shell-команды
5. Контроль выполнения работы
Отчет должен содержать:
- краткие описание проделанной работы
- дискету с данными результатов
Студент должен уметь рассказать о достижении полученных результатов, а также, при необходимости показать, как он достиг этого.
6. Контрольные вопросы
1. Опишите концепцию прав доступа, которая применяется в LINUX?
2. Какие права доступа могут быть в Linux, и что каждое право позволяет сделать?
3. Что такое группы, зачем они используются, и какие бывают?
4. Объясните, что означает строка "-rw-r—r—" в правах доступа к файлу?
5. Зависимости прав доступа файла и каталога. Приведите примеры?
6. Команда изменения прав доступа к фалам и каталогам: имя, синтаксис, примеры?
7. Какие бывают связи в Linux, чем они отличаются?
11. Команды, используемые для работы . со связями: имена, синтаксис, примеры?
12. Что такое процессы и работы?
13. Что такое отложенная работа?
14. Как могут выполняться работы? В чем отличие?
15. Какая разница между фоновой и остановленной работой?
16. Команда просмотра процессов: имя, синтаксис, примеры?
17. Назначение команды jobs, и ее отличие от команды ps?
18. Команды для переноса процессов: имена, синтаксис, примеры?
19. Методы остановки и возобновления работ?
20. Команда для удаления процессов: имена, синтаксис, примеры?
Лабораторная работа № 10 Программирование на SHELL. Часть 1
1.Сценарии shell
Shell обеспечивает различные механизмы настройки вашей рабочей среды. Мы уже упоминали ранее, что shell больше, чем команда интерпретации - это также мощный язык программирования.
Предположим, что вы часто используете серию команд и хотели бы сократить объем постоянной печати за счет группировки их в одну команду. Например, команды
/home/guest# cat chapter1 chapter2 chapter3 > book
/home/guest# wc -1 book /home/guest# lp book
объединяют файлы, содержащие главы книги: chapter1, chapter2, chapter3, и помещают результат в файл book. Затем подсчитывается число строк в книге (в файле book) и отображается на дисплее и, наконец, печатается командой 1р.
Вместо введения каждый раз этих команд, вы можете собрать их в один сценарий (командный файл). Сценарий, который выполнит вышеприведенные команды, будет выглядеть следующим образом
#!/bin/sh
# A shell script to create and print the book
cat chapter1 chapter2 chapter3 > book wc -1 book lp book
Если этот сценарий будет помещен в файл makebook, то вы можете просто использовать далее команду
/home/guest# makebook
которая выполнит все команды сценария. Сценарии shell - это обычные текстовые файлы, которые вы можете создавать с помощью редактора.
Давайте посмотрим на этот сценарий. Первая строка "#!bin/sh/" говорит о том, что этот файл есть сценарий и сообщает shell, как выполнить сценарий. В данном случае необходимо передать сценарий для выполнения команде bin/sh/, где bin/sh/ - сама программа shell. Почему это важно? В большинстве систем UNIX bin/sh/ - это shell Баурновского типа, например bash. Инициируя работу сценария shell выполняется, используя bin/sh/, при этом мы гарантируем, что сценарий будет выполняться именно под shell Баурновского типа (а не, скажем, под С shell). Этот сценарий будет выполняться под shell Баурна, даже если вы используете Tcsh (или какой-то другой С shell) как свою рабочую оболочку.
Вторая строка представляет из себя комментарий. Комментарии начинаются символом "#" и могут продолжаться до конца строки - они игнорируются shell и могут использоваться программистом для пояснений.
Остальные строки сценария - обычные команды в том виде, в каком бы вы их вводили прямо на выполнение. Shell читает каждую строку сценария и выполняет эту строку, как будто вы ввели эту строку в ответ на подсказку shell.
Права доступа важны для сценариев. Если вы создали сценарий, вы должны убедиться, что вы имеете права на его выполнение. Если вы создавали сценарий в редакторе, то он (обычно) не получает автоматически прав на выполнение. Можно использовать команду
/home/guest# chmod u+x makebook чтобы дать самому себе разрешение на выполнение shell- сценария makebook.
2.Среда SHELL 2.1.shell-переменные
Имя shell-переменной - это начинающаяся с буквы последовательность букв, цифр и подчеркиваний. Значение shell- переменной - строка символов.
То, что в shell всего два типа данных: строка символов и текстовый файл, с одной стороны, позволяет легко вовлекать в программирование конечных пользователей, никогда ранее программированием не занимавшихся, а с другой стороны, вызывает некий внутренний протест у многих программистов, привыкших к существенно большему разнообразию и большей гибкости языковых средств.
Имя переменной аналогично традиционному представлению об идентификаторе, т.е. именем может быть последовательность букв, цифр и подчеркиваний, начинающаяся с буквы или подчеркивания.
Для присваивания значений переменным может использоваться оператор присваивания "=".
var_1=13 - "13" - это не число, а строка из двух цифр.
var_2="OC UNIX" - здесь двойные кавычки {" ") необходимы, так как в строке есть пробел.
Возможны и иные способы присваивания значений shell- переменным. Так например запись, DAT= `date'
приводит к тому, что сначала выполняется команда "date" (обратные кавычки говорят о том, что сначала должна быть выполнена заключенная в них команда), а результат ее выполнения, вместо выдачи на стандартный выход, приписывается в качестве значения переменной, в данном случае "DAT".
Можно присвоить значение переменной и с помощью команды "read", которая обеспечивает прием значения переменной с (клавиатуры) дисплея в диалоговом режиме. Обычно команде "read" в командном файле предшествует команда "echo", которая позволяет предварительно выдать какое- то сообщение на экран. Например:
echo -n "Введите трехзначное число:" read x
При выполнении этого фрагмента командного файла, после вывода на экран сообщения
Введите трехзначное число:
интерпретатор остановится и будет ждать ввода значения с клавиатуры. Если вы ввели, скажем, "753" то это и станет значением переменной "х".
Одна команда "read" может прочитать (присвоить) значения сразу для нескольких переменных. Если переменных в "read" больше, чем их введено (через пробелы), оставшимся присваивается пустая строка. Если передаваемых значений больше, чем переменных в команде "read", то лишние игнорируются.
При обращении к shell-переменной необходимо перед именем ставить символ "$".
Например,
/home/guest# foo="hello there"
Переменной foo присвоено значение "hello there". Теперь вы можете обратиться к этой переменной, добавив перед именем символ "$". Команда
/home/guest# echo $foo hello there /home/guest#
Там, где действительно выполняется присваивание, пробелы в этих местах НЕДОПУСТИМЫ. Присваивание, скажем, w= означает присваивание переменной "w" пустой строки. Но и пустую строку лучше присваивать аккуратно, например w="".
Для того, чтобы имя переменной не сливалось со строкой, следующей за именем переменной, используются фигурные скобки.
Пусть a=/mnt/lab/asu/
тогда cat /mnt/lab/asu/prim
и
cat ${a}prim
равноценны (т.е. "cat" выдаст на экран содержимое одного и того же файла).
Если также предположить, что в системе есть переменная "prim" и "prim=dir" , то команда echo ${a}$prim
выдаст на экран
/mnt/lab/asu/dir
2.2. Экранирование
Рассмотрим более подробно приемы экранирования, используемые в shell. В качестве средств экранирования используются двойные кавычки (" "), одинарные кавычки (' ') и бэк-слэш(\).
Из примеров очевидно их действие:
Можно в одной строке записывать несколько присваиваний.
(присваивание G=$x + $y не было бы выполнено из-за пробелов)
Тогда
echo А = $А В = $В С = $С echo D = $D E = $Е F = $F eval echo evaluated A = $A eval echo evaluated В = $B eval echo evaluated С = $C Выдадут на экран
A = 22 В = $x С = $x
D = 22 + 33 + 22 E = $x + $y + $z F = 22 + 33 + 22
evaluated A = 22
evaluated В = 22
evaluated С = 22
В трех последних случаях использована своеобразная команда "eval" (от evaluate - означивать), которая в подставленной в нее (в качестве аргумента) команде выполняет означивание переменных (если таковые имеются). В результате значение "А" остается прежним, поскольку "А" имеет значение "22". А переменные "В" и "С" имеют значение "$х". За счет означивания, которое было выполнено командой "eval" - evaluated "В" и "С" дают значения "22".
Приведем еще примеры, связанные с экранированием перевода строки. Пусть переменной "string" присвоено значение "массива" 2x3:
abc def
Обратим внимание, что для избежания присваивания лишних пробелов вторая строка массива начата с первой позиции следующей строки:
string="abc def"
Тогда три варианта записи переменной в команде "echo"
echo $string echo '$string' echo "$string"
дадут соответственно три различных результата:
abc def
$string
abc
def
а последовательность команд
echo "строка первая строка вторая" > f1 echo 'строка первая строка вторая' > f2 cat f1 f2
даст выдаст последовательно одинаковые файлы f1 и £2:
строка первая строка вторая строка первая строка вторая
Заметим также, что бэк-слэш (\) не только экранирует следующий за ним символ, что позволяет использовать специальные символы просто как символы, представляющие сами себя (он может экранировать и сам себя - \\), но в командном файле бэк-слэш позволяет об'единять строки в одну (экранировать конец строки).
Например, приводившийся ранее пример командной строки:
cat f1 | grep -h result I sort I cat -b > f2 может быть записан в командном файле, скажем, как
cat f1 | grep -h \
result | sort | cat -b > f2
Кстати, эффект продолжения командной строки обеспечивает и символ конвейера. В данном случае это может дать более симпатичный результат, например:
cat f1 I
grep -h result |
sort I
cat -b > f2
2.3.Манипуляции с shell-переменными
Несмотря на то, что shell-переменные в общем случае воспринимаются как строки, т.е. "35" - это не число, а строка из двух символов "3" и "5", в раде случаев они могут интерпретироваться иначе, например, как целые числа.
Разнообразные возможности имеет команда "ехрr".
Проиллюстрируем некоторые на примерах:
Выполнение командного файла:
х=7 у=2
a='expr $x + $у' ; echo a=$a
а=`ехрг $а + 1' ; echo a=$a
b=`expr $у - $х' ; echo b=$b
c=`expr $x '*' $y' ; echo c=$c
d='expr $x / $y' ; echo d=$d
e=`expr $x % $y' ; echo e=$e выдаст на экран
a=9
a=10
b=-5
c=14
d=3
e=l
Операция умножения ("*") обязательно должна быть заэкранирована, поскольку в shell этот значок воспринимается, как спецсимвол, означающий, что на это место может быть подставлена любая последовательность символов. Следует обратить также внимание на обязательные пробелы, отделяющие переменные и знаки операций.
С командой "ехрr" возможны не только (целочисленные) арифметические операции, но и строковые:
A=`expr 'cocktail' : 'cock'` ; echo $A B=`expr 'cocktail' : 'tail'` ; echo $B C='expr 'cocktail' : 'cook'` ; echo $C D=`expr 'cock' : 'cocktail'` ; echo $D . На экран будут выведены числа, показывающее число совпадающих символов в цепочках (от начала). Вторая из строк не может быть длиннее первой : 4 0 0 0
И наконец, об условной замене переменных. Если переменные, скажем "х", "у", "z", не определены, то при обращении к переменным
${x-new} в качестве значения "х" будет выдано "new",
${y=new} в качестве значения "у" будет присвоено "new", ${z?new} в качестве значения "z" будет выдано "z:new" и
соответствующая процедура прекращается. Во всех этих случаях, если переменная была к этому времени определена, то ее значение используется обычным образом.
А в следующем случае наоборот, пусть переменная "v" имеет какое-то значение, тогда
в качестве значения "z" будет выдано "new", a ${z+new} если не было присвоено значение, то пустая строка.
2.4.Экспорт переменных
В ОС UNIX существует понятие процесса. Процесс возникает тогда, когда запускается на выполнение какая-либо команда (расчет).
Например, при наборе на клавиатуре "р <Enter>" порождается процесс расчета "р". В свою очередь "р" может
породить другие процессы. Допустим, что "р" вызывает расчеты "р1" и "р2", которые последовательно порождают соответствующие процессы.
У каждого процесса есть своя среда - множество доступных ему переменных. Например, до запуска расчета "р" уже существовала среда, в которой уже были определены некоторые переменные (о стандартных переменных речь пойдет несколько позже). Запуск "р" порождает новую среду; уже в ней будут порождены расчеты "р1" и "р2".
Переменные локальны в рамках процесса, в котором они объявлены, т.е. где им присвоены значения (описание переменных отсутствует - они все одного типа). Для того, чтобы они были доступны и другим порождаемым процессам, надо передать их явным образом. Для этого используется встроенная команда "export".
B командный файл могут быть переданы параметры. В shell используются позиционные параметры (т.е. существенна очередность их следования). В командном файле соответствующие параметрам переменные (аналогично shell- переменным) начинаются с символа "$", а далее следует одна из цифр от 0 до 9:
Пусть расчет "ехаmpl" вызывается с параметрами "cock" и "tail". Эти параметры попадают в новую среду под стандартными именами "1" и "2". В (стандартной) переменной с именем "О" будет храниться имя вызванного расчета.
При обращении к параметрам перед цифрой ставится символ доллара "$" (как и при обращении к переменным):
0 соответствует имени данного командного файла; 1 первый по порядку параметр;
2 второй параметр и т.д.
Пусть командный файл с именем "ехаmpl" имеет вид
echo Это расчет $0: sort $2 » $1 cat $1
а файлы "cock" и "tail" содержат соответственно
cock:
Это отсортированный файл:
tail:
1 3 2 Тогда после вызова команды
examp-1 cock tail на экране будет
Это расчет examp-1:
Это отсортированный файл:
Поскольку число переменных, в которые могут передаваться параметры, ограничено одной цифрой, т.е. 9-ю ("О", как уже отмечалось имеет особый смысл), то для передачи большего числа параметров используется специальная команда "shift".
Рассмотрим ее действие на примере.
Пусть командный файл "many" вызывается с 13-ю параметрами
В результате первого применения команды "shift" второй параметр расчета вызывается как $1, третий параметр вызывается как $2, ... десятый параметр, который был исходно недоступен, вызывается как $9.Но стал недоступным первый параметр!
После выполнения этого расчета на экране будет:
many: Много параметров
Общее число параметров =13
Исходное состояние: 10 50 90
1 сдвиг: первый=20 пятый=6О девятый=100
1+2=3 сдвиг: первый=40 пятый=80 девятый=120
Своеобразный подход к параметрам дает команда "set". Например, фрагмент расчета
set a b c
echo первый=$1 второй=$2 третий=$3
выдаст на экран
первый=а второй=Ь третий=с
т.е. команда "set" устанавливает значения параметров. Это бывает очень удобно. Например, команда "date" выдает на экран текущую дату, скажем, "Mon May 0112:15:10 2000",состоящую из пяти слов, тогда
set 'date' echo $1 $3 $5 выдаст на экран
Моn 01 2000
Команда "set" позволяет также осуществлять контроль выполнения программы, например:
set -v на терминал выводятся строки, читаемые shell. Set +v отменяет предыдущий режим. Set -х на терминал выводятся команды перед выполнением. Set +x отменяет предыдущий режим.
2.6. Подстановки shell-интерпретатора
Перед началом непосредственной интерпретации и выполнением команд, содержащихся в командных файлах, shell выполняет различные виды подстановок:
ПОДСТАНОВКА РЕЗУЛЬТАТОВ. Выполняются все команды, заключенные в обратные кавычки, ина их место подставляется результат.
ПОДСТАНОВКА ЗНАЧЕНИЙ ПАРАМЕТРОВ И ПЕРЕМЕННЫХ. То есть слова, начинающиеся на "$",
ГЕНЕРАЦИЯ ИМЕН ФАЙЛОВ. Проверяются слова на наличие в них спецсимволов ("*", "?","[]") и выполняются соответствующие генерации.
2.7.Программная среда
Каждый процесс имеет среду, в которой он выполняется. Shell использует ряд переменных этой среды.
Если вы наберете команду "set" без параметров, то на экран будет выдана информация о ряде стандартных переменных, созданных при входе в систему (и передаваемых далее всем вашим новым процессам "по наследству"), атакже переменных, созданных и экспортируемых вашими процессами.
Конкретный вид и содержание выдаваемой информации в немалой степени зависит от того, какая версия UNIX используется икак инсталлирована система.
3.Порядок выполнения работы
Внимательно ознакомившись с приведенным выше материалом:
Написать скрипты проделывающие следующее:
-присваивает переменным (любым по выбору) имена файлов, полученных в 8-ой работе.
-присваивает переменным размеры файлов, полученных в 8-ой работе.
-производит арифметические действия с этими переменными (сложение, вычитание, умножение).
-производит сортировку в прямом и обратном направлении
-все результаты действия скриптов должны быть записаны в выходящий файл.
4.Контроль выполнения работы
Отчет должен содержать:
-краткое описание проделанной работы
-распечатки скриптов с начальными данными и конечными результатами
-дискету с данными результатов
Студент должен уметь рассказать о достижении полученных результатов, а также, при необходимости показать как он достиг этого.
5.Контрольные вопросы
1.Сценарии SHELL: назначение и использование?
2.Вид сценариев SHELL?
3. Опишите структуру сценария?
4.Что означает строка "#!bin/sh/" в сценарии? Какой смысл она несет?
