3-часовое руководство по Bash

В этой статье вы научитесь печатать простое «Hello World», как использовать условные операторы, такие как операторы if, операторы case, использовать циклы, такие как while, for until, циклы awk, grep, sed и отладку сценарии bash. В этой статье мы рассмотрим следующие темы:

В этой статье рассматриваются следующие темы сценариев bash:

Hello Bash Scripting
Перенаправить в файл
Комментарии
Условные операторы
Циклы
Ввод скрипта
Вывод сценария
Отправка вывода из одного сценария в другой
Обработка строк
Числа и арифметика
Объявить команду
Массивы
Функции
Файлы и каталоги
Отправка электронной почты с помощью сценария
Curl
Профессиональные меню
Ожидание файловой системы с помощью inotify
Введение в grep
Введение в awk
Введение в sed
Отладка сценариев Bash

Содержание

1. Сценарии Hello Bash
2. Перенаправление в файл
3. Комментарии
4. Условные операторы
5. Циклы
6. Ввод скрипта
7 . Вывод сценария
8. Отправлять вывод из одного сценария в другой сценарий
9. Обработка строк
10. Числа и арифметика
11. Команда Declare
12 . Массивы
13. Функции
14. Файлы и каталоги
15. Отправка электронной почты с помощью скрипта
16. Curl в скриптах
17. Профессиональные меню
18. Дождитесь появления файловой системы с помощью inotify
19. Введение в grep
20. Введение в awk
21. Введение в sed
22. Отладка сценариев Bash

1. Сценарии Hello Bash

В этом разделе вы узнаете об основах создания сценариев Bash и о том, как создать файл для написания сценария для печати «Hello» с помощью сценариев bash. После этого вы знаете, как сделать файл исполняемым.

Нажмите «CTRL + ALT + T», чтобы открыть терминал, или вы можете выполнить поиск в терминале вручную. Введите следующую команду в терминале

$ cat/etc/shells

Выполнение указанной выше команды ‘cat’ дает следующее вывод.

Эта команда показывает все оболочки, доступные на вашем system, и вы можете использовать любой из них. Для этой задачи вы должны проверить, есть ли в вашей системе оболочка bash или нет. Чтобы узнать путь к bash, вы должны написать в терминале команду «which bash», которая задает путь к оболочке. Этот путь должен быть записан в каждом сценарии bash для его выполнения.

Теперь откройте терминал с рабочего стола. Вы можете сделать это вручную, перейдя на рабочий стол, а затем выбрав опцию «открыть в терминале» или используя команду «cd Desktop/» в текущем терминале. Создайте сценарий с помощью команды ‘touch helloScript.sh’

Откройте файл ‘ helloScript.sh ‘и следующие команды в файле:

#! /bin/bash
echo «hello bash script»

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

Из вывода ясно, что файл еще не является исполняемым.. «Rw-rw-r–» показывает, что владелец файла имеет права на чтение и запись, относящиеся к файлу, другие группы также имеют такие же разрешения, а публика имеет единственное разрешение на чтение файла. Чтобы сделать этот скрипт исполняемым, вы должны запустить в своем терминале следующую команду:

$ chmod + x helloScript.sh

Затем используйте ‘ ls -al ‘, чтобы проверить права доступа к файлу’ helloScript.sh ‘, в результате вы получите следующий результат.

Теперь запустите файл с помощью команды ‘./helloScript.sh’ в терминале. Чтобы изменить содержимое файла, вы можете вернуться к файлу. Отредактируйте содержимое, указанное в команде «echo», а затем снова запустите файл. Надеюсь, он покажет желаемый результат.

2. Перенаправление в файл

В этом разделе вы узнаете, как захватить вывод оболочки или вывод файла и отправить его в другой файл. Для этого вам нужно добавить следующую команду в свой ‘helloScript.sh’

echo «hello bash linuxhint audit»> file.txt

Сохраните файл, вернитесь в терминал и запустите свой скрипт с помощью команды ‘./helloScript.sh’. Он покажет вам следующий результат. Нажмите ‘ls -al’, чтобы подтвердить существование нового файла.

Вы также можете взять файл из оболочки и сохранить его в файл. Для этого вам нужно написать сценарий «cat> file.txt». Сохраните его и запустите скрипт. Теперь все, что вы напишете в этой оболочке, будет сохранено в файле ‘file.txt’

А затем выйдите из этого процесса, нажав ‘CTRL + D’. Сценарий «cat> file.txt» заменит текст тем, что вы напишете в терминале. Чтобы создать сценарий, который может добавлять содержимое файла «file.txt», вы должны написать в своем сценарии «cat >> file.txt». Сохраните файл, запустите скрипт с помощью команды «./helloscript.sh» в терминале. Теперь все, что вы напишете в терминале, будет добавлено в файл вместе с текстом, который в нем уже есть.

3. Комментарии

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

Однострочные комментарии
Многострочные комментарии
HereDoc Delimeter

Для однострочного комментария вы можете использовать знак ‘#’ перед оператором комментария. Вы можете написать следующий код в своем «helloScript.sh».

#! /bin/bash

# это команда cat
cat >> file. txt

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

#! /bin/bash
: ‘
Это сегмент многострочных комментариев
С помощью этого скрипта вы узнаете
Как делать многострочные комментарии
‘
cat >> file.txt

Итак, эти строки не имеют значения. Они просто существуют в вашем скрипте для лучшего понимания кода.

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

#! /bin/bash

cat это hereDocDelimeter
Это переменная
Вы можете называть ее как хотите
hereDocDelimeter

Запустите сценарий, и вы увидите следующий результат.

4. Условные операторы

В этом разделе вы узнаете об операторах if, операторах if-else, операторах if-else if, условных операторах с использованием операторов AND и OR.

Оператор If
Чтобы записать условие в сегменте if, вы должны добавить дополнительное значение в пределах ‘[]’ до и после условия. После этого укажите код вашего условия, перейдите к следующей строке, напишите «then» и укажите строки кода, которые вы хотите выполнить, если условие истинно. В конце концов, используйте «fi», чтобы закрыть оператор if. Ниже приведен пример кода сценария, который понимает синтаксис оператора if.

#! /bin/bash

count = 10
if [$ count -eq 10]
тогда
echo «условие истинно»
fi

Сначала этот скрипт присваивает значение ’10’ переменной ‘count’. Переходя к блоку «if», «[$ count -eq 10]» — это условие, которое проверяет, равно ли значение переменной count «равному» 10 или нет. Если это условие становится истинным, то процедура выполнения будет перемещена к следующим операторам. «Then» указывает, что если условие истинно, то выполнить блок кода, написанный после меня. В конце ‘fi’ находится ключевое слово, которое показывает окончание этого блока if-оператора. В этом случае условие истинно, так как «$ count» представляет значение переменной count, равное 10.. Условие истинно, перейдите к ключевому слову «then» и напечатайте на терминале «условие истинно».

