Учебник bash: Основы BASH. Часть 1 / Хабр

Основы BASH. Часть 1 / Хабр

Безусловно, все те кто общается с ОС Linux хоть раз да имели дело(во всяком случае слышали точно) с командной оболочкой BASH. Но BASH не только командная оболочка, это еще и превосходный скриптовый язык программирования.
Цель этой статьи — познакомить поближе юзеров с bash, рассказать про синтаксис, основные приемы и фишки языка, для того чтобы даже обычный пользователь смог быстренько написать простой скрипт для выполнения ежедневной(-недельной, -месячной) рутинной работы или, скажем, «на коленке» наваять скриптик для бэкапа директории.

Введение

BASH — Bourne-Again SHell (что может переводится как «перерожденный шел», или «Снова шел Борна(создатель sh)»), самый популярный командный интерпретатор в юниксоподобных системах, в особенности в GNU/Linux. Ниже приведу ряд встроенных команд, которые мы будем использовать для создания своих скриптов.

break выход из цикла for, while или until

continue выполнение следующей итерации цикла for, while или until

echo вывод аргументов, разделенных пробелами, на стандартное устройство вывода

exit выход из оболочки

export отмечает аргументы как переменные для передачи в дочерние процессы в среде

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

kill посылает сигнал завершения процессу

pwd выводит текущий рабочий каталог

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

return заставляет функцию оболочки выйти с указанным значением

shift перемещает позиционные параметры налево

test вычисляет условное выражение

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

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

unset вызывает уничтожение переменных оболочки

wait ждет выхода из дочернего процесса и сообщает выходное состояние.


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

Что необходимо знать с самого начала

1. Любой bash-скрипт должен начинаться со строки:

#!/bin/bash

в этой строке после #! указывается путь к bash-интерпретатору, поэтому если он у вас установлен в другом месте(где, вы можете узнать набрав whereis bash) поменяйте её на ваш путь.

2. Коментарии начинаются с символа # (кроме первой строки).

3. В bash переменные не имеют типа(о них речь пойдет ниже)

Переменные и параметры скрипта

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

#!/bin/bash

#указываем где у нас хранится bash-интерпретатор

parametr1=$1 #присваиваем переменной parametr1 значение первого параметра скрипта

script_name=$0 #присваиваем переменной script_name значение имени скрипта

echo "Вы запустили скрипт с именем $script_name и параметром $parametr1" # команда echo выводит определенную строку, обращение к переменным осуществляется через $имя_переменной.

echo 'Вы запустили скрипт с именем $script_name и параметром $parametr1' # здесь мы видим другие кавычки, разница в том, что в одинарных кавычках не происходит подстановки переменных.

exit 0 #Выход с кодом 0 (удачное завершение работы скрипта)


Результат выполнения скрипта:

ite@ite-desktop:~$ ./test.sh qwerty

Вы запустили скрипт с именем ./test.sh и параметром qwerty

Вы запустили скрипт с именем $script_name и параметром $parametr1


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

$DIRSTACK - содержимое вершины стека каталогов

$EDITOR - текстовый редактор по умолчанию

$EUID - Эффективный UID. Если вы использовали программу su для выполнения команд от другого пользователя, то эта переменная содержит UID этого пользователя, в то время как...

$UID - ...содержит реальный идентификатор, который устанавливается только при логине.

$FUNCNAME - имя текущей функции в скрипте.

$GROUPS - массив групп к которым принадлежит текущий пользователь

$HOME - домашний каталог пользователя

$HOSTNAME - ваш hostname

$HOSTTYPE - архитектура машины.

$LC_CTYPE - внутренняя переменная, котороя определяет кодировку символов

$OLDPWD - прежний рабочий каталог

$OSTYPE - тип ОС

$PATH - путь поиска программ

$PPID - идентификатор родительского процесса

$SECONDS - время работы скрипта(в сек.)

$# - общее количество параметров переданных скрипту

$* - все аргументы переданыне скрипту(выводятся в строку)

$@ - тоже самое, что и предыдущий, но параметры выводятся в столбик

$! - PID последнего запущенного в фоне процесса

$$ - PID самого скрипта

Условия

Условные операторы, думаю, знакомы практически каждому, кто хоть раз пытался на чем-то писать программы. В bash условия пишутся след. образом (как обычно на примере):
#!/bin/bash
source=$1 #в переменную source засовываем первый параметр скрипта
dest=$2 #в переменную dest засовываем второй параметр скрипта

if [[ «$source» -eq «$dest» ]] # в ковычках указываем имена переменных для сравнения. -eq — логическое сравнение обозначающие «равны»

then # если они действительно равны, то

echo «Применик $dest и источник $source один и тот же файл!» #выводим сообщение об ошибке, т.к. $source и $dest у нас равны

exit 1 # выходим с ошибкой (1 — код ошибки)

else # если же они не равны

cp $source $dest # то выполняем команду cp: копируем источник в приемник

echo «Удачное копирование!»

fi #обозначаем окончание условия.

Результат выполнения скрипта:
ite@ite-desktop:~$ ./primer2.sh 1 1

Применик 1 и источник 1 один и тот же файл!

ite@ite-desktop:~$ ./primer2.sh 1 2

Удачное копирование!


Структура if-then-else используется следующим образом:

if <команда или набор команд возвращающих код возврата(0 или 1)>

then

<если выражение после if истино, то выполняется этот блок>

else

<если выражение после if ложно, тот этот>

В качестве команд возвращающих код возврата могут выступать структуры [[ , [ , test, (( )) или любая другая(или несколько) linux-команда.

test — используется для логического сравнения. после выражения, неоьбходима закрывающая скобка «]»

[ — синоним команды test

[[ — расширенная версия «[» (начиная с версии 2.02)(как в примере), внутри которой могут быть использованы || (или), & (и). Долна иметь закрывающуб скобку «]]»

(( )) — математическое сравнение.

для построения многоярусных условий вида:
if ...

then ....

else

if ....

then....

else ....


для краткости и читаемости кода, можно использовать структуру:
if ..

then ...

elif ...

then ...

elif ...


Условия. Множественный выбор

Если необходимо сравнивать какоую-то одну переменную с большим количеством параметров, то целесообразней использовать оператор case.
#!/bin/bash

echo "Выберите редатор для запуска:"

echo "1 Запуск программы nano"

echo "2 Запуск программы vi"

echo "3 Запуск программы emacs"

echo "4 Выход"

read doing #здесь мы читаем в переменную $doing со стандартного ввода

case $doing in

1)

/usr/bin/nano # если $doing содержит 1, то запустить nano

;;

2)

/usr/bin/vi # если $doing содержит 2, то запустить vi

;;

3)

/usr/bin/emacs # если $doing содержит 3, то запустить emacs

;;

4)

exit 0

;;

*) #если введено с клавиатуры то, что в case не описывается, выполнять следующее:

echo "Введено неправильное действие"

esac #окончание оператора case.

Результат работы:
ite@ite-desktop:~$ ./menu2.sh

Выберите редатор для запуска:

1 Запуск программы nano

2 Запуск программы vi

3 Запуск программы emacs

4 Выход

После выбор цифры и нажатия Enter запуститься тот редактор, который вы выбрали(если конечно все пути указаны правильно, и у вас установлены эти редакторы 🙂 )
Прведу список логических операторв, которые используются для конструкции if-then-else-fi:
-z # строка пуста

-n # строка не пуста

=, (==) # строки равны

!= # строки неравны

-eq # равно

-ne # неравно

-lt,(< ) # меньше

-le,(<=) # меньше или равно

-gt,(>) #больше

-ge,(>=) #больше или равно

! #отрицание логического выражения

-a,(&&) #логическое «И»

-o,(||) # логическое «ИЛИ»

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

UPD: Исправил некоторые ошибки
UPD: Обновил часть про условия if-then-else

Статьи на unix-admin.su

30 легких команд для новичков

Список из 30 легких команд, с которыми вы быстро освоите Bash и не будете бояться терминала Linux. Идеально для новичков.

Если вы здесь, вероятно, вы столкнулись с проблемой изучения Bash команд. Давайте это исправим 🙂

Современные файловые системы – это древовидные каталоги с корневой и родительскими директориями. Движение вверх по родительским каталогам приводит к корневому. В некоторых системах встречается несколько корневых каталогов, например, всем известные диски Windows: C:\ , A:\, etc.

Но в Unix-подобных системах все по-другому: здесь принят один корневой каталог с именем \. А вот и основные команды Bash для перемещения по файловой системе:

pwd / ls / cd

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

geekpress@proglib:~$ pwd
/home/geekpress

С ls вы сможете вывести содержимое каталога (файлы и дочерние директории):

geekpress@proglib:~$ ls
imports  temp   playground  README.md example dir

Перейти в другой каталог поможет cd:

geekpress@proglib:~$ cd imports/

geekpress@proglib:~imports$ pwd
/home/geekpress/imports

geekpress@proglib:~imports$ cd testdata

geekpress@proglib:~testdata$ pwd
/home/geekpress/imports/testdata

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

geekpress@proglib:~testdata$ cd ..

geekpress@proglib:~imports$ pwd
/home/geekpress/imports

Сокращение cd ~ используется для перемещения домой, в /home/$USER:

geekpress@proglib:~imports$ cd ~

geekpress@proglib:~$ pwd
/home/geekpress

Три bash команды для управления

Иногда вам потребуется запускать эти команды одну за другой. Тогда на помощь приходит оператор ;:

geekpress@proglib:~$ ls; pwd
imports temp playground README.md
/home/geekpress

Точка с запятой означает, что сначала перечисляется содержимое рабочего каталога с помощью ls, а затем pwd выводит местоположение каталога. Еще один полезный инструмент для создания цепочек команд – &&. При использовании && команда справа не будет выполняться, если команда слева не выполнена:

# Ой! Тут опечатка!
geekpress@proglib~:$ cd /pplayground/socket/ && pwd && ls && cd
-bash: cd: /pplayground/socket: No such file or directory

