First

3 files changed, 665 insertions, 0 deletions

diff --git a/LINUX/BASH_github/bash-guide-1.md b/LINUX/BASH_github/bash-guide-1.md
new file mode 100644
index 0000000..0128e08
--- /dev/null
+++ b/LINUX/BASH_github/bash-guide-1.md
@@ -0,0 +1,218 @@
+Бесплатная книга-сайт на русском, полный гайд  
+[Advanced Bash-Scripting Guide](http://rus-linux.net/MyLDP/BOOKS/abs-guide/flat/abs-book.html)  
+
+# [Основы BASH. Часть 1](https://habr.com/post/47163/)
+## Введение
+
+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 значение первого параметра скрипта  
+> `parametr1=$1`  
+> \#присваиваем переменной script_name значение имени скрипта  
+> `script_name=$0`  
+> \# команда echo выводит определенную строку, обращение к переменным осуществляется через $имя_переменной.  
+> `echo "Вы запустили скрипт с именем $script_name и параметром $parametr1"`  
+> \# здесь мы видим другие кавычки, разница в том, что в одинарных кавычках не происходит подстановки переменных.  
+> `echo 'Вы запустили скрипт с именем $script_name и параметром $parametr1'`  
+> \#Выход с кодом 0 (удачное завершение работы скрипта)  
+> `exit 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 засовываем первый параметр скрипта  
+> `source=$1`  
+> \#в переменную dest засовываем второй параметр скрипта  
+> `dest=$2`  
+>
+> \# в ковычках указываем имена переменных для сравнения. -eq - логическое сравнение обозначающие "равны"  
+> `if [[ "$source" -eq "$dest" ]]`  
+> \# если они действительно равны, то  
+> `then`  
+> \#выводим сообщение об ошибке, т.к. $source и $dest у нас равны  
+> `echo "Применик $dest и источник $source один и тот же файл!"`  
+> \# выходим с ошибкой (1 - код ошибки)  
+> `exit 1`  
+> \# если же они не равны  
+> `else`  
+> \# то выполняем команду cp: копируем источник в приемник  
+> `cp $source $dest`  
+> `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 Выход"`  
+\#здесь мы читаем в переменную $doing со стандартного ввода  
+> `read 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,(||)` # логическое «ИЛИ»  
+
diff --git a/LINUX/BASH_github/bash-guide-2.md b/LINUX/BASH_github/bash-guide-2.md
new file mode 100644
index 0000000..92c42fa
--- /dev/null
+++ b/LINUX/BASH_github/bash-guide-2.md
@@ -0,0 +1,225 @@
+# [Основы BASH. Часть 2](https://habr.com/post/52871/)
+
+## Циклы. Цикл 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:~$ ./bash2_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:~$ ./bash2_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:~$ ./bash2_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/ пгомещенных в одну строку(для того чтобы её стравить циклу.
\ No newline at end of file
diff --git a/LINUX/BASH_github/Основы Bash.md b/LINUX/BASH_github/Основы Bash.md
new file mode 100644
index 0000000..7100ab1
--- /dev/null
+++ b/LINUX/BASH_github/Основы Bash.md
@@ -0,0 +1,222 @@
+## синтаксис, переменные и команды ##
+
+Кодить будем в терминале Linux — он открывается сочетанием клавиш **Ctrl + Alt + T**. Если вы хотите научиться работать с Bash, но пока не пользуетесь Linux, то пишите код в одном из онлайн-терминалов — например, [Replit](https://repl.it/languages/bash).
+
+### **Переменные**
+
+Переменные в Bash объявляются просто:
+
+`   message="Hello, World!"   `
+
+Теперь переменная message хранит значение — текстовое сообщение «Hello, World!». Давайте выведем его — сделать это можно с помощью команды echo:
+
+`   echo $message # Будет выведено «Hello, World!»   `
+
+Обратите внимание на отсутствие пробелов. В Bash пробелы являются разделителями. Если пробелы есть, то Bash будет считать их отдельными токенами и выдавать ошибки.
+
+Следующий код приведёт к ошибке:
+
+`   message = "Hello, World!" bash: message: command not found   `
+
+Также обратите внимание на символ $ **—** в Bash он называется символом расширения (expansion character). Поставленный перед именем переменной, он указывает на то, что нужно использовать именно значение переменной, а не одноимённую строку.
+
+Следующий код выведет сообщение «message»:
+
+`   message="Hello, World!" echo message   `
+
+Чтобы сохранить в переменной введённое пользователем значение, используйте команду read:
+
+`   read name # Пользователь вводит что-то — например, «Olga» echo $name # Будет выведено «Olga»   `
+
+Если вы хотите добавить сообщение перед пользовательским вводом, добавьте флаг -p и сообщение после команды read:
+
+`   read -p "Enter your name: " name # Будет выведено «Enter your name: » # Пользователь вводит что-то — например, «Olga» echo $name # Будет выведено «Olga»   `
+
+В Bash есть несколько правил именования переменных:
+
+- Имя переменной должно начинаться с буквы латинского алфавита (нижнего или верхнего регистра) или символа подчёркивания _.
+- Оно может включать буквы, цифры и символ подчёркивания, но не может содержать пробелы или специальные символы.
+- Регистр букв в именах переменных имеет значение. Например, переменные var1 и Var1 будут рассматриваться как разные.
+- Не рекомендуется использовать зарезервированные слова Bash в качестве имён переменных.
+
+### **Типы данных**
+
+Ну что же, вот мы и создали нашу первую переменную. Поздравляем! Пока эта переменная содержит всего один тип данных — строковый (string). Но в Bash он далеко не единственный — давайте разберём ещё несколько.
+
+**ВАЖНАЯ ОГОВОРКА**
+
+В Bash нет строгой системы типов, как в некоторых других языках. Тип данных зависит от содержимого переменной и контекста её использования. Поэтому термин «типы данных» в этой статье используется условно, для облегчения понимания. Простите нам это упрощение.
+
+**Строки (strings)** — это набор символов, заключённый в кавычки. В Bash можно писать строки в одинарных '…' или двойных "…" кавычках. Например, 'Привет' и "Мир" — это строки.
+
+**Числа (numbers)** — это целочисленные значения. Bash поддерживает арифметические операции с целыми числами, включая сложение, вычитание, умножение и деление. Арифметические выражения нужно предварять знаком $ и обрамлять двойными круглыми скобками:
+
+`   a=2 b=3 echo $(($a + $b)) # Будет выведено 5   `
+
+Также можно использовать команду expr:
+
+`   echo $(expr $a + $b)  # Будет выведено 5   `
+
+Стандартные библиотеки Bash поддерживают следующие арифметические операции:
+
+- Сложение — +.
+- Вычитание — -.
+- Умножение — *.
+- Целочисленное деление — /.
+- Остаток от деления — %.
+- Возведение в степень — **.
+
+**Примечание**: арифметические операторы в Bash не работают с числами с плавающей точкой.
+
+**Массивы (arrays)** — тип переменных, который может хранить несколько значений. Элементы массива перечисляются в круглых скобках через пробел:
+
+`   my_array=(apple banana cherry)   `
+
+При использовании переменной массива в команде применяются фигурные скобки. Если мы хотим вывести его отдельные элементы, это можно сделать с помощью символа $ и номера индекса в квадратных скобках:
+
+`   echo ${my_array[0]} # Выведет «apple» echo ${my_array[1]} # Выведет «banana» echo ${my_array[2]} # Выведет «cherry»   `
+
+А если нам нужно получить сразу все элементы массива, вместо индекса в квадратных скобках нужно поставить символ * или @:
+
+`   echo ${my_array[*]} # Выведет «apple banana cherry» echo ${my_array[@]} # Выведет «apple banana cherry»   `
+
+**Логические значения (boolean)** — нужны для того, чтобы проверить, выполняется ли какое-то условие или нет. Они могут быть либо true (истина), либо false (ложь). Например, в операторах if и while мы пишем условие, и если оно true, то выполняем какое-то действие.
+
+В Bash логические значения представлены целыми числами. Число 0 означает true, а любое другое число означает false. Когда мы выводим логическое значение на экран, то вместо true мы видим 0.
+
+Также в Bash есть операторы сравнения. Например, эти нужны для строк:
+
+- = проверяет, одинаковы ли две строки.
+- != проверяет, различаются ли две строки.
+
+А эти — для чисел:
+
+- -eq проверяет, равны ли два числа.
+- -ne проверяет, различаются ли два числа.
+- -gt проверяет, больше ли первое число, чем второе.
+- -lt проверяет, меньше ли первое число, чем второе.
+- -ge выводит true, если первое число больше или равно второму.
+- -le выводит true, если первое число меньше или равно второму.
+
+Использовать операторы сравнения можно с помощью команды test. Команда test принимает два значения и оператор сравнения и возвращает 1 или 0 в зависимости от результата:
+
+`   test "hello" = "hello"  echo $?  # Выведет 0 (true), так как строки одинаковые test "hello" != "world"  echo $?  # Выведет 0 (true), так как строки различаются   `
+
+Помимо команды test, операторы сравнения можно использовать квадратных скобках [ ]. Но для этого нам понадобится разобраться, как работать с ветвлениями.
+
+### **Ветвления**
+
+Ветвления if-then-else позволяют проверить условие и выполнить один набор команд, если условие истинно, и другой набор команд, если условие ложно. Это выглядит так:
+
+`   if [ условие ];  then     # Команды, которые нужно выполнить, если условие истинно else     # Команды, которые нужно выполнить, если условие ложно fi   `
+
+**Обратите внимание**: открывающую и закрывающую квадратные скобки нужно отделять от операндов пробелами.
+
+А если в паре с основным условием нужно проверить дополнительное, используют конструкцию elif:
+
+`   if [ условие_1 ];  then     # Команды, которые нужно выполнить, если условие_1 истинно elif [ условие_2 ]; then     # Команды, которые нужно выполнить, если условие_2 истинно else     # Команды, которые нужно выполнить, если все условия ложны fi   `
+
+Существует и более короткая форма записи условной конструкции — if-then. Её используют, когда нужно проверить только одно условие:
+
+`   if [ условие ];  then  # Команды, которые нужно выполнить fi   `
+
+В этом случае команды будут выполнены, только если условие истинно.
+
+Для наглядности давайте напишем скрипт, который проверяет правильность введённого пароля:
+
+`   #!/bin/bash # Задаём значение переменной password password="14pomTEr"  # Запрашиваем ввод пароля у пользователя и сохраняем полученное значение в переменную user_input read -p "Enter the password: " user_input  # Сравниваем значение переменной password с введённым пользователем значением user_input if [ "$password" = "$user_input" ]; then   # Если пароли совпадают, выводим сообщение о том, что пароль введён правильно   echo "Password accepted" else   # Если пароли не совпадают, выводим сообщение о том, что пароль введён неправильно   echo "Wrong password" fi   `
+
+Кроме того, в Bash есть логические операторы & & (логическое И) и **||** (логическое ИЛИ), которые позволяют комбинировать несколько условий и возвращать соответствующее булево значение.
+
+Например, вот как будет выглядеть наша программа, если мы добавим проверку логина:
+
+`   #!/bin/bash username="OlgaBelova94"  # Устанавливаем переменную с именем пользователя password="14pomTEr"  read -p "Enter your username: " user_input_username  # Запрашиваем имя пользователя read -p "Enter the password: " user_input_username  # Запрашиваем пароль  echo "Enter the password: " read user_input_password  # Запрашиваем пароль  if [ "$username" == "$user_input_username" ] && [ "$password" == "$user_input_password" ]; then   echo "Password accepted" else   echo "Wrong username or password"  # Уточняем, что именно было неверно fi   `
+
+Здесь мы получим значение true и сообщение «Password accepted», только если будут выполнены оба условия.
+
+### **Циклы**
+
+Как и в большинстве языков программирования, в Bash есть циклы. Они бывают двух видов:
+
+- for — когда количество итераций заранее известно.
+- while — когда количество итераций заранее не известно.
+
+Вот как выглядит сигнатура цикла for:
+
+`   for переменная цикла in элемент1 элемент2 ... элементN do # Команды, которые будут выполняться в цикле done   `
+
+Количество итераций (часть между in и do) можно указать простым перечислением элементов:
+
+`   for fruit in apple banana cherry do     echo "I like $fruit" done  # Будет выведено: # I like apple # I like banana # I like cherry   `
+
+Можно перебрать элементы массива:
+
+`   my_array=("apple" "banana" "orange")  for fruit in "${my_array[@]}" do     echo "I like $fruit" done  # Будет выведено: # I like apple # I like banana # I like cherry   `
+
+Для явного указания нужного количества итераций используют арифметические выражения:
+
+`   for ((i=0; i<5; i++)) do   echo "Iteration number $i" done # Будет выведено: # Iteration number 0 # Iteration number 1 # Iteration number 2 # Iteration number 3 # Iteration number 4   `
+
+А вот так выглядит сигнатура цикла while:
+
+`   while [ условие ] do   # Команды, которые будут выполняться в цикле done   `
+
+**Условие** **(condition)** — это выражение, результат которого является логическим значением true или false. Команды внутри цикла будут выполняться до тех пор, пока condition возвращает true.
+
+Давайте усовершенствуем нашу программу проверки пароля так, чтобы она запрашивала его до тех пор, пока пользователь не введёт верный:
+
+`   #!/bin/bash password="14pomTEr" user_input=""  while [ "$user_input" != "$password" ] do   read -p "Enter the password: " user_input   echo "Wrong password, login denied" done  echo "Password accepted, login allowed"   `
+
+**Что здесь происходит.** В этом примере цикл while запрашивает пароль у пользователя, а потом проверяет его на совпадение с правильным с помощью оператора ["$user_input" != "$password"]. А дальше происходит следующее:
+
+- Если пароль неверный, программа выводит соответствующее сообщение, а цикл продолжается.
+- Если пароль верный, программа выводит сообщение о принятии пароля и завершает выполнение.
+
+### **Функции**
+
+Функции на языке Bash имеют такой вид:
+
+`   имя_функции (аргументы) {     # Тело функции }   `
+
+Например, вот как выглядит простая функция без аргументов:
+
+`   say_hello () {       # Создаём функцию      echo hello }  say_hello        # Вызываем функцию, будет выведено «hello»   `
+
+А вот как выглядит функция, которая принимает аргументы:
+
+`   repeat_text () {     local text=$1     local reps=$2      for (( i=0; i<$reps; i++ )); do         echo "$text"     done } repeat_text "hello" 3   `
+
+**Что здесь происходит:**
+
+- С помощью ключевого слова local мы создали две локальные переменные — то есть переменные, существующие только внутри функции.
+- В одну из них поместили текст, а во вторую — количество повторов.
+- Затем создали цикл, который берёт текст из первой переменной и повторяет его столько раз, сколько раз указано во второй.
+- Вызвали функцию, передав ей значения hello и 3 — то есть приказали повторить слово «hello» три раза.
+
+## **Ну здравствуй, Bash! Пишем первый скрипт**
+
+Настало время применить знания на практике — напишем скрипт для автоматической очистки кэша браузера и DNS.
+
+Состоять наш скрипт будет из трёх функций: первая — для очистки кэша браузера, вторая — для очистки кэша DNS, а в третью завернём небольшое меню для выбора нужного действия.
+
+Начинаем, как водится, с шебанга — специальной строки, которая говорит компьютеру, с помощью какой программы нужно запускать скрипт. Так как мы хотим использовать bash, которая лежит в папке /bin, шебанг будет выглядеть так:
+
+`   #!/bin/bash   `
+
+Теперь напишем функцию, которая будет очищать браузерный кэш. В комментариях — разбор синтаксиса.
+
+`   clear_browser_cache() {  # Проверяем, какой браузер установлен на компьютере     if command -v google-chrome >/dev/null 2>&1; then  # Если установлен Google Chrome, очищаем кэш браузера         google-chrome --user-data-dir=$(mktemp -d) --disable-extensions --disable-plugins --disable-geolocation --no-default-browser-check --no-first-run --noerrdialogs --disable-session-crashed-bubble --disable-infobars --disk-cache-size=0 --media-cache-size=0  # Далее проверяем, установлен ли Firefox     elif command -v firefox >/dev/null 2>&1; then  # Если установлен Firefox, очищаем кэш браузера         firefox --new-instance --safe-mode  # Если браузер не установлен, выводим сообщение об ошибке     else         echo "Error: no supported browser found"     fi }   `
+
+Далее напишем функцию для очистки кэша DNS.
+
+`   clear_dns_cache() { # Проверяем, какая операционная система установлена на компьютере # Если установлена Linux, очищаем кэш DNS     if [[ "$OSTYPE" == "linux-gnu"* ]]; then         sudo systemd-resolve --flush-caches # Если установлена macOS, очищаем кэш DNS     elif [[ "$OSTYPE" == "darwin"* ]]; then         sudo dscacheutil -flushcache         sudo killall -HUP mDNSResponder # Если операционная система не поддерживается, выводим сообщение об ошибке     else         echo "Error: unsupported operating system"     fi }   `
+
+Ну а теперь дело за малым. Напишем небольшое меню, чтобы пользователь мог выбрать, кэш браузера или кэш DNS нужно очистить.
+
+`   # Сначала выведем варианты clear_cache() {     echo "Select cache to clear:"     echo "1. Browser cache"     echo "2. DNS cache" # Запросим у пользователя номер выбранного пункта меню     read -p "Enter your choice: " choice # В зависимости от выбранного пункта меню вызываем соответствующую функцию для очистки кэша     if [ "$choice" -eq 1 ]; then     clear_browser_cache elif [ "$choice" -eq 2 ]; then     clear_dns_cache else     echo "Invalid choice" fi }   `
+
+Вуаля! Наш скрипт готов. Чтобы его запустить, нам нужно лишь вызвать функцию clear_cache:
+
+`   clear_cache   `
+
+В теории можно сделать скрипт и ещё лучше — например, добавить больше браузеров, реализовать проверку прав администратора и другие фишки. Но на сегодня, пожалуй, достаточно.
\ No newline at end of file