Простое руководство по скриптованию оболочки Linux с помощью Bash

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

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

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

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

Что вам нужно для изучения написания сценариев оболочки Bash

Для написания и запуска сценария Bash вам нужно всего три вещи:

• Любой текстовый редактор, такой как Блокнот, Текстовый редактор, TextEdit, vi, emacs или Visual Studio Code.
• A terminal emulator, an application that comes preinstalled with most operating systems and is often called Terminal, Console, or Command Prompt.
• Bash сам по себе.

Терминальный эмулятор – это место, где вы будете вводить команды и запускать их, нажимая Enter или Return. Что касается Bash, то наличие его предварительно установленным будет зависеть от вашей платформы:

• На macOS, Bash установлен по умолчанию. На более новых версиях Z shell (zsh) является стандартной оболочкой, и это нормально. Пока Bash установлен, вы можете запускать скрипты Bash из zsh тоже.
• Linux дистрибутивы обычно имеют Bash установленным. (Вы можете проверить, если ваша система включает файл /bin/bash.) Android является особым случаем, который не поставляется с Bash. Существуют шаги для получения Bash на Android, о которых эта статья не будет.
• Windows не поставляется с Bash. PowerShell является стандартной оболочкой командной строки в Windows. Вам потребуется установить дистрибутив Linux под управлением Подсистемы Windows для Linux (WSL), чтобы запустить Bash.

Чтобы узнать версию вашего Bash, выполните команду bash –version. Даже более старые версии Bash предоставляют вам много возможностей, но Bash 3 и 4 вводят удобные сокращения для некоторых базовых команд. Если для выполнения какой-либо команды требуется одна из этих версий Bash, это будет указано ниже.

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

В мире компьютеров оболочка – это программа, служащая интерфейсом для основной ОС. Оболочка может быть графическим пользовательским интерфейсом (GUI), например, оболочкой Windows.

Языки сценариев оболочки

Однако люди обычно используют этот термин, чтобы относиться конкретно к интерфейсу командной строки (CLI) — интерфейсу, состоящему из строк текста, с которыми вы взаимодействуете, используя только клавиатуру. Вот некоторые примеры языков сценариев оболочки для *nix операционных систем:

• оболочка Bash (сокращение от “Bourne Again Shell”)
• оболочка C
• оболочка Korn

Здесь мы сосредоточимся на оболочке Bash. Это популярная бесплатная Unix-оболочка, предустановленная на большинстве дистрибутивов Linux и на macOS.

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

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

Эта статья рассмотрит основы сценариев оболочки для создания этого файла.

Основы сценариев оболочки

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

1. Создайте новый пустой текстовый файл в текстовом редакторе.
2. Напишите #!/bin/bash на первой строке.
3. Введите ваши команды ниже этой строки.
4. Сохраните файл, предпочтительно с расширением “.sh” или без расширения вообще.

Строка #!/bin/bash называется “шебанг”. Она сообщает вашему оболочке, что этот сценарий должен выполняться в Bash и должен быть первой строкой в вашем сценарии. Если вы переключитесь на другую оболочку, ваш сценарий все равно будет выполняться в Bash.

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

#!/bin/bash
echo "hello world"

Вот и все — вы создали сценарий Bash!

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

Установка разрешений для запуска оболочечного сценария с помощью chmod

Чтобы изменить разрешения на нашем файле ‘hello_world‘, вы должны выполнить эту конкретную команду в вашем эмуляторе терминала. Это дает пользователю, владеющему файлом, разрешение на выполнение файла.:

chmod u+x 'hello_world'

Если вам просто нужно запустить ваш сценарий оболочки, вы можете перейти к следующему разделу. Для тех, кто интересуется командой chmod, chmod является сокращением от “change mode” и служит для изменения “режимов” файла (или разрешений) в Unix. В операционных системах, подобных Unix, вы можете установить разрешения на файлы для 3 классов пользователей:

• Пользователь, владеющий файлом (обозначается u в chmod).
• Группа, которой принадлежит файл (g).
• Другие (o).

С помощью команды chmod вы также можете использовать a для ссылки на все этих пользователей.

У каждого файла есть 3 вида разрешений (или “режимы”):

• Чтение (r)
• Запись (w)
• Исполнение (x)

И также можно добавить (+) или удалить (-) разрешения.

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

• chmod gu+rw 'hello_world' добавит разрешения на чтение и запись для владельца и группы.
• chmod a-x 'hello_world' удалит разрешение на исполнение для всех.
• chmod u+rwx 'hello_world' 'hello_world_2' даст владельцу разрешение на чтение, запись и выполнение файлов “hello_world” и “hello_world_2”.

Мы рассмотрели только самые основы команды chmod здесь. Существует также более сложный, но менее подробный способ определения этих режимов («числовая нотация»), а также другая команда, которую можно использовать для просмотра разрешений ваших файлов (ls -l). Мы не будем касаться этих тем здесь.

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

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

./hello_world

Можно использовать относительный или абсолютный путь. При использовании относительного пути всегда используйте ./ в начале вашей команды: Это говорит терминалу искать в текущей папке (представленной как '.'), а не в каталогах, определенных в переменной среды PATH.

Использование комментариев для аннотации вашего сценария

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

Например:

#!/bin/bash

#
# This shell script prints "hello world".
#

echo "hello world" # This line prints "hello world".

Введение в переменные

При написании сценариев полезно определять переменные. В Bash это делается путем ввода имени переменной и значения, разделенных знаком равенства: VARIABLENAME='VALUE'.

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

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

Чтобы обратиться к значению переменной, используйте имя переменной, предшествующее символу доллара: $VARIABLENAME.

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

#!/bin/bash
HELLO="hello variable world"
echo $HELLO # should print "hello variable world"

Получение аргументов

Индивидуальные слова, которые вы пишете при вводе команды, называются аргументами. В нашем примере chmod u+x 'hello_world', chmod, u+x, и 'hello_world' — три различных аргумента. chmod – это имя команды, а u+x и hello_world называются параметрами — аргументами, которые предоставляют дополнительную информацию команде.

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

Давайте попробуем это:

#!/bin/bash
HELLO="hello $1 world"
echo $HELLO

Теперь запустите этот сценарий с этими параметрами:

./hello_world bash script

На выходе должно быть hello bash world, где используется первый параметр, а второй игнорируется.

Если вы хотите, чтобы bash script был рассмотрен как один параметр, вам нужно поставить его в кавычки: 

./hello_world 'bash script'

Использование оператора if для выполнения кода условно

Одно из основных желаний программистов при написании сценария – запускать код только в случае выполнения определенного условия. Bash предлагает для этого оператор if:

NUM=$RANDOM
if (( $NUM % 2 )) # if CONDITION
then
    echo "$NUM is odd"
fi # this is how you end an if statement

Совет: Далее в этих примерах предполагается, что они являются частью более крупного сценария и не включают #!/bin/bash в начале. Однако не забывайте о нем как о первой строке вашего сценария!

Вы также можете использовать else внутри оператора if для указания действий в случае невыполнения условия, или elif (сокращение от “else if“) для указания другого условия, если первое не было выполнено:

NUM=$RANDOM
if [ $NUM -eq 12 ]
then
    echo "$NUM is my favorite number"
elif (( $NUM % 2 ))
then
    echo "$NUM is odd"
else
    echo "$NUM is even"fi

‘fi‘ используется для завершения оператора if.

Совет: Если вы не уверены, как написать само условие, изучите нотацию с использованием test, одиночных скобок ([]) и двойных скобок ((())).

Повторение серии команд с помощью цикла for

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

Цикл for идеально подходит для такой задачи, особенно его “синтаксис с тремя выражениями”. Идея заключается в том, чтобы задать переменную для цикла и постепенно изменять ее, пока не будет выполнено определенное условие. Вот как он структурирован:

for (( ASSIGNMENT_EXPRESSION ; CONDITION_EXPRESSION ; UPDATE_EXPRESSION ))
do
    COMMANDS
done

Например, если вы хотите, чтобы цикл выполнился 10 раз с переменной i, меняющейся от 0 до 9, ваш цикл for может выглядеть так:

for (( i=0; i<10; i++ ))
do
    echo $i
done

Разберем подробнее:

• i=0 is the assignment expression here. It’s run only once before the loop is executed, which is why it’s useful for initializing a variable.
• i<10 is our condition expression. This expression is evaluated before each iteration of a loop. If it is equal to zero (which means the same as “true” in Bash), the next iteration is not run.
• i++ is our update expression. It’s run after each iteration of a loop.

Перебор элементов в списке

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

Самый простой пример – просто перечислить набор элементов, которые вы хотите перебрать после ключевого слова in, разделенных пробелами. Например:

for i in 0 1 2 3 4 5 6 7 8 9 # space-separated list items
do
    echo $i
done

Вы также можете перебирать элементы, выводимые командой:

for i in $(seq 0 1 9)

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

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

• for i in {0..9}, доступно в Bash 3.
• for i in {0..9..1}, доступно в Bash 4, где последнее число представляет шаг.

Также можно перебирать строки: 

for s in 'item1' 'item2' 'item3'

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

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

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

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

• echo *: Команда, возвращающая имена всех файлов в вашем текущем каталоге, кроме скрытых.
• echo *.txt: Команда, возвращающая имена всех не скрытых файлов с расширением txt в вашем текущем каталоге.
• echo ????: Команда, возвращающая все имена файлов из четырех букв в вашем текущем каталоге.

Использованные нами шаблоны здесь были * и ?. Есть еще один шаблон, который мы не использовали. Вот обзор:

• Звездочка (*) представляет собой любое количество символов (включая 0) в имени файла или каталога.
• Вопросительный знак (?) представляет собой один символ в имени файла или каталога.
• Двойная звездочка (**) представляет собой любое количество символов в полном пути к файлу. Это функция в Bash 4 и выше и должна быть включена с помощью выполнения shopt -s globstar.
• Квадратные скобки ([]) используются для представления символа в наборе символов в имени файла или каталога. Например [st]ake найдет файлы с именами sake или take, но не stake.

Обратите внимание, что все скрытые файлы (которые являются файлами с именами, начинающимися с точки .) игнорируются при использовании расширения глобуса.

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

• Диапазоны, определенные первым и последним значением, например [1-8];
• Исключение определенных символов с помощью ! в качестве первого символа внутри скобок, например [!3].

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

Повторение файлов с использованием цикла for

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

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

for f in *
do
    echo $f
done

Чтобы напечатать имена каждого файла в текущем каталоге, а также его подкаталогах, убедитесь, что вы запускаете Bash версии 4.0 или выше, выполнив bash --version, а затем вы можете выполнить следующую команду:

shopt -s globstar # enables using **
for f in **
do
    echo $f
done

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

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

i=1
for f in *.jpg
do
    mv -i -- "$f" "image_$i.jpg"
    let i=i+1
done

Запуск кода при выполнении условия

Цикл for – не единственный тип цикла, который мы можем использовать в Bash — у нас также есть while: Этот тип цикла выполняется до тех пор, пока определенное условие истинно.

Синтаксис аналогичен синтаксису цикла for:

while CONDITION
do
    COMMANDS
done

На практическом примере, вот как можно считать файл построчно (за исключением начальных или конечных пробелов) до тех пор, пока не достигнете конца файла:

while read -r line
do
    echo "$line"
done < FILENAME # Replace FILENAME with the path to a text file you'd like to read

Вы также можете заменить цикл for на цикл while, например, для перебора от 0 до 9:

i=0
while [ $i -lt 10 ]
do
    echo $i
    let i=i+1
done

И теоретически можно также запустить цикл бесконечно. Вот пример команды:

while true
do
    echo "running forever"
done

Совет: Чтобы прервать выполнение скрипта, просто нажмите Ctrl+C.

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

Выход из цикла

Оператор break используется для выхода из цикла.

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

Для простого примера мы можем воссоздать наш цикл с перебором от 0 до 9 с помощью бесконечного цикла вот так:

i=0while true
do
    if [ $i -eq 10 ]
    then
        break
    fi
    echo $i
    let i=i+1
done

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

Давайте рассмотрим быстрый пример с использованием циклов for, перебирающих все комбинации четырехбуквенных слов до тех пор, пока не будет найдено слово «bash»:

for l4 in {a..z}
do
    for l3 in {a..z}
    do
        for l2 in {a..z}
        do
            for l1 in {a..z}
            do
                echo "$l4$l3$l2$l1"
                if [ $l4 = "b" -a $l3 = "a" -a $l2 = "s" -a $l1 = "h" ]
                then
                    break 4
                fi
            done
        done
    done
done

A related keyword that’s also worth a mention is continue, which skips to the next iteration of the loop. Just like break, it also takes an optional numeric argument that corresponds to the loop level.

Вот глупый пример, где мы пропускаем все слова с буквой E в нашем укороченном списке четырехбуквенных слов:

for l4 in {a..z}
do
    if [ $l4 = "e" ]
    then
        continue
    fi
    for l3 in {a..z}
    do
        if [ $l3 = "e" ]
        then
            continue
        fi
        for l2 in {a..z}
        do
            if [ $l2 = "e" ]
            then
                continue
            fi
            for l1 in {a..z}
            do
                if [ $l1 = "e" ]
                then
                    continue
                fi
                echo "$l4$l3$l2$l1"
                if [ $l4 = "b" -a $l3 = "a" -a $l2 = "s" -a $l1 = "h" ]
                then
                    break 4
                fi
            done
        done
    done
done

Кроме того, все эти операторы continue можно выполнять на уровне самого глубокого цикла:

for l4 in {a..z}
do
    for l3 in {a..z}
    do
        for l2 in {a..z}
        do
            for l1 in {a..z}
            do
                if [ $l4 = "e" ]
                then
                    continue 4
                fi
                if [ $l3 = "e" ]
                then
                    continue 3
                fi
                if [ $l2 = "e" ]
                then
                    continue 2
                fi
                if [ $l1 = "e" ]
                then
                    continue
                fi
                echo "$l4$l3$l2$l1"
                if [ $l4 = "b" -a $l3 = "a" -a $l2 = "s" -a $l1 = "h" ]
                then
                    break 4
                fi
            done
        done
    done
done

Как получить ввод пользователя в сценарии оболочки

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

Чтобы получить ввод пользователя и сохранить его в переменную с именем NAME, вы бы использовали эту команду:

read NAME 

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

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

Вот как можно запросить имя, присвоив его переменной с именем NAME:

read -p "Your name: " NAME
echo "Your name is $NAME." # this line is here just to show that the name has been saved to the NAME variable

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

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

Чтобы указать Bash’у игнорировать их специальное значение в определенных местах, можно либо “экранировать” их, либо обернуть в литеральные кавычки.

“Экранирование” специального символа означает указание Bash на то, чтобы рассматривать его просто как символ без какого-либо специального значения. Для этого напишите обратный слэш перед этим символом.

Предположим, у нас есть файл с именем img \ 01 *DRAFT*, например. В Bash мы можем обратиться к нему следующим образом:

img\ \\\ 01\ \*DRAFT\*

Вот неполный список специальных символов в Bash:

• Пробелы: пробел, табуляция, пустая строка
• Кавычки: ”, “”
• Скобки: ( ), { }, [ ]
• Пайпы и перенаправления: |, <, >
• Шаблоны: *, ?
• Прочие: !, #, ;, =, &, ~, `
• Сам символ экранирования: \

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

Вот как это выглядит для нашего примера:

'img \ 01 *DRAFT*'

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

Например, предположим, что у вас есть несколько файлов с именами img \ 01 *v1 DRAFT*, img \ 01 *v2 DRAFT*, img \ 01 *ROUGH DRAFT* и т.д., и вы хотите использовать расширение глоба для сопоставления всех этих имен файлов. Вот что вы можете написать:

'img \ 01 *'*' DRAFT*'

Если то, что вам нужно написать, содержит одиночную кавычку – например, img \ 01 *’FINAL’* – вы можете использовать аналогичную стратегию, комбинируя литеральные строки и экранирование:

'img \ 01 '\''FINAL'\'

Как объединить строки в Bash

Допустим, у вас есть две или более строковых переменных – имя и фамилию, например:

FIRST_NAME="Johnny"LAST_NAME="Appleseed"

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

NAME="$LAST_NAME"', '"$FIRST_NAME"

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

NAME="${LAST_NAME}, ${FIRST_NAME}"

Bash также позволяет использовать оператор += для добавления текста к строке, вот так:

NAME='Appleseed'NAME+=', 'NAME+='Johnny'

Выполнение команд внутри строки

Bash также позволяет вам использовать вывод команды внутри строки, также известное как подстановка команд. Просто заключите вашу команду в $(). Например, чтобы вывести текущую метку времени, вы можете выполнить:

echo "Current timestamp: $(date)"

Вы также можете помнить этот синтаксис из предыдущего примера цикла for, когда мы итерировали по последовательности целых чисел от 0 до 9:

for i in $(seq 0 1 9)
do
    echo $i
done

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

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

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

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

• 0: Программа успешно выполнилась.
• 2: Программа использована неправильно (например, из-за недопустимых или отсутствующих аргументов).
• 1 и 3-124: Ошибки, определенные пользователем.
• 126: Команда не является исполняемой.
• 127: Команда не найдена.
• 125 и 128-255: Статусы ошибок, которые использует оболочка. Если процесс завершается сигналом N, статус выхода равен 128 + N.

Как видите, все числа, кроме 0, указывают на какой-то вид ошибки. Код завершения 1 обычно используется для общих ошибок. В большинстве случаев вам не потребуется использовать любой код завершения выше 2.

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

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

Чтобы получить код завершения последней запущенной команды в вашем shell, используйте переменную $?: echo $?.

Как вызвать функцию

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

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

function_name () {
    echo "This is where your function code goes"
}

Другой формат использует ключевое слово function перед именем функции:

function function_name {
    echo "This is where your function code goes"
}

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

function_name

Передача данных в функцию с использованием переменных

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

Например:

is_your_name_defined () {
    if [ -z "$YOUR_NAME" ]
    then
        echo "It doesn't seem like I have your name."
    else
        echo "Is this your name: ${YOUR_NAME}?"
    fi
}
read -p "Your name: " YOUR_NAME

is_your_name_defined

В отличие от того, к чему вы могли быть привыкли в других языках, переменные, которые вы определяете внутри вашей функции, являются глобальными и видимыми для кода за пределами вашего скрипта. Чтобы определить переменную, ограниченную локальной областью только для вашей функции (то есть недоступную для всего кода за её пределами), используйте ключевое слово local: например local i=0.

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

is_your_name_defined () {
    if [ -z "$YOUR_NAME" ]
    then
        MESSAGE="It doesn't seem like I have your name."
    else
        MESSAGE="Is this your name: ${YOUR_NAME}?"
    fi
}
read -p "Your name: " YOUR_NAME

is_your_name_defined

echo $MESSAGE

Итог

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

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

Связанная статья:

• Как использовать Chmod рекурсивно для изменения прав доступа к файлам в Linux и macOS