# теперь первая команда проходит, так что выполняются следующие
geekpress@proglib:~$ cd /playground/socket/ && pwd && ls && cd
/home/geekpress/playground/socket
socket.go  socket_test.go

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

# pwd и ls запустятся даже после ошибок в cd
geekpress@proglib:~$ cd /pplayground/socket ; pwd ; ls
-bash: cd: /pplayground/socket: No such file or directory
/home/geekpress
imports LICENSE playground README.md

А вот вам небольшой трюк в bash. Команда & похожа на &&, но на самом деле выполняет другую функцию. Часто процессы блокируют ввод в терминал во время работы. Чтобы свернуть подобный процесс в фон, используйте & в конце команды. Тогда процесс выполняется в фоне, не блокируя ввод в окно терминала:

geekpress@proglib:~$ cd /playground/socket && mv socket.go ~/ & cd
geekpress@proglib:~$

Скорая помощь для тех, кто забыл

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

geekpress@proglib:~$ ls --help
Usage: ls [OPTION]... [FILE]...
List information about the FILEs (the current directory by default).
Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.

Mandatory arguments to long options are mandatory for short options too.
  -a, --all                  do not ignore entries starting with .
  -A, --almost-all           do not list implied . and ..
      --author               with -l, print the author of each file
  -b, --escape               print C-style escapes for nongraphic characters
      --block-size=SIZE      scale sizes by SIZE before printing them; e.g.,
                               '--block-size=M' prints sizes in units of
                               1,048,576 bytes; see SIZE format below
  -B, --ignore-backups       do not list implied entries ending with ~
...

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

CAT(1)                                                              User Commands                                                             CAT(1)

NAME
       cat - concatenate files and print on the standard output

SYNOPSIS
       cat [OPTION]... [FILE]...

DESCRIPTION
       Concatenate FILE(s) to standard output.

       With no FILE, or when FILE is -, read standard input.

       -A, --show-all
              equivalent to -vET

...

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

head выводит первые строки файла. Флаг -n указывает количество отображаемых строк:

# вывод трех начальных строк
geekpress@proglib:~$ head -n 3 tempfile
first
three
lines

tail выводит последние строки файла. Можно получить последние n строк или конец файла, начиная с N-й строки, с помощью tail -n + N:

# выводит конец файла, начиная с 4-ой строки
geekpress@proglib:~$ tail -n +4 testfile
last
from
fourth

Используйте cat с одним или несколькими файлами: так можно быстро посмотреть содержание.

geekpress@proglib:~$ cat x
file x
geekpress@proglib:~$ cat x y
file x
file y

nano – минималистичный текстовый редактор командной строки. Редактор подходит начинающим и тем, кто не любит разнообразия. На начальных этапах он покроет все ваши требования.

nedit – легкий графический редактор, который открывается в окне. Редактирование по принципу «укажи и щелкни» с перетаскиванием, есть подсветка синтаксиса. Можно использовать nedit, когда следует постоянно вносить небольшие изменения и перезапускать скрипт.

Современные редакторы предлагают функции поиска и замены, подсветки синтаксиса и так далее. vi (m) и emacs функциональней nano и nedit, но сложней в освоении.

Создаем и удаляем файлы/директории

touch нужен для изменения временных меток файлов и для создания пустого файла. Можно создать новый файл в nano:

geekpress@proglib:~temp$ ls

geekpress@proglib:~temp$ nano newfile

Затем править файл и сохранить:

geekpress@proglib:~temp$ ls
newfile

Или использовать touch:

geekpress@proglib:~temp$ touch another && ls
newfile another

mkdir создает новые каталоги:

geekpress@proglib:~temp$ ls && mkdir fold && ls
newfile another
newfile another fold

Теперь удалим файл с помощью команды rm.

WARNING: файл невозможно восстановить!

geekpress@proglib:~temp$ rm newfile && ls
another fold

Необходимость подтверждения вызывается флагом -i:

geekpress@proglib:~temp$ rm -i another
rm: remove regular empty file 'another'? y

Удаляйте пустые каталоги с помощью rmdir. Если ls -a используется в пустом каталоге, команда выводит только ссылку на сам каталог . и ссылку на родительский каталог ..:

geekpress@proglib:~temp$ rmdir fold && ls -a
.  ..

Команда rmdir удаляет только директории:

geekpress@proglib:~temp$ cd .. && ls temp/
zzz.txt  big.txt  4.txt  x  bb.txt  y  z

geekpress@proglib:~$ rmdir temp/
rmdir: failed to remove 'test/': Directory not empty

Чтобы удалить директорию с содержимым, используйте rm -rf:

geekpress@proglib:~$ rm –rf temp

Перемещаемся, копируем, ссылаемся

mv перемещает и переименовывает файл. Для переименования введите новое имя файла:

geekpress@proglib:~example$ ls && mv x 2 && ls
x  y  z  1
y  z  1  2

cp копирует файл:

geekpress@proglib:~example$ cp 2 22 && ls
y  z  1  2  22

ln -s создает симлинк:

geekpress@proglib:~example$ ln -s y b && ls
y  z  1  2  22  f  b

Bash: история команд

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

geekpress@proglib:~dir$ ls <ENTER>
mobilizeemberduty  mobilizeember  mobilize

geekpress@proglib:~dir$ ls t <TAB>

Нажмите клавишу tab после ls t, и команда будет завершена автоматически.

geekpress@proglib:~dir$ ls mobilizeemberduty <ENTER>
mobilizeemberduty

Иногда нужно нажимать tab несколько раз:

geekpress@proglib:~dir$ ls m <TAB>

geekpress@proglib:~dir$ ls mo <TAB>
mobilize  mobilizeember

Bash хранит историю ранее введенных команд. Чтобы выполнить поиск нажмите Ctrl + r:

geekpress@proglib:~dir$

Нажимаем Ctrl + r:

(reverse-i-search)`':

Вводим «mobi» и находим последнюю команду с этой строкой:

(reverse-i-search)`mobi': touch mobilize

Деревья каталогов, использование диска и процессы

По умолчанию mkdir создает только один каталог. Это означает, что, например, если каталога a/b не существует, то a/b/c не может быть создан с помощью mkdir:

geekpress@proglib:~example$ ls && mkdir a/b/c
x  y  z
mkdir: cannot create directory 'd/e/f': No such file or directory

Но если указать флаг -p, mkdir создаст все директории, которые отсутствуют в указанном пути:

geekpress@proglib:~example$ mkdir -p a/b/c && ls
x  y  z  a

tree отображает структуру каталога в виде отформатированного дерева. По умолчанию tree печатает древовидную структуру, начиная с указанного каталога, но количество уровней ограничивается флагом -L:

geekpress@proglib:~example$ tree -L 2
.
|-- x
|-- y
|-- z
`-- a
    `--b

3 directories, 2 files

Скрывайте пустые каталоги в дереве с помощью --prune. Обратите внимание, что при этом не выводятся каталоги, которые содержат другие пустые каталоги:

geekpress@proglib:~example$ tree --prune
.
|-- x
`-- y

df показывает, сколько места занимают файлы на дисках.

geekpress@proglib:~example$ df -h
Filesystem      Size  Used Avail Use% Mounted on
udev            1.9G     0  1.9G   0% /dev
tmpfs           389M  6.3M  383M   2% /run
...

В приведенной выше команде -h означает не «help», а «human-readable». Некоторые команды используют этот флаг для отображения размеров в K для килобайт и G для гигабайт, вместо записи гигантского числа байтов.

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

geekpress@proglib:~example$ du
12760	./.git/objects
13016	./.git
72	./container/intsets
76	./container
27380	.

df принимает флаг --max-deep = N, который показывает директории только на N уровней в указанном каталоге:

ps показывает запущенные процессы пользователей:

geekpress@proglib:~example$ ps
  PID TTY          TIME CMD
15333 pts/0    00:00:00 bash
15344 pts/0    00:00:00 ps

Вот вам и основы Bash. Но давайте копнем чуть глубже.

Другие полезные команды bash

Меняйте пароль учетной записи с помощью passwd. Команда проверяет текущий пароль и просит ввести новый пароль дважды:

geekpress@proglib:~example$ passwd
Changing password for user.
(current) UNIX password:    <type current password>
Enter new UNIX password:    <type new password>
Retype new UNIX password:   <type new password again>
passwd: password updated successfully

logout выполняет выход пользователя из сеанса оболочки:

geekpress@proglib:~example$ logout

──────────────────────────────────────────────────────────────────────────────
Session stopped
    - Press <return> to exit tab
    - Press R to restart session
    - Press S to save terminal output to file

exit выходит из консоли:

geekpress@proglib:~example$ exit
logout

──────────────────────────────────────────────────────────────────────────────
Session stopped
    - Press <return> to exit tab
    - Press R to restart session
    - Press S to save terminal output to file

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

Используйте * при поиске файлов. Обратите внимание на разницу между следующими командами:

geekpress@proglib:~$ ls imports/
fix.go          imports.go      mkstdlib.go     mod_test.go     testdata/       
fix_test.go     mkindex.go      mod.go          sortimports.go  zstdlib.go

geekpress@proglib:~$ ls imports/fi*
fix.go       fix_test.go

Используйте * много раз в одной команде с символами и без:

geekpress@proglib:~$ ls Git/Parser/source/f*i*x*
fix.go       fix_test.go  

Ну все! Теперь вы точно застрахованы от случаев, когда bash команда не найдена. А как вы начинали работать с bash? Поделитесь своим списком команд bash для начинающих 😉

Интересуют другие команды Bash? Вас могут заинтересовать следующие статьи:

Источник: 101 команда Bash для начинающих и экспертов

Основы BASH. Часть 2 / Хабр

Основы BASH. Часть 2.
Извиняюсь за такую большую задержку между статьями, но сессия дает о себе знать в самый неподходящий момент 🙂
Всем спасибо за замечания, критику и дополнения, которые были озвучены в комментариях к прошлой статье.
Эта часть, как и обещал, будет посвящена циклам, математическим операциям и использованию внешних команд.
Начнем.

Циклы. Цикл for-in.

Оператор for-in предназначен для поочередного обращения к значениям перечисленным в списке. Каждое значение поочередно в списке присваивается переменной.
Синтаксис следующий:
for переменная in список_значений

do

команды

done

Рассмотрим небольшой пример:

#!/bin/bash

for i in 0 1 2 3 4 #переменной $i будем поочередно присваивать значения от 0 до 4 включительно

do

echo "Console number is $i" >> /dev/pts/$i #Пишем в файл /dev/pts/$i(файл виртуального терминала) строку "Console number is $i"

done #цикл окончен

exit 0


После выполнения примера в первых 5 виртуальных консолях(терминалах) появится строка с её номером. В переменную $i поочередно подставляются значения из списка и в цикле идет работа со значением этой переменной

Циклы. Цикл while.

Цикл while сложнее цикла for-in и используется для повторения команд, пока какое-то выражение истинно( код возврата = 0).
Синтаксис оператора следующий:
while выражение или команда возвращающая код возврата

do

команды

done

Пример работы цикла рассмотрим на следующем примере:

#!/bin/bash

again=yes #присваиваем значение "yes" переменной again

while [ "$again" = "yes" ] #Будем выполнять цикл, пока $again будет равно "yes"

do

echo "Please enter a name:"

read name

echo "The name you entered is $name"

echo "Do you wish to continue?"

read again

done

echo "Bye-Bye"

А теперь результат работы скрипта:

ite@ite-desktop:~$ ./bash3_primer1.sh

Please enter a name:

ite

The name you entered is ite

Do you wish to continue?

yes

Please enter a name:

mihail

The name you entered is mihail

Do you wish to continue?

no

Bye-Bye


Как видим цикл выполняется до тех пор, пока мы не введем что-то отличное от «yes». Между do и done можно описывать любые структуры, операторы и т.п., все они будут выполнятся в цикле.Но следует быть осторожным с этим циклом, если вы запустите на выполнение в нём какую-либо команду, без изменения переменной выражения, вы можете попасть в бесконечный цикл.

Теперь об условии истинности. После while, как и в условном операторе if-then-else можно вставлять любое выражение или команду, которая возвращает код возврата, и цикл будет исполнятся до тех пор, пока код возврата = 0! Оператор «[» аналог команды test, которая проверяет истинность условия, которое ей передали.

Рассмотрим еще один пример, я взял его из книги Advanced Bash Scripting. Уж очень он мне понравился :), но я его немного упростил. В этом примере мы познакомимся с еще одним типом циклов UNTIL-DO. Эта практически полный аналог цикла WHILE-DO, только выполняется пока какое-то выражение ложно.

Вот пример:

#!/bin/bash

echo "Введите числитель: "

read dividend

echo "Введите знаменатель: "

read divisor

dnd=$dividend #мы будем изменять переменные dividend и divisor,

#сохраним их знания в других переменных, т.к. они нам

#понадобятся

dvs=$divisor

remainder=1

until [ "$remainder" -eq 0 ]

do

let "remainder = dividend % divisor"

dividend=$divisor

divisor=$remainder

done

echo "НОД чисел $dnd и $dvs = $dividend"

Результат выполнения скрипта:

ite@ite-desktop:~$ ./bash3_primer3.sh

Введите числитель:

100

Введите знаменатель:

90

НОД чисел 100 и 90 = 10


Математические операции

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

#!/bin/bash

echo "Введите a: "

read a

echo "Введите b: "

read b

let "c = a + b" #сложение

echo "a+b= $c"

let "c = a / b" #деление

echo "a/b= $c"

let "c <<= 2" #сдвигает c на 2 разряда влево

echo "c после сдвига на 2 разряда: $c"

let "c = a % b" # находит остаток от деления a на b

echo "$a / $b. остаток: $c "

Результат выполнения:

ite@ite-desktop:~$ ./bash3_primer2.sh

Введите a:

123

Введите b:

12

a+b= 135

a/b= 10

c после сдвига на 2 разряда: 40

123 / 12. остаток: 3


Ну вот, как видите ничего сложного, список математических операций стандартный:
+ — сложение
— — вычитание
* — умножение
/ — деление
** — возведение в степень
% — модуль(деление по модулю), остаток от деления
let позволяет использовать сокращения арифметических команд, тем самым сокращая кол-во используемых переменных. Например: a = a+b эквивалентно a +=b и т.д

Работа с внешними программами при написании shell-скриптов

Для начала немного полезной теории.

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

В bash(как и многих других оболочках) есть встроенные файловые дескрипторы: 0 (stdin), 1 (stdout), 2 (stderr).
stdout — Стандартный вывод. Сюда попадает все что выводят программы
stdin — Стандартный ввод. Это все что набирает юзер в консоли
stderr — Стандартный вывод ошибок.

Для операций с этими дескрипторами, существуют специальные символы: > (перенаправление вывода),

cat /dev/random > /dev/null

перенаправить вывод команды cat /dev/random в /dev/null (абсолютно бесполезная операция :)) ) или

ls -la > listing

записать в файл listing содержание текущего каталога (уже полезней)
Если есть необходимость дописывать в файл(при использовании «>» он заменятеся), необходимо вместо «>» использовать «>>»

sudo < my_password

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

./program_with_error 2> error_file

цифра 2 перед «>» означает что нужно перенаправлять все что попадет в дескриптор 2(stderr).
Если необходимо заставить stderr писать в stdout, то это можно можно след. образом:

./program_with_error 2>&1

символ «&» означает указатель на дескриптор 1(stdout)
(Поумолчанию stderr пишет на ту консоль, в котрой работает пользователь(вренее пишет на дисплей)).

2.Конвееры.

Конвеер — очень мощный инструмент для работы с консолью Bash. Синтаксис простой:
команда1 | команда 2 — означает, что вывод команды 1 передастся на ввод команде 2
Конвееры можно группировать в цепочки и выводить с помощью перенаправления в файл, например:

ls -la | grep «hash» |sort > sortilg_list

вывод команды ls -la передается команде grep, которая отбирает все строки, в которых встретится слово hash, и передает команде сортировке sort, которая пишет результат в файл sorting_list. Все довольно понятно и просто.

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

1. Передача вывода в переменную.

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

a = `echo "qwerty"`

echo $a


Результат работы: qwerty

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

LIST=`find /svn/ -type d 2>/dev/null| awk '{FS="/"} {print $4}'| sort|uniq | tr '\n' ' '`

for ONE_OF_LIST in $LIST

do

svnadmin hotcopy /svn/$ONE_OF_LIST /svn/temp4backup/$ONE_OF_LIST

done


Здесь мы используем цикл for-do-done для архивирование всех директорий в папке /svn/ с помощью команды svnadmin hotcopy(что в нашем случае не имеет никого значения, просто как пример). Наибольшй интерес вызывает строка: LIST=`find /svn/ -type d 2>/dev/null| awk '{FS="/"} {print $4}'| sort|uniq | tr '\n' ' '` В ней переменной LIST присваивается выполнение команды find, обработанной командами awk, sort, uniq,tr(все эти команды мы рассматривать не будем, ибо это отдельная статья). В переменной LIST будут имена всех каталогов в папке /svn/ пгомещенных в одну строку(для того чтобы её стравить циклу.

Как видно, все не сложно, достаточно понять принцип и написать пару своих скриптов. В заключении статьи хочу пожелать удачи в изучении BASH и Linux в целом. Критика, как водится приветствуется. Следующая статья возможно будет посвещена использованию таких программ как sed, awk.

Статьи на unix-admin.su

21 полезная команда / Блог компании RUVDS.com / Хабр

Материал, перевод которого мы публикуем сегодня, предназначен для тех, кто хочет освоить командную строку Linux. Умение эффективно пользоваться этим инструментом позволяет экономить немало времени. В частности, речь здесь пойдёт о командной оболочке Bash и о 21 полезной команде. Также мы поговорим о том, как пользоваться флагами команд и псевдонимами Bash, которые позволяют ускорить ввод длинных инструкций.

→ Также читайте в нашем блоге цикл публикаций про bash-скрипты

Термины

В ходе освоения работы в командной строке Linux вам может встретиться множество понятий, в которых полезно будет ориентироваться. Некоторые из них, вроде «Linux» и «Unix», или «командная оболочка» и «терминал», иногда путают. Поговорим об этих и о других важных терминах.

Unix — это популярная операционная система, которая была разработана Bell Labs в 1970-х. Её код был закрытым.

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

Терминал (terminal), или эмулятор терминала — это программа, дающая доступ к операционной системе. Одновременно можно открывать несколько окон терминала.

Оболочка (shell) — это программа, которая позволяет отправлять операционной системе команды, написанные на особом языке.

Bash расшифровывается как Bourne Again SHell. Это — самый распространённый язык командной оболочки, используемый для взаимодействия с операционной системой. Кроме того, оболочка Bash по умолчанию используется в macOS.

Интерфейс командной строки (Command Line Interface, CLI) — это способ взаимодействия человека и компьютера, при использовании которого пользователь вводит команды с клавиатуры, а компьютер, выполняя эти команды, выводит, в текстовом виде, сообщения для пользователя. В основном CLI используется для получения свежей информации о неких сущностях, например, о файлах, и для работы с файлами. Интерфейс командной строки следует отличать от графического пользовательского интерфейса (Graphical User Interface, GUI), при работе с которым, в основном, используется мышь. Интерфейс командной строки часто называют просто командной строкой.

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

Теперь, когда мы рассмотрели важные термины, хочу отметить, что здесь я буду пользоваться терминами «Bash», «оболочка» и «командная строка» как взаимозаменяемыми, равно как и понятиями «директория» (directory) и «папка» (folder).

Стандартные потоки, которыми мы будем здесь пользоваться — это стандартный ввод (standard input, stdin), стандартный вывод (standard output, stdout) и стандартный вывод ошибок (standard error, stderr).

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

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

21 Bash-команда

▍Получение информации

• man: выводит руководство пользователя (справку) по команде.
• pwd: выводит сведения о рабочей директории.
• ls: выводит содержимое директории.
• ps: позволяет просматривать сведения о работающих процессах.

▍Манипуляции с файловой системой

• cd: изменение рабочей директории.
• touch: создание файла.
• mkdir: создание директории.
• cp: копирование файла.
• mv: перемещение или удаление файла.
• ln: создание ссылки.

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

• <: перенаправление stdin.
• >: перенаправление stdout.
• |: перенаправление с помощью конвейера вывода одной команды на вход другой команды.

▍Чтение файлов

• head: чтение начала файла.
• tail: чтение конца файла.
• cat: чтение файла и вывод его содержимого на экран или конкатенация файлов.

▍Удаление файлов, остановка процессов

• rm: удаление файла.
• kill: остановка процесса.

▍Поиск

• grep: поиск информации.
• ag: продвинутая команда для поиска.

▍Архивация

• tar: создание архивов и работа с ними.

Поговорим об этих командах подробнее.

Подробности о командах

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

▍Получение информации

man command_name: вывод руководства по команде, то есть — справочной информации.

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

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

ls -a: вывод скрытых файлов. Здесь применён флаг -a команды ls. Использование флагов помогает настраивать поведение команд.

ls -l: вывод подробной информации о файлах.

Обратите внимание на то, что флаги можно комбинировать. Например — так: ls -al.

ps: просмотр выполняющихся процессов.

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

▍Манипуляции с файловой системой

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

touch my_file: создание файла my_file по заданному пути.

mkdir my_directory: создание папки my_directory по заданному пути.

mv my_file target_directory: перемещение файла my_file в папку target_directory. При указании целевой директории нужно использовать абсолютный путь к ней (а не конструкцию вроде ../).

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

mv my_old_file_name.jpg my_new_file_name.jpg

cp my_source_file target_directory: создание копии файла my_source_file и помещение её в папку target_directory.

ln -s my_source_file my_target_file: создание символической ссылки my_target_file на файл my_source_file. Если изменить ссылку, то изменится и исходный файл.

Если файл my_source_file будет удалён, то my_target_file останется. Флаг -s команды ln позволяет создавать ссылки и для директорий.

Теперь поговорим о перенаправлении ввода-вывода и конвейерах.

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

my_command < my_file: заменяет дескриптор файла стандартного ввода (stdin) на файл my_file. Это может оказаться полезным в том случае, если команда ожидает ввода неких данных с клавиатуры, а эти данные заранее сохранены в файле.

my_command > my_file: перенаправляет результаты работы команды, то есть то, что обычно попадает в stdout и выводится на экран, в файл my_file. Если файл my_file не существует — он создаётся. Если файл существует — он перезаписывается.

Например, после выполнения команды ls > my_folder_contents.txt будет создан текстовый файл, содержащий список того, что находится в текущей рабочей директории.

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

Теперь взглянем на конвейерную обработку данных.

То, что выводит одна команда, подаётся на вход другой команды. Это похоже на подключение одной трубы к другой

first_command | second_command: символ конвейера, |, используется для того чтобы отправить результаты работы одной команды другой команде. То, что команда, находящаяся в левой части описываемой конструкции, отправляет в stdout, попадает в stdin команды, которая находится справа от символа конвейера.

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

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

first_command | second_command | third_command

Конвейер из нескольких команд можно сравнить с трубопроводом

Обратите внимание на то, что когда команда, находящаяся слева от символа |, выводит что-то в stdout, то, что она вывела, немедленно становится доступным в виде stdin второй команде. То есть оказывается, что, используя конвейер, мы имеем дело с параллельным выполнением команд. Иногда это может привести к неожиданным результатам. Подробности об этом можно почитать здесь.

Теперь поговорим о чтении данных из файлов и о выводе их на экран.

▍Чтение файлов

head my_file: считывает строки из начала файла и выводит их на экран. Читать можно не только содержимое файлов, но и то, что команды выводят в stdin, используя эту команду в качестве элемента конвейера.

tail my_file: считывает строки из конца файла. Эту команду тоже можно использовать в конвейере.

Head (голова) находится спереди, а tail (хвост) — сзади

Если вы работаете с данными, используя библиотеку pandas, тогда команды head и tail должны быть вам знакомы. Если это не так — взгляните на вышеприведённый рисунок, и вы без труда их запомните.

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

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

Команда cat

cat my_one_file.txt: когда этой команде передают один файл — она выводит его в stdout.

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

cat my_file1.txt my_file2.txt: получив на вход несколько файлов эта команда конкатенирует их содержимое и выведет то, что получилось в stdout.

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

cat my_file1.txt my_file2.txt > my_new_file.txt

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

▍Удаление файлов, остановка процессов

rm my_file: удаляет файл my_file.

rm -r my_folder: удаляет папку my_folder и все содержащиеся в ней файлы и папки. Флаг -r указывает на то, что команда будет работать в рекурсивном режиме.

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

kill 012345: останавливает указанный выполняющийся процесс, давая ему время на корректное завершение работы.

kill -9 012345: принудительно завершает указанный запущенный процесс. Флаг вида -s SIGKILL означает то же самое, что и флаг -9.

▍Поиск

Для поиска данных можно использовать разные команды. В частности — grep, ag и ack. Начнём наше знакомство с этими командами с grep. Это — проверенная временем, надёжная команда, которая, правда, медленнее других и не так, как они, удобна в использовании.
Команда grep

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

grep -i my_regex my_file: поиск выполняется без учёта регистра символов.

grep -v my_regex my_file: возвращает все строки, в которых не содержится my_regex. Флаг -v означает инверсию, он напоминает оператор NOT, имеющийся во многих языках программирования.

grep -c my_regex my_file: возвращает сведения о количестве совпадений с искомым шаблоном, найденных в файле.

grep -R my_regex my_folder: выполняет рекурсивный поиск во всех файлах, находящихся в заданной папке и в папках, вложенных в неё.

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

Команда ag

ag my_regex my_file: возвращает сведения о номерах строк, и сами строки, в которых найдены совпадения с my_regex.

ag -i my_regex my_file: поиск выполняется без учёта регистра символов.

Команда ag автоматически обрабатывает файл .gitignore и исключает из вывода то, что найдено в папках или файлах, перечисленных в этом файле. Это очень удобно.

ag my_regex my_file -- skip-vcs-ignores: содержимое файлов систем автоматического контроля версий (наподобие .gitignore) при поиске не учитывается.

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

В начале этого раздела мы упомянули о команде ack. Команды ack и ag очень похожи, можно сказать, что они взаимозаменяемы на 99%. Однако команда ag работает быстрее, поэтому я описал именно её.

Теперь поговорим о работе с архивами.

▍Архивация

tar my_source_directory: объединяет файлы из папки my_source_directory в один файл tarball. Такие файлы удобно использовать для того, чтобы передавать кому-нибудь большие наборы файлов.
Команда tar

Tarball-файлы, создаваемые этой командой, представляют собой файлы с расширением .tar (Tape ARchive). То, что в названии команды и в расширении имён файлов, создаваемых ей, скрыто слово «tape» (лента), говорит о том, как давно существует эта команда.

tar -cf my_file.tar my_source_directory: создаёт tarball-файл с именем my_file.tar с содержимым папки my_source_directory. Флаг -c расшифровывается как «create» (создание), а флаг -f как «file» (файл).

Для извлечения файлов, находящихся в .tar-файле, используется команда tar c флагами -x («extract», извлечение) и -f («file», файл).

tar -xf my_file.tar: извлекает файлы из my_file.tar в текущую рабочую директорию.

Теперь поговорим о том, как сжимать и распаковывать .tar-файлы.

tar -cfz my_file.tar.gz my_source_directory: здесь, с использованием флага -z («zip», алгоритм сжатия) указано, что для сжатия файлов должен использоваться алгоритм gzip (GNU zip). Сжатие файлов позволяет экономить дисковое пространство при хранении таких файлов. Если же файлы планируется, например, передавать другим пользователям, это способствует более быстрой загрузке таких файлов.

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

tar -xfz my_file.tar.gz

Надо отметить, что у команды tar есть ещё множество полезных флагов.

Bash-псевдонимы

Bash-псевдонимы (их ещё называют алиасами или сокращениями) предназначены для создания сокращённых наименований команд или их последовательностей, использование которых вместо обычных команд ускоряет работу. Если у вас, предположим, имеется псевдоним bu, за которым скрывается команда python setup.py sdist bdist_wheel, то для вызова данной команды достаточно воспользоваться этим псевдонимом.

Для создания подобного псевдонима достаточно добавить следующую команду в файл ~/.bash_profile:

alias bu="python setup.py sdist bdist_wheel"

Если в вашей системе нет файла ~/.bash_profile, то вы можете создать его самостоятельно, воспользовавшись командой touch. После создания псевдонима перезапустите терминал, после чего вы сможете этим псевдонимом пользоваться. В данном случае ввод двух символов заменяет ввод более чем трёх десятков символов команды, которая предназначена для сборки Python-пакетов.

В ~/.bash_profile можно добавлять псевдонимы для любых часто используемых команд.

▍Итоги

В этом материале мы рассмотрели 21 популярную команду Bash и поговорили о создании псевдонимов для команд. Если вам эта тема интересна — вот цикл публикаций, посвящённый Bash. Здесь можно найти pdf-версию этих публикаций. Кроме того, если вы хотите освоить Bash, помните о том, что тут, как и при изучении любой другой программной системы, важна практика.

Уважаемые читатели! Какие команды, которые полезно знать начинающим, вы добавили бы к тем, которые были рассмотрены в этой статье?

→ Также читайте в нашем блоге цикл публикаций про bash-скрипты

функции и разработка библиотек / Блог компании RUVDS.com / Хабр

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

Занимаясь разработкой bash-скриптов, вы рано или поздно столкнётесь с тем, что вам периодически приходится использовать одни и те же фрагменты кода. Постоянно набирать их вручную скучно, а копирование и вставка — не наш метод. Как быть? Хорошо бы найти средство, которое позволяет один раз написать блок кода и, когда он понадобится снова, просто сослаться на него в скрипте.

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

Объявление функций

Функцию можно объявить так:

functionName {
}

Или так:

functionName() {
}

Функцию можно вызвать без аргументов и с аргументами.

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

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

#!/bin/bash
function myfunc {
echo "This is an example of using a function"
}
count=1
while [ $count -le 3 ]
do
myfunc
count=$(( $count + 1 ))
done
echo "This is the end of the loop"
myfunc
echo "End of the script"

Здесь создана функция с именем myfunc. Для вызова функции достаточно указать её имя.
Результаты вызова функции

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

#!/bin/bash
count=1
while [ $count -le 3 ]
do
myfunc
count=$(( $count + 1 ))
done
echo "This is the end of the loop"
function myfunc {
echo "This is an example of using a function"
}
echo "End of the script"

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

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

#!/bin/bash
function myfunc {
echo "The first function definition"
}
myfunc
function myfunc {
echo "The second function definition"
}
myfunc
echo "End of the script"

Как видно, новая функция преспокойно затёрла старую.
Переопределение функции

Использование команды return

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

#!/bin/bash
function myfunc {
read -p "Enter a value: " value
echo "adding value"
return $(( $value + 10 ))
}
myfunc
echo "The new value is $?"

Команда echo вывела сумму введённого числа и числа 10.
Вывод значения, возвращаемого функцией

Функция myfunc добавляет 10 к числу, которое содержится в переменной $value, значение которой задаёт пользователь во время работы сценария. Затем она возвращает результат, используя команду return. То, что возвратила функция, выводится командой echo с использованием переменной $?.

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

Учтите, что максимальное число, которое может вернуть команда return — 255. Если функция должна возвращать большее число или строку, понадобится другой подход.

Запись вывода функции в переменную

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

#!/bin/bash
function myfunc {
read -p "Enter a value: " value
echo $(( $value + 10 ))
}
result=$( myfunc)
echo "The value is $result"

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

Аргументы функций

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

Функции могут использовать стандартные позиционные параметры, в которые записывается то, что передаётся им при вызове. Например, имя функции хранится в параметре $0, первый переданный ей аргумент — в $1, второй — в $2, и так далее. Количество переданных функции аргументов можно узнать, обратившись к переменной $#. Если вы знакомы с третьей частью этого цикла материалов, вы не можете не заметить, что всё это очень похоже на то, как скрипты обрабатывают переданные им параметры командной строки.

Аргументы передают функции, записывая их после её имени:

myfunc $val1 10 20

Вот пример, в котором функция вызывается с аргументами и занимается их обработкой:

#!/bin/bash
function addnum {
if [ $# -eq 0 ] || [ $# -gt 2 ]
then
echo -1
elif [ $# -eq 1 ]
then
echo $(( $1 + $1 ))
else
echo $(( $1 + $2 ))
fi
}
echo -n "Adding 10 and 15: "
value=$(addnum 10 15)
echo $value
echo -n "Adding one number: "
value=$(addnum 10)
echo $value
echo -n "Adding no numbers: "
value=$(addnum)
echo $value
echo -n "Adding three numbers: "
value=$(addnum 10 15 20)
echo $value

Запустим скрипт.
Вызов функции с аргументами

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

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

#!/bin/bash
function myfunc {
echo $(( $1 + $2 ))
}
if [ $# -eq 2 ]
then
value=$( myfunc)
echo "The result is $value"
else
echo "Usage: myfunc  a b"
fi

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

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

#!/bin/bash
function myfunc {
echo $(( $1 + $2 ))
}
if [ $# -eq 2 ]
then
value=$(myfunc $1 $2)
echo "The result is $value"
else
echo "Usage: myfunc a b"
fi

Теперь всё работает правильно.
Передача функции параметров, с которыми запущен скрипт

Работа с переменными в функциях

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

Существуют два вида переменных:

• Глобальные переменные.
• Локальные переменные.

▍Глобальные переменные

Глобальные переменные — это переменные, которые видны из любого места bash-скрипта. Если вы объявили глобальную переменную в основном коде скрипта, к такой переменной можно обратиться из функции.

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

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

#!/bin/bash
function myfunc {
value=$(( $value + 10 ))
}
read -p "Enter a value: " value
myfunc
echo "The new value is: $value"

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

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

Что если такое поведение нас не устраивает? Ответ прост — надо использовать локальные переменные.

▍Локальные переменные

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

local temp=$(( $value + 5 ))

Если за пределами функции есть переменная с таким же именем, это на неё не повлияет. Ключевое слово local позволяет отделить переменные, используемые внутри функции, от остальных переменных. Рассмотрим пример:

#!/bin/bash
function myfunc {
local temp=$[ $value + 5 ]
echo "The Temp from inside function is $temp"
}
temp=4
myfunc
echo "The temp from outside is $temp"

Запустим скрипт.
Локальная переменная в функции

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

Передача функциям массивов в качестве аргументов

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

#!/bin/bash
function myfunc {
echo "The parameters are: $@"
arr=$1
echo "The received array is ${arr[*]}"
}
myarray=(1 2 3 4 5)
echo "The original array is: ${myarray[*]}"
myfunc $myarray

Неправильный подход к передаче функциям массивов

Как видно из примера, при передаче функции массива, она получит доступ лишь к его первому элементу.

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

#!/bin/bash
function myfunc {
local newarray
newarray=("$@")
echo "The new array value is: ${newarray[*]}"
}
myarray=(1 2 3 4 5)
echo "The original array is ${myarray[*]}"
myfunc ${myarray[*]}

Запустим сценарий.
Сборка массива внутри функции

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

Рекурсивные функции

Рекурсия — это когда функция сама себя вызывает. Классический пример рекурсии — функция для вычисления факториала. Факториал числа — это произведение всех натуральных чисел от 1 до этого числа. Например, факториал 5 можно найти так:

5! = 1 * 2 * 3 * 4 * 5

Если формулу вычисления факториала написать в рекурсивном виде, получится следующее:

x! = x * (x-1)!

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

#!/bin/bash
function factorial {
if [ $1 -eq 1 ]
then
echo 1
else
local temp=$(( $1 - 1 ))
local result=$(factorial $temp)
echo $(( $result * $1 ))
fi
}
read -p "Enter value: " value
result=$(factorial $value)
echo "The factorial of $value is: $result"

Проверим, верно ли работает этот скрипт.
Вычисление факториала

Как видите, всё работает как надо.

Создание и использование библиотек

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

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

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

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

. ./myscript

Предположим, что у нас имеется файл myfuncs, который содержит следующее:

function addnum {
echo $(( $1 + $2 ))
}

Это — библиотека. Воспользуемся ей в сценарии:

#!/bin/bash
. ./myfuncs
result=$(addnum 10 20)
echo "The result is: $result"

Вызовем его.
Использование библиотек

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

Вызов bash-функций из командной строки

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

Отредактируйте .bashrc, добавив в него такую строку (путь к файлу библиотеки в вашей системе, естественно, будет другим):

. /home/likegeeks/Desktop/myfuncs

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

$ addnum 10 20

Вызов функции из командной строки

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

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

Итоги

Функции в bash-скриптах позволяют оформлять блоки кода и вызывать их в скриптах. А наиболее часто используемые функции стоит выделить в библиотеки, которые можно подключать к скриптам, используя оператор source. Если же среди ваших функций найдутся такие, без которых вы прямо таки жить не можете — библиотеки с ними можно подключить в файле .bashrc. Это позволит удобно пользоваться ими в командной строке или в других скриптах. Главное — чтобы имена ваших функций не совпадали с именами встроенных команд.

На сегодня это всё. В следующий раз поговорим об утилите sed — мощном средстве обработки строк.

Уважаемые читатели! А вы пользуетесь функциями собственной разработки для решения повседневных задач?

Полное руководство по программированию на Bash, Linux и Shell

Курс: «Полное руководство по программированию на Bash, Linux и Shell». Данный материал будет полезен многим. Отзывы отличные! Материал полностью на английском языке + субтитры (которые легко перевести). Материал прислал анонимный пользователь без комментариев. 

Материал может быть удален по запросу правообладателя!

Описание курса:

Узнайте обо всем, что нужно знать о Linux Bash Scripting. Пошаговый процесс используется для объяснения каждого аспекта этих тем. ПРИМЕЧАНИЕ: этот курс включает в себя информацию о разработке и разработке приложений!

Получите хорошее понимание следующих понятий с этим курсом:

• Что такое Bash-скриптинг?
• Сертификаты Linux
• Как разрабатывать с использованием языка программирования Linux
• Особенности языка программирования Linux
• Семантика кодирования
• Прикладное программирование
• Сетевое программирование

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

Для кого этот курс:

• Любой, кто хочет узнать о сценариях Bash
• Разработчики, желающие изучить навыки, необходимые для использования возможностей Linux
• Разработчики Linux
• Unix Developers
• Разработчики Mac
• Программисты приложений
• Люди хотят узнать о программировании
• Те, кто хочет понять, как работает Linux-программирование
• Люди, ищущие руководство о том, как создавать скрипты для Linux и Mac
• Новички и эксперты в этой области
• Люди с желанием улучшить свои знания программирования

Если Вы не видите ссылку для скачивания материала — отключите блокиратор рекламы и добавьте наш сайт в список исключений. Если Вы против рекламы на нашем сайте — покупайте контент напрямую у авторов.

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

Материал предоставлен исключительно для ознакомления!

Опубликовано: Анонимно

OPENSSOURCE проводит масштабную ПРАЗДНИЧНУЮ акцию в честь СЕМИЛЕТИЯ ПРОЕКТА, которая продлится 3 дня! Более 300.000 материалов, доступ к закрытому порталу с эксклюзивными курсами, закрытый чат в Telegram и многое другое со скидкой навсегда! Пришло время развиваться и зарабатывать на любимом деле!

НАЖМИТЕ ДЛЯ ПОЛУЧЕНИЯ ПОДРОБНОСТЕЙ

параметры и ключи командной строки / Блог компании RUVDS.com / Хабр

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

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

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

$ ./myscript 10 20

В данном примере сценарию передано два параметра — «10» и «20». Всё это хорошо, но как прочесть данные в скрипте?

Чтение параметров командной строки

Оболочка bash назначает специальным переменным, называемым позиционными параметрами, введённые при вызове скрипта параметры командной строки:

• $0 — имя скрипта.
• $1 — первый параметр.
• $2 — второй параметр — и так далее, вплоть до переменной $9, в которую попадает девятый параметр.

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

#!/bin/bash
echo $0
echo $1
echo $2
echo $3

Запустим сценарий с параметрами:

./myscript 5 10 15

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

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

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

#!/bin/bash
total=$[ $1 + $2 ]
echo The first parameter is $1.
echo The second parameter is $2.
echo The sum is $total.

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

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

#!/bin/bash
echo Hello $1, how do you do

Запустим его:

./myscript Adam

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

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

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

${10}

Проверка параметров

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

#!/bin/bash
if [ -n "$1" ]
then
echo Hello $1.
else
echo "No parameters found. "
fi

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

Подсчёт параметров

В скрипте можно подсчитать количество переданных ему параметров. Оболочка bash предоставляет для этого специальную переменную. А именно, переменная $# содержит количество параметров, переданных сценарию при вызове.

Опробуем её:

#!/bin/bash
echo There were $# parameters passed.

Вызовем сценарий.

./myscript 1 2 3 4 5

В результате скрипт сообщит о том, что ему передано 5 параметров.
Подсчёт количества параметров в скрипте

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

#!/bin/bash
echo The last parameter was ${!#}

Вызовем скрипт и посмотрим, что он выведет.
Обращение к последнему параметру

Захват всех параметров командной строки

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

Переменная $* содержит все параметры, введённые в командной строке, в виде единого «слова».

В переменной $@ параметры разбиты на отдельные «слова». Эти параметры можно перебирать в циклах.

Рассмотрим разницу между этими переменными на примерах. Сначала взглянем на их содержимое:

#!/bin/bash
echo "Using the \$* method: $*"
echo "-----------"
echo "Using the \$@ method: $@"

Вот вывод скрипта.
Переменные $* и $@

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

#!/bin/bash
count=1
for param in "$*"
do
echo "\$* Parameter #$count = $param"
count=$(( $count + 1 ))
done
count=1
for param in "$@"
do
echo "\$@ Parameter #$count = $param"
count=$(( $count + 1 ))
done

Взгляните на то, что скрипт вывел в консоль. Разница между переменными вполне очевидна.
Разбор переменных $* и $@ в цикле

Переменная $* содержит все переданные скрипту параметры как единый фрагмент данных, в то время как в переменной $@ они представлены самостоятельными значениями. Какой именно переменной воспользоваться — зависит от того, что именно нужно в конкретном сценарии.

Команда shift

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

Когда вы используете эту команду, она, по умолчанию, сдвигает значения позиционных параметров влево. Например, значение переменной $3 становится значением переменной $2, значение $2 переходит в $1, а то, что было до этого в $1, теряется. Обратите внимание на то, что при этом значение переменной $0, содержащей имя скрипта, не меняется.

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

#!/bin/bash
count=1
while [ -n "$1" ]
do
echo "Parameter #$count = $1"
count=$(( $count + 1 ))
shift
done

Скрипт задействует цикл while, проверяя длину значения первого параметра. Когда длина станет равна нулю, происходит выход из цикла. После проверки первого параметра и вывода его на экран, вызывается команда shift, которая сдвигает значения параметров на одну позицию.
Использование команды shift для перебора параметров

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

Ключи командной строки

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

#!/bin/bash
echo
while [ -n "$1" ]
do
case "$1" in
-a) echo "Found the -a option" ;;
-b) echo "Found the -b option" ;;
-c) echo "Found the -c option" ;;
*) echo "$1 is not an option" ;;
esac
shift
done

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

$ ./myscript –a –b –c –d

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

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

Как различать ключи и параметры

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

Эта последовательность — двойное тире (—). Оболочка использует её для указания позиции, на которой заканчивается список ключей. После того, как скрипт обнаружит признак окончания ключей, то, что осталось, можно, не опасаясь ошибок, обрабатывать как параметры, а не как ключи. Рассмотрим пример:

#!/bin/bash
while [ -n "$1" ]
do
case "$1" in
-a) echo "Found the -a option" ;;
-b) echo "Found the -b option";;
-c) echo "Found the -c option" ;;
--) shift
break ;;
*) echo "$1 is not an option";;
esac
shift
done
count=1
for param in $@
do
echo "Parameter #$count: $param"
count=$(( $count + 1 ))
done

Этот сценарий использует команду break для прерывания цикла while при обнаружении в строке двойного тире.

Вот что получится после его вызова.

Обработка ключей и параметров командной строки

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

Обработка ключей со значениями

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

./myscript -a test1 -b -c test2

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

#!/bin/bash
while [ -n "$1" ]
do
case "$1" in
-a) echo "Found the -a option";;
-b) param="$2"
echo "Found the -b option, with parameter value $param"
shift ;;
-c) echo "Found the -c option";;
--) shift
break ;;
*) echo "$1 is not an option";;
esac
shift
done
count=1
for param in "$@"
do
echo "Parameter #$count: $param"
count=$(( $count + 1 ))
done

Вызовем этот скрипт в таком виде:

./myscript -a -b test1 -d

Посмотрим на результаты его работы.
Обработка параметров ключей

В данном примере в конструкции case обрабатываются три ключа. Ключ -b требует наличия дополнительного параметра. Так как обрабатываемый ключ находится в переменной $1, соответствующий ему параметр будет находиться в $2 (тут используется команда shift, поэтому, по мере обработки, всё, что передано сценарию, сдвигается влево). Когда с этим мы разобрались, осталось лишь извлечь значение переменной $2 и у нас будет параметр нужного ключа. Конечно, тут понадобится ещё одна команда shift для того, чтобы следующий ключ попал в $1.

Использование стандартных ключей

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

-a Вывести все объекты.
-c Произвести подсчёт.
-d Указать директорию.
-e Развернуть объект.
-f Указать файл, из которого нужно прочитать данные.
-h Вывести справку по команде.
-i Игнорировать регистр символов.
-l Выполнить полноформатный вывод данных.
-n Использовать неинтерактивный (пакетный) режим.
-o Позволяет указать файл, в который нужно перенаправить вывод.
-q Выполнить скрипт в quiet-режиме.
-r Обрабатывать папки и файлы рекурсивно.
-s Выполнить скрипт в silent-режиме.
-v Выполнить многословный вывод.
-x Исключить объект.
-y Ответить «yes» на все вопросы.

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

Получение данных от пользователя

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

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

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

#!/bin/bash
echo -n "Enter your name: "
read name
echo "Hello $name, welcome to my program."

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

При вызове read можно указывать и несколько переменных:

#!/bin/bash
read -p "Enter your name: " first last
echo "Your data for $last, $first…"

Вот что выведет скрипт после запуска.
Несколько переменных в команде read

Если, вызвав read, не указывать переменную, данные, введённые пользователем, будут помещены в специальную переменную среды REPLY:

#!/bin/bash
read -p "Enter your name: "
echo Hello $REPLY, welcome to my program.

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

Если скрипт должен продолжать выполнение независимо от того, введёт пользователь какие-то данные или нет, вызывая команду read можно воспользоваться ключом -t. А именно, параметр ключа задаёт время ожидания ввода в секундах:

#!/bin/bash
if read -t 5 -p "Enter your name: " name
then
echo "Hello $name, welcome to my script"
else
echo "Sorry, too slow! "
fi

Если данные не будут введены в течение 5 секунд, скрипт выполнит ветвь условного оператора else, выведя извинения.
Ограничение времени на ввод данных

Ввод паролей

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

#!/bin/bash
read -s -p "Enter your password: " pass
echo "Is your password really $pass? "

Вот как отработает этот скрипт.
Ввод конфиденциальных данных

Чтение данных из файла

Команда read может, при каждом вызове, читать одну строку текста из файла. Когда в файле больше не останется непрочитанных строк, она просто остановится. Если нужно получить в скрипте всё содержимое файла, можно, с помощью конвейера, передать результаты вызова команды cat для файла, конструкции while, которая содержит команду read (конечно, использование команды cat выглядит примитивно, но наша цель — показать всё максимально просто, ориентируясь на новичков; опытные пользователи, уверены, это поймут).

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

#!/bin/bash
count=1
cat myfile | while read line
do
echo "Line $count: $line"
count=$(( $count + 1 ))
done
echo "Finished"

Посмотрим на него в деле.
Чтение данных из файла

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

Итоги

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

В следующий раз поговорим об операциях ввода и вывода.

Уважаемые читатели! Спасибо вам за то, что делитесь опытом в комментариях к предыдущим частям этого цикла материалов. Если вам есть что сказать об обработке всего того, что можно передать в скрипт при запуске или во время его работы, уверены, многим будет интересно об этом почитать.

Учебное пособие по созданию сценариев для

Bash — Учебники Райана

Добро пожаловать!

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

Введение

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

Сценарии

Bash используются системными администраторами, программистами, сетевыми инженерами, учеными и почти всеми, кто регулярно использует систему Linux / Unix. Независимо от того, что вы делаете или каков ваш общий уровень владения компьютером, вы обычно можете найти способ использовать сценарии Bash, чтобы облегчить себе жизнь.Bash — это язык командной строки. Название расшифровывается как Bourne Again SHell . Это версия Bourne Shell с открытым исходным кодом, впервые выпущенная в 1989 году.

BASH — это оболочка по умолчанию в большинстве дистрибутивов Linux и MacOS от Apple (ранее OS X). Недавно появилась версия для Windows 10.

.

Наброски

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

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

1. Что такое Bash Script — что это такое, как они работают и как их запускать.
2. Переменные — временное хранение данных для последующего использования.
3. Input — Различные способы предоставления данных и направлений для вашего сценария Bash.
4. Арифметика — Выполняйте различные арифметические операции в сценарии Bash.
5. If Statements — Как принимать решения в вашем сценарии Bash.
6. Loops — Различные способы выполнения повторяющихся задач.

Функции

7. — Используйте код повторно, чтобы облегчить жизнь.
8. Пользовательский интерфейс — Сделайте ваши скрипты удобными для пользователя.

Сценарий

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

Структура

Лучший способ изучить Bash Scripting — это серия небольших, простых в управлении шагов.Это учебное пособие организовано таким образом, каждый раздел основан на знаниях и навыках, полученных в предыдущих разделах. Если вы работаете с ними по порядку, прочтите их полностью (материала довольно много, но он важен для правильного понимания) и потренируйтесь в командной строке по ходу работы. Я считаю, что у вас должен быть довольно приятный и плавный путь к Мастерство написания сценариев на Bash.

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

Каждый раздел имеет следующий формат:

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

Думайте о занятиях не как об учебных вопросах (например, вы можете получить их на уроках в школе), а как о том, где исследовать среду Linux, чтобы извлечь пользу из ваших новых знаний и навыков.Относитесь к занятиям как к отправной точке для исследования. Чем дальше вы пойдете, тем лучше у вас получится. (Насколько хорошо вы справляетесь и насколько далеко вы зайдете, зависит от того, насколько вы нелицеприятны.)

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

Общие правила дома

• Я буду ссылаться на Linux на следующих страницах, всякий раз, когда я это делаю, предполагаю, что на самом деле я говорю Unix / Linux. Linux является ответвлением Unix и ведет себя примерно так же.
• Всякий раз, когда вы видите <что-то> , это означает, что вы должны заменить это на что-то полезное. Заменить все (включая). Если вы видите что-то вроде , то обычно это означает замену этим числом.
• Каждый раз, когда вы видите [что-то] , это обычно означает, что это что-то не является обязательным. Когда вы запускаете команду, вы можете вставить что-то или опустить.

Решение проблем и творческое мышление

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

• Исследуй и экспериментируй .Помните, вы учитесь собирать набор строительных блоков, и из них вы можете построить практически все, что угодно. Примеры, которые вы найдете, предназначены для иллюстрации того, как они работают, а не единственного, что вы можете с ними делать. Я рекомендую вам настроить примеры и посмотреть, как они себя ведут. Это позволит вам лучше понять, как они работают. У вас будет много вопросов типа «А что, если …?» и «Могу я …?» на что я говорю: «Попробуйте и посмотрите, что произойдет.«Худшее, что вы действительно можете получить — это сообщение об ошибке. В этом случае вы читаете сообщение об ошибке, чтобы понять, почему она не работает, а затем попробуйте еще раз. Не сдерживайтесь!
• Внимательно прочтите и не пропустите мелкие детали. Я не могу этого не подчеркнуть. Мелкие детали важны и часто являются разницей между работающим и неработающим сценарием. Если что-то не работает, внимательно перечитайте материал и еще раз просмотрите то, что вы ввели, чтобы убедиться, что вы не допустили маленькой глупой опечатки.

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

Об авторе

Привет. Меня зовут Райан Чедвик, и я преподаю Linux студентам уже более 10 лет. Это то, что мне очень нравится. В мире, где мы все больше скрываем сложности от пользователей (в частности, смартфонов и планшетов), всегда приятно вернуть эту силу людям и позволить им делать гораздо больше с помощью своих технологий.

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

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

Напишите нам по номеру

Извините, вам нужен Javascript, чтобы написать мне письмо.

Используя этот материал

Кто угодно может ссылаться на содержимое этого веб-сайта.

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

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

Заявление об ограничении ответственности

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

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

.Учебное пособие по

Linux для начинающих — изучение Linux и командной строки Bash

Добро пожаловать!

Хорошо, поэтому вы хотите узнать, как использовать интерфейс командной строки Bash (терминал) в Unix / Linux. Или это часть предмета, который вы изучаете, и поэтому вы изучаете его, потому что должны. В любом случае, это здорово. Вы учитесь использовать мощный инструмент, который может облегчить вашу жизнь и сделать вас крутым (даже больше, чем я уверен, что вы уже есть).

Введение

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

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

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

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

Возможно, вам в голову пришел вопрос: «Зачем мне нужно изучать командную строку? Графический интерфейс пользователя намного проще, и я уже могу делать большую часть того, что мне нужно». В определенной степени вы были бы правы, и я ни в коем случае не предлагаю вам отказаться от графического интерфейса.Для некоторых задач лучше всего подходит графический интерфейс, отличными примерами являются обработка текста и редактирование видео. В то же время некоторые задачи больше подходят для командной строки, например, манипулирование данными (создание отчетов) и управление файлами. Некоторые задачи будут такими же простыми в любой среде. Думайте о командной строке как о еще одном инструменте, который вы можете добавить к своему поясу. Как всегда, выберите лучший инструмент для работы.

Наброски

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

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

1. Командная строка — что это такое, как она работает и как добраться до нее.
2. Базовая навигация — Введение в систему каталогов Linux и способы ее обхода.
3. Подробнее о файлах — Узнайте некоторые интересные характеристики файлов и каталогов в среде Linux.
4. страницы руководства — узнайте, как максимально эффективно использовать изучаемые вами команды Linux.
5. File Manipulation — Как создавать, удалять, переименовывать, копировать и перемещать файлы и каталоги.
6. Vi Text Editor — Откройте для себя мощный текстовый редактор на базе Linux.
7. Подстановочные знаки — также называемое подстановкой, это средство для одновременного обращения к нескольким файлам.
8. Разрешения — Узнайте, как определять и изменять разрешения для файлов и каталогов и каковы их последствия.
9. Filters — Введение в различные команды, которые позволяют нам изменять данные интересными и полезными способами.
10. Grep и регулярные выражения — освоите мощный язык сопоставления с образцом, который полезен для анализа и обработки данных.
11. Трубопровод и перенаправление — объединяйте команды в мощные комбинации.
12. Управление процессами — узнайте, что в настоящее время работает в вашей системе Linux и в каком состоянии находится система, узнайте, как уничтожать зависшие программы и переводить задания в фоновый режим.
13. Скрипты — Будьте счастливы. Заставьте компьютер выполнять за вас утомительные и повторяющиеся задачи.

Шпаргалка по

14. — краткий справочник по основным моментам, затронутым в этом руководстве.

Структура

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

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

Каждый раздел имеет следующий формат:

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

Думайте о занятиях не как об учебных вопросах (например, вы можете получить в классе в школе), а как о том, где исследовать среду Linux, чтобы извлечь пользу из ваших новых знаний и навыков.Относитесь к занятиям как к отправной точке для исследования. Чем дальше вы пойдете, тем лучше у вас получится. (Насколько хорошо вы справляетесь и насколько далеко вы зайдете, зависит от того, насколько вы нелицеприятны.)

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

Некоторые общие правила дома:

• Я буду ссылаться на Linux на следующих страницах, когда я это сделаю, предполагая, что я на самом деле говорю Unix / Linux. Linux является ответвлением Unix и ведет себя примерно так же.
• Когда вы видите <что-то> , это означает, что вы должны заменить это на что-то полезное. Заменить все (включая). Если вы видите что-то вроде , это обычно означает замену этим числом.
• Когда вы видите [что-то] , это обычно означает, что это что-то необязательно. Когда вы запускаете команду, вы можете вставить что-то или опустить.

Решение проблем и творческое мышление

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

• Исследуй и экспериментируй .Помните, что вы изучаете набор строительных блоков, и с их помощью вы можете построить практически все, что угодно. Примеры, которые вы найдете, предназначены для иллюстрации того, как они работают, а не единственного, что вы можете с ними делать. Я рекомендую вам настроить примеры и посмотреть, как они себя ведут. Это позволит вам лучше понять, как они работают. У вас будет много вопросов типа «А что, если …?» и «Могу я …?» на что я говорю: «Попробуйте и посмотрите, что произойдет.«Худшее, что вы действительно можете получить, — это сообщение об ошибке. В этом случае вы читаете сообщение об ошибке, чтобы понять, почему оно не сработало, а затем попробуйте еще раз. Не сдерживайтесь!
• Внимательно прочтите и не пропускайте мелкие детали. Я не могу этого не подчеркнуть. Мелкие детали важны и часто являются разницей между работой вашей команды и неработающей. Если что-то не работает, внимательно перечитайте материал и еще раз просмотрите то, что вы ввели, чтобы убедиться, что вы не допустили маленькой глупой опечатки.

Итак, общий подход:

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

Узнайте больше о навыках решения проблем.

Получение Linux

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

• Если у вас Mac, то вам повезло, у вас уже есть терминал.
• Другой вариант — запустить Linux. Linux полностью бесплатен, и есть много хороших дистрибутивов. Я бы порекомендовал включить Ubuntu (довольно популярный и простой в использовании) и OpenSuSe (мой личный фаворит). Если вы воспользуетесь этим подходом, вы можете пойти несколькими путями.
  • Если у вас есть запасная машина, вы можете просто установить ее на нее.
  • Вы можете создать систему с двойной загрузкой (т.е. на компьютере установлены и Windows, и Linux, вы выбираете, какую из них запускать при загрузке). Большинство современных дистрибутивов Linux будут создавать это за вас при установке (также изменяя размер существующих разделов Windows). Сделайте резервную копию любых важных файлов, прежде чем использовать этот метод (я никогда не видел, чтобы он терпел неудачу, но лучше на всякий случай).
  • Вы можете запустить Linux на виртуальной машине.VirtualBox — отличный инструмент для этого, к тому же он совершенно бесплатный.
• У вас также может быть удаленный доступ к машине на работе или в универе. Если вы это сделаете, то удаленный вход в них для доступа к терминалу также является вариантом.

Об авторе

Привет. Меня зовут Райан Чедвик, и я преподаю Linux студентам уже более 10 лет. Это то, что мне очень нравится. В мире, где мы все больше скрываем сложности от пользователей (в частности, смартфонов и планшетов), всегда приятно вернуть эту силу людям и позволить им делать гораздо больше с помощью своих технологий.

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

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

Напишите нам по номеру

Извините, вам нужен Javascript, чтобы написать мне письмо.

Используя этот материал

Кто угодно может ссылаться на содержимое этого веб-сайта.

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

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

Заявление об ограничении ответственности

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

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

.

Полное руководство по командной строке Linux

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

Что такое Bash?

Bash (сокращение от Bourne Again SHell) — это оболочка Unix и интерпретатор командного языка. Оболочка — это просто макропроцессор, выполняющий команды. Это наиболее широко используемая оболочка, используемая по умолчанию для большинства дистрибутивов Linux, и преемница оболочки Korn (ksh) и оболочки C (csh).

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

• Редактирование файлов
• Регулировка объема операционной системы
• Получение веб-страниц из Интернета
• Автоматизация повседневной работы

Подробнее о bash можно прочитать здесь, в документации GNU, и через руководство по tldp.

Использование bash в командной строке (Linux, OS X)

Вы можете начать использовать bash в большинстве операционных систем Linux и OS X, открыв терминал.Давайте рассмотрим простой пример Hello World. Откройте свой терминал и напишите следующую строку (все после знака $):

  zach @ marigold: ~ $ echo "Hello world!"
Привет мир!  

Как видите, мы использовали команду echo для вывода строки «Hello world!» к терминалу.

Написание сценария bash

Вы также можете поместить все свои команды bash в файл .sh и запускать их из командной строки. Допустим, у вас есть сценарий bash со следующим содержимым:

  #! / Bin / bash
echo "Привет, мир!"  

Стоит отметить, что первая строка скрипта начинается с #! .Это специальная директива, к которой Unix относится иначе.

Почему мы использовали #! / Bin / bash в начале файла сценария?

Это потому, что это соглашение, позволяющее интерактивной оболочке знать, какой интерпретатор запускать для следующей программы. Первая строка сообщает Unix, что файл должен быть выполнен / bin / bash. Это стандартное расположение оболочки Bourne практически в каждой системе Unix. Добавление #! / Bin / bash в качестве первой строки вашего сценария указывает операционной системе вызвать указанную оболочку для выполнения команд, которые следуют в сценарии. #! часто называют «hash-ba

.

Что такое сценарий Bash?

Что такое сценарий Bash?

Погрузимся в

Введение

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

Так какие именно?

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

Сценарий Bash — это простой текстовый файл, содержащий серию команд. Эти команды представляют собой смесь команд, которые мы обычно вводим сами в командной строке (например, ls или cp ), и команд, которые мы могли бы вводить в командной строке, но обычно не будем (вы обнаружите их через следующие несколько страниц).Однако важно помнить:

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

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

По соглашению файлы, являющиеся сценариями Bash, имеют расширение .sh (например, myscript.sh). Как вы знаете (а если нет, то, возможно, вам стоит рассмотреть возможность ознакомления с нашим Руководством по Linux), Linux — это система без расширений, поэтому сценарий не обязательно должен иметь эту характеристику для работы.

Как они работают?

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

В области Linux (и компьютеров в целом) у нас есть концепция программ и процессов. Программа — это блок двоичных данных, состоящий из серии инструкций для ЦП и, возможно, других ресурсов (изображений, звуковых файлов и т. Д.), Организованных в пакет и обычно хранящихся на вашем жестком диске.Когда мы говорим, что запускаем программу, мы на самом деле запускаем не программу, а ее копию, которая называется процессом. Что мы делаем, так это копируем эти инструкции и ресурсы с жесткого диска в рабочую память (или RAM). Мы также выделяем немного места в ОЗУ для процесса для хранения переменных (для хранения временных рабочих данных) и несколько флагов, позволяющих операционной системе (ОС) управлять процессом и отслеживать его во время его выполнения.

По сути, процесс — это запущенный экземпляр программы.

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

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

Как мы их запускаем?

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

1. ./myscript.sh
2. bash: ./myscript.sh: В доступе отказано
3. ls -l myscript.sh
4. -rw-r — r— 18 пользователей ryan 4096 17 февраля, 09:12 myscript.ш
5. chmod 755 myscript.sh
6. ls -l myscript.sh
7. -rwxr-xr-x 18 пользователей ryan 4096 17 февраля 09:12 myscript.sh
8. ./myscript.sh
9. Привет, мир!

Сокращение 755 часто используется для сценариев, поскольку оно позволяет владельцу писать или изменять сценарий, а всем — выполнять сценарий.

Вот содержимое myscript.sh

myscript.ш

1. #! / Bin / bash
4. echo Привет, мир!

Давайте разберемся:

• Строка 1 — это то, что называется shebang . См. Ниже, что это такое.
• Строка 2 — Это комментарий. Все, что находится после # , не выполняется. Это только для справки.
• Строка 4 — Это команда echo, которая выводит сообщение на экран.Вы можете ввести эту команду самостоятельно в командной строке, и она будет вести себя точно так же.
• Подсветка синтаксиса предназначена только для облегчения чтения, и это не то, что вам нужно делать в ваших собственных файлах (помните, что это просто текстовые файлы).

Почему ./

Возможно, вы заметили, что когда мы запускаем обычную команду (например, ls ), мы просто вводим ее имя, но при запуске сценария выше я ставлю перед ним ./.Когда вы просто набираете имя в командной строке, Bash пытается найти его в серии каталогов, хранящихся в переменной с именем $ PATH. Мы можем увидеть текущее значение этой переменной, используя команду echo (вы узнаете больше о переменных в следующем разделе).

1. echo $ PATH
2. / дома / Райан / бен: / USR / местные / бен: / USR / бен: / бен

Каталоги разделены знаком «: »

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

Переменная $ PATH — это индивидуальная пользовательская переменная, поэтому каждый пользователь в системе может установить ее по своему усмотрению.

Это сделано по нескольким причинам.

• Это позволяет нам установить несколько разных версий программы. Мы можем контролировать, какой из них будет выполняться, в зависимости от того, где он находится в нашем $ PATH.
• Это позволяет для удобства.Как вы видели выше, мой первый каталог — это каталог bin в моем домашнем каталоге. Это позволяет мне помещать туда свои собственные сценарии и программы, а затем я могу использовать их независимо от того, где я нахожусь в системе, просто набрав их имя. Я мог бы даже создать сценарий с тем же именем, что и программа (чтобы действовать как оболочка), если бы мне хотелось немного другого поведения.
• Это повышает безопасность. Например, злоумышленник может создать сценарий под названием ls , который фактически удаляет все в вашем домашнем каталоге.Вы бы не захотели случайно запустить этот сценарий. Но пока это не в вашем $ PATH, этого не произойдет.

Если программа или сценарий не находится в одном из каталогов в вашем $ PATH, вы можете запустить его, указав Bash, где он должен искать его. Для этого нужно указать абсолютный или относительный путь перед именем программы или скрипта. Вы помните, что точка (.) На самом деле является ссылкой на ваш текущий каталог. Предполагая, что этот сценарий находится в моем домашнем каталоге, я также мог бы запустить его, используя абсолютный путь.

1. /home/ryan/myscript.sh
2. Привет, мир!

Шебанг (#!)

#! / Bin / bash

Это первая строка приведенного выше скрипта. Последовательность символов восклицательного знака решетки (#!) Обозначается как Shebang. За ним следует путь к интерпретатору (или программе), который следует использовать для запуска (или интерпретации) остальных строк в текстовом файле.(Для сценариев Bash это будет путь к Bash, но есть много других типов сценариев, и каждый из них имеет свой собственный интерпретатор.)

Здесь важно форматирование. Shebang должен находиться в самой первой строке файла (строка 2 не подходит, даже если первая строка пуста). Также не должно быть пробелов перед # или между ! и путь к интерпретатору.

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

Можно оставить строку с shebang и по-прежнему запускать сценарий, но это неразумно. Если вы находитесь на терминале и запускаете оболочку Bash и выполняете сценарий без shebang, то Bash будет считать, что это сценарий Bash. Таким образом, это будет работать только при условии, что пользователь, запускающий сценарий, запускает его в оболочке Bash, и есть множество причин, по которым это может быть не так, что опасно.

Вы также можете запустить Bash, передав сценарий в качестве аргумента.

1. bash myscript.sh
2. Привет, мир!

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

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

Форматирование

Как мы видели выше, форматирование для shebang было важным (т.е. без пробелов, должно быть в первой строке).В сценариях Bash есть много областей, где важно форматирование. Обычно он включает в себя пробелы, и наличие или отсутствие пробела может быть разницей между работой команды или нет. Я буду указывать на них, когда мы с ними встречаемся. Также приобретите привычку помнить о наличии или отсутствии пробелов при просмотре кода.

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

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

Отступы в коде — еще одна важная область форматирования. Мы рассмотрим отступы в коде в разделе 5 (Если операторы), когда это станет актуальным. Отступы не требуются, но они упрощают чтение кода и затрудняют совершение простых ошибок.

.