Bash образцы простых скриптов

Array.sh

#!/bin/bash
r=1
 
for r in {0..31}
do
        array[$r]="fuck"
        echo $r
        let r=$r+1
done
 
for a in "${array[@]}"; do
        echo "$a ${n}"
        let a=$a+1
done
 

backup.sh

#!/bin/bash
find . -mtime -1 -type f -exec tar rvf "$archive.tar" '{}' \;
# более универсальный вариант, хотя и более медленный,
# зато может использоваться в других версиях UNIX.
exit 0

backup1.sh

#!/bin/bash
find . -mtime -1 -type f -print0 | xargs -0 tar rvf "$archive.tar"
exit 0

backup2.sh

#!/bin/bash
 
# Резервное архивирование (backup) всех файлов в текущем каталоге,
# которые были изменены в течение последних 24 часов
#+ в тарболл (tarball) (.tar.gz - файл).
 
BACKUPFILE=backup
archive=${1:-$BACKUPFILE}
#  На случай, если имя архива в командной строке не задано,
#+ т.е. по-умолчанию имя архива -- "backup.tar.gz"
 
tar cvf - `find . -mtime -1 -type f -print` > $archive.tar
gzip $archive.tar
echo "Каталог $PWD заархивирован в файл \"$archive.tar.gz\"."
 
 
#  Stephane Chazelas заметил, что вышеприведенный код будет "падать"
#+ если будет найдено слишком много файлов
#+ или если имена файлов будут содержать символы пробела.
 
# Им предложен альтернативный код:
# -------------------------------------------------------------------
#   find . -mtime -1 -type f -print0 | xargs -0 tar rvf "$archive.tar"
#      используется версия GNU утилиты "find".
 
 
#   find . -mtime -1 -type f -exec tar rvf "$archive.tar" '{}' \;
#         более универсальный вариант, хотя и более медленный,
#         зато может использоваться в других версиях UNIX.
# -------------------------------------------------------------------
 
 
exit 0

Emu_cpu.sh

#!/bin/bash
 
# Инициализация регистров:
for r in {0..7}
do
	REG[$r]=0
	let r=$r+1
done
# REG[0] питание
#Включаем питание:
REG[0]=1
 
# Инициализация ОЗУ, 32 байт
for t in {0..32}
do
	RAM[$t]=0
	let t=$t+1
done
 
# Запуск
clear
echo -n "mk51"
for x in {0..5}
do
	sleep 1
	echo -n "."
done
 
echo 
 
# Основной цикл
while [ "${REG[0]}"=1 ]
do
	echo -n ">"
	read comm
	RAM[0]=$comm
done
#for a in "${RAM[@]}"; do
#	echo "$a ${n}"
#	let a=$a+1
#done

monitor.sh

#!/bin/bash
 
filename=sys.log
 
cat /dev/null > $filename; echo "Создание / очистка временного файла."
#  Если файл отсутствует, то он создается,
#+ и очищается, если существует.
#  : > filename   и   > filename дают тот же эффект.
 
tail /var/log/messages > $filename
# Файл /var/log/messages должен быть доступен для чтения.
 
echo "В файл $filename записаны последние строки из /var/log/messages."
 
exit 0

tree.sh

#!/bin/bash
 
(cd /source/directory && tar cf - . ) | (cd /dest/directory && tar xpvf -)
# Перемещение полного дерева файлов и подкаталогов из одной директории в другую
# [спасибо Алану Коксу (Alan Cox) <a.cox@swansea.ac.uk>, за небольшие поправки]
 
# 1) cd /source/directory    Переход в исходный каталог, содержимое которого будет перемещено
# 2) &&                     "И-список": благодаря этому все последующие команды будут выполнены
#                            только тогда, когда 'cd' завершится успешно
# 3) tar cf - .              ключом 'c' архиватор 'tar' создает новый архив,
#                            ключом 'f' (file) и последующим '-' задается файл архива -- stdout,
#                            в архив помещается текущий каталог ('.') с вложенными подкаталогами.
# 4) |                       конвейер с ...
# 5) ( ... )                 subshell-ом (дочерним экземпляром командной оболочки)
# 6) cd /dest/directory      Переход в каталог назначения.
# 7) &&                     "И-список", см. выше
# 8) tar xpvf -              Разархивирование ('x'), с сохранением атрибутов "владельца" и прав доступа ('p') к файлам,
#                            с выдачей более подробных сообщений на stdout ('v'),
#                            файл архива -- stdin ('f' с последующим '-').
#
#                            Примечательно, что 'x' -- это команда, а 'p', 'v' и 'f' -- ключи
# Во как!
 
 
 
# Более элегантный вариант:
#   cd source-directory
#   tar cf - . | (cd ../target-directory; tar xzf -)
#
# cp -a /source/directory /dest     имеет тот же эффект.

whois.sh

#!/bin/bash
 
# Команда 'whois domain-name' выясняет имя домена на одном из 3 серверов:
#                    ripe.net, cw.net, radb.net
 
# Разместите этот скрипт под именем 'wh' в каталоге /usr/local/bin
 
# Требуемые символические ссылки:
# ln -s /usr/local/bin/wh /usr/local/bin/wh-ripe
# ln -s /usr/local/bin/wh /usr/local/bin/wh-cw
# ln -s /usr/local/bin/wh /usr/local/bin/wh-radb
 
 
if [ -z "$1" ]
then
  echo "Порядок использования: `basename $0` [domain-name]"
  exit 65
fi
 
case `basename $0` in
# Проверка имени скрипта и, соответственно, имени сервера
    "wh"     ) whois $1@whois.ripe.net;;
    "wh-ripe") whois $1@whois.ripe.net;;
    "wh-radb") whois $1@whois.radb.net;;
    "wh-cw"  ) whois $1@whois.cw.net;;
    *        ) echo "Порядок использования: `basename $0` [domain-name]";;
esac
 
exit 0

Аналог pwd.sh

#!/bin/bash
 
E_WRONG_DIRECTORY=73
 
clear # Очистка экрана.
 
TargetDirectory=/home/bozo/projects/GreatAmericanNovel
 
cd $TargetDirectory
echo "Удаление файлов в каталоге $TargetDirectory."
 
if [ "$PWD" != "$TargetDirectory" ]
then    # Защита от случайного удаления файлов не в том каталоге.
  echo "Неверный каталог!"
  echo "Переменная $PWD указывает на другой каталог!"
  exit $E_WRONG_DIRECTORY
fi
 
rm -rf *
rm .[A-Za-z0-9]*    # удалить "скрытые" файлы (начинающиеся с ".")
# rm -f .[^.]* ..?*   удалить файлы, чьи имена начинаются с нескольких точек.
# (shopt -s dotglob; rm -f *)   тоже работает верно.
 
# Имена файлов могут содержать любые символы из диапазона 0-255, за исключением "/".
# Оставляю вопрос удаления файлов с "необычными" символами для самостоятельного изучения.
 
# Здесь можно вставить дополнительные действия, по мере необходимости.
 
echo
echo "Конец."
echo "Файлы, из каталога $TargetDirectory, удалены."
echo
 
 
exit 0

Архиватор.sh

#!/bin/bash
if [ -f cfg_arh ] 				# проверяем наличие конфига 
	then
		true
	else
		echo "Файл конфигурации не найден!!!"
		exit 1
fi
. cfg_arh 					# грузим конфиг
ar_name="$(date +%Y-%m-%d) backup" 		# префикс имени архива
cd $folder_in
echo $(date) " архивация начата">>"$folder_log" # архивируем все файлы в каталоге
for i in *
	do
	tar -cvzf "$folder_out/$ar_name $i.tar.gz" $i &>/dev/null
	echo "файл $i обработан">>"$folder_log"
done
echo $(date)" архивация закончена">>"$folder_log"
echo "------------------------------------------">>"$folder_log"

Генератор.sh

#!/bin/bash
 
# $RANDOM возвращает различные случайные числа при каждом обращении к ней.
# Диапазон изменения: 0 - 32767 (16-битовое целое со знаком).
 
MAXCOUNT=10
count=1
 
echo
echo "$MAXCOUNT случайных чисел:"
echo "-----------------"
while [ "$count" -le $MAXCOUNT ]      # Генерация 10 ($MAXCOUNT) случайных чисел.
do
  number=$RANDOM
  echo $number
  let "count += 1"  # Нарастить счетчик.
done
echo "-----------------"
 
# Если вам нужны случайные числа не превышающие определенного числа,
# воспользуйтесь оператором деления по модулю (остаток от деления).
 
RANGE=500
 
echo
 
number=$RANDOM
let "number %= $RANGE"
echo "Случайное число меньше $RANGE  ---  $number"
 
echo
 
# Если вы желаете ограничить диапазон "снизу",
# то просто производите генерацию псевдослучайных чисел в цикле до тех пор,
# пока не получите число большее нижней границы.
 
FLOOR=200
 
number=0   # инициализация
while [ "$number" -le $FLOOR ]
do
  number=$RANDOM
done
echo "Случайное число, большее $FLOOR ---  $number"
echo
 
 
# Эти два способа могут быть скомбинированы.
number=0   #initialize
while [ "$number" -le $FLOOR ]
do
  number=$RANDOM
  let "number %= $RANGE"  # Ограничение "сверху" числом $RANGE.
done
echo "Случайное число в диапазоне от $FLOOR до $RANGE ---  $number"
echo
 
 
# Генерация случайных "true" и "false" значений.
BINARY=2
number=$RANDOM
T=1
 
let "number %= $BINARY"
# let "number >>= 14"    дает более равномерное распределение
# (сдвиг вправо смещает старший бит на нулевую позицию, остальные биты обнуляются).
if [ "$number" -eq $T ]
then
  echo "TRUE"
else
  echo "FALSE"
fi
 
echo
 
 
# Можно имитировать бросание 2-х игровых кубиков.
SPOTS=7   # остаток от деления на 7 дает диапазон 0 - 6.
ZERO=0
die1=0
die2=0
 
# Кубики "выбрасываются" раздельно.
 
  while [ "$die1" -eq $ZERO ]     # Пока на "кубике" ноль.
  do
    let "die1 = $RANDOM % $SPOTS" # Имитировать бросок первого кубика.
  done
 
  while [ "$die2" -eq $ZERO ]
  do
    let "die2 = $RANDOM % $SPOTS" # Имитировать бросок второго кубика.
  done
 
let "throw = $die1 + $die2"
echo "Результат броска кубиков = $throw"
echo
 
 
exit 0

Запись логов.sh

$!/bin/bash
LOG=$0.log
COMMAND1="sleep 100"
echo "Запись в лог всех PID фоновых процессов, запущенных из сценария: $0" >> "$LOG"
# Таким образом возможен мониторинг и удаление процессов по мере необходимости.
echo >> "$LOG"
# Команды записи в лог.
echo -n "PID of \"$COMMAND1\": " >> "$LOG"
${COMMAND1} &
echo $! >> "$LOG"
# PID процесса "sleep 100": 1506
exit 0

Поиск и замена.sh

#!/bin/bash
 
v0=abc1234zip1234abc    # Начальное значение переменной.
echo "v0 = $v0"         # abc1234zip1234abc
echo
 
# Поиск совпадения с начала строки.
v1=${v0/#abc/ABCDEF}    # abc1234zip1234abc
                        # |-|
echo "v1 = $v1"         # ABCDE1234zip1234abc
                        # |---|
 
# Поиск совпадения с конца строки.
v2=${v0/%abc/ABCDEF}    # abc1234zip123abc
                        #              |-|
echo "v2 = $v2"         # abc1234zip1234ABCDEF
                        #               |----|
 
echo
 
#  ----------------------------------------------------
#  Если совпадение находится не с начала/конца строки,
#+ то замена не производится.
#  ----------------------------------------------------
v3=${v0/#123/000}       # Совпадение есть, но не в начале строки.
echo "v3 = $v3"         # abc1234zip1234abc
                        # ЗАМЕНА НЕ ПРОИЗВОДТСЯ!
v4=${v0/%123/000}       # Совпадение есть, но не в конце строки.
echo "v4 = $v4"         # abc1234zip1234abc
                        # ЗАМЕНА НЕ ПРОИЗВОДТСЯ!
 
exit 0

Просмотр gs.sh

#!/bin/bash
 
#Просмотр gz-файлов с помощью утилиты 'most'
 
NOARGS=65
NOTFOUND=66
NOTGZIP=67
 
if [ $# -eq 0 ] # то же, что и:  if [ -z "$1" ]
# $1 должен существовать, но может быть пустым:  zmost "" arg2 arg3
then
  echo "Порядок использования: `basename $0` filename" >&2
  # Сообщение об ошибке на stderr.
  exit $NOARGS
  # Код возврата 65 (код ошибки).
fi
 
filename=$1
 
if [ ! -f "$filename" ]   # Кавычки необходимы на тот случай, если имя файла содержит пробелы.
then
  echo "Файл $filename не найден!" >&2
  # Сообщение об ошибке на stderr.
  exit $NOTFOUND
fi
 
if [ ${filename##*.} != "gz" ]
# Квадратные скобки нужны для выполнения подстановки значения переменной
then
  echo "Файл $1 не является gz-файлом!"
  exit $NOTGZIP
fi
 
zcat $1 | most
 
# Используется утилита 'most' (очень похожа на 'less').
# Последние версии 'most' могут просматривать сжатые файлы.
# Можно вставить 'more' или 'less', если пожелаете.
 
 
exit $?   # Сценарий возвращает код возврата, полученный по конвейеру.
# На самом деле команда "exit $?" не является обязательной,
# так как работа скрипта завершится здесь в любом случае,

Время работы сценария.sh

#!/bin/bash
 
TIME_LIMIT=10
INTERVAL=1
 
echo
echo "Для прерывания работы сценария, ранее чем через $TIME_LIMIT секунд, нажмите Control-C."
echo
 
while [ "$SECONDS" -le "$TIME_LIMIT" ]
do
  let "last_two_sym = $SECONDS - $SECONDS / 100 * 100" # десятки и единицы
  if [ "$last_two_sym" -ge 11 -a "$last_two_sym" -le 19 ]
  then
    units="секунд"               # для чисел, которые заканчиваются на "...надцать"
  else
    let "last_sym = $last_two_sym - $last_two_sym / 10 * 10"  # единицы
    case "$last_sym" in
      "1" )
        units="секунду"         # для чисел, заканчивающихся на 1
      ;;
      "2" | "3" | "4" )
        units="секунды"         # для чисел, заканчивающихся на 2, 3 и 4
      ;;
      * )
        units="секунд"          # для всех остальных (0, 5, 6, 7, 8, 9)
      ;;
    esac
  fi
 
  echo "Сценарий отработал $SECONDS $units."
  #  В случае перегруженности системы, скрипт может перескакивать через отдельные
  #+  значения счетчика
  sleep $INTERVAL
done
 
echo -e "\a"  # Сигнал!
 
exit 0

Длина переменной.sh

#!/bin/bash
 
E_NO_ARGS=65
 
if [ $# -eq 0 ]  # Для работы скрипта необходим хотя бы один входной параметр.
then
  echo "Вызовите сценарий с одним или более параметром командной строки."
  exit $E_NO_ARGS
fi
 
var01=abcdEFGH28ij
 
echo "var01 = ${var01}"
echo "Length of var01 = ${#var01}"
 
echo "Количество входных параметров = ${#@}"
echo "Количество входных параметров = ${#*}"
 
exit 0

Косвенные ссылки.sh

#!/bin/bash
# Косвенные ссылки на переменные.
 
a=letter_of_alphabet
letter_of_alphabet=z
 
echo
 
# Прямое обращение к переменной.
echo "a = $a"
 
# Косвенное обращение к переменной.
eval a=\$$a
echo "А теперь a = $a"
 
echo
 
 
# Теперь попробуем изменить переменную, на которую делается ссылка.
 
t=table_cell_3
table_cell_3=24
echo "\"table_cell_3\" = $table_cell_3"
echo -n "разыменование (получение ссылки) \"t\" = "; eval echo \$$t
# В данном, простом, случае,
#   eval t=\$$t; echo "\"t\" = $t"
# дает тот же результат (почему?).
 
echo
 
t=table_cell_3
NEW_VAL=387
table_cell_3=$NEW_VAL
echo "Значение переменной \"table_cell_3\" изменено на $NEW_VAL."
echo "Теперь \"table_cell_3\" = $table_cell_3"
echo -n "разыменование (получение ссылки) \"t\" = "; eval echo \$$t
# инструкция "eval" принимает два аргумента "echo" и "\$$t" (назначает равным $table_cell_3)
echo
 
exit 0

Передача ссылок в awk.sh

#!/bin/bash
 
# Другая версия сценария "column totaler"
# который суммирует заданную колонку (чисел) в заданном файле.
# Здесь используются косвенные ссылки.
 
ARGS=2
E_WRONGARGS=65
 
if [ $# -ne "$ARGS" ] # Проверка количества входных аргументов.
then
   echo "Порядок использования: `basename $0` filename column-number"
   exit $E_WRONGARGS
fi
 
filename=$1
column_number=$2
 
#===== До этой строки идентично первоначальному варианту сценария =====#
 
 
# Мнгострочные скрипты awk вызываются конструкцией   awk ' ..... '
 
 
# Начало awk-сценария.
# ------------------------------------------------
awk "

{ total += \$${column_number} # косвенная ссылка
}
END {
     print total
     }

     " "$filename"
# ------------------------------------------------
# Конец awk-сценария.
 
 
exit 0

Подстановка параметров.sh

#!/bin/bash
# usage-message.sh
 
: ${1?"Порядок использования: $0 ARGUMENT"}
#  Сценарий завершит свою работу здесь, если входные аргументы отсутствуют,
#+ со следующим сообщением.
#    usage-message.sh: 1: Порядок использования: usage-message.sh ARGUMENT
 
echo "Эти две строки появятся, только когда задан аргумент в командной строке."
echo "Входной аргумент командной строки = \"$1\""
 
exit 0 # Точка выхода находится здесь, только когда задан аргумент командной строки.
 
# Проверьте код возврата в обеих случаях, с и без аргумента командной строки.
# Если аргумент задан, то код возврата будет равен 0.
# Иначе -- 1.

Поиск по шаблону.sh

#!/bin/bash
#Поиск по шаблону всех, ранее объявленных переменных, имена которых начинаются с varprefix.
 
xyz23=whatever
xyz24=
 
a=${!xyz*}      # Подстановка имен объявленных переменных, которые начинаются с "xyz".
echo "a = $a"   # a = xyz23 xyz24
a=${!xyz@}      # То же самое.
echo "a = $a"   # a = xyz23 xyz24
exit 0

Поиск по шаблону2.sh

#!/bin/bash
 
var1=abcd-1234-defg
echo "var1 = $var1"
 
t=${var1#*-*}
echo "var1 (все, от начала строки по первый символ \"-\", включительно, удаляется) = $t"
#  t=${var1#*-}  то же самое,
#+ поскольку оператор # ищет кратчайшее совпадение,
#+ а * соответствует любым предшествующим символам, включая пустую строку.
 
t=${var1##*-*}
echo "Если var1 содержит \"-\", то возвращается пустая строка...   var1 = $t"
 
 
t=${var1%*-*}
echo "var1 (все, начиная с последнего \"-\" удаляется) = $t"
 
echo
 
# -------------------------------------------
path_name=/home/bozo/ideas/thoughts.for.today
# -------------------------------------------
echo "path_name = $path_name"
t=${path_name##/*/}
echo "Из path_name удален путь к файлу = $t"
#  В данном случае, тот же эффект можно получить так:  t=`basename $path_name`
#  t=${path_name%/}; t=${t##*/}   более общее решение,
#+ но имеет некоторые ограничения.
#  Если $path_name заканчивается символом перевода строки, то `basename $path_name` не будет работать,
#+ но для данного случая вполне применимо.
 
t=${path_name%/*.*}
# Тот же эффект дает    t=`dirname $path_name`
echo "Из path_name удалено имя файла = $t"
# Этот вариант будет терпеть неудачу в случаях: "../", "/foo////", # "foo/", "/".
#  Удаление имени файла, особенно когда его нет,
#+ использование dirname имеет свои особенности.
 
echo
 
t=${path_name:11}
echo "Из $path_name удалены первые 11 символов = $t"
t=${path_name:11:5}
echo "Из $path_name удалены первые 11 символов, выводится 5 символов = $t"
 
echo
 
t=${path_name/bozo/clown}
echo "В $path_name подстрока \"bozo\" заменена на \"clown\" = $t"
t=${path_name/today/}
echo "В $path_name подстрока \"today\" удалена = $t"
t=${path_name//o/O}
echo "В $path_name все символы \"o\" переведены в верхний регистр, = $t"
t=${path_name//o/}
echo "Из $path_name удалены все символы \"o\" = $t"
 
exit 0

Поиск по шаблону3.sh

#!/bin/bash
# Поиск по шаблону в операциях подстановки параметров # ## % %%.
 
var1=abcd12345abc6789
pattern1=a*c  # * (символ шаблона), означает любые символы между a и c.
 
echo
echo "var1 = $var1"           # abcd12345abc6789
echo "var1 = ${var1}"         # abcd12345abc6789   (альтернативный вариант)
echo "Число символов в ${var1} = ${#var1}"
echo "pattern1 = $pattern1"   # a*c  (между 'a' и 'c' могут быть любые символы)
echo
 
 
echo '${var1#$pattern1}  =' "${var1#$pattern1}"    #         d12345abc6789
# Наименьшая подстрока, удаляются первые 3 символа  abcd12345abc6789
                                  ^^^^^^            |-|
echo '${var1##$pattern1} =' "${var1##$pattern1}"   #                  6789
# Наибольшая подстрока, удаляются первые 12 символов abcd12345abc6789
#                                 ^^^^^^             |----------|
 
echo; echo
 
pattern2=b*9            # все, что между 'b' и '9'
echo "var1 = $var1"     # abcd12345abc6789
echo "pattern2 = $pattern2"
echo
 
echo '${var1%pattern2}  =' "${var1%$pattern2}"     #     abcd12345a
# Наименьшая подстрока, удаляются последние 6 символов  abcd12345abc6789
#                                 ^^^^^^^^^                       |----|
echo '${var1%%pattern2} =' "${var1%%$pattern2}"    #     a
# Наибольшая подстрока, удаляются последние 12 символов  abcd12345abc6789
#                                 ^^^^^^^^^               |-------------|
 
# Запомните, # и ## используются для поиска с начала строки,
#            % и %% используются для поиска с конца строки.
 
echo
 
exit 0

Преобразование.sh

#!/bin/bash
#  Преобразование всех файлов в заданном  каталоге,
#+ из графического формата MacPaint, в формат "pbm".
 
#  Используется утилита "macptopbm", входящая в состав пакета "netpbm",
#  Netpbm -- стандартный пакет для большинства дистрибутивов Linux.
 
OPERATION=macptopbm
SUFFIX=pbm          # Новое расширение файла.
 
if [ -n "$1" ]
then
  directory=$1      # Если каталог задан в командной строке при вызове сценария
else
  directory=$PWD    # Иначе просматривается текущий каталог.
fi
 
#  Все файлы в каталоге, имеющие расширение ".mac", считаются файлами
#+ формата  MacPaint.
 
for file in $directory/* # Подстановка имен файлов.
do
  filename=${file%.*c}   #  Удалить расширение ".mac" из имени файла
                         #+ ( с шаблоном '.*c' совпадают все подстроки
                         #+ начинающиеся с '.' и заканчивающиеся 'c',
  $OPERATION $file > "$filename.$SUFFIX"
                         # Преобразование с перенаправлением в файл с новым именем
  rm -f $file            # Удаление оригинального файла после преобразования.
  echo "$filename.$SUFFIX"  # Вывод на stdout.
done
 
exit 0

Проверка битых ссылок.sh

#!/bin/bash
 
#Сценарий поиска "битых" ссылок и их вывод в "окавыченном" виде
#таким образом они могут передаваться утилите xargs для дальнейшей обработки
#например. broken-link.sh /somedir /someotherdir|xargs rm
#Если скрипт не получает входных аргументов,
#то каталогом поиска является текущая директория
#В противном случае, каталог поиска задается из командной строки
[ $# -eq 0 ] && directorys=`pwd` || directorys=$@
 
#Функция linkchk проверяет каталог поиска
#на наличие в нем ссылок на несуществующие файлы, и выводит их имена.
#Если анализируемый файл является каталогом,
#то он передается функции linkcheck рекурсивно.
linkchk () {
    for element in $1/*; do
    [ -h "$element" -a ! -e "$element" ] && echo \"$element\"
    [ -d "$element" ] && linkchk $element
    # Само собой, '-h' проверяет символические ссылки, '-d' -- каталоги.
    done
}
 
#Вызов функции linkchk для каждого аргумента командной строки,
#если он является каталогом.  Иначе выводится сообщение об ошибке
#и информация о порядке пользования скриптом.
for directory in $directorys; do
    if [ -d $directory ]
        then linkchk $directory
        else
            echo "$directory не является каталогом"
            echo "Порядок использования: $0 dir1 dir2 ..."
    fi
done
 
exit 0

Смена расширений.sh

#!/bin/bash
 
#                 rfe
#                 ---
 
# Изменение расширений в именах файлов.
#
#         rfe old_extension new_extension
#
# Пример:
# Изменить все расширения *.gif в именах файлов на *.jpg, в текущем каталоге
#          rfe gif jpg
 
ARGS=2
E_BADARGS=65
 
if [ $# -ne "$ARGS" ]
then
  echo "Порядок использования: `basename $0` old_file_suffix new_file_suffix"
  exit $E_BADARGS
fi
 
for filename in *.$1
# Цикл прохода по списку имен файлов, имеющих расширение равное первому аргументу.
do
  mv $filename ${filename%$1}$2
  #  Удалить первое расширение и добавить второе,
done
 
exit 0