Что делать, если условие ложно? Программа не знает, что делать, потому что у вас нет блока else. В «else clock» вы можете написать операторы, которые будут выполняться, когда условие неверно. Вот код, который вы можете написать в своем файле «helloScript.sh», чтобы увидеть, как блок else работает в вашей программе.

#! /bin/bash

count = 11
if [$ count -eq 10]
то
echo «условие истинно»
else
echo «условие ложно»
fi

В этой программе переменной ‘count’ присваивается значение 11. Программа проверяет «оператор if». Поскольку условие в блоке if не является истинным, оно переместится к блоку else, игнорируя весь раздел then. Терминал покажет утверждение, что условие ложно.

Существует также другой формат записи условия. В этом методе все, что вам нужно сделать, это заменить скобки «[]» на скобки «(())» и записать условие между ними. Вот пример этого формата.

#! /bin/bash

count = 10
if (($ count> 9))
then
echo «условие истинно»
else
echo «условие ложно»
fi

Выполнение вышеуказанного кода, написанного в файле ‘helloScript.sh’, даст вы получите следующий результат.

Если -else if операторы
Когда вы используете if-else if в качестве блока операторов в вашем скрипте, программа дважды проверяет условия. Точно так же, если вы напишете приведенный ниже пример кода в «helloScript.sh», вы увидите, что программа сначала проверяет условие «if». Переменной «count» присваивается значение «10». В первом условии «if» программа проверяет, что «count» имеет значение больше 9, что является истинным. После этого операторы, написанные в блоке «if», будут выполнены и выйдут из него. Например, если у нас есть случай, в котором условие, записанное в ‘elif’, истинно, тогда программа будет выполнять только операторы, записанные в блоке ‘elif’, и будет игнорировать блоки операторов ‘if’ и ‘else’.

#! /bin/bash

count = 10
if (($ count> 9))
then
echo «первое условие истинно»
elif (($ count then
echo «тогда второе условие истинно»
else
echo «условие false «
fi

Оператор И
Чтобы использовать оператор ‘И’ в ваших условиях, вы должны использовать символ ‘&&’ между вашими условиями, чтобы проверить их оба.. Например, если вы напишете следующий код в своем ‘helloScript.sh’, вы увидите, что программа проверит оба условия ‘[«$ age» -gt 18] && [«$ age» -lt 40]’, что если возраст больше 18 И возраст меньше 40, что в вашем случае неверно. Программа проигнорирует операторы, написанные после «then», и перейдет к блоку «else», напечатав на терминале «возраст неверен»

#! /bin/bash

age = 10
if [«$ age» -gt 18] && [«$ age» -lt 40]
тогда
echo «возраст правильный»
else
echo «возраст неверен»
fi

Выполнив вышеуказанное кода, написанного в ‘helloScript.sh’, вы увидите следующий результат.

Вы также можете записать условие в следующем формате:

#! /bin/bash

age = 30
if [[«$ age» -gt 18 && «$ age» -lt 40]]
тогда
echo «возраст правильный»
else
echo «возраст неверный»
fi

Условие правильное в данном случае — возраст «30». У вас будет следующий результат.

Вы также можете использовать ‘-a’ вместо ‘&&’ для использования оператора AND в условиях вашей программы. Он будет работать так же.

#! /bin/bash

age = 30
если [«$ age» -gt 18 -a «$ age» -lt 40]
, то
echo «возраст правильный»
else
echo «возраст неверен»
fi

Сохраните этот код в своем сценарий ‘helloScript.sh’ и выполнить его из терминала

Оператор ИЛИ
Если у вас есть два условия и вы хотите выполнить предыдущие операторы, если какое-либо из них или оба из них истинны, в этих случаях используются операторы ИЛИ. ‘-O’ используется для обозначения оператора ИЛИ. Вы также можете использовать ‘|| ‘Подпишите для него.
Напишите следующий пример кода в’ helloScript.sh ‘и выполните его из терминала, чтобы проверить его работу.

#! /bin/bash

age = 30
если [«$ age» -gt 18 -o «$ age» -lt 40]
, то
echo «возраст правильный»
else
echo «возраст неверный»
fi

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

Некоторые из примеров: нижеприведенный. Сохраните сценарий в «helloScript.sh» и запустите файл через терминал, написав команду

$ ./helloScript. sh

#! /bin/bash

age = 30
если [«$ age» -lt 18 -o «$ age» -lt 40]
, то
echo «возраст правильный»
else
echo «возраст неверный»
fi

#! /bin/bash

age = 30
если [«$ age» -lt 18 -o «$ age» -gt 40]
, то
echo «возраст правильный»
else
echo «возраст неверный»
fi

#! /bin/bash

age = 30
if [[«$ age» -lt 18 || «$ age» -gt 40]]
затем
echo «возраст правильный»
else
echo «возраст неверный»
fi

#! /bin/bash

age = 30
if [«$ age» -lt 18] || [«$ age» -gt 40]
затем
echo «возраст правильный»
else
echo «возраст неверный»
fi

5. Циклы

В этой теме мы обсудим

Циклы пока
Циклы до
Циклы For
Операторы Break и Continue

Циклы While:
Цикл While выполняет блок кода (заключенный в do… done), когда условие истинно, и продолжает выполнять его, пока условие не станет ложным. Как только условие становится ложным, цикл while завершается. Вернитесь к своему сценарию, чтобы написать код, в котором есть цикл. Используйте ключевое слово «while» и после этого напишите условие для проверки. После этого используйте ключевое слово «do», а затем напишите набор операторов, которые вы хотите выполнить, если условие вашей программы истинно. Вы также должны указать здесь статус приращения, чтобы цикл продолжался. Закройте цикл while, написав ключевое слово «готово». Сохраните сценарий как «helloScript.sh».

#! /bin/bash

number = 1
в то время как [$ number -lt 10]
do
echo «$ number»
Number = $ ((number + 1))
done

Запустите скрипт с помощью команды ‘$ ./helloScript.sh’ в терминале, и вы увидите следующий вывод на вашем терминале.

В цикле While , в первую очередь проверяется условие, истинно оно или нет. Если условие ложно, оно выйдет из цикла и завершит программу. Однако, если условие истинно, последовательность выполнения переместится к оператору, написанному после ключевого слова «do». В вашем случае он напечатает число из-за использования оператора «echo». Затем вы должны упомянуть оператор инкремента, который позволяет циклу зацикливаться. После увеличения переменной условия он снова проверит условие и продвинется вперед.. Когда условие становится ложным, оно выйдет из цикла и завершит программу.

#! /bin/bash

number = 1
в то время как [$ number -le 10]
do
echo «$ number»
Number = $ ((number + 1))
готово

Циклы до:
Пока цикл выполняет блок кода (заключенный в do… done), когда условие ложно, и продолжайте выполнение этого пока условие не станет истинным. Как только условие становится истинным, цикл до конца завершается. Синтаксис циклов «Пока» почти такой же, как и у циклов while, за исключением того, что вы должны использовать слово «до» вместо «пока». В приведенном ниже примере переменной с именем «число» присваивается значение «1». В этом примере цикл проверит условие, если оно ложно, он переместится вперед и напечатает значение переменной ‘number’ на терминале. Затем у нас есть инструкция, относящаяся к приращению переменной «число». Он увеличит значение и снова проверит условие. Значение будет печататься снова и снова, пока значение переменной «number» не станет равным 10. когда условие станет ложным, программа будет завершена.

#! /bin/bash

number = 1
до [$ number -ge 10]
do
echo «$ number»
Number = $ ((number + 1))
done

Сохраните приведенный выше код в свой файл helloScript.sh. Запустите его с помощью команды

$ ./helloScript.sh

Вы увидите следующий результат.

Для циклов:
Это тип цикла, в котором мы указываем условие, при котором цикл будет выполняться повторно. Есть два основных способа написания циклов for в вашем коде. В первом способе вы можете записать числа для итерации. В приведенном ниже коде цикл for будет выполняться 5 раз, поскольку эти итерации указаны для переменной «i», которая управляет итерациями. Сохраните код в файле сценария «helloScript.sh».

#! /bin/bash

для i in 1 2 3 4 5
do
echo $ i
готово

Выполните файл helloScript.sh, набрав в терминале следующую команду.

$ ./helloScript.sh

Вы получите следующий результат для сценария.

Этот метод кажется простым, но что, если вы хотите выполнить 1000 раз? Вам не нужно записывать количество итераций от 1 до 1000, вместо этого используйте другой метод записи для цикла. В этом методе вы должны объявить начальную и конечную точки итерации, как в приведенном ниже примере кода «for i in {0..10}», цикл for будет выполняться 10 раз. «0» определяется как начальная точка, а «10» определяется как конечная точка итерации. Этот цикл for будет печатать значение «i» на каждой итерации..

#! /bin/bash

for i in {0..10}
do
echo $ i
done

Сохраните код в файле helloScript.sh. Запустите файл, и вы увидите следующий результат.

Вы также можете определить значение приращения для переменной, которая управляет циклом. Например, в ‘for i in {0..10..2}’ 0 — это начальная точка цикла, 10 — конечная точка, и цикл выполнит оператор ‘echo $ i’ с приращением 2 в ‘я’. Таким образом, в примере, приведенном ниже, программа распечатает 0 при первом запуске цикла, а затем увеличит значение «i». Теперь значение «i» равно 2. На терминале будет напечатано 2. Этот код напечатает значение «i» как 0,2,4,6,8,10.

#! /bin/bash

для i в {0..10..2}
# {start..ending..increment}
do
echo $ i
готово

Есть еще один метод написания цикла for, который является обычным для всех языков программирования. В приведенном ниже примере кода этот метод используется для представления цикла for. Здесь, в операторе «for ((i = 0; i

#! /bin/bash
for ((i = 0; i
do
echo $ i
готово

Программа перейдет к циклу for. ‘I’ инициализируется 0, и он проверит условие, что ‘i’ имеет значение меньше 5, что в данном случае истинно. Он будет двигаться дальше и печатать значение «i» как «0» на терминале. После этого значение «i» увеличивается, а затем программа снова проверяет условие, меньше ли его значение 5, что является истинным, поэтому она снова распечатает значение «i», которое равно «1». Этот поток выполнения продолжается до тех пор, пока ‘i’ не достигнет значения ’5’, и программа выйдет из цикла for, и программа будет завершена.

Сохраните код. Запустите файл из терминала, и он покажет следующий результат.

Оператор break и continue

Оператор break используется для завершения цикла при заданном условии. Например, в приведенном ниже коде цикл for будет выполнять свое обычное выполнение, пока значение i не станет равным 6. Поскольку мы указали это в коде, цикл for прервет сам себя и остановит дальнейшие итерации, когда i станет равным 6. больше 5.

#! /bin/bash

for ((i = 0; i do
if [$ i -gt 5]
затем
break
fi
echo $ i
done

Сохраните скрипт и выполните файл . Это даст вам следующий результат.

Оператор Continue работает в отличие от оператора break. Он пропускает итерацию, если условие истинно, и переходит к следующей итерации. Например, приведенный ниже код цикла for напечатает значение переменной ‘i’ на терминале от 0 до 20, за исключением 3 и 7. В качестве инструкции ‘if [$ i -eq 3] || [$ i -eq 7] ‘указывает программе пропускать итерацию всякий раз, когда значение’ ‘i равно 3 или 7, и переходить к следующей итерации, не выводя их.

Выполните следующий код для лучшего понимание этой концепции.

#! /bin/bash

for ((i = 0; i do
if [$ i -eq 3] || [$ I -eq 7]
затем
продолжить
fi
echo $ i
готово

6. Ввод скрипта

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

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

Этот код распечатает три значения на терминале. Сохраните приведенный выше код в скрипте helloScript.sh и запишите команду в ./helloScript.sh с тремя значениями, которые будут напечатаны на терминале. В этом примере «BMW» представляет «$ 1», «MERCEDES» представляет » $ 2 ‘, а’ TOYOTA ‘представляет’ 3 доллара ‘.

Если вы также укажете ‘$ 0’ в операторе echo, он также напечатает имя сценария.

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

Для этой цели также можно использовать массивы. Для объявления массива бесконечных чисел используйте код «args = (« [email protected] »)», в котором «args» — это имя массива, а «@» означает, что он может иметь бесконечное количество значений. Этот тип объявления массива можно использовать, когда вы не знаете размер входных данных. Этот массив назначит блок для каждого входа и будет продолжать делать это, пока не достигнет последнего.

#! /bin/bash

args = («[email protected]») # здесь вы также можете указать размер массива
echo $ {args [0]} $ {args [ 1]} $ {args [2]}

Сохраните сценарий в файле helloScript.sh. Откройте терминал и выполните файл с помощью команды ‘./helloScript.sh’ со значениями, которые представляют элементы объявленного массива в сценарии. Согласно приведенной ниже команде BMW »представляет $ {args [0]},« MERCEDES »представляет $ {args [1]}, а« HONDA »представляет $ {args [2]}.

Приведенный ниже код можно использовать для объявления массива имея бесконечное количество значений и выводя эти значения на терминал. Разница между этим и предыдущим примером заключается в том, что в этом примере будут распечатаны все значения, которые представляют элементы массива и команду, использованную в предыдущем примере ‘echo $ {args [0]} $ {args [1]} $ {args [2]} будет печатать только первые три значения массива.

#! /bin/bash

args = («[электронная почта защищена]»)
echo $ @

Вы также можете распечатать размер массива, написав ‘echo $ #’ в скрипте. Сохраните сценарий. Запустите файл с помощью терминала.

#! /bin/bash

args = («[email protected]»)
echo $ @ # печатает все элементы массива
echo $ # # печатает массив размер

Чтение файл с помощью stdin

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

#! /bin/bash

при чтении строки
do
echo «$ line»
done

Сохраните сценарий в файле helloScript.sh. Откройте терминал и напишите команду для выполнения «helloScript» с именем файла, который вы хотите прочитать. В этом случае файл, который мы хотим прочитать, помещается на рабочий стол с именем «Документ без названия 1». Оба символа » используются для обозначения того, что это одно имя файла. В противном случае просто написание «Документ без названия 1» будет восприниматься как несколько файлов.

$ ./helloScript. sh Без названия Document 1

7 . Вывод сценария

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

Вы можете перенаправить стандартный вывод и стандартную ошибку на один или несколько файлов. Приведенный ниже код сценария перенаправит оба файла в один файл. Здесь «ls -al 1> file1.txt 2> file2.txt», 1 представляет стандартный вывод, а 2 представляет стандартную ошибку. Стандартный вывод будет перенаправлен на «file1.txt», а стандартная ошибка будет перенаправлена на «file2.txt».

#! /bin/bash

ls -al 1> file1.txt 2> file2.txt

Сохраните этот код в ‘helloScript.sh’ и запустите его через терминал с помощью команды ‘$ ./helloScript.sh’. Сначала он создаст два файла на рабочем столе, а затем перенаправит их соответствующий вывод.. После этого вы можете использовать команду ‘ls’, чтобы проверить, созданы ли файлы или нет.

После этого проверьте содержимое обоих файлов.

Как видите, стандартный вывод перенаправлен на ‘file1.txt’.

‘file2.txt’ пуст, потому что для сценария не существует стандартной ошибки. Теперь попробуем создать стандартную ошибку. Для этого вам нужно изменить команду с «ls -al» на «ls + al». Сохраните приведенный ниже сценарий, запустите файл из терминала, перезагрузите оба файла и посмотрите результаты.

#! /bin/bash

ls + al 1> file1.txt 2> file2.txt

Выполнить файл с помощью команды ‘./helloScript .sh ‘на терминале и теперь проверьте файлы.

‘file1.txt’ пуст, потому что для сценария не существует стандартного вывода, и стандартная ошибка будет сохранена в ‘file2.txt’, как показано ниже.

Для этой цели также можно создать два отдельных скрипта. В этом случае первый сценарий сохранит стандартный вывод в файле «file1.txt», а второй сценарий сохранит стандартную ошибку. Оба сценария приведены ниже с соответствующими выходными данными.

#! /bin/bash

ls -al> file1.txt

#! /bin/bash

ls + al> file1.txt

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

#! /bin/bash

ls -al> file1.txt 2> & 1

8. Отправлять вывод из одного сценария в другой сценарий

Чтобы отправить вывод из одного сценария в другой сценарий, необходимо иметь две вещи. Во-первых, оба сценария должны существовать в одном месте, и оба файла должны быть исполняемыми. Шаг 1 — создать два скрипта. Сохраните один как helloScript, а другой как secondScript.

Откройте файл helloScript.sh и напишите приведенный ниже код.

#! /bin/bash

MESSAGE = «Hello LinuxHint Audience»
экспорт СООБЩЕНИЯ
./secondScript.sh

Этот скрипт экспортирует значение, хранящееся в переменной «MESSAGE», которая является важной «Hello LinuxHint Audience», в «secondScript.sh».

Сохраните этот файл и перейдите к другому для кодирования. Напишите следующий код в «secondScript.sh», чтобы получить это «СООБЩЕНИЕ» и распечатать его в терминале.

#! /bin/bash

echo «сообщение от helloScript: $ MESSAGE»

Итак, до сих пор у обоих сценариев есть свой код для экспорта, получить и распечатать сообщение на терминале. Сделайте исполняемый файл ‘secondScript’, набрав в терминале следующую команду.

chmod + x ./secondScript.sh

Теперь запустите файл helloScript.sh, чтобы получить желаемый результат.

9. Обработка строк

Первая операция, которую вы изучите в этом разделе, — это сравнение строк. Возьмите два ввода от пользователя в виде строк. Считайте эти значения с терминала и сохраните их в двух разных переменных. Используйте оператор «if» для сравнения значений обеих переменных с помощью оператора «==». Закодируйте оператор так, чтобы отображалось, что «строки совпадают», если они совпадают, и напишите «строки не совпадают» в его операторе «else», а затем закройте оператор «if». Ниже приведен код сценария всей этой процедуры.

#! /bin/bash
echo «введите первую строку»
прочитайте st1
echo «введите вторую строку»
прочитайте st2

if [«$ st1» == «$ st2»]
тогда
строки echo «соответствуют»
else
строки echo «не соответствуют»
fi

Сохраните сценарий в helloScript.sh. Запустите файл из терминала и дайте две строки для сравнения.

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

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

Проверка строки меньше или меньше

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

#! /bin/bash
echo «введите первую строку»
прочитайте st1
echo «введите вторую строку»
прочитайте st2

if [«$ st1» «$ st2»]
then
echo «Вторая строка $ st2 меньше, чем $ st1»
else
echo «строки являются equal «
fi

Сохраните этот ‘helloScript.sh’ и выполните его.

Объединение

Вы также можете объединить две строки. Возьмите две переменные, прочтите строки из терминала и сохраните их в этих переменных. Следующий шаг — создать другую переменную и объединить в ней обе переменные, просто написав в скрипте «c = $ st1 $ st2» и затем распечатав его.

#! /bin/bash
echo «введите первую строку»
прочитайте st1
echo «введите вторую строку»
прочитайте st2

c = $ st1 $ st2
echo $ c

Сохраните этот код в ‘helloScript. sh ‘, запустите файл с помощью терминала и проверьте результаты.

Преобразование ввода в нижний и верхний регистр

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

#! /bin/bash
echo «введите первую строку»
прочитайте st1
echo «введите вторую строку»
прочитайте st2

echo $ {st1 ^} # для нижнего регистра
echo $ {st2 ^^} # для верхнего регистра

Вы также можете преобразовать только первую букву строки, просто написав переменная как ‘$ [st1 ^ l}’.

#! /bin/bash
echo «введите первую строку»
прочитайте st1
echo «введите вторую строку»
прочитайте st2

echo $ {st1 ^ l} # для использования первой буквы с заглавной буквы

10. Числа и арифметика

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

#! /bin/bash
n1 = 4
n2 = 20
echo $ ((n1 + n2))

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

#! /bin/bash
n1 = 20
n2 = 4

echo $ ((n1 + n2))
echo $ ((n1 — n2))
echo $ ((n1 * n2))
echo $ ((n1/n2))
echo $ ((n1% n2))

Второй способ выполнения арифметической операции — использование ‘ expr ‘. Что делает этот «expr», так это то, что он рассматривает эти n1 и n2 как другие переменные, а затем выполняет операцию.

#! /bin/bash
n1 = 20
n2 = 4

echo $ (expr $ n1 + $ n2)

Вы также можете использовать один файл для выполнения нескольких операций с помощью expr. Ниже приведен пример сценария для этого.

#! /bin/bash
n1 = 20
n2 = 4

echo $ (expr $ n1 + $ n2)
echo $ (expr $ n1 — $ n2)
echo $ (expr $ n1 * $ n2)
echo $ (expr $ n1/$ n2)
echo $ (expr $ n1% $ n2 )

Преобразование шестнадцатеричного числа в десятичное

Чтобы преобразовать шестнадцатеричное число в десятичное, напишите сценарий, который принимает шестнадцатеричное число от пользователя и прочтите число. Мы собираемся использовать для этой цели «калькулятор bc». Определите «obase» как 10 и «ibase» как 16. Вы можете использовать приведенный ниже код сценария для лучшего понимания этой процедуры.

#!/bin/bash

echo «Введите номер в шестнадцатеричном формате по вашему выбору»
прочитайте в шестнадцатеричном формате
echo -n » десятичное значение $ Hex: «
echo» obase = 10; ibase = 16; $ Hex «| bc

11. Команда Declare

Идея этой команды заключается в том, что сам bash не имеет строгой системы типов, поэтому вы не можете ограничить переменную в bash. Однако, чтобы разрешить поведение типа, он использует атрибуты, которые могут быть установленной командой, которая является командой ‘declare’. ‘declare’ — это встроенная команда bash, которая позволяет вам обновлять атрибуты, применяемые к переменным в пределах вашей оболочки. Она позволяет вам объявлять и просматривать переменные.

Написание приведенной ниже команды покажет вам список переменных, которые уже существуют в системе.

$ declare -p

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

$ declare myvariable

После этого используйте ‘$ declare -p’команда для проверки вашей переменной в списке.

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

$ declare myvariable = 11
$ declare -p

Теперь попробуем ограничить файл. Используйте ‘-r’, чтобы применить к файлу ограничение только на чтение, а затем запишите имя переменной с ее путем.

#! /bin/bash
объявить -r pwdfile =/etc/passwd
echo $ pwdfile

Теперь попробуем внести некоторые изменения в файл.

#! /bin/bash
объявить -r pwdfile =/etc/passwd
echo $ pwdfile
pwdfile =/etc/abc.txt

Поскольку pwdfile ограничен как файл только для чтения. После выполнения скрипта должно отображаться сообщение об ошибке.

12 . Массивы

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

#! /bin/bash
car = (‘BMW’ ‘TOYOTA’ ‘HONDA’)
echo «$ {car [@]}»

Вы также можете использовать индекс элементов массива для их печати, например, в приведенном ниже примере» BMW «хранится в» 0 «индексе,» TOYOTA «хранится в» 1 «. ‘-й индекс, а’ HONDA ‘хранится во’ 2-м индексе. Для печати ‘BMW’ вы должны написать $ {car [0]}, и наоборот.

#!/ bin/bash
car = (‘BMW’ ‘TOYOTA’ ‘HONDA’)
echo «$ {car [@]}»
# печать значения с использованием индекса
echo «вывод значения с использованием индекса»
echo «$ {car [0]}»
echo «$ {car [1]}»
echo «$ {car [ 2]} «

Вы также можете распечатайте индексы массива. Для этого вы должны написать «$ {! car [@]}», здесь ‘!’ используется для представления индекса, а ‘@’ представляет весь массив.

#!/bin/bash
car = (‘BMW’ ‘TOYOTA’ ‘HONDA’)
echo «$ {car [@]}»
echo «печать индексов»
echo «$ {! car [@]}»

Если вы хотите напечатать общее количество значений в массиве, просто напишите «$ {# car [@]}» здесь # представляет общее количество элементов.

#! /bin/bash
car = (‘BMW’ ‘TOYOTA’ ‘HONDA’ ‘ROVER’)
echo «$ {car [@]}»
echo «печать индексов «
echo» $ {! car [@]} «
echo» выводит количество значений «
echo» $ {# car [@]} «

Предположим, вы объявили массив, а затем хотите удалить любой элемент. Для удаления любого элемента используйте команду «unset» с именем массива и индексом элемента, который вы хотите удалить. Если вы хотите удалить значение, хранящееся во 2-м индексе массива «car», просто напишите в скрипте «unset car [2]». Команда Unset удалит элемент массива с его индексом из массива. Для лучшего понимания ознакомьтесь со следующим кодом:

#! /bin/bash
car = (‘BMW’ ‘TOYOTA’ ‘HONDA’ ‘ROVER’)
снятая машина [2]
echo «$ {car [@]}»
echo «печать индексов»
echo «$ {! car [@]}»
echo «печать количества значений»
echo «$ {# car [@]} «
Сохраните следующий код в ‘helloScript.sh’. Запустите файл, используя ‘./helloScript.sh’.

Теперь вы знаете, что нужно удалить элемент массива, но что, если вы хотите сохранить любое другое значение, например ‘MERCEDES’, в его индексе, равном 2. После использования команды unset в следующей строке напишите ‘car [ 2] = «МЕРСЕДЕС». Это оно.

#! /bin/bash
car = (‘BMW’ ‘TOYOTA’ ‘HONDA’ ‘ROVER’)
снятая машина [2]
car [2] = ‘MERCEDES’
echo «$ {car [@]}»
echo «печать индексов»
echo «$ {! car [@]}»
echo «печать количества values »
echo» $ {# car [@]} «

Сохраните сценарий и запустите файл через терминал.

13. Функции

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

Ниже приведен пример, демонстрирующий синтаксис функции. Самое важное, что нужно помнить, — это то, что вы должны сначала определить или объявить свою функцию где-нибудь в коде, прежде чем вызывать ее. Для определения функции в вашем коде на шаге 1 необходимо использовать команду «function» с именем функции, которое вы хотите присвоить, а затем «()». Шаг 2 — написать код функции внутри «{}». Шаг 3 — вызвать функцию, используя имя функции, в которой вы хотите, чтобы она выполнялась.

#! /bin/bash
function funcName ()
{
echo «это новая функция»
}
funcName

Вы также можете указать параметры функции. Например, вы хотите любое слово в качестве аргумента, которое будет дано во время вызова функции. Для этого вам нужно просто создать функцию, используя синтаксис, описанный выше, и в теле функции напишите «echo $ 1», эта строка будет печатать первый параметр, назначенный во время вызова функции. Выйдите из тела, вызовите функцию, используя имя функции и слова в качестве «параметра», которые вы хотите отобразить на терминале.

#! /bin/bash
function funcPrint ()
{
echo $ 1
}

funcPrint HI

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

Вот пример кода.

#! /bin/bash
function funcPrint ()
{
echo $ 1 $ 2 $ 3 $ 4
}
funcPrint Привет, это Linuxhint

Вы также можете проверить, работает ли функция правильно или нет .

#! /bin/bash
function funcCheck ()
{
returnValue = «используя функцию прямо сейчас»
echo «$ returnValue»
}

funcCheck

Сохраните код в ‘helloScript.sh’ и выполните его через терминал.

Переменная, объявленная внутри функции, является локальной переменной. Например, в приведенном ниже коде» returnValue «- это локальная переменная. Под термином» локальная переменная «мы подразумеваем, что его значение — «I love Linux» в рамках этой функции, и мы не можем получить доступ к этой переменной вне тела функции. Где бы вы ни вызывали эту функцию, переменной «returnValue» будет присвоено значение «I love Linux».

#!/bin/bash
function funcCheck ()
{
returnValue = «Я люблю Linux»

}
ReturnValue = «Я люблю MAC»
echo $ ReturnValue
funcCheck
echo $ ReturnValue

В В этом скрипте у вас есть локальная функция с именем funcCheck (). Эта функция имеет локальную переменную returnValue со значением «I love Linux». Это «returnValue» является локальной переменной. После определения функции вы видите есть еще одно выражение «returnValue =« I love MAC »», но на этот раз это другая переменная, а не та определено в функции. Сохраните сценарий и выполните его, и вы увидите разницу.

14. Файлы и каталоги

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

Первый пример сценария — создать каталог с именем ‘Directory2’. Команда создания каталога «mkdir» используется с флагом «-p», который имеет дело с ошибкой создания таких же каталогов или папки в определенном месте.

Сохраните этот «helloScript.sh». Откройте терминал и запустите файл. Затем используйте «ls -al», чтобы проверить его существование.

#! /bin/bash
mkdir -p Directory2

Вы также можете использовать этот ‘.helloScript.sh’, чтобы проверить, существует ли каталог в текущем месте или нет. Ниже приведен пример сценария для реализации этой идеи. Первое, что вам нужно сделать, это получить имя каталога из терминала. Прочтите строку терминала или имя каталога и сохраните его в любой переменной. После этого используйте оператор «if» плюс флаг «-d», который проверяет, существует ли каталог.

#! /bin/bash

echo «введите имя каталога, чтобы проверить»
прямое чтение

if [-d «$ direct»]
тогда
echo «$ direct существует»
else
echo «$ direct не существует»
fi

Сохраните этот файл helloScript.sh. Запустите его из терминала и введите имя каталога для поиска.

Переходим к созданию файла. команда «touch» используется для создания файла. Вся процедура получения имени и чтения из терминала такая же, как и для создания каталога, но для создания файла вы должны использовать команду ‘touch’ вместо ‘mkdir’.

#! /bin/bash

echo «введите имя файла для создания»
read fileName

touch $ fileName

Сохраните сценарий, выполните его и проверьте его существование через терминал с помощью команды ‘ls -al’.

Вы также можете следовать сценарию для поиска каталога с помощью сценария, за исключением мелочей. Вам нужно просто заменить флаг ‘-d’ на ‘-f’, поскольку флаг ‘-f’ выполняет поиск файла, а ‘-d’ — каталоги.

#! /bin/bash

echo «введите имя файла для проверки»
прочтите имя файла

if [-f «$ fileName»]
затем
echo «$ fileName exists»
else
echo «$ fileName не существует»
fi

Для добавления текста в файл мы должны выполнить тот же процесс. Шаг 1 — получить имя файла с терминала. Шаг 2 — поиск этого файла, если программа находит файл и просит ввести текст, который вы хотите добавить, иначе распечатайте, что файл не существует на терминале. Если программа обнаруживает файл, переходите к следующему шагу. Шаг 3 — прочитать этот текст и записать текст в искомый файл. Как видите, все эти шаги аналогичны процедуре поиска файлов, за исключением строки добавления текста. Для добавления текста в файл вам нужно только написать следующую команду «echo« $ fileText »>> $ fileName» в вашем «helloScript.sh»

#! /bin/bash

echo «введите имя файла, в который вы хотите добавить текст»
прочитать имя файла

if [-f «$ fileName «]
затем
echo» введите текст, который вы хотите добавить «
read fileText
echo» $ fileText «>> $ fileName
else
echo «$ fileName не существует»
fi

Запустите файл, чтобы увидеть результаты.

Теперь откройте файл, чтобы узнать, сработало он или нет.

Запустите файл еще раз и добавьте второй раз, чтобы убедиться.

Для замены содержимого файла текстом, который вы хотите передать во время выполнения, единственное, что вам нужно сделать, это использовать символ ‘>’ вместо ‘>>’ в том же скрипте..

#! /bin/bash

echo «введите имя файла, в который вы хотите добавить текст»
прочитать имя файла

if [-f «$ fileName «]
затем
echo» введите текст, который вы хотите добавить «
read fileText
echo» $ fileText «> $ fileName
else
echo «$ fileName не существует»
fi

Сохраните этот ‘helloScript.sh’ и запустите файл через терминал. Вы увидите, что текст был заменен.

Откройте файл, чтобы увидеть изменения.

Вы также можете прочитать любой файл с помощью скрипта . Следуйте описанному выше методу поиска файла. После этого используйте условие while, чтобы прочитать файл с помощью «read -r line». Поскольку мы собираемся читать файл, мы будем использовать этот символ ‘

#! /bin/bash

echo «введите имя файла, из которого вы хотите читать»
читать имя файла

if [-f «$ fileName «]
затем
пока IFS = read -r line
выполните
echo» $ line «
done else
echo «$ fileName не существует»
fi

Чтобы удалить файл, первое, что нужно сделать — это выяснить, существует файл или нет. После нахождения файла с помощью команды «rm» с переменной имени файла, чтобы удалить его. Для подтверждения его удаления используйте ‘ls -al’ для просмотра файловой системы.

echo «введите имя файла, из которого вы хотите удалить»
читать fileName

if [-f «$ fileName»]
тогда
rm $ fileName
else
echo «$ fileName не существует»
fi

15. Отправка электронной почты с помощью скрипта

Существует несколько способов отправки электронной почты через оболочку, но мы собираемся следовать простейшему из них. Чтобы работать с электронной почтой, первое, что вам нужно сделать, это установить ‘ssmtp’

$ sudo apt install ssmtp

Сначала вы можете создать тестовое электронное письмо для понимания всей процедуры. У нас есть тестовое электронное письмо «[электронная почта защищена]».

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

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

$ gedit/etc/ssmtp/ssmtp.conf

Или

sudo -H gedit/etc/ssmtp/ssmtp.conf

Измените следующие сведения в ssmtp.conf

root=testingm731@gmail.com
mailhub = smtp.gmail.com: 587
AuthUser = testingm731 @ gmail. com
AuthPass = (здесь вы можете указать пароль своей электронной почты)
UseSTARTTLS = yes

Теперь напишите следующие строки кода в вашем ‘ helloScript.sh ‘.

#! /bin/bash
ssmtp testingm731@gmail.com

Откройте терминал, выполните свой «helloScript.sh» и определите структуру своего электронного письма. Укажите следующие данные для отправки тестового письма на ваш аккаунт самостоятельно.

$ ./helloScript.sh

To:testingm731@gmail .com
От: testingm731@gmail.com
Копия: testingm731@gmail.com
Тема: testingm731@gmail.com
bodytestingm731@gmail.com

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

Если вы отправили себе тестовое письмо, оно должно быть присутствует в отправленных товарах тоже имеет смысл? справа.

16. Curl в скриптах

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

sudo apt install curl

После установки curl вернитесь к своему ‘helloScript.sh’ и напишите код для загрузки тестового файла с использованием URL-адреса. Чтобы загрузить файл данных с помощью curl, вы должны знать два шага. Первый — иметь полный адрес ссылки на этот файл. Следующее, что нужно сделать, это сохранить этот адрес в переменной «url» в вашем скрипте, а затем использовать команду curl с этим URL-адресом для его загрузки. Здесь «-O» означает, что он унаследует имя файла от источника.

#! /bin/bash
url=»http://www.ovh.net/files/1Mb.dat»
curl $ {url} -O

Чтобы дать загруженному файлу новое имя, просто используйте флаг ‘-o’ и после этого напишите новое имя файла, как показано в сценарии ниже.

#! /bin/bash
url=»http://www.ovh.net/files/1Mb.dat»
curl $ {url} -o NewFileDownload

Сохраните это в ‘helloScript.sh’, запустите файл, и вы увидите следующий результат.

Что делать, если вы хотите скачать файл размером в несколько сотен гигабайт? Не думаете ли вы, что вам будет легче, если вы будете знать, что загружаете нужный файл или нет. В этом случае вы можете загрузить файл заголовка для подтверждения. Все, что вам нужно сделать, это написать «-I» перед URL-адресом файла. Вы получите заголовок файла, из которого вы можете решить, загружать файл или нет.

#! /bin/bash
url=»http://www.ovh.net/files/1Mb.dat»
curl -I $ {url}

Сохраните и выполните файл с помощью команды ‘./helloScript/sh’, после чего вы увидите следующий вывод на терминале.

17. Профессиональные меню

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

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

#! /bin/bash
выбрать машину в BMW MERCEDES TESLA ROVER TOYOTA
сделать
echo «you selected $ car»
done

Сохраните код в ‘helloScript.sh’ и запустите файл, чтобы лучше понять работу цикла выбора.

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

#! /bin/bash
выбрать автомобиль в BMW MERCEDES TESLA ROVER TOYOTA
сделать
case $ car в
BMW)
echo «BMW SELECTED»; ;
MERCEDES)
echo «MERCEDES SELECTED» ;;
TESLA)
echo «TESLA SELECTED» ;;
ROVER)
Echo «ROVER SELECTED» ;;
TOYOTA)
echo «TOYOTA SELECTED» ;;
*)
echo «ERROR! Пожалуйста, выберите от 1 до 5» ;;
esac
done

Сохраните скрипт helloScript.sh и запустите файл с помощью терминала.

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

#! /bin/bash
echo «нажмите любую клавишу, чтобы продолжить»
while [true]
do
read -t 3 -n 1
если [$? = 0]
затем
echo «вы завершили сценарий»
exit;
else
echo «ждут, пока вы нажмете клавишу Сэр «
fi
готово

18. Дождитесь появления файловой системы с помощью inotify

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

sudo apt install inotify-tools

Вы можете попробовать inotify в воображаемом каталоге, чтобы проверить, как он на это отреагирует. Для этого вам нужно написать следующий код в вашем файле «helloScript.sh».

#! /bin/bash
Inotifywait -m/temp/NewFolder

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

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

#! /bin/bash
mkdir -p temp/NewFolder
inotifywait -m temp/NewFolder

Сохраните этот сценарий ‘helloScript.sh’, выполните файл, и вы увидите следующий вывод на терминале.

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

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

Теперь попробуйте написать что-нибудь в ‘file1.text’, используя другое окно терминала, и проверьте ответ из окна терминала, работающего с inotify.

19. Введение в grep

Grep означает «печать глобального регулярного выражения». Эта команда используется для поиска шаблона в файле путем построчной обработки текста. Прежде всего, мы собираемся создать файл с именем filegrep.txt с помощью сенсорной команды. Введите в терминал следующий код.

$ touch filegrep.txt

Откройте файл grep.txt и напишите следующее содержимое файла.

Это Linux
Это Windows
Это MAC
Это Linux
Это Windows
Это MAC
Это Linux
Это Windows
Это MAC
Это Linux
Это это Windows
Это MAC

Теперь вернитесь к вашему ‘helloScript.sh’, и теперь мы собираемся повторно использовать код поиска файлов с несколькими изменяется в соответствии с требованиями нашей текущей программы. Базовый метод поиска файлов описан выше в теме «Файлы и каталоги». Сначала скрипт получит имя файла от пользователя, затем он прочитает ввод, сохранит его в переменной, а затем попросит пользователя ввести текст для поиска.. После этого он будет читать ввод с терминала, который является текстом для поиска в файле. Он сохранит значение в другой переменной с именем «grepvar». Теперь вам нужно сделать главное — использовать команду grep с переменной grep и именем файла. Ir будет искать слово во всем документе.

#! /bin/bash
echo «введите имя файла для поиска текста из»
прочтите имя файла
if [[-f $ fileName]]
то
Echo «введите текст для поиска»
прочитайте grepvar
grep $ grepvar $ fileName
else
echo «$ fileName не существует»
fi

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

$ ./ helloScript.sh

Вы ничего не видите после процедуры поиска, потому что вводится «linux», а текст в файле написан как «Linux». Здесь вы должны решить эту проблему чувствительности к регистру, просто добавив флаг ‘-i’ в команду grep.

grep -i $ grepvar $ fileName

Теперь снова выполните сценарий.

$ ./helloScript.sh

Вы также можете извлечь номер строки с выводом. Для этого вам нужно только добавить еще один флаг ‘-n’ в свою команду grep.

grep -i -n $ grepvar $ fileName

Сохраните сценарий и выполните файл с помощью терминала.

$ ./helloScript.sh

Вы также можете получить количество вхождений этого конкретного слова в документе. Добавьте флаг ‘-c’ в команду grep ‘grep -i -c $ grepvar $ fileName’, сохраните сценарий и выполните его с помощью терминала.

$ ./helloScript.sh

Вы также можете проверить различные команды grep просто набрав «man grep» на терминале.

20. Введение в awk

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

Вы можете спросить, для чего это ‘шило’ полезно? Идея состоит в том, что awk преобразует файлы данных, а также создает отформатированные отчеты. Это также дает вам возможность выполнять арифметические и строковые операции, а также использовать условные операторы и циклы.

Прежде всего, мы собираемся сканировать файл построчно с помощью команды awk. В этом примере вы также увидите код поиска файла, потому что он необходим для получения необходимого файла. После этого используйте команду ‘awk’ с операцией print ‘{print}’ и переменной имени файла.

#! /bin/bash
echo «введите имя файла для печати из awk»
прочитать имя файла
if [[-f $ fileName]]
то
Awk ‘{print}’ $ fileName
else
echo «$ fileName не существует»
fi

Сохраните это ‘.helloScript.sh и выполните его через терминал.

Не беспокойтесь об имени файла ‘filegrep.txt’. Это просто имя файла, и имя filgrep.txt не сделает его файлом grep.

Мы также можем искать определенный шаблон с помощью awk. Для этого вам нужно просто заменить указанную выше команду awk на эту «awk»/Linux/{print} «$ fileName». Этот сценарий будет искать «Linux» в файле и отображать строки, содержащие его.

#! /bin/bash
echo «введите имя файла для печати из awk»
прочитать имя файла
if [[-f $ fileName]]
то

awk ‘/Linux/{print}’ $ fileName
else
echo «$ fileName не существует»
fi

Теперь замените содержимое файла ‘filegrep.txt’ заданным текстом. ниже для дальнейших экспериментов.

Это Linux 2000
Это Windows 3000
Это MAC 4000
Это Linux 2000
Это Windows 3000
Это MAC 4000
Это Linux 2000
Это Windows 3000
Это MAC 4000
Это Linux 2000
Это Windows 3000
Это MAC 4000

В следующем примере вы увидите, как мы можем извлечь содержимое из строк. , где программа нашла целевое слово. «$ 1» представляет первое слово в этой строке, аналогично «$ 2» представляет второе, «$ 3» представляет третье слово, а «$ 4» представляет последнее слово в этом случае.

#! /bin/bash
echo «введите имя файла для печати из awk»
прочитать имя файла
if [[-f $ fileName]]
то

awk ‘/Linux/{print $ 2}’ $ fileName
else
echo «$ fileName не существует»
fi

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

Теперь запускаем скрипт с командой ‘awk’ для получения последнего слова ‘$ 4’ из строк, в которых он нашел ‘ Linux ‘.

#! /bin/bash
echo «введите имя файла для печати из awk»
прочитать имя файла
if [[-f $ fileName]]
то

awk ‘/Linux/{print $ 4}’ $ fileName
else
echo «$ fileName не существует»
fi

Теперь используйте ‘awk’/Linux/{print $ 3, $ 4} Команда ‘$ fileName’, чтобы проверить, работает ли она для печати второго последнего и последнего слова строк, содержащих ‘Linux’.

#! /bin/bash
echo «введите имя файла для печати из awk»
прочитать имя файла
if [[-f $ fileName]]
то

awk ‘/Linux/{print $ 3, $ 4}’ $ fileName
else
echo «$ fileName не существует»
fi

21. Введение в sed

Команда sed обозначает редактор потока, выполняет операции редактирования текста, поступающего из стандартного ввода или файла. sed редактирует построчно и не интерактивно. Это означает, что вы принимаете все решения по редактированию при вызове команды, а sed выполняет инструкции автоматически. Здесь вы узнаете, как использовать «sed» очень просто. Используйте тот же скрипт, который мы использовали для предыдущей задачи. Мы собираемся заменить «i» на «I». Для этого просто напишите следующую команду sed ‘cat filegrep.txt | sed ‘s/i/I/’ ’, здесь команда cat используется для получения содержимого файла, а после знака вертикальной черты‘ | ’с ключевым словом‘ sed ’мы указываем операцию, которая в данном случае является подстановкой. Поэтому здесь пишется «s» с косой чертой и буквой, которая будет заменена, затем снова косая черта и затем последняя буква, которой мы будем заменять.

#! /bin/bash
echo «введите имя файла для замены с помощью sed»
прочтите имя файла
if [[-f $ fileName]]
затем
cat filegrep.txt | sed ‘s/i/I/’

else
echo «$ fileName не существует»
fi

Сохраните сценарий и выполните его с помощью терминала.

Из вывода видно, что только первый экземпляр «i» был заменен на «I». Для подстановки экземпляров «i» всего документа вам нужно написать только «g» (что означает глобальное значение) после последней косой черты «/». Теперь сохраните сценарий и выполните его, и вы увидите это изменение во всем содержимом.

#! /bin/bash
echo «введите имя файла для замены с помощью sed»
прочтите имя файла
if [[-f $ fileName]]
затем
cat filegrep.txt | sed ‘s/i/I/g’

else
echo «$ fileName не существует»
fi

Эти изменения вносятся только во время выполнения. Вы также можете создать другой файл для хранения содержимого файла, отображаемого на терминале, просто написав следующую команду в файле «helloScript.sh»

cat filegrep.txt | sed ‘s/i/I/g’> newfile.txt

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

#! /bin/bash
echo «введите имя файла для замены с помощью sed»
прочтите имя файла
if [[-f $ fileName]]
затем
sed ‘s/Linux/Unix/g’ $ fileName

else
echo «$ fileName не существует»
fi

22. Отладка сценариев Bash

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

#! /bin/bash
echo «введите имя файла для замены с помощью sed»
прочтите имя файла
if [[-f $ fileName]]
затем
sed ‘s/Linux/Unix/g’ $ fileName

else
echo «$ fileName не существует»
fi

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

$ bash -x ./helloScript.sh

Теперь запустите скрипт.

Просто установите флаг ‘-x’ первая строка скрипта после пути bash. В этом методе вы собираетесь отлаживать свой сценарий с помощью сценария.

#! /bin/bash -x
echo «введите имя файла для замены с помощью sed»
прочитать имя файла
if [[-f $ fileName]]
то
sed ‘s/Linux/Unix/g’ $ fileName

else
echo «$ fileName не существует»
fi

Итак, в последнем методе вы можете выбрать начальную и конечные точки отладки. Запишите команду «set -x» в начальной точке отладки, а для ее завершения просто напишите «set + x», сохраните этот «helloScript.sh», выполните его через терминал и проверьте результаты..

#! /bin/bash
set -x
echo «введите имя файла для замены с помощью sed»
прочитать имя файла
set + x
if [[- f $ fileName]]
затем
sed ‘s/Linux/Unix/g’ $ fileName

else
echo «$ fileName не ‘ t exist «
fi

Смотрите 3-часовой курс BASH на YouTube: