Что такое сценарии оболочки

Всем привет. Это перевод из книги по подготовке к экзамену RedHat RHCE. На мой взгляд очень доступно рассказывается об основах bash.

Сценарии оболочки — наука сама по себе. Не вдаваясь в подробности всего, что происходит «под капотом», вы узнаете, как применять базовые элементы для написания собственных скриптов, и анализировать, что происходит в сторонних сценариях оболочки.

Понимание основных элементов сценариев оболочки

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

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

Ниже показан очень простой скрипт:

#!/bin/bash
#
# #This is a script that greets the world
# Usage: ./hello
clear
echo hello world
exit 0

Здесь содержатся несколько элементов, которые должны использоваться во всех скриптах. Для начала, есть shebang — это строка #!/bin/bash. Когда скрипт запускается из родительской оболочки, он открывает подоболочку, в которой и выполняются команды, указанные в скрипте.

Эти команды могут быть интерпретированы различными способами. Для того, чтобы понять, как именно они должны интерпретироваться, используется shebang. В примере выше shebang ясно даёт понять, что скрипт должен выполняться оболочкой bash.

Также могут быть указаны другие оболочки. Например, если ваш скрипт содержит код на языке Perl, shebang должен быть #!/usr/bin/perl. Начинать сценарий с shebang является хорошей практикой; если он опущен, код сценария будет выполняться такой же оболочкой, которая используется для запуска скрипта.

Сразу после shebang расположена часть, объясняющая, о чем сценарий. Несколько строк комментариев в начале каждого сценария — хорошая идея. В коротком скрипте часто очевидно, что он делает, но когда сценарий становится длиннее, и по мере того, как всё больше людей вовлекаются в его написание и поддержку, становится менее понятно, что авторы намереваются сделать.

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

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

Независимо от того, в какой позиции он используется, всё от символа # и до конца строки является комментарием.

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

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

Полезно знать, что вы можете работать с exit, чтобы сообщить родительской оболочке, как все прошло.

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

После создания сценария убедитесь, что он может быть выполнен. Самый распространённый способ сделать это — применить к нему бит выполнения. Итак, если имя файла скрипта — hello, используйте команду chmod +x ./hello для того, чтобы сделать его исполняемым.

Сценарий также может быть выполнен в качестве аргумента команды bash. В этом случае введите bash ./hello для запуска скрипта hello. Если сценарий запускается как аргумент команды bash, файл скрипта не обязательно должен быть исполняемым.

По сути, вы можете хранить скрипт в любом месте, но если вы собираетесь хранить его в каталоге, который не включён в переменную $PATH, вам нужно выполнить его с ./ перед именем скрипта.

Введите ./hello для того, чтобы запустить сценарий, или поместите его в стандартный каталог, который включён в переменную $PATH, например, /usr/local/bin.

Также вы можете разместить сценарий в каталоге /bin, после чего в любом месте файловой системы просто ввести имя файла, и сценарий выполнится.

Пример

Командой vi /bin/datetime создадим в каталоге /bin файл с именем datetime. В созданный файл вставим это содержимое:

#!/bin/bash
# выводит дату и время. а так же список пользователей, которые залогинены в данный момент

date
who

Сохранив файл, введите chmod +x /bin/datetime, чтобы дать файлу права на выполнение. Перейдите, к примеру, в домашний каталог с помощью команды cd ~ и просто введите datetime.

Перейдите, к примеру, в домашний каталог cd ~ и просто введите datetime.

[root@localhost ~]# datetime
Sat Sep 28 00:33:41 EDT 2019
root     tty1         2019-09-25 20:28
root     pts/0        2019-09-27 20:07 (comp.corp.domain.ru)

Использование переменных и входных данных

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

Использование позиционных параметров

При запуске скрипта можно использовать аргументы. Аргумент — это всё, что вы помещаете за командой сценария. Аргументы могут быть использованы для того, чтобы сделать скрипт более гибким. Возьмём команду useradd lisa. В этом примере команда — это useradd, а её аргумент — lisa — указывает, что нужно сделать.

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

В тексте сценария первый аргумент обозначается $1, второй аргумент — $2 и т. д. Листинг 1 показывает, как можно использовать аргументы. Попробуйте запустить этот код, указав в качестве параметров любые имена пользователей.

Листинг 1

#!/bin/bash
# run this script with a few arguments
echo The first argument is $1
echo The second argument is $2
echo The third argument is $3

Под параметрами подразумевается ввод данных перед запуском скрипта. В данном случае в качестве параметров после имени скрипта argument я указал lisa, lori и bob:

[root@server1 ~]# ./argument lisa lori bob
The first argument is lisa
The second argument is lori
The third argument is bob
[root@server1 ~]#

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

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

Листинг 2

#!/bin/bash
# run this script with a few arguments 
echo you have entered $# arguments
for i in $@
 do
       echo $i
 done
exit 0

В Листинге 2 представлены два новых элемента, которые относятся к аргументам:

$# — это счетчик, который показывает, сколько аргументов было использовано при запуске скрипта.
$@ — список всех аргументов, которые использовались при запуске скрипта.

Чтобы перечислить аргументы, которые использовались при запуске этого скрипта, используется цикл for. В циклах for команды выполняются до тех пор, пока условие истинно. В этом сценарии условие for i in $@ означает «для каждого аргумента». Каждый раз, когда сценарий проходит цикл, значение из переменной $@ присваивается переменной $i.

Итак, пока есть аргументы, тело сценария выполняется.

Тело цикла for всегда начинается с do и закрывается done, а между этими двумя ключевыми словами перечисляются команды, которые необходимо выполнить. Таким образом, пример сценария будет использовать echo для отображения значения каждого аргумента и останавливаться, когда больше нет доступных аргументов.

Давайте попробуем воспользоваться скриптом из листинга 2 в этом примере:

Введите vi argument, чтобы создать файл argument и скопируйте содержимое из скрипта листинга 2 в этот файл.
Сохраните файл и сделайте его исполняемым.
Запустите команду ./argument a b c. Вы увидите, что отобразятся три строки.
Запустите команду ./argument a b c d e f. Вы увидите, что помимо a b c отобразятся и d e f.

Переменные

Переменная — это метка, которая используется для обозначения определённого места в памяти, которое содержит определённое значение. Переменные могут быть определены статически с помощью NAME=value или динамическим способом. Существует два решения для динамического определения переменной:

Используйте ключевое слово read в скрипте, чтобы запросить данные у пользователя, запускающего скрипт.
Используйте подстановку команд, чтобы использовать результат команды и назначить его переменной. Например, команда date +%d-%m-%y показывает текущую дату в формате день-месяц-год. Чтобы сделать это в сценарии, вы можете использовать TODAY=$(date +%d-%m-%y). Для подстановки команд вам просто нужно поместить команду, результат которой вы хотите использовать, между скобками.

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

Листинг 3. Пример скрипта, использующего команду read

#!/bin/bash
if [ -z $1 ]; then
     echo enter a text
     read TEXT
else
     TEXT=$1
fi
echo you have entered the text $TEXT
exit 0

В сценарии листинга 3 оператор if… then… else… fi используется для проверки существования аргумента $1. Это делается с помощью test (test — это отдельная команда). Команда test может быть написана двумя способами*: test или [… ]. В примере строка if [ -z $1 ] … выполняется, чтобы увидеть тест (проверку) -z $1.

* — на самом деле тремя источник (прим. переводчика)

-z test проверяет, существует или нет $1. Иначе говоря, строка if [ -z $1 ] проверяет, является ли $1 пустым, что означает, что при запуске этого сценария не было предоставлено никаких аргументов. Если это так, команды после оператора then выполняются.

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

Обратите внимание, что оператор then следует сразу за test. Это возможно, потому что используется точка с запятой (;). Точка с запятой является разделителем команд и может заменить новую строку в скрипте.

В операторе then выполняются две команды: команда echo, которая отображает сообщение на экране, и команда read.

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

Следующая часть представлена оператором else. Команды после оператора else выполняются во всех других случаях, что в данном случае означает «иначе, если аргумент был предоставлен». Если это так, то определяется переменная TEXT и ей присваивается текущее значение $1.

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

Затем условия if замыкается с помощью оператора fi. После завершения условия if вы точно знаете, что переменная TEXT определена и имеет значение. Предпоследняя строка скрипта считывает значение переменной TEXT и отображает это значение в STDOUT с помощью команды echo. Обратите внимание, что для запроса текущего значения переменной ссылается на имя переменной, начиная со знака $ перед ним.

Вы можете попрактиковаться на этом примере при работе с вводом.

Откройте редактор и создайте файл с именем text. Введите содержимое кода из листинга 3 в этот файл.
Запишите файл на диск и выполните chmod +x text, чтобы сделать его исполняемым.
Запустите скрипт, выполнив ./text и без дополнительных аргументов. Вы увидите, что он запрашивает ввод.
Запустите скрипт, используя «hello» в качестве аргумента (./text hello). Результат отобразит «you have entered the text hello» в STDOUT.

Использование условий и циклов

Как вы уже видели, в скрипте могут использоваться условные операторы. Эти условные операторы выполняются только в том случае, если определённое условие выполняется.

В bash есть несколько условных операторов и циклов, которые часто используются.

if… then… else — используется для выполнения кода, если определенное условие выполняется
for — используется для выполнения команд для диапазона значений
while — используется для выполнения кода, если выполняется определенное условие
before — используется для выполнения кода, пока не выполнено определенное условие
case — используется для оценки ограниченного количества конкретных значений

if then else

Конструкция if then else является общей для оценки конкретных условий. Вы уже видели пример с ним. Этот условный оператор часто используется вместе с командой test. Эта команда позволяет вам проверять многие вещи: например, не только, существует ли файл, но и сравнивать файлы, сравнивать целые числа и многое другое.

Подробнее о test можно узнать в справочнике командой man test.

Основная конструкция if есть if… then… fi.

Она сравнивает одно условие, как показано в следующем примере:

if [ -z $1 ]
then
     echo no value provided
fi

В листинге 3 вы увидели, как можно оценить два условия, включая else в выражении. В листинге 4 показано, как можно оценить несколько условий от if до else. Это полезно, если нужно проверить много разных значений.

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

Листинг 4. Пример с if then else

#!/bin/bash
# run this script with one argument
# the goal is to find out if the argument is a file or a directory
if [ -f $1 ]
then
    echo "$1 is a file"
elif [ -d $1 ]
then
    echo "$1 is a directory"
else
    echo "I do not know what $1 is"
fi
exit 0

|| и &&

Вместо написания полных операторов if… then вы можете использовать логические операторы || а также &&. || является логическим «ИЛИ» и выполнит вторую часть оператора, только если первая часть не верна; && является логическим «И» и выполнит вторую часть оператора только в том случае, если первая часть верна.

Рассмотрим эти две строки:

[ -z $1 ] && echo no argument provided

ping -c 1 8.8.8.8 2>/dev/null || echo node is not available

В первом примере выполняется проверка, чтобы увидеть, пуст ли $1. Если эта проверка верна (что, в основном, означает, что команда завершается с кодом выхода 0), выполняется вторая команда.

Во втором примере команда ping используется для проверки доступности хоста.
В этом примере используется логическое «ИЛИ» для вывода текста «node is not available» в случае неудачной команды ping.

Вы обнаружите, что часто вместо условного оператора if будут использоваться && и ||. В упражнении ниже вы можете попрактиковаться в использовании условных операторов, используя либо if… then… else, либо && и ||.

Упражнение. Использование if… then… else

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

Запустите редактор и создайте скрипт с именем filechk.
Скопируйте содержимое из листинга 4 в этот скрипт.
Запустите с ним пару тестов, такие как ./filechk /etc/hosts, ./filechck /usr, ./filechk non-existing-file.

Цикл for

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

Листинг 5

#!/bin/bash
#
for (( COUNTER=100; COUNTER>1; COUNTER-- )); do
     echo $COUNTER
done
exit 0

Цикл for всегда начинается с ключевого слова for, за которым следует условие, которое необходимо проверить. Затем следует ключевое слово do, за которым следуют команды, которые должны быть выполнены, если условие истинно, завершается цикл с помощью ключевого слова done.

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

Маленькое пояснение

Внутри ((… )) вычисляются арифметические выражения и возвращается их результат. Например, в простейшем случае, конструкция a=$(( 5 + 3 )) присвоит переменной «a» значение выражения «5 + 3», или 8. Кроме того, двойные круглые скобки позволяют работать с переменными в стиле языка C.

Сначала переменная инициализируется значением 100, и до тех пор, пока значение больше 1, в каждой итерации вычитается 1. Пока условие истинно, значение переменной $COUNTER отображается с использованием команды echo.

В листинге 6 вы можете увидеть один из моих любимых однострочников с for. Диапазон определяется на этот раз как последовательность чисел, начиная со 100 и доходя до 104.

Листинг 6

for i in {100..104}; do ping –c 1 192.168.4.$i >/dev/null && echo 192.168.4.$i is up; done

Обратите внимание, как определяется диапазон: сначала вы указываете первое число, затем две точки и указываете последнее число в диапазоне. При этом с for i in для каждого из этих номеров присваивается переменная i. Каждое из этих чисел присваивается переменной i и затем выполняется команда ping, где опция -c 1 гарантирует, что отправляется только один запрос.

Результат выполнения команды ping не учитывается, поэтому её вывод перенаправляется в /dev/null. На основании состояния выхода команды ping выполняется часть выражения за &&. Таким образом, если хост доступен, отображается строка, указывающая, что он работает.

Понимание while и until

Если оператор for, о котором вы только что прочитали, полезен для работы с диапазонами элементов, то оператор while полезен тогда, когда вы хотите отслеживать что-то вроде доступности процесса. Также существует оператор until, который выполняется до тех пор, пока проверяемое условие ложно. В листинге 7 вы можете прочитать, как while используется для мониторинга активности процесса.

Примечание. Так и не понял, что делает этот скрипт. В моём случае используется CentOS 7 и по умолчанию там нет monitor, хотя в скрипте явно написано:
usage: monitor <processname>
Где-то пол часа гуглил для CetOS программу monitor, но так и не нашёл. И вообще не понятно каким тут боком monitor если используется ps aux. В любом случае так и не понял, что делает этот срипт. Большая просьба помочь решить этот вопрос, чтобы откорректировать текст и/или скрипт.

Листинг 7

#!/bin/bash
#
# usage: monitor <processname>
while ps aux | grep $1 | grep -v grep > /dev/tty11
do
     sleep 5
done

clear
echo your process has stopped
logger $1 is no longer present
mail -s "process $1 has stopped" root < .

Сценарий в листинге 7 состоит из двух частей. Во-первых, есть цикл while. Во-вторых, есть всё, что нужно выполнить, когда цикл while больше не оценивается как true.

Ядром цикла while является команда ps, которая имеет значение $1.

Обратите внимание на использование grep -v grep, который исключает строки, содержащие команду grep, из результата. Помните, что команда ps будет включать в себя все запущенные процессы, включая команду grep, которой передаётся вывод команды ps. Это может привести к ложному положительному совпадению.

Вывод команды ps aux перенаправляются в /dev/tty11. Это позволяет позже прочитать результаты из tty11, если это необходимо, но они не отображаются по умолчанию.

После операторов while следуют команды, которые необходимо выполнить, если проверяемое условие истинно. В данном случае это команда sleep 5, которая приостанавливает выполнение скрипта на 5 секунд.

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

Вам должны быть знакомы все эти команды, кроме последней. В строке mail -s “process $1 has stopped” root < . сообщение отправляется пользователю root с использованием внутренней почтовой системы, которая по умолчанию работает на Linux*. Команда mail принимает в качестве первого аргумента тему сообщения, указанную с помощью опции -s.

* — по крайней мере в CentOS по умолчанию работает. (при. переводчика)

Обратите внимание на < . в конце команды.

Обычно при использовании команды mail в интерактивном режиме открывается редактор, в котором можно написать тело сообщения. Этот редактор закрыт, предоставляя строку, которая имеет только точку. В этой команде точка предоставляется путём перенаправления STDIN. Это позволяет обрабатывать сообщение без каких-либо дополнительных требований к пользовательской активности.

Цикл while — это противоположность циклу until, пример которого приведён в листинге 8. until запускает итерацию, которая длится до тех пор, пока условие не станет истинным.

В листинге 8 он используется для фильтрации выходных данных команды users по вхождению $1, которое будет именем пользователя. Пока эта команда не верна, итерация продолжается. Когда имя пользователя найдено в выводе пользователей, итерация закрывается, и после цикла until выполняются остальные команды.

Листинг 8

#!/bin/bash
#
until users | grep $1 > /dev/null
do
     echo $1 is not logged in yet
     sleep 5
done
echo $1 has just logged in
mail -s "$1 has just logged in" root < .

Понимание case

Последний из важных итерационных циклов — это case*. Оператор case используется для оценки ряда ожидаемых значений. В частности, инструкции case важны в сценариях запуска Linux, которые в предыдущих версиях использовались для запуска служб.

* — цикл ли?

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

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

Листинг 9

case "$1" in
     start)
          start;;
     stop)
          rm -f $lockfile
          stop;;
     restart)
          restart;;
     reload)
          reload;;
     status)
          status
          ;;
     *)
          echo "Usage: $0 (start|stop|restart|reload|status)"
          ;;
esac

case имеет несколько особенностей. Сначала идет строка — case последовательность in. Затем следует список всех возможных значений, которые необходимо оценить. Каждый элемент закрывается скобкой ).

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

Также обратите внимание, что *) относится ко всем другим параметрам, не указанным ранее. Это «всеохватывающий» оператор.

Цикл итераций case завершается оператором esac.

Обратите внимание, что последовательности в case выполняются по порядку. Когда будет выполнено первое совпадение, оператор case не будет ничего оценивать.

В рамках оценки могут использоваться шаблоны, подобные шаблону. Это показано в *) последовательности, которая соответствует всему. Но вы также можете использовать последовательности, такие как start|Start|START), чтобы соответствовать использованию другого case.

Отладка скриптов в Bash

Когда скрипт не делает того, что вы ожидаете, полезно выполнить некоторую отладку. Для начала, попробуйте выполнить его как аргумент команды bash -x. Это покажет вам построчно, что пытается сделать скрипт, а также конкретные ошибки, если он не работает как надо.

В листинге 10 показан пример использования bash -x, где сразу становится ясно, что команда grep не знает, что она должна делать, так как пропущен аргумент для её работы.

[root@server1 ~]# bash -x 319.sh
+ grep
Usage: grep [OPTION]... PATTERN [FILE]...
Try 'grep --help' for more information.
+ users
+ echo is not logged in yet is not logged in yet
+ sleep 5

Подводим итоги

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

Источник

Сценарии оболочки

Взаимодействие пользователя с операционной
системой осуществляется через оболочку.
Оболочка (shell) –
это программа, обрабатывающая команды,
вводимые пользователем или содержащиеся
в файле (при этом файл называется
сценарием и является интерпретируемой
программой). Аналогами оболочки в среде
Windows являются командный
процессор command.com
или cmd.exe, а
аналогами сценариев – командные файлы
(bat-файлы). В Linux
существует ряд различных оболочек
(например, sh, ksh,
csh, yacc),
наиболее популярной из которых является
bash.

Сразу после запуска оболочки производится
её инициализация для установки ряда
параметров. При этом оболочкой производится
чтение двух файлов: /etc/profile
и ~/.profile.
В первом из них содержатся настройки
параметров, общие для всех пользователей.
Во втором файле каждый пользователь
может разместить свои собственные
настройки для работы с оболочкой.

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

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

имя_оболочки
имя_файла

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

В качестве имени_оболочки
может выступать, например, sh,
bash
или имя любой другой оболочки.

Запуск сценария

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

chmod
+x имя_файла

Кроме этого, необходимо явно указать,
какая оболочка должна использоваться
для выполнения данного сценария. Это
можно сделать, разместив в первой строке
сценария последовательность символов
#!путь_к_программе-оболочке.
Например, если необходимо указать,
что для выполнения сценария следует
использовать оболочку bash,
первой строкой сценария должна быть
строка

#!/bin/bash

Сценарий может содержать комментарии.
Комментарий – это оператор, который
может размещаться в сценарии оболочки,
но оболочкой не исполняется. Комментарий
начинается с символа # и продолжается
до конца строки.

Ниже приведён пример короткого сценария:

#!/bin/sh

date

who

Примечание: несколько команд в
сценарии могут записываться в одну
строку. В качестве разделителя между
ними необходимо указывать точку с
запятой (;).
Например:

#!/bin/sh

date;
who;

Переменные

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

Определяются переменные следующим
образом (отсутствие пробелов до и после
символа = существенно):

имя_переменной=значение

Все переменные по умолчанию имеют
строковый тип. Например, MY_NAME=Sergey
определяет переменную с именем MY_NAME
и присваивает ей значение Sergey.
В переменной можно сохранять любое
нужное значение. Особый случай – когда
это значение содержит пробелы. Для
правильного выполнения такого действия
указанное значение достаточно заключить
в кавычки.

Если переменной присвоена последовательность
чисел, то значение этой переменной будет
трактоваться как число. Например,
а=12345.
Теперь переменную а
можно использовать в арифметических
выражениях.

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

Например, в результате выполнения
команды

echo
a

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

echo
${a}

будет напечатано число 12345.

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

echo
${a}1

к значению переменной а будет дописана
1, то есть получим значение 123451, а в
результате выполнения команды

echo
$a1

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

С помощью конструкции
${#имя_переменной}
можно получить количество символов в
определенной переменной (длину
переменной).

С помощью конструкции ${имя_переменной:m:n}
можно выделить подстроку из определенной
переменной (здесь где m
– номер позиции, начиная с которой будет
производиться выделение подстроки, а
n
– количество выделяемых символов).

Примечание: значение
n
можно опускать. Тогда будет
производиться выделение символов до
конца строки.

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

Ниже приведён пример, иллюстрирующий
работу с переменными в сценариях.

#!/bin/bash

MY_NAME=Sergey

MY_FULL_NAME=»Sergey
B. Sidorov»

echo
name = $MY_NAME and full name = $MY_FULL_NAME

echo
Length of my full name is ${#MY_FULL_NAME} symbols

echo
My surname is ${MY_FULL_NAME:10}

m=0

n=6

echo
My
name
is
${MY_FULL_NAME:m:n}
#подстановка
распространяется на

#все переменные в фигурных скобках

echo
${MY_FULL_NAME:10:5}

unset
MY_NAME

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

name
= Sergey and full name = Sergey B. Sidorov

Length
of my full name is 17 symbols

My
surname is Sidorov

My
surname is Sergey

Sidor

Все рассмотренные выше примеры переменных
– это примеры скалярных переменных,
то есть таких, которые могут хранить
только одно значение. Наряду с ними
можно использовать переменные-массивы.
Доступ к элементам массива осуществляется
операцией индексирования [].
Язык программирования оболочки не
требует предварительного объявления
переменной массивом с указанием его
размерности. При этом отдельные элементы
массива создаются по мере доступа к
ним. Ниже приведён пример работы с
массивом NAME.

#!/bin/sh

NAME[0]=Сергей

NAME[10]=Катя

NAME[2]=Лиза

echo
все имена: ${NAME[*]}

echo
${NAME[10]} и ${NAME[2]} сестры

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

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

Источник

This article is about scripting in Unix-like systems. For batch programming in DOS, OS/2 and Windows, see Batch file. For batch programming in Windows PowerShell shell, see Windows PowerShell § Scripting. For programming in the shells (cmd.exe) in operating systems of the Windows NT/2000 series, see cmd.exe. For shell programming, by means of files called Command Scripts or Procedures on Vax/VMS machines, see DIGITAL Command Language.

A shell script is a computer program designed to be run by a Unix shell, a command-line interpreter.^[1] The various dialects of shell scripts are considered to be scripting languages. Typical operations performed by shell scripts include file manipulation, program execution, and printing text. A script which sets up the environment, runs the program, and does any necessary cleanup or logging, is called a wrapper.

The term is also used more generally to mean the automated mode of running an operating system shell; each operating system uses a particular name for these functions including batch files (MSDos-Win95 stream, OS/2), command procedures (VMS), and shell scripts (Windows NT stream and third-party derivatives like 4NT—article is at cmd.exe), and mainframe operating systems are associated with a number of terms.

Shells commonly present in Unix and Unix-like systems include the Korn shell, the Bourne shell, and GNU Bash. While a Unix operating system may have a different default shell, such as Zsh on macOS, these shells are typically present for backwards compatibility.

Capabilities[edit]

[edit]

Comments are ignored by the shell. They typically begin with the hash symbol (#), and continue until the end of the line.^[2]

Configurable choice of scripting language[edit]

The shebang, or hash-bang, is a special kind of comment which the system uses to determine what interpreter to use to execute the file. The shebang must be the first line of the file, and start with «#!«.^[2] In Unix-like operating systems, the characters following the «#!» prefix are interpreted as a path to an executable program that will interpret the script.^[3]

Shortcuts[edit]

A shell script can provide a convenient variation of a system command where special environment settings, command options, or post-processing apply automatically, but in a way that allows the new script to still act as a fully normal Unix command.

One example would be to create a version of ls, the command to list files, giving it a shorter command name of l, which would be normally saved in a user’s bin directory as /home/username/bin/l, and a default set of command options pre-supplied.

#!/bin/sh
LC_COLLATE=C ls -FCas "$@"

Here, the first line uses a shebang to indicate which interpreter should execute the rest of the script, and the second line makes a listing with options for file format indicators, columns, all files (none omitted), and a size in blocks. The LC_COLLATE=C sets the default collation order to not fold upper and lower case together, not intermix dotfiles with normal filenames as a side effect of ignoring punctuation in the names (dotfiles are usually only shown if an option like -a is used), and the "$@" causes any parameters given to l to pass through as parameters to ls, so that all of the normal options and other syntax known to ls can still be used.

The user could then simply use l for the most commonly used short listing.

Another example of a shell script that could be used as a shortcut would be to print a list of all the files and directories within a given directory.

In this case, the shell script would start with its normal starting line of #!/bin/sh. Following this, the script executes the command clear which clears the terminal of all text before going to the next line. The following line provides the main function of the script. The ls -al command lists the files and directories that are in the directory from which the script is being run. The ls command attributes could be changed to reflect the needs of the user.

Note: If an implementation does not have the clear command, try using the clr command instead.

Batch jobs[edit]

Shell scripts allow several commands that would be entered manually at a command-line interface to be executed automatically, and without having to wait for a user to trigger each stage of the sequence. For example, in a directory with three C source code files, rather than manually running the four commands required to build the final program from them, one could instead create a script for POSIX-compliant shells, here named build and kept in the directory with them, which would compile them automatically:

#!/bin/sh
printf 'compiling...n'
cc -c foo.c
cc -c bar.c
cc -c qux.c
cc -o myprog foo.o bar.o qux.o
printf 'done.n'

The script would allow a user to save the file being edited, pause the editor, and then just run ./build to create the updated program, test it, and then return to the editor. Since the 1980s or so, however, scripts of this type have been replaced with utilities like make which are specialized for building programs.

Generalization[edit]

Simple batch jobs are not unusual for isolated tasks, but using shell loops, tests, and variables provides much more flexibility to users. A POSIX sh script to convert JPEG images to PNG images, where the image names are provided on the command-line—possibly via wildcards—instead of each being listed within the script, can be created with this file, typically saved in a file like /home/username/bin/jpg2png

#!/bin/sh
for jpg; do                                  # use $jpg in place of each filename given, in turn
    png=${jpg%.jpg}.png                      # construct the PNG version of the filename by replacing .jpg with .png
    printf 'converting "%s" ...n' "$jpg"    # output status info to the user running the script
    if convert "$jpg" jpg.to.png; then       # use convert (provided by ImageMagick) to create the PNG in a temp file
        mv jpg.to.png "$png"                 # if it worked, rename the temporary PNG image to the correct name
    else                                     # ...otherwise complain and exit from the script
        printf >&2 'jpg2png: error: failed output saved in "jpg.to.png".n'
        exit 1
    fi                                       # the end of the "if" test construct
done                                         # the end of the "for" loop
printf 'all conversions successfuln'        # tell the user the good news

The jpg2png command can then be run on an entire directory full of JPEG images with just /home/username/bin/jpg2png *.jpg

Programming[edit]

Many modern shells also supply various features usually found only in more sophisticated general-purpose programming languages, such as control-flow constructs, variables, comments, arrays, subroutines and so on. With these sorts of features available, it is possible to write reasonably sophisticated applications as shell scripts. However, they are still limited by the fact that most shell languages have little or no support for data typing systems, classes, threading, complex math, and other common full language features, and are also generally much slower than compiled code or interpreted languages written with speed as a performance goal.

The standard Unix tools sed and awk provide extra capabilities for shell programming; Perl can also be embedded in shell scripts as can other scripting languages like Tcl. Perl and Tcl come with graphics toolkits as well.

Typical POSIX scripting languages[edit]

Scripting languages commonly found on UNIX, Linux, and POSIX-compliant operating system installations include:

KornShell (ksh) in several possible versions such as ksh88, Korn Shell ’93 and others.
The Bourne shell (sh), one of the oldest shells still common in use
The C shell (csh)
GNU Bash (bash)
tclsh, a shell which is a main component of the Tcl/Tk programming language.
The wish is a GUI-based Tcl/Tk shell.

The C and Tcl shells have syntax quite similar to that of said programming languages, and the Korn shells and Bash are developments of the Bourne shell, which is based on the ALGOL language with elements of a number of others added as well.^[4] On the other hand, the various shells plus tools like awk, sed, grep, and BASIC, Lisp, C and so forth contributed to the Perl programming language.^[5]

Other shells that may be available on a machine or for download and/or purchase include:

Almquist shell (ash)
PowerShell (msh)
Z shell (zsh, a particularly common enhanced KornShell)
The Tenex C Shell (tcsh).

Related programs such as shells based on Python, Ruby, C, Java, Perl, Pascal, Rexx etc. in various forms are also widely available. Another somewhat common shell is Old shell (osh), whose manual page states it «is an enhanced, backward-compatible port of the standard command interpreter from Sixth Edition UNIX.»^[6]

So called remote shells such as

a Remote Shell (rsh)
a Secure Shell (ssh)

are really just tools to run a more complex shell on a remote system and have no ‘shell’ like characteristics themselves.

Other scripting languages[edit]

Many powerful scripting languages have been introduced for tasks that are too large or complex to be comfortably handled with ordinary shell scripts, but for which the advantages of a script are desirable and the development overhead of a full-blown, compiled programming language would be disadvantageous. The specifics of what separates scripting languages from high-level programming languages is a frequent source of debate, but, generally speaking, a scripting language is one which requires an interpreter.

Life cycle[edit]

Shell scripts often serve as an initial stage in software development, and are often subject to conversion later to a different underlying implementation, most commonly being converted to Perl, Python, or C. The interpreter directive allows the implementation detail to be fully hidden inside the script, rather than being exposed as a filename extension, and provides for seamless reimplementation in different languages with no impact on end users.

While files with the «.sh» file extension are usually a shell script of some kind, most shell scripts do not have any filename extension.^[7]^[8]^[9]^[10]

Advantages and disadvantages[edit]

Perhaps the biggest advantage of writing a shell script is that the commands and syntax are exactly the same as those directly entered at the command-line. The programmer does not have to switch to a totally different syntax, as they would if the script were written in a different language, or if a compiled language were used.

Often, writing a shell script is much quicker than writing the equivalent code in other programming languages. The many advantages include easy program or file selection, quick start, and interactive debugging. A shell script can be used to provide a sequencing and decision-making linkage around existing programs, and for moderately sized scripts the absence of a compilation step is an advantage. Interpretive running makes it easy to write debugging code into a script and re-run it to detect and fix bugs. Non-expert users can use scripting to tailor the behavior of programs, and shell scripting provides some limited scope for multiprocessing.

On the other hand, shell scripting is prone to costly errors. Inadvertent typing errors such as rm -rf * / (instead of the intended rm -rf */) are folklore in the Unix community; a single extra space converts the command from one that deletes all subdirectories contained in the current directory, to one which deletes everything from the file system’s root directory. Similar problems can transform cp and mv into dangerous weapons, and misuse of the > redirect can delete the contents of a file. This is made more problematic by the fact that many UNIX commands differ in name by only one letter: cp, cd, dd, df, etc.

Another significant disadvantage is the slow execution speed and the need to launch a new process for almost every shell command executed. When a script’s job can be accomplished by setting up a pipeline in which efficient filter commands perform most of the work, the slowdown is mitigated, but a complex script is typically several orders of magnitude slower than a conventional compiled program that performs an equivalent task.

There are also compatibility problems between different platforms. Larry Wall, creator of Perl, famously wrote that «It is easier to port a shell than a shell script.»^[11]

Similarly, more complex scripts can run into the limitations of the shell scripting language itself; the limits make it difficult to write quality code, and extensions by various shells to ameliorate problems with the original shell language can make problems worse.^[12]

Many disadvantages of using some script languages are caused by design flaws within the language syntax or implementation, and are not necessarily imposed by the use of a text-based command-line; there are a number of shells which use other shell programming languages or even full-fledged languages like Scsh (which uses Scheme).

Interoperability among scripting languages[edit]

Different scripting languages may share many common elements, largely due to being POSIX based, and some shells offer modes to emulate different shells. This allows a shell script written in one scripting language to be adapted into another.

One example of this is Bash, which offers the same grammar and syntax as the Bourne shell, and which also provides a POSIX-compliant mode.^[13] As such, most shell scripts written for the Bourne shell can be run in BASH, but the reverse may not be true since BASH has extensions which are not present in the Bourne shell. As such, these features are known as bashisms.^[14]

Shell scripting on other operating systems[edit]

Interoperability software such as Cygwin, the MKS Toolkit, Interix (which is available in the Microsoft Windows Services for UNIX), Hamilton C shell, UWIN (AT&T Unix for Windows) and others allow Unix shell programs to be run on machines running Windows NT and its successors, with some loss of functionality on the MS-DOS-Windows 95 branch, as well as earlier MKS Toolkit versions for OS/2. At least three DCL implementations for Windows type operating systems—in addition to XLNT, a multiple-use scripting language package which is used with the command shell, Windows Script Host and CGI programming—are available for these systems as well. Mac OS X and subsequent are Unix-like as well.^[15]

In addition to the aforementioned tools, some POSIX and OS/2 functionality can be used with the corresponding environmental subsystems of the Windows NT operating system series up to Windows 2000 as well. A third, 16-bit subsystem often called the MS-DOS subsystem uses the Command.com provided with these operating systems to run the aforementioned MS-DOS batch files.^[16]

The console alternatives 4DOS, 4OS2, FreeDOS, Peter Norton’s NDOS and 4NT / Take Command which add functionality to the Windows NT-style cmd.exe, MS-DOS/Windows 95 batch files (run by Command.com), OS/2’s cmd.exe, and 4NT respectively are similar to the shells that they enhance and are more integrated with the Windows Script Host, which comes with three pre-installed engines, VBScript, JScript, and VBA and to which numerous third-party engines can be added, with Rexx, Perl, Python, Ruby, and Tcl having pre-defined functions in 4NT and related programs. PC DOS is quite similar to MS-DOS, whilst DR DOS is more different. Earlier versions of Windows NT are able to run contemporary versions of 4OS2 by the OS/2 subsystem.

Scripting languages are, by definition, able to be extended; for example, a MS-DOS/Windows 95/98 and Windows NT type systems allows for shell/batch programs to call tools like KiXtart, QBasic, various BASIC, Rexx, Perl, and Python implementations, the Windows Script Host and its installed engines. On Unix and other POSIX-compliant systems, awk and sed are used to extend the string and numeric processing ability of shell scripts. Tcl, Perl, Rexx, and Python have graphics toolkits and can be used to code functions and procedures for shell scripts which pose a speed bottleneck (C, Fortran, assembly language &c are much faster still) and to add functionality not available in the shell language such as sockets and other connectivity functions, heavy-duty text processing, working with numbers if the calling script does not have those abilities, self-writing and self-modifying code, techniques like recursion, direct memory access, various types of sorting and more, which are difficult or impossible in the main script, and so on. Visual Basic for Applications and VBScript can be used to control and communicate with such things as spreadsheets, databases, scriptable programs of all types, telecommunications software, development tools, graphics tools and other software which can be accessed through the Component Object Model.

References[edit]

^ Kernighan, Brian W.; Pike, Rob (1984), «3. Using the Shell», The UNIX Programming Environment, Prentice Hall, Inc., p. 94, ISBN 0-13-937699-2, The shell is actually a programming language: it has variables, loops, decision-making, and so on.
^ ^a ^b Johnson, Chris (2009).
[1] Pro Bash Programming: Scripting the Linux Shell, Apress, Retrieved on September 27, 2019. ISBN 9781430219989
^ «exec(3p) – POSIX Programmer’s Manual». Retrieved 2020-07-24.
^ Unix Shells By Example, pp 7-10,
^ Programming Perl, 5th Edition, preface
^ «osh — manned.org». manned.org. Retrieved 2019-01-16.
^ Robbins, Arnold; Hannah, Elbert; Lamb, Linda (2008). Learning the vi and Vim Editors. p. 205. ISBN 9781449313258.
^ Easttom, Chuck (2012). Essential Linux Administration:: A Comprehensive Guide for Beginners. p. 228. ISBN 978-1435459571.
^ Kumari, Sinny (November 23, 2015). Linux Shell Scripting Essentials. Packt Publishing Ltd. ISBN 9781783552375. Retrieved May 7, 2017. Rather than using a file extension for shell scripts, it’s preferred to keep a filename without extension and let an interpreter identify the type by looking into shebang(#!).
^ Taylor, Dave; Perry, Brandon (December 16, 2016). Wicked Cool Shell Scripts, 2nd Edition: 101 Scripts for Linux, OS X and UNIX Systems. No Starch Press. ISBN 9781593276027. Retrieved May 7, 2017. Shell scripts don’t need a special file extension, so leave the extension blank (or you can add the extension .sh if you prefer, but this isn’t required.
^ Larry Wall (January 4, 1991). «Finding the last arg». Newsgroup: comp.unix.shell. Retrieved January 5, 2023.
^ Christiansen, Tom. «Csh Programming Considered Harmful».
^ «Major Differences From The Bourne Shell».
^ «24 Bashism To Avoid for POSIX-Compliant Shell Scripts». 18 May 2022.
^ MSDN^{[not specific enough to verify]}
^ Windows NT 4 Workstation Resource Kit

External links[edit]

An Introduction To Shell Programming by Greg Goebel
UNIX / Linux shell scripting tutorial by Steve Parker
Shell Scripting Primer (Apple)
What to watch out for when writing portable shell scripts by Peter Seebach
Free Unix Shell scripting books
Beginners/BashScripting, Ubuntu Linux

Источник

Capabilities[edit]

[edit]

Comments are ignored by the shell. They typically begin with the hash symbol (#), and continue until the end of the line.^[2]

Configurable choice of scripting language[edit]

Shortcuts[edit]

#!/bin/sh
LC_COLLATE=C ls -FCas "$@"

The user could then simply use l for the most commonly used short listing.

Another example of a shell script that could be used as a shortcut would be to print a list of all the files and directories within a given directory.

Note: If an implementation does not have the clear command, try using the clr command instead.

Batch jobs[edit]

#!/bin/sh
printf 'compiling...n'
cc -c foo.c
cc -c bar.c
cc -c qux.c
cc -o myprog foo.o bar.o qux.o
printf 'done.n'

Generalization[edit]

#!/bin/sh
for jpg; do                                  # use $jpg in place of each filename given, in turn
    png=${jpg%.jpg}.png                      # construct the PNG version of the filename by replacing .jpg with .png
    printf 'converting "%s" ...n' "$jpg"    # output status info to the user running the script
    if convert "$jpg" jpg.to.png; then       # use convert (provided by ImageMagick) to create the PNG in a temp file
        mv jpg.to.png "$png"                 # if it worked, rename the temporary PNG image to the correct name
    else                                     # ...otherwise complain and exit from the script
        printf >&2 'jpg2png: error: failed output saved in "jpg.to.png".n'
        exit 1
    fi                                       # the end of the "if" test construct
done                                         # the end of the "for" loop
printf 'all conversions successfuln'        # tell the user the good news

The jpg2png command can then be run on an entire directory full of JPEG images with just /home/username/bin/jpg2png *.jpg

Programming[edit]

Typical POSIX scripting languages[edit]

Scripting languages commonly found on UNIX, Linux, and POSIX-compliant operating system installations include:

KornShell (ksh) in several possible versions such as ksh88, Korn Shell ’93 and others.
The Bourne shell (sh), one of the oldest shells still common in use
The C shell (csh)
GNU Bash (bash)
tclsh, a shell which is a main component of the Tcl/Tk programming language.
The wish is a GUI-based Tcl/Tk shell.

Other shells that may be available on a machine or for download and/or purchase include:

Almquist shell (ash)
PowerShell (msh)
Z shell (zsh, a particularly common enhanced KornShell)
The Tenex C Shell (tcsh).

So called remote shells such as

a Remote Shell (rsh)
a Secure Shell (ssh)

are really just tools to run a more complex shell on a remote system and have no ‘shell’ like characteristics themselves.

Other scripting languages[edit]

Life cycle[edit]

While files with the «.sh» file extension are usually a shell script of some kind, most shell scripts do not have any filename extension.^[7]^[8]^[9]^[10]

Advantages and disadvantages[edit]

There are also compatibility problems between different platforms. Larry Wall, creator of Perl, famously wrote that «It is easier to port a shell than a shell script.»^[11]

Interoperability among scripting languages[edit]

Shell scripting on other operating systems[edit]

References[edit]

^ Kernighan, Brian W.; Pike, Rob (1984), «3. Using the Shell», The UNIX Programming Environment, Prentice Hall, Inc., p. 94, ISBN 0-13-937699-2, The shell is actually a programming language: it has variables, loops, decision-making, and so on.
^ ^a ^b Johnson, Chris (2009).
[1] Pro Bash Programming: Scripting the Linux Shell, Apress, Retrieved on September 27, 2019. ISBN 9781430219989
^ «exec(3p) – POSIX Programmer’s Manual». Retrieved 2020-07-24.
^ Unix Shells By Example, pp 7-10,
^ Programming Perl, 5th Edition, preface
^ «osh — manned.org». manned.org. Retrieved 2019-01-16.
^ Robbins, Arnold; Hannah, Elbert; Lamb, Linda (2008). Learning the vi and Vim Editors. p. 205. ISBN 9781449313258.
^ Easttom, Chuck (2012). Essential Linux Administration:: A Comprehensive Guide for Beginners. p. 228. ISBN 978-1435459571.
^ Kumari, Sinny (November 23, 2015). Linux Shell Scripting Essentials. Packt Publishing Ltd. ISBN 9781783552375. Retrieved May 7, 2017. Rather than using a file extension for shell scripts, it’s preferred to keep a filename without extension and let an interpreter identify the type by looking into shebang(#!).
^ Taylor, Dave; Perry, Brandon (December 16, 2016). Wicked Cool Shell Scripts, 2nd Edition: 101 Scripts for Linux, OS X and UNIX Systems. No Starch Press. ISBN 9781593276027. Retrieved May 7, 2017. Shell scripts don’t need a special file extension, so leave the extension blank (or you can add the extension .sh if you prefer, but this isn’t required.
^ Larry Wall (January 4, 1991). «Finding the last arg». Newsgroup: comp.unix.shell. Retrieved January 5, 2023.
^ Christiansen, Tom. «Csh Programming Considered Harmful».
^ «Major Differences From The Bourne Shell».
^ «24 Bashism To Avoid for POSIX-Compliant Shell Scripts». 18 May 2022.
^ MSDN^{[not specific enough to verify]}
^ Windows NT 4 Workstation Resource Kit

External links[edit]

An Introduction To Shell Programming by Greg Goebel
UNIX / Linux shell scripting tutorial by Steve Parker
Shell Scripting Primer (Apple)
What to watch out for when writing portable shell scripts by Peter Seebach
Free Unix Shell scripting books
Beginners/BashScripting, Ubuntu Linux

Источник

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

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

1. История раковины

Начиная с Unix в 1970-х годах, была разработана программа оболочки под названием V6 Shell, разработанная Кеном Томсоном. Это была интерактивная оболочка, и ей не хватало скриптов.

За ним последовала Bourne Shell в 1977 году, и она по-прежнему используется сегодня в качестве оболочки по умолчанию для корневой учетной записи. Эта оболочка добавила скриптовые возможности, которые оказались чрезвычайно полезными на практике в течение многих лет.

Дальнейшее развитие оболочки в 1980-х годах привело к появлению множества популярных вариантов оболочек, наиболее популярными из которых были C-Shell и Korn Shell . У каждой из этих оболочек был свой синтаксис, который в некоторых случаях резко отличался от оригинальной оболочки.

Одной из самых популярных оболочек сегодня является Bash Shell . Bash расшифровывается как Bourne-Again-Shell и представляет собой значительно улучшенный вариант оригинальной Bourne Shell.

В этой статье мы опишем сценарии оболочки для Bash Shell

2. Выполнение сценария оболочки

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

Пример сценария оболочки:

echo "hello world"

Запустите его следующим образом:

 $ bash hello.sh # prints hello world

Примечание . Оболочка требует, чтобы строки заканчивались символами LF (перевод строки). Если вы напишите свой сценарий оболочки в Windows и попытаетесь выполнить его непосредственно в системе Linux, вы можете столкнуться с ошибками. Windows использует комбинацию CR-LF (Carriage-Return-Line-Feed) для завершения строки. Это должно быть преобразовано только в LF. Проверьте ваш редактор Windows для способов сделать это.

Существует еще один способ выполнения сценария оболочки непосредственно в виде команды. Вставьте следующую строку (объявление hashbang ) в качестве первой строки вашего сценария оболочки.

 #!/bin/bash

С этим изменением наш простой сценарий оболочки теперь:

 #!/bin/bash echo "hello world"

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

 $ chmod +x hello.sh

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

 $ hello.sh # prints hello world

Давайте теперь посмотрим на некоторые преимущества использования сценариев оболочки

3. Автоматизация задач

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

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

4. Объединение нескольких команд

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

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

Ниже приведен пример сценария оболочки / etc / profile , который выполняется каждый раз, когда пользователь входит в систему. Представьте, что вы вводите эти команды вручную!

 # /etc/profile: system-wide .profile file for the Bourne shell (sh(1)) # and Bourne compatible shells (bash(1), ksh(1), ash(1), ...). if [ "$PS1" ]; then if [ "$BASH" ] && [ "$BASH" != "/bin/sh" ]; then # The file bash.bashrc already sets the default PS1. # PS1='h:w$ ' if [ -f /etc/bash.bashrc ]; then . /etc/bash.bashrc fi else if [ "`id -u`" -eq 0 ]; then PS1='# ' else PS1='$ ' fi fi fi # The default umask is now handled by pam_umask. # See pam_umask(8) and /etc/login.defs. if [ -d /etc/profile.d ]; then for i in /etc/profile.d/*.sh; do if [ -r $i ]; then . $i fi done unset i fi

5. Легче развивать

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

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

6. Прозрачность

Сценарий оболочки, благодаря тому, что он является текстовым файлом, может быть легко просмотрен, чтобы проверить, какие действия он выполняет. В отличие от этого, единственный способ узнать, что делает программа, написанная на таком языке, как C / C ++ (и скомпилирована в исполняемый файл), — если она решит сообщить вам или у вас есть доступ к исходному коду. Например, вы можете проверить, удаляет ли сценарий оболочки какие-либо файлы, и если вам нужны эти файлы, вы можете скопировать их в другое место.

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

7. Портативный

Сценарий оболочки можно перенести в другие Unix и Unix-подобные операционные системы и выполнить (если присутствует сама оболочка). Даже при переносе сценария оболочки из разных архитектур, таких как x86, MIPS, Sparc и т. Д., Сценарии оболочки гораздо более переносимы, чем программы на C / C ++.

Единственный способ передачи и использования программы на C / C ++ в другой системе — это скопировать исходный код, собрать программу и попытаться запустить ее. Даже в этом случае он может работать не так, как ожидается, если он использует специфичный для архитектуры код.

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

Источник

Содержание

1 1. История раковины
2 2. Выполнение сценария оболочки
3 3. Автоматизация задач
4 4. Объединение нескольких команд
5 5. Легче развивать
6 6. Прозрачность
7 7. Портативный

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

1. История раковины

Начиная с Unix в 1970-х годах, появилась программа-оболочка под названием V6 Shell разработанный Кеном Томсоном. Это была интерактивная оболочка, в которой не хватало скриптов.

Это сопровождалось Борн Шелл в 1977 году и остается в использовании сегодня в качестве оболочки по умолчанию для корень учетная запись. Эта оболочка добавила скриптовые возможности, которые оказались чрезвычайно полезными на практике в течение многих лет.

Дальнейшее развитие оболочки в 1980-х годах породило множество популярных вариантов оболочки, наиболее популярными из которых были C-Shell и Корн Шелл. У каждой из этих оболочек был свой синтаксис, который в некоторых случаях резко отличался от оригинальной оболочки.

Одна из самых популярных оболочек сегодня — это Bash Shell. Баш означает Bourne-Again-Shell и является значительно улучшенным вариантом оригинальной Bourne Shell.

В этой статье мы опишем сценарии оболочки для Bash Shell

2. Выполнение сценария оболочки

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

Пример сценария оболочки:

echo "hello world"

Запустите его следующим образом:

$ bash hello.sh
# prints
hello world

Замечания: Оболочка требует, чтобы строки заканчивались символами LF (перевод строки). Если вы напишите свой сценарий оболочки в Windows и попытаетесь выполнить его непосредственно в системе Linux, вы можете столкнуться с ошибками. Windows использует комбинацию CR-LF (Carriage-Return-Line-Feed) для завершения строки. Это должно быть преобразовано только в LF. Проверьте ваш редактор Windows для способов сделать это.

Существует еще один способ выполнения сценария оболочки непосредственно в виде команды. Вставьте следующую строку (объявление hashbang) в качестве первой строки вашего сценария оболочки.

#!/bin/bash

С этим изменением наш простой сценарий оболочки теперь:

#!/bin/bash
echo "hello world"

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

$ chmod +x hello.sh

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

$ hello.sh
# prints
hello world

Давайте теперь посмотрим на некоторые преимущества использования сценариев оболочки

3. Автоматизация задач

Первое преимущество использования сценариев оболочки — это автоматизация часто выполняемых задач.

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

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

4. Объединение нескольких команд

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

Примером может служить последовательность загрузки операционной системы Linux

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

Ниже приведен пример сценария оболочки / etc / profile, который выполняется каждый раз, когда пользователь входит в систему. Представьте, что вы вводите эти команды вручную!

# /etc/profile: system-wide .profile file for the Bourne shell (sh(1))
# and Bourne compatible shells (bash(1), ksh(1), ash(1), ...).
if [ "$PS1" ]; then
if [ "$BASH" ] && [ "$BASH" != "/bin/sh" ]; then
# The file bash.bashrc already sets the default PS1.
# PS1='h:w$ '
if [ -f /etc/bash.bashrc ]; then
. /etc/bash.bashrc
fi
else
if [ "`id -u`" -eq 0 ]; then
PS1='# '
else
PS1='$ '
fi
fi
fi
# The default umask is now handled by pam_umask.
# See pam_umask(8) and /etc/login.defs.
if [ -d /etc/profile.d ]; then
for i in /etc/profile.d/*.sh; do
if [ -r $i ]; then
. $i
fi
done
unset i
fi

5. Легче развивать

6. Прозрачность

7. Портативный

Сценарий оболочки

могут быть перенесены в другие Unix и Unix-подобные операционные системы и выполнены (если присутствует сама оболочка). Даже при переносе сценария оболочки из разных архитектур, таких как x86, MIPS, Sparc и т. Д., Сценарии оболочки гораздо более переносимы, чем программы на C / C ++.

Единственный способ переноса и использования программы на C / C ++ в другой системе — это скопировать исходный код, собрать программу и попытаться запустить ее. Даже в этом случае он может работать не так, как ожидается, если он использует специфичный для архитектуры код.

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

Источник

оглавление

1. Что такое оболочка?

2. Классификация языков программирования.

3. Что такое сценарий оболочки?

(1) Концепция сценария оболочки

(2) Первый сценарий оболочки

(3) Шаги по созданию программы оболочки

(4) Выполнение сценария оболочки

4. Переменная SHELL и ее применение.

(1) Правила определения переменных оболочки

(2) Классификация переменных

(3) Замена команд

(4) Разница между одинарными и двойными кавычками в оболочке

(5) Удалить переменные

(6) переменные окружающей среды

1) команда env для просмотра всех глобальных переменных

2) Используйте экспорт, чтобы экспортировать эту локальную переменную как глобальную переменную.

3) Установите переменную среды PATH

Фактический бой: установить операционную среду Java-jdk1.8

(7) Переменная положения оболочки

5. Математические операции в SHELL.

(1) команда expr

(2) Используйте $ (())

1.Что такое оболочка?

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

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

2. Классификация языков программирования.

Статический язык: компилируемый язык Такие как:c 、 c++ 、 java，

Динамический язык: интерпретируемый язык Такие как: php 、 shell 、 python 、 perl

3.Что такое сценарий SHELL?

(1) Концепция сценария оболочки

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

(2) Первый сценарий оболочки

、

Заметки:

1、! / bin / bash Функция: Сообщите сценарию, какой интерпретатор команд используется. Если он не относится к оболочке, текущая оболочка используется в качестве исполняемой оболочки.
2. Вв оболочке#Означает начало,Вся строка рассматривается как комментарий. Игнорируется во время выполнения.
3、Программы оболочки обычно заканчиваются на .sh

(3) СоздатьshellШаги процедуры

Шаг 1. Создайте файл, содержащий команды и управляющие структуры.
Шаг 2: Измените разрешения этого файла, чтобы сделать его исполняемым. § использоватьchmod +x test.sh
Шаг 3. Проверьте грамматические ошибки
Шаг 4: Реализация./Script

（4）Выполнение сценария оболочки

1. /root/test.sh или ./test.sh (если вы выполняете скрипт по текущему пути, у вас должно быть разрешение на выполнение chmod + x test.sh)
2. bash test.sh или sh test.sh (этот метод не требует добавления разрешений на выполнение в файл сценария)
3. исходный файл test.sh (у вас может не быть разрешения на выполнение)
4. sh <test.sh или cat test.sh | sh (bash)

4.Переменная SHELL и ее применение

(1) Правила определения переменных оболочки

（2）Классификация переменных

По функциям переменных его можно разделить на 4 категории:

1、Пользовательские переменные
2. Переменные среды. Переменные этого типа в основном хранят данные, относящиеся к операционной среде системы.
3、Переменная с позиционным параметром: этот тип переменных в основном используется для передачи параметров или данных в сценарий. Имя переменной не может быть изменено, а функция переменной является фиксированной.
4. Предопределенные переменные: даBashПеременные, которые были определены в, имя переменной не может быть изменено, и функция переменной также фиксирована.

По объему переменные можно разделить на 2 категории:

Глобальная переменная: это переменная среды, ее значение не следуетshell Выполнение скрипта завершается и исчезает.

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

（3）Подстановка команд

Используйте $ () или обратные кавычки (то есть клавишу над клавишей Tab)

Вложенное использование команд, используйте $ ($ ())

Фактический бой: сообщение об ошибке системного времени, в результате чего tar сообщает предупреждение

Примечание. Если это сообщение появляется, это значит, что текущее системное время неверно. Например: текущее системное время позже, чем время файла mtime.

(4) Разница между одинарными и двойными кавычками в оболочке

» Все символы в одинарных кавычках, включая специальные символы ($, `, ʻand ), будут интерпретироваться как сами символы и станут обычными символами.
«» В двойных кавычках все символы, кроме $, », ʻand , интерпретируются как сам символ, который имеет особое значение «значение переменной вызова», «команда кавычек» и «escape-символ»
Примечание: escape-символ, за которым следуетСпециальные символы после этого проиграютПерейдите к особому смыслу и станьте обычными персонажами. Такие как$Выведет“$”Символ, а не как ссылка на переменную

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

Разница между одинарными и двойными кавычками при присвоении значений

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

(5) Удалить переменные

(6) переменные окружающей среды

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

Глобальные переменные: видны сеансу оболочки и всем подоболочкам
Локальная переменная: используется только в собственном процессе

1) команда env для просмотра всех глобальных переменных

2) Используйте экспорт, чтобы экспортировать эту локальную переменную как глобальную переменную.

Хотя мы установили глобальную переменную экспорта, переменная VAR1 не может быть прочитана во вновь открытом соединении secureCRT. Что мне делать?

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

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

/etc/profile # Системная глобальная среда и некоторые конфигурации системы входа в систему

/etc/bashrc #shellГлобальный самоопределяющийся файл конфигурации для настраиваемой оболочки

/root/.bashrc # Используется для индивидуальной настройки bash пользователя

/root/.bash_profile# Пользователь индивидуально настраивает системную среду пользователя

Как узнать последовательность загрузки этих 4 файлов конфигурации при создании нового ssh-соединения?

Вы можете добавить команду echo в конец каждого файла, чтобы вывести имя файла

Какой смысл знать порядок загрузки?

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

Начните вставлять постоянные переменные ниже:

Повторно открыть баш

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

3) Установите переменную среды PATH

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

Пример:

Постоянно изменять, изменять файл конфигурации / etc / profile

Актуальный бой:Установите операционную среду Java-jdk1.8

скачатьjdk-8u161-linux-x64.rpm

1) Установка
rpm -ivh jdk-8u161-linux-x64.rpm
2) Проверьте место установки jdk, обычно в / usr / java
rpm -pql /root/jdk-8u161-linux-x64.rpm
3) Отредактируйте / etc / profile
vim /etc/profile
4）Добавьте в конец файла следующее
export JAVA_HOME=/usr/java/jdk1.8.0_161
export JAVA_BIN=/usr/java/jdk1.8.0_161/bin
export PATH=${JAVA_HOME}/bin:$PATH
export CLASSPATH=.:${JAVA_HOME}/lib/dt.jar:${JAVA_HOME}/lib/tools.jar
5）Сделайте файл конфигурации эффективным
source /etc/profile
6）Убедитесь, что среда выполнения java успешно установлена
java -version

(7) Переменная положения оболочки

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

$ 0 Получить имя файла исполняемого в данный момент сценария оболочки, включая путь к сценарию и саму команду

$ n Получить n-й параметр текущего скрипта n = 1,2 ….. n Когда n больше 9, он представлен как $ {10}.

Пример:

print.sh скрипт:

результат операции:

Типичное использование: параметры запуска сервера

(8) Специальные переменные

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

$*	Вывести все параметры, переданные в скрипт, в одну строку; *Если «$ » заключено в [«], все параметры выводятся в виде» $ 1 $ 2… $ n «.**
$#	Количество параметров, переданных в скрипт
$$	PID текущего процесса
$?	Отображение статуса выхода последней команды; 0 означает отсутствие ошибки, любое другое значение означает наличие ошибки
$!	Идентификатор номера процесса последнего запущенного в фоновом режиме

Пример 1:

special_variable.sh скрипт:

результат операции:

Пример 2: Часто используемые переменные среды

env.sh скрипт:

Результаты запуска в корневом каталоге /:

Переместите скрипт в каталог / opt и переключитесь в каталог / opt для выполнения:

5. Математические операции в SHELL.

（1）команда expr

1) Для базовых вычислений чисел при сравнении выходной результат ложный как 0, 1 как истинный; специальные символы используют escape-символы

2) Обработка строк

(2) Используйте $ (())

Формат: ((имя переменной = выражение 1, выражение 2))

Функции:

1. В структуре с двойными скобками все выражения могут быть похожими на язык c, например: ++ a, a ++, b— и т. Д. a ++ эквивалентно a = a + 1, и это те же правила, что и в языке C
2. В структуре с двойными скобками все переменные могут быть опущены: префикс знака «$».
3. Вы можете использовать $ для вызова двойных скобок.
4. Поддержка нескольких операций с выражениями, разделяя каждое выражение символом «,»
5. Если в двойных скобках указано несколько выражений, вызовите их с помощью $, предыдущее выражение будет вычислено, но будет возвращен только результат последнего выражения.
6. Двойные скобки могут использоваться для логических операций, четыре операции
7. Структура двойных скобок, расширенная для условных тестовых операций while if.

Часто используемые арифметические операторы

Оператор	Смысл
++ —	Увеличение и уменьшение, может быть до или после
+ — ! ~	Признаки унарных операций Логическое И отрицание
*+ — / %**	Сложение, вычитание, умножение, деление и остаток
< <= > >=	Сравните обозначение размера
== !=	Равно не равно
>> <<	Сдвиг влево сдвиг вправо
& ^ \|	Побитовое и побитовое исключающее или побитовое или
&& \|\|	Логично и логично или
？ :	Условное суждение

Источник

Что такое Шелл?

Операционная система состоит из множества компонентов, но два ее основных компонента –

ядро
Ракушка

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

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

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

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

В этом уроке вы узнаете

Что такое Шелл?
Типы Shell
Что такое сценарии оболочки?
Добавление комментариев оболочки
Что такое переменные оболочки?

Нажмите здесь, если видео не доступно

Типы Shell

В Linux есть две основные оболочки:

1 . Bourne Shell : Подсказка для этой оболочки $ и ее производные, перечислены ниже:

Оболочка POSIX также известна как sh
Корн Шелл также знал как ш
B ourne усиления SH ELL также знал , как Баш (самые популярные)

2. Оболочка C : приглашение для этой оболочки -%, и его подкатегории:

C shell также известен как csh
Топы C shell также известен как tcsh

В этом руководстве мы обсудим сценарии оболочки на основе оболочки bash.

Что такое сценарии оболочки?

SHELL SCRIPTING пишет серию команд для выполнения оболочки. Он может объединять длинные и повторяющиеся последовательности команд в один простой скрипт, который можно хранить и выполнять в любое время. Это уменьшает усилия, требуемые конечным пользователем.

Давайте разберемся, как создать сценарий оболочки

Создайте файл , используя в VI редактор (или любой другой редактор). Имя скриптового файла с расширением .sh
Запустите скрипт с #! / бен / ш
Напишите немного кода.
Сохраните файл скрипта как filename.sh
Для выполнения скрипта введите bash filename.sh

“#!” это оператор с именем shebang, который направляет скрипт в местоположение интерпретатора. Итак, если мы используем «#! / Bin / sh», скрипт будет направлен на оболочку bourne.

Давайте создадим небольшой скрипт –

#!/bin/sh
ls

Давайте посмотрим шаги для его создания –

Команда ‘ls’ выполняется, когда мы выполняем файл script sample.sh.

Добавление комментариев оболочки

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

#comment

Позвольте понять это на примере.

Что такое переменные оболочки?

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

Например, следующее создает переменную оболочки и затем печатает ее:

variable ="Hello"
echo $variable

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

#!/bin/sh
echo "what is your name?"
read name
echo "How do you do, $name?"
read remark
echo "I am $remark too!"

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

Как вы видите, программа выбрала значение переменной name как Joy, а замечание – как превосходное.

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

Резюме:

Ядро – это ядро операционных систем, и оно взаимодействует между аппаратным и программным обеспечением.
Shell – это программа, которая интерпретирует пользовательские команды через CLI, такие как Terminal
Оболочка Bourne и оболочка C являются наиболее часто используемыми оболочками в Linux.
Сценарии оболочки пишут серию команд для запуска оболочки
Переменные оболочки хранят значение строки или число для чтения оболочкой
Сценарии оболочки могут помочь вам создавать сложные программы, содержащие условные операторы, циклы и функции

Источник

Понимание основных элементов сценариев оболочки

Использование переменных и входных данных

Использование позиционных параметров

Переменные

Использование условий и циклов

if then else

|| и &&

Цикл for

Понимание while и until

Понимание case

Отладка скриптов в Bash

Подводим итоги

Сценарии оболочки

Запуск сценария

Capabilities[edit]

[edit]

Configurable choice of scripting language[edit]

Shortcuts[edit]

Batch jobs[edit]

Generalization[edit]

Programming[edit]

Typical POSIX scripting languages[edit]

Other scripting languages[edit]

Life cycle[edit]

Advantages and disadvantages[edit]

Interoperability among scripting languages[edit]

Shell scripting on other operating systems[edit]

See also[edit]

References[edit]

External links[edit]

Capabilities[edit]

[edit]

Configurable choice of scripting language[edit]

Shortcuts[edit]

Batch jobs[edit]

Generalization[edit]

Programming[edit]

Typical POSIX scripting languages[edit]

Other scripting languages[edit]

Life cycle[edit]

Advantages and disadvantages[edit]

Interoperability among scripting languages[edit]

Shell scripting on other operating systems[edit]

See also[edit]

References[edit]

External links[edit]

1. История раковины

2. Выполнение сценария оболочки

3. Автоматизация задач

4. Объединение нескольких команд

5. Легче развивать

6. Прозрачность

7. Портативный

1. История раковины

2. Выполнение сценария оболочки

3. Автоматизация задач

4. Объединение нескольких команд

5. Легче развивать

6. Прозрачность

7. Портативный

1.Что такое оболочка?

2. Классификация языков программирования.

3.Что такое сценарий SHELL?

(1) Концепция сценария оболочки

(2) Первый сценарий оболочки

(3) СоздатьshellШаги процедуры

（4）Выполнение сценария оболочки

4.Переменная SHELL и ее применение

(1) Правила определения переменных оболочки

（2）Классификация переменных

（3）Подстановка команд

(4) Разница между одинарными и двойными кавычками в оболочке

(5) Удалить переменные

(6) переменные окружающей среды

1) команда env для просмотра всех глобальных переменных

2) Используйте экспорт, чтобы экспортировать эту локальную переменную как глобальную переменную.

3) Установите переменную среды PATH

Актуальный бой:Установите операционную среду Java-jdk1.8

(7) Переменная положения оболочки

5. Математические операции в SHELL.