Запуск скрипта sh в Linux. Как писать скрипты sh

Как написать простой скрипт на bash

Изучение программированию всегда начинается с примеров написания простых скриптов

Этот совет расскажет вам о том, как написать простой скрипт на bash в Linux.

Для написания простого скрипта на bash, нам потребуется выполнить следующие простые действия:

Скопируем/вставим или просто наберем вручную следующий текст: #!/bin/bash
mkdir testdircd testdirtouch file1 file2 file3ls -al
Выйдем из текстового редактора с сохранением созданного файла.
Сделаем наш скрипт исполняемым, чтобы в дальнейшем мы его могли без проблем запускать из командной строки, выполнив команду:chmod +x firstscript
Попробуем запустить созданный нами скрипт, выполнив в командной строке:./firstscript И, вот результат:

Как это все работает:

первая строка нашего скрипта #!/bin/bashкрайне необходима, для того, чтобы наш скрипт успешно выполнился.

вторая строка mkdir testdir создает каталог testdir

третья строка cd testdir позволяет перейти в созданный каталог testdir

команда touch в следующей строке touch file1 file2 file3 создает три файла

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

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

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

www.ithowto.ru

Написание скриптов в Linux. Каковы принципы составления сценариев на Bash?

Цели использования скриптов

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

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

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

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

Небольшой пример сценария

Ниже приводится пример скрипта, ищущего все файлы журналов в директории /var/log. Если вызов происходит без указания параметров, имена всех журналов записываются в файл log-list.txt, лежащий в домашней директории пользователя. При указании строкового параметра поиск осуществляется по его вхождению в имена файлов. Данный Bash скрипт должен работать одинаково в любом дистрибутиве Linux.

#!/bin/bash if [ -n "$1" ]; then find /var/log -type f -name "*$1*.log" -print > ~/log-list.txt echo "Осуществлен поиск по фразе '$1'" else find /var/log -type f -name "*.log" -print > ~/log-list.txt echo 'Поиск всех файлов журналов закончен' fi

Создайте в директории /usr/local/bin файл с именем findlog и скопируйте в него, приведенный выше программный код. Файл нужно сделать исполняемым с помощью команды chmod, или нажмите по нему правой кнопкой мыши и зайдите в пункт «свойства». В открывшемся окне выберите закладку «права» и активируйте переключатель «разрешить выполнение файла как программы». После данных операций вы сможете запускать сценарий в терминале с помощью указания его имени.

sudo findlog 'error' Осуществлен поиск по фразе 'error' sudo findlog Поиск всех файлов журналов закончен

Пояснения к использованию сценариев

Любой скрипт, создаваемый в Linux, должен начинаться со строки определения исполняемой программы. Обратите внимание на первую строчку из примера «#!/bin/bash». Она, по сути, является комментарием, так как начинается со знака решетки, но восклицательный знак говорит терминалу о том, что последующий текст определяет место расположения программы обработчика. В данном случае мы указали место расположения исполняемого файла командного интерпретатора Bash.

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

Мы поместили сценарий в директории /usr/local/bin. Это одна из папок, на которые операционная система обращает особое внимание. При вводе имени команды в окне терминала, ОС просматривает ряд папок на наличие одноименного исполняемого файла.

Если скрипт расположен в какой-либо другой директории, вызвать его можно с помощью прямого обращения. Для этого нужно указать абсолютный или относительный путь до файла. Если файл расположен в текущей директории, обязательным условием является использование конструкции «./имя_скрипта».

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

echo $PATH /home/username/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

coder-booster.ru

Запуск скрипта sh в Linux

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

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

Содержание статьи:

Как работают скрипты

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

Теперь о том, как работают скрипты. Это обычные файлы, которые содержат текст. Но если для них установлен атрибут исполняемости, то для их открытия используется специальная программа - интерпретатор, например, оболочка bash. А уже интерпретатор читает последовательно строку за строкой и выполняет все команды, которые содержатся в файле. У нас есть несколько способов выполнить запуск скрипта linux. Мы можем запустить его как любую другую программу через терминал или же запустить оболочку и сообщить ей какой файл нужно выполнять. В этом случае не нужно даже флага исполняемости.

Запуск скрипта sh в Linux

Сначала рассмотрим пример небольшого sh скрипта:

#!/bin/bashecho "Hello world"

Вторая строка - это действие, которое выполняет скрипт, но нас больше всего интересует первая - это оболочка, с помощью которого его нужно выполнить. Это может быть не только /bin/bash, но и /bin/sh, и даже /usr/bin/python или /usr/bin/php. Также часто встречается ситуация, что путь к исполняемому файлу оболочки получают с помощью утилиты env: /usr/bin/env php и так далее. Чтобы выполнить скрипт в указанной оболочке, нужно установить для него флаг исполняемости:

chmod ugo+x sript.sh

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

./script.sh

Или полный путь от корня:

/home/user/script.sh

Если вы не хотите писать полный путь к скрипту, это можно сделать, достаточно переместить скрипт в одну из папок, которые указаны в переменной PATH. Одна из них, которая предназначена для ручной установки программ - /usr/local/bin.

cp script.sh /usr/local/bin/script.sh

Теперь вы можете выполнить:

script.sh

Это был первый способ вызвать скрипт, но есть еще один - мы можем запустить оболочку и сразу же передать ей скрипт, который нужно выполнить. Вы могли редко видеть такой способ с bash, но он довольно часто используется для скриптов php или python. Запустим так наш скрипт:

bash script.sh

А если нам нужно запустить скрипт на php, то выполните:

php script.php

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

script.sh &

Даже запустить процесс linux не так сложно.

Выводы

Как видите, запуск скрипта sh в linux - это довольно простая задача, даже если вы еще плохо знакомы с терминалом. Существует действительно много скриптов и некоторые из них вам возможно придется выполнять. Если у вас остались вопросы, спрашивайте в комментариях!

losst.ru

начало / Блог компании RUVDS.com / Хабр

Bash-скрипты: началоBash-скрипты, часть 2: циклыBash-скрипты, часть 3: параметры и ключи командной строки Bash-скрипты, часть 4: ввод и выводBash-скрипты, часть 5: сигналы, фоновые задачи, управление сценариями Bash-скрипты, часть 6: функции и разработка библиотекBash-скрипты, часть 7: sed и обработка текстовBash-скрипты, часть 8: язык обработки данных awkBash-скрипты, часть 9: регулярные выраженияBash-скрипты, часть 10: практические примерыBash-скрипты, часть 11: expect и автоматизация интерактивных утилит Сегодня поговорим о bash-скриптах. Это — сценарии командной строки, написанные для оболочки bash. Существуют и другие оболочки, например — zsh, tcsh, ksh, но мы сосредоточимся на bash. Этот материал предназначен для всех желающих, единственное условие — умение работать в командной строке Linux.

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

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

pwd ; whoami На самом деле, если вы опробовали это в своём терминале, ваш первый bash-скрипт, в котором задействованы две команды, уже написан. Работает он так. Сначала команда pwd выводит на экран сведения о текущей рабочей директории, потом команда whoamiпоказывает данные о пользователе, под которым вы вошли в систему.

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

getconf ARG_MAX Командная строка — отличный инструмент, но команды в неё приходится вводить каждый раз, когда в них возникает необходимость. Что если записать набор команд в файл и просто вызывать этот файл для их выполнения? Собственно говоря, тот файл, о котором мы говорим, и называется сценарием командной строки.

Как устроены bash-скрипты

Создайте пустой файл с использованием команды touch. В его первой строке нужно указать, какую именно оболочку мы собираемся использовать. Нас интересует bash, поэтому первая строка файла будет такой:#!/bin/bash В других строках этого файла символ решётки используется для обозначения комментариев, которые оболочка не обрабатывает. Однако, первая строка — это особый случай, здесь решётка, за которой следует восклицательный знак (эту последовательность называют шебанг) и путь к bash, указывают системе на то, что сценарий создан именно для bash.

Команды оболочки отделяются знаком перевода строки, комментарии выделяют знаком решётки. Вот как это выглядит:

#!/bin/bash # This is a comment pwd whoami Тут, так же, как и в командной строке, можно записывать команды в одной строке, разделяя точкой с запятой. Однако, если писать команды на разных строках, файл легче читать. В любом случае оболочка их обработает.

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

Сохраните файл, дав ему имя myscript, и работа по созданию bash-скрипта почти закончена. Сейчас осталось лишь сделать этот файл исполняемым, иначе, попытавшись его запустить, вы столкнётесь с ошибкой Permission denied.Попытка запуска файла сценария с неправильно настроенными разрешениями

Сделаем файл исполняемым:

chmod +x ./myscript Теперь попытаемся его выполнить:./myscript После настройки разрешений всё работает как надо.Успешный запуск bash-скрипта

Вывод сообщений

Для вывода текста в консоль Linux применяется команда echo. Воспользуемся знанием этого факта и отредактируем наш скрипт, добавив пояснения к данным, которые выводят уже имеющиеся в нём команды:#!/bin/bash # our comment is here echo "The current directory is:" pwd echo "The user logged in is:" whoami Вот что получится после запуска обновлённого скрипта.Вывод сообщений из скрипта

Теперь мы можем выводить поясняющие надписи, используя команду echo. Если вы не знаете, как отредактировать файл, пользуясь средствами Linux, или раньше не встречались с командой echo, взгляните на этот материал.

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

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

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

Существуют два типа переменных, которые можно использовать в bash-скриптах:

Переменные среды
Пользовательские переменные

Переменные среды

Иногда в командах оболочки нужно работать с некими системными данными. Вот, например, как вывести домашнюю директорию текущего пользователя:#!/bin/bash # display user home echo "Home for the current user is: $HOME" Обратите внимание на то, что мы можем использовать системную переменную $HOME в двойных кавычках, это не помешает системе её распознать. Вот что получится, если выполнить вышеприведённый сценарий.Использование переменной среды в сценарии

А что если надо вывести на экран значок доллара? Попробуем так:

echo "I have $1 in my pocket" Система обнаружит знак доллара в строке, ограниченной кавычками, и решит, что мы сослались на переменную. Скрипт попытается вывести на экран значение неопределённой переменной $1. Это не то, что нам нужно. Что делать?

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

echo "I have \$1 in my pocket" Теперь сценарий выведет именно то, что ожидается.Использование управляющей последовательности для вывода знака доллара

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

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

Как и в случае с системными переменными, к пользовательским переменным можно обращаться, используя знак доллара:TNW-CUS-FMP — промо-код на 10% скидку на наши услуги, доступен для активации в течение 7 дней

#!/bin/bash # testing variables grade=5 person="Adam" echo "$person is a good boy, he is in grade $grade" Вот что получится после запуска такого сценария.Пользовательские переменные в сценарии

Подстановка команд

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

Сделать это можно двумя способами.

С помощью значка обратного апострофа «`»
С помощью конструкции $()

Используя первый подход, проследите за тем, чтобы вместо обратного апострофа не ввести одиночную кавычку. Команду нужно заключить в два таких значка:mydir=`pwd` При втором подходе то же самое записывают так:mydir=$(pwd) А скрипт, в итоге, может выглядеть так:#!/bin/bash mydir=$(pwd) echo $mydir В ходе его работы вывод команды pwdбудет сохранён в переменной mydir, содержимое которой, с помощью команды echo, попадёт в консоль.Скрипт, сохраняющий результаты работы команды в переменной

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

Для выполнения математических операций в файле скрипта можно использовать конструкцию вида $((a+b)):#!/bin/bash var1=$(( 5 + 5 )) echo $var1 var2=$(( $var1 * 2 )) echo $var2Математические операции в сценарии

Управляющая конструкция if-then

В некоторых сценариях требуется управлять потоком исполнения команд. Например, если некое значение больше пяти, нужно выполнить одно действие, в противном случае — другое. Подобное применимо в очень многих ситуациях, и здесь нам поможет управляющая конструкция if-then. В наиболее простом виде она выглядит так:if команда then команды fi А вот рабочий пример:#!/bin/bash if pwd then echo "It works" fi В данном случае, если выполнение команды pwdзавершится успешно, в консоль будет выведен текст «it works».

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

#!/bin/bash user=likegeeks if grep $user /etc/passwd then echo "The user $user Exists" fi Вот что получается после запуска этого скрипта.Поиск пользователя

Здесь мы воспользовались командой grepдля поиска пользователя в файле /etc/passwd. Если команда grepвам незнакома, её описание можно найти здесь.

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

Управляющая конструкция if-then-else

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

Напишем такой скрипт:

#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "The user $user Exists" else echo "The user $user doesn’t exist" fi Его исполнение пошло по ветке else.Запуск скрипта с конструкцией if-then-else

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

if команда1 then команды elif команда2 then команды fi Если первая команда вернёт ноль, что говорит о её успешном выполнении, выполнятся команды в первом блоке then, иначе, если первое условие окажется ложным, и если вторая команда вернёт ноль, выполнится второй блок кода.#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "The user $user Exists" elif ls /home then echo "The user doesn’t exist but anyway there is a directory under /home" fi В подобном скрипте можно, например, создавать нового пользователя с помощью команды useradd, если поиск не дал результатов, или делать ещё что-нибудь полезное.

Сравнение чисел

В скриптах можно сравнивать числовые значения. Ниже приведён список соответствующих команд.n1 -eq n2Возвращает истинное значение, если n1 равно n2.n1 -ge n2 Возвращает истинное значение, если n1больше или равно n2.n1 -gt n2Возвращает истинное значение, если n1 больше n2.n1 -le n2Возвращает истинное значение, если n1меньше или равно n2.n1 -lt n2Возвращает истинное значение, если n1 меньше n2.n1 -ne n2Возвращает истинное значение, если n1не равно n2. В качестве примера опробуем один из операторов сравнения. Обратите внимание на то, что выражение заключено в квадратные скобки.#!/bin/bash val1=6 if [ $val1 -gt 5 ] then echo "The test value $val1 is greater than 5" else echo "The test value $val1 is not greater than 5" fi Вот что выведет эта команда.Сравнение чисел в скриптах

Значение переменной val1больше чем 5, в итоге выполняется ветвь thenоператора сравнения и в консоль выводится соответствующее сообщение.

Сравнение строк

В сценариях можно сравнивать и строковые значения. Операторы сравнения выглядят довольно просто, однако у операций сравнения строк есть определённые особенности, которых мы коснёмся ниже. Вот список операторов.str1 = str2 Проверяет строки на равенство, возвращает истину, если строки идентичны. str1 != str2Возвращает истину, если строки не идентичны.str1 < str2Возвращает истину, если str1меньше, чем str2.str1 > str2 Возвращает истину, если str1больше, чем str2.-n str1 Возвращает истину, если длина str1больше нуля.-z str1Возвращает истину, если длина str1равна нулю. Вот пример сравнения строк в сценарии:#!/bin/bash user ="likegeeks" if [$user = $USER] then echo "The user $user is the current logged in user" fi В результате выполнения скрипта получим следующее.Сравнение строк в скриптах

Вот одна особенность сравнения строк, о которой стоит упомянуть. А именно, операторы «>» и «<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>» как команду перенаправления вывода.

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

#!/bin/bash val1=text val2="another text" if [ $val1 \> $val2 ] then echo "$val1 is greater than $val2" else echo "$val1 is less than $val2" fi Вот результаты работы скрипта.Сравнение строк, выведенное предупреждение

Обратите внимание на то, что скрипт, хотя и выполняется, выдаёт предупреждение:

./myscript: line 5: [: too many arguments Для того, чтобы избавиться от этого предупреждения, заключим $val2 в двойные кавычки:#!/bin/bash val1=text val2="another text" if [ $val1 \> "$val2" ] then echo "$val1 is greater than $val2" else echo "$val1 is less than $val2" fi Теперь всё работает как надо.Сравнение строк

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

Likegeeks likegeeks Сохраним его, дав имя myfile, после чего выполним в терминале такую команду:sort myfile Она отсортирует строки из файла так:likegeeks Likegeeks Команда sort, по умолчанию, сортирует строки по возрастанию, то есть строчная буква в нашем примере меньше прописной. Теперь подготовим скрипт, который будет сравнивать те же строки:#!/bin/bash val1=Likegeeks val2=likegeeks if [ $val1 \> $val2 ] then echo "$val1 is greater than $val2" else echo "$val1 is less than $val2" fi Если его запустить, окажется, что всё наоборот — строчная буква теперь больше прописной.Команда sort и сравнение строк в файле сценария

В командах сравнения прописные буквы меньше строчных. Сравнение строк здесь выполняется путём сравнения ASCII-кодов символов, порядок сортировки, таким образом, зависит от кодов символов.

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

Проверки файлов

Пожалуй, нижеприведённые команды используются в bash-скриптах чаще всего. Они позволяют проверять различные условия, касающиеся файлов. Вот список этих команд.-d fileПроверяет, существует ли файл, и является ли он директорией.-e fileПроверяет, существует ли файл.-f file Проверяет, существует ли файл, и является ли он файлом.-r fileПроверяет, существует ли файл, и доступен ли он для чтения.-s file Проверяет, существует ли файл, и не является ли он пустым.-w fileПроверяет, существует ли файл, и доступен ли он для записи.-x fileПроверяет, существует ли файл, и является ли он исполняемым.file1 -nt file2 Проверяет, новее ли file1, чем file2.file1 -ot file2Проверяет, старше ли file1, чем file2.-O file Проверяет, существует ли файл, и является ли его владельцем текущий пользователь.-G fileПроверяет, существует ли файл, и соответствует ли его идентификатор группы идентификатору группы текущего пользователя. Эти команды, как впрочем, и многие другие рассмотренные сегодня, несложно запомнить. Их имена, являясь сокращениями от различных слов, прямо указывают на выполняемые ими проверки.

Опробуем одну из команд на практике:

#!/bin/bash mydir=/home/likegeeks if [ -d $mydir ] then echo "The $mydir directory exists" cd $ mydir ls else echo "The $mydir directory does not exist" fi Этот скрипт, для существующей директории, выведет её содержимое.Вывод содержимого директории

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

Итоги

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

Bash Script Step By Step — здесь речь идёт о том, как начать создание bash-скриптов, рассмотрено использование переменных, описаны условные конструкции, вычисления, сравнения чисел, строк, выяснение сведений о файлах.
Bash Scripting Part 2, Bash the awesome — тут раскрываются особенности работы с циклами for и while.
Bash Scripting Part 3, Parameters & options — этот материал посвящён параметрам командной строки и ключам, которые можно передавать скриптам, работе с данными, которые вводит пользователь, и которые можно читать из файлов.
Bash Scripting Part 4, Input & Output — здесь речь идёт о дескрипторах файлов и о работе с ними, о потоках ввода, вывода, ошибок, о перенаправлении вывода.
Bash Scripting Part 5, Sighals & Jobs — этот материал посвящён сигналам Linux, их обработке в скриптах, запуску сценариев по расписанию.
Bash Scripting Part 6, Functions — тут можно узнать о создании и использовании функций в скриптах, о разработке библиотек.
Bash Scripting Part 7, Using sed — эта статья посвящена работе с потоковым текстовым редактором sed.
Bash Scripting Part 8, Using awk — данный материал посвящён программированию на языке обработки данных awk.
Bash Scripting Part 9, Regular Expressions — тут можно почитать об использовании регулярных выражений в bash-скриптах.
Bash Scripting Part 10, Practical Examples — здесь приведены приёмы работы с сообщениями, которые можно отправлять пользователям, а так же методика мониторинга диска.
Bash Scripting Part 11, Expect Command — этот материал посвящён средству Expect, с помощью которого можно автоматизировать взаимодействие с интерактивными утилитами. В частности, здесь идёт речь об expect-скриптах и об их взаимодействии с bash-скриптами и другими программами.

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

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

habr.com

Как создать собственный script (скрипт-сценарий) в Linux

Прежде всего давайте разберём, что такое script и для чего он нужен.

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

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

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

Все действия я буду проводить с системе Ubuntu, но они применимы и к другим системам Linux, производных от Ubuntu. Для этого нам понадобятся: Текстовый редактор, чтобы наполнить его нужными задачами для создания скрипта (кода) и Терминал - для выполнения созданного скрипта. Эти инструменты установлены в любом дистрибутие Linux по умолчанию.

Итак, открываем текстовый редактор Gedit и вводим в него первые обязательные символы под названием shebang.shebang в программировании, это последовательность из двух символов: решётки и восклицательного знака (#!) в начале файла скрипта. И добавляем к данным символам без пробелов /bin/sh - интерпретатор, где будет выполняться скрипт. /bin/sh - это обычно Bourne shell или совместимый интерпретатор командной строки, который передаёт "path/to/script" как первый параметр. Первая обязательная строка скрипта будет выглядеть следующим образом:

#!/bin/sh

Далее, следующей строкой следует описание того, что должен выполнить наш первый скрипт/сценарий:

# Мой первый Script обновления Ubuntu

Знак решётки (#) в самом начале строки даёт понять интерпретатору/терминалу, что эту строку читать и выполнять не нужно. Строка нужна в коде данного скрипта для того чтобы сам создатель скрипта знал, что он собирается выполнить на данном отрезке/сценке в коде, чтобы не запутаться в дальнейшем, когда таких строк будет много. Такие строки с знаком решётки называются - закомментированные.

Далее в скрипте следуют выполняемые строки с командами, в данном случае для обновления системы Ubuntu:

sudo apt updatesudo apt upgrade -y

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

Вот и всё. Ваш первый скрипт создан. У вас должно получиться как на снимке:

Остаётся сохранить созданный файл/скрипт и дать ему Имя с обязательным расширением в конце - .sh. Расширение .sh присваивается исполняемому файлу. Я дал ему Имя - обновление.sh, сохранив в Домашней папке пользователя:

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

1. Выполнить следующую команду в терминале:

sudo chmod +x обновление.sh

2. Либо открыть файловый менеджер в Домашней папке (где вы сохранили созданный скрипт), правый клик на файле, в контекстном меню - Свойства - Права и активировать пункт - Выполнение: Разрешить выполнение файла как программы:

Чтобы выполнить созданный скрипт, нужно открыть терминал ( о чём я писал в самом начале статьи, что терминал - необходимый атрибут/инструмент для выполнения скрипта), ввести sh, через пробел название скрипта - обновление.sh и нажать клавишу Ввод:

Либо в терминале вводим sh и перетаскиваем из файлового менеджера созданный файл с скриптом (также через пробел):

После того как путь к файлу отобразится после команды sh и пробела, достаточно нажать клавишу Enter (Ввод), чтобы выполнить обновление системы:

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

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

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

Многие из вас, скорее всего, пользуются сайтами по настройке системы, типа тех что я публикую после выхода очередного релиза Ubuntu - Ubuntu после установки или подобными сайтами. Откройте один из таких сайтов: http://compizomania.blogspot.com/2016/04/ubuntu-1604.html, затем текстовый редактор для создания скрипта.Для примера я сделал следующую заготовку.

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

#!/bin/bash

Далее закомментированные строки с описанием:

# Настройка Ubuntu после уставновки# Обновление системы

Ниже следуют команды обновления системы:

sudo apt updatesudo apt upgrade -y

Строка описания: Добавление репозиториев:

# Добавление репозиториев

И добавляете необходимые репозитории для дальнейшей установки программного обеспечения:

sudo add-apt-repository "deb http://archive.canonical.com/ $(lsb_release -sc) partner" -ysudo add-apt-repository ppa:atareao/telegram -ysudo add-apt-repository ppa:atareao/atareao -y sudo add-apt-repository ppa:nemh/systemback -ysudo add-apt-repository ppa:gerardpuig/ppa -ysudo add-apt-repository ppa:haecker-felix/gradio-daily -y

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

Строка с описанием:

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

И команда на выполнение:

sudo apt update

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

# Установка программ

Для установки программ достаточно один раз ввести команду sudo apt install, а затем через пробел в данную строку добавлять сколько угодно программ, главное чтобы они были правильно составлены. Если какая-то программа состоит из нескольких слов, её команда должна быть монолитной, т.е. все слова в ней должны вводится через чёрточку, например: unity-tweak-tool:

sudo apt install my-weather-indicator telegram skype lm-sensors hddtemp psensor gdebi systemback unity-tweak-tool ubuntu-cleaner gradio -y

Установка дополнительных кодеков

# Мультимедиа и кодеки

sudo apt install ubuntu-restricted-extras -y

Отключение о сбоях в системе

# Отключить отчёты о сбоях в системе

sudo sed -i "s/enabled=1/enabled=0/g" '/etc/default/apport'

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

Необходимо сохранить его (нажать кнопку Сохранить) и дать Имя с расширением .sh. Я назвал его Настройка\ Ubuntu.sh (вы можете назвать по-другому, но обязвтельно с расширением .sh):

Делаем созданный скрипт исполняемым:

sudo chmod +x Настройка\ Ubuntu.sh

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

Примечание. Обратный слэш в команде Настройка\ Ubuntu.sh экранирует пробел в названии файла для терминала между двумя отдельными словами.

После того как скрипт будет выполнен, хранить его на будущее, для возможной переустановки системы и повторной настройки, лучше всего на отдельном разделе ж/диска в папке /home. Если таковой нет, то в облачном сервисе (Облачное хранилище данных) типа: DropBox, Облако Mail.Ru, Mega.co и т.п., чтобы в любой момент воспользоваться скриптом самому, либо помочь знакомым или родственникам в настройке системы.

Удачи.

compizomania.blogspot.com

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

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

Введение

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

break выход из цикла for, while или until continue выполнение следующей итерации цикла for, while или until echo вывод аргументов, разделенных пробелами, на стандартное устройство вывода exit выход из оболочки export отмечает аргументы как переменные для передачи в дочерние процессы в среде hash запоминает полные имена путей команд, указанных в качестве аргументов, чтобы не искать их при следующем обращении kill посылает сигнал завершения процессу pwd выводит текущий рабочий каталог read читает строку из ввода оболочки и использует ее для присвоения значений указанным переменным.\ return заставляет функцию оболочки выйти с указанным значением shift перемещает позиционные параметры налево test вычисляет условное выражение times выводит имя пользователя и системное время, использованное оболочкой и ее потомками trap указывает команды, которые должны выполняться при получении оболочкой сигнала unset вызывает уничтожение переменных оболочки wait ждет выхода из дочернего процесса и сообщает выходное состояние. И конечно же кроме встроенных команд мы будем использовать целую кучу внешних, отдельных команд-программ, с которыми мы познакомимся уже в процессе

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

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

#!/bin/bash в этой строке после #! указывается путь к bash-интерпретатору, поэтому если он у вас установлен в другом месте(где, вы можете узнать набрав whereis bash) поменяйте её на ваш путь. 2. Коментарии начинаются с символа # (кроме первой строки). 3. В bash переменные не имеют типа(о них речь пойдет ниже)

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

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

#!/bin/bash #указываем где у нас хранится bash-интерпретатор parametr1=$1 #присваиваем переменной parametr1 значение первого параметра скрипта script_name=$0 #присваиваем переменной script_name значение имени скрипта echo "Вы запустили скрипт с именем $script_name и параметром $parametr1" # команда echo выводит определенную строку, обращение к переменным осуществляется через $имя_переменной. echo 'Вы запустили скрипт с именем $script_name и параметром $parametr1' # здесь мы видим другие кавычки, разница в том, что в одинарных кавычках не происходит подстановки переменных. exit 0 #Выход с кодом 0 (удачное завершение работы скрипта)

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

ite@ite-desktop:~$ ./test.sh qwerty Вы запустили скрипт с именем ./test.sh и параметром qwerty Вы запустили скрипт с именем $script_name и параметром $parametr1

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

$DIRSTACK - содержимое вершины стека каталогов $EDITOR - текстовый редактор по умолчанию $EUID - Эффективный UID. Если вы использовали программу su для выполнения команд от другого пользователя, то эта переменная содержит UID этого пользователя, в то время как... $UID - ...содержит реальный идентификатор, который устанавливается только при логине. $FUNCNAME - имя текущей функции в скрипте. $GROUPS - массив групп к которым принадлежит текущий пользователь $HOME - домашний каталог пользователя $HOSTNAME - ваш hostname $HOSTTYPE - архитектура машины. $LC_CTYPE - внутренняя переменная, котороя определяет кодировку символов $OLDPWD - прежний рабочий каталог $OSTYPE - тип ОС $PATH - путь поиска программ $PPID - идентификатор родительского процесса $SECONDS - время работы скрипта(в сек.) $# - общее количество параметров переданных скрипту $* - все аргументы переданыне скрипту(выводятся в строку) $@ - тоже самое, что и предыдущий, но параметры выводятся в столбик $! - PID последнего запущенного в фоне процесса $$ - PID самого скрипта

Условия

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

if [[ "$source" -eq "$dest" ]] # в ковычках указываем имена переменных для сравнения. -eq - логическое сравнение обозначающие "равны" then # если они действительно равны, то echo "Применик $dest и источник $source один и тот же файл!" #выводим сообщение об ошибке, т.к. $source и $dest у нас равны exit 1 # выходим с ошибкой (1 - код ошибки) else # если же они не равны cp $source $dest # то выполняем команду cp: копируем источник в приемник echo "Удачное копирование!" fi #обозначаем окончание условия. Результат выполнения скрипта:ite@ite-desktop:~$ ./primer2.sh 1 1 Применик 1 и источник 1 один и тот же файл! ite@ite-desktop:~$ ./primer2.sh 1 2 Удачное копирование! Структура if-then-else используется следующим образом: if <команда или набор команд возвращающих код возврата(0 или 1)> then <если выражение после if истино, то выполняется этот блок> else <если выражение после if ложно, тот этот> В качестве команд возвращающих код возврата могут выступать структуры [[ , [ , test, (( )) или любая другая(или несколько) linux-команда. test - используется для логического сравнения. после выражения, неоьбходима закрывающая скобка "]" [ - синоним команды test [[ - расширенная версия "[" (начиная с версии 2.02)(как в примере), внутри которой могут быть использованы || (или), & (и). Долна иметь закрывающуб скобку "]]" (( )) - математическое сравнение. для построения многоярусных условий вида:if ... then .... else if .... then.... else .... для краткости и читаемости кода, можно использовать структуру:if .. then ... elif ... then ... elif ...

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

Если необходимо сравнивать какоую-то одну переменную с большим количеством параметров, то целесообразней использовать оператор case.#!/bin/bash echo "Выберите редатор для запуска:" echo "1 Запуск программы nano" echo "2 Запуск программы vi" echo "3 Запуск программы emacs" echo "4 Выход" read doing #здесь мы читаем в переменную $doing со стандартного ввода

case $doing in 1) /usr/bin/nano # если $doing содержит 1, то запустить nano ;; 2) /usr/bin/vi # если $doing содержит 2, то запустить vi ;; 3) /usr/bin/emacs # если $doing содержит 3, то запустить emacs ;; 4) exit 0 ;; *) #если введено с клавиатуры то, что в case не описывается, выполнять следующее: echo "Введено неправильное действие"

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

Результат работы:ite@ite-desktop:~$ ./menu2.sh Выберите редатор для запуска: 1 Запуск программы nano 2 Запуск программы vi 3 Запуск программы emacs 4 Выход После выбор цифры и нажатия Enter запуститься тот редактор, который вы выбрали(если конечно все пути указаны правильно, и у вас установлены эти редакторы :) ) Прведу список логических операторв, которые используются для конструкции if-then-else-fi:-z # строка пуста -n # строка не пуста =, (==) # строки равны != # строки неравны -eq # равно -ne # неравно -lt,(< ) # меньше -le,(<=) # меньше или равно -gt,(>) #больше -ge,(>=) #больше или равно ! #отрицание логического выражения -a,(&&) #логическое «И» -o,(||) # логическое «ИЛИ» С основами языка и условиями мы разобрались, чтобы не перегружать статью, разобью её на несколько частей(допустим на 3). Во второй части разберем операторы цикла и выполнение математических операций.

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

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

habr.com

Пишем скрипты на Bash - Как стать программистом

Каждый Bash-скрипт стоит начинать со следующих строк:

#!/bin/bash set -o nounset set -o errexit

Это защищает от двух частых ошибок1) Попыток использовать не объявленные переменные2) Игнорирование аварийного завершения командЕсли команда может завершиться аварийно, и нас это устраивает, можно использовать следующий код:

if ! <possible failing command> ; then echo "failure ignored" fi

Нужно помнить что некоторые команды не возвращают код аварийного завершения например “mkdir -p” и “rm -f”.Так же есть сложности с вызовом цепочек подпрограмм (command1 | command 2 | command3) из скрипта, для обхода этого ограничения можно использовать следующую конструкцию:

(./failing_command && echo A)

В этом случае оператор ‘&&’ не позволит выполниться следующей команде, подробнее — ‘http://fvue.nl/wiki/Bash:_Error_handling’

Функции

Bash позволяет использовать функции как обычные команды, это очень сильно повышает читаемость вашего кода:Пример 1:

ExtractBashComments() { egrep "^#" } cat myscript.sh | ExtractBashComments | wc

comments=$(ExtractBashComments < myscript.sh)

Пример 2:

SumLines() { # iterating over stdin - similar to awk local sum=0 local line=”” while read line ; do sum=$((${sum} + ${line})) done echo ${sum} } SumLines < data_one_number_per_line.txt

Пример 3:

log() { # classic logger local prefix="[$(date +%Y/%m/%d\ %H:%M:%S)]: " echo "${prefix} $@" >&2 } log "INFO" "a message"

Попробуйте перенести весь ваш код в функции оставив только глобальные переменные/константы и вызов функции «main» в которой будет вся высокоуровневая логика.

Объявление переменных

Bash позволяет объявлять переменные нескольких типов, самые важные:local (Для переменных используемых только внутри функций)readonly (Переменные попытка переназначения которых вызывает ошибку)

## Если DEFAULT_VAL уже объявлена, то использовать ее значение, иначе использовать '-7' readonly DEFAULT_VAL=${DEFAULT_VAL:-7} myfunc() { # Использование локальной переменной со значением глобальной local some_var=${DEFAULT_VAL} ... }

Есть возможность сделать переменную типа readonly из уже объявленной:

x=5 x=6 readonly x x=7 # failure

Стремитесь к тому что бы все ваши переменные были либо local, либо readonly, это улучшит читаемость и снизит количество ошибок.

Используйте $() вместо обратных кавычек «

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

# обе команды выводят: A-B-C-D echo "A-`echo B-\`echo C-\\\`echo D\\\`\``" echo "A-$(echo B-$(echo C-$(echo D)))"

Используйте двойные квадратные скобки [[]] вместо одинарных []

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

$ [ a < b ] -bash: b: No such file or directory $ [[ a < b ]]

В некоторых случаях упрощают синтаксис:

[ "${name}" \> "a" -o ${name} \< "m" ] [[ "${name}" > "a" && "${name}" < "m" ]]

А так же предоставляют дополнительную функциональность:

Новые операторы:

|| Логическое ИЛИ (logical or) — только с двойными скобками.
&& Логическое И (logical and) — только с двойными скобками.
< Сравнение строковых переменных (string comparison) — с двойными скобками экранирование не нужно.
== Сравнение строковых переменных с подстановкой (string matching with globbing) — только с двойными скобками.
=~ Сравнение строковых переменных используя регулярные выражения (string matching with regular expressions) — только с двойными скобками.

Дополненные/измененные операторы:

-lt Цифровое сравнение (numerical comparison)
-n Строковая переменная не пуста (string is non-empty)
-z Строковая переменная пуста (string is empty)
-eq Цифровое равенство (numerical equality)
-ne Цифровое не равенство (numerical inequality)

Примеры:

t="abc123" [[ "$t" == abc* ]] # true (globbing) [[ "$t" == "abc*" ]] # false (literal matching) [[ "$t" =~ [abc]+[123]+ ]] # true (regular expression) [[ "$t" =~ "abc*" ]] # false (literal matching)

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

r="a b+" [[ "a bbb" =~ $r ]] # true

Сравнене строковых переменных с подстановкой так же доступно в операторе case:

case $t in abc*) <action> ;; esac

Работа со строковыми переменными:

В bash встроено несколько (недооцененных) возможностей работы со строковыми переменными:Базовые:

f="path2/path3/file.ext" len="${#f}" # = 20 (длина строковой переменной) # выделение участка из переменной: ${<переменная>:<начало_участка>} или ${<переменная>:<начало_участка>:<размер_участка>} slice1="${f:6}" # = "path3/file.ext" slice2="${f:6:5}" # = "path3" slice3="${f: -8}" # = "file.ext" (обратите внимание на пробел перед знаком '-') pos=6 len=5 slice4="${f:${pos}:${len}}" # = "path3"

Замена с подстановкой:

f="path2/path3/file.ext" single_subst="${f/path?/x}" # = "x/path3/file.ext" (змена первого совпадения) global_subst="${f//path?/x}" # = "x/x/file.ext" (замена всех совпадений)

Разделение переменных:

f="path2/path3/file.ext" readonly DIR_SEP="/" array=(${f//${DIR_SEP}/ }) second_dir="${array[1]}" # = path3

Удаление с подстановкой:# Удаление с начала строки, до первого совпадения

f="path2/path3/file.ext" extension="${f#*.}" # = "ext"

# Удаление с начала строки, до последнего совпадения

f="path2/path3/file.ext" filename="${f##*/}" # = "file.ext"

# Удаление с конца строки, до первого совпадения

f="path2/path3/file.ext" dirname="${f%/*}" # = "path2/path3"

# Удаление с конца строки, до последнего совпадения

f="path2/path3/file.ext" root="${f%%/*}" # = "path2"

Избавляемся от временных файлов

Некоторые команды ожидают на вход имя файла, с ними нам поможет оператор ‘<()’, он принимает на вход команду и преобразует в нечто что можно использовать как имя файла:# скачать два URLa и передать их в diff

diff <(wget -O - url1) <(wget -O - url2)

Использование маркера для передачи многострочных переменных:# MARKER — любое слово.

command << MARKER ... ${var} $(cmd) ... MARKER

Если нужно избежать подстановки, то маркер можно взять в кавычки:# конструкция вернет ‘$var’ а не значение переменной

var="text" cat << 'MARKER' ... $var ... MARKER

Встроенные переменные

$0 Имя скрипта (name of the script)
$1 $2… $n Параметры переданные скрипту/фнукции (positional parameters to script/function)
$$ PID скрипта (PID of the script)
$! PID последней команды выполненной в фоне(PID of the last command executed (and run in the background))
$? Статус возвращенный последней командой (exit status of the last command (${PIPESTATUS} for pipelined commands))
$# Количество параметров переданных скрипту/функции (number of parameters to script/function)
$@ Все параметры переданные скрипту/функции, представленные в виде слов (sees arguments as separate word)
$* Все параметры переданные скрипту/функции, представленные в виде одного слова (sees arguments as single word)
Как правило:
$* Редко является полезной
$@ Корректно обрабатывает пустые параметры и параметры с пробелами
$@ При использовании обычно заключается в двойные кавычки — «$@»

Пример:

for i in "$@"; do echo '$@ param:' $i; done for i in "$*"; do echo '$! param:' $i; done

вывод:

bash ./parameters.sh arg1 arg2 $@ param: arg1 $@ param: arg2 $! param: arg1 arg2

Отладка

Проверка синтаксиса (экономит время если скрипт выполняется дольше 15 секунд):

bash -n myscript.sh

Трассировка:

bash -v myscripts.sh

Трассировка с раскрытием сложных команд:

bash -x myscript.sh

Параметры -v и -x можно задать в коде, это может быть полезно если ваш скрипт работает на одной машине а журналирование ведется на другой:

set -o verbose set -o xtrace

Признаки того, что вы не должны использовать shell скрипты:

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

Если ваш проект соответствует пунктам из этого списка, рассмотрите для него языки языки Python или Ruby.Ссылки:Advanced Bash-Scripting Guide: tldp.org/LDP/abs/html/Bash Reference Manual: www.gnu.org/software/bash/manual/bashref.htmlОригинал статьи: robertmuth.blogspot.ru/2012/08/better-bash-scripting-in-15-minutes.html

itman.in