12.2. Более сложные команды | ABS Guide

Команды для более опытных пользователей

find

-exec COMMAND \;

Для каждого найденного файла, соответствующего заданному шаблону поиска, выполняет команду COMMAND. Командная строка должна завершаться последовательностью символов \; (здесь символ ";" экранирован обратным слэшем, чтобы информировать командную оболочку о том, что символ ";" должен быть передан команде find как обычный символ). Если COMMAND содержит {}, то find подставляет полное имя найденого файла вместо "{}".

bash$ find ~/ -name '*.txt'
/home/bozo/.kde/share/apps/karm/karmdata.txt
/home/bozo/misc/irmeyc.txt
/home/bozo/test-scripts/1.txt

find /home/bozo/projects -mtime 1
# Найти все файлы в каталоге /home/bozo/projects и вложенных подкаталогах,
#+ которые изменялись в течение последних суток.
#
# mtime = время последнего изменения файла
# ctime = время последнего изменения атрибутов файла (через 'chmod' или как-то иначе)
# atime = время последнего обращения к файлу

DIR=/home/bozo/junk_files
find "$DIR" -type f -atime +5 -exec rm {} \;
# Удалить все файлы в каталоге "/home/bozo/junk_files"
#+ к которым не было обращений в течение последних 5 дней.
#
# "-type filetype", где
# f = обычный файл
# d = каталог, и т.п.
# (Полный список ключей вы найдете в 'man find'.)

find /etc -exec grep '[0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*' {} \;

# Поиск всех IP-адресов (xxx.xxx.xxx.xxx) в файлах каталога /etc.
# Однако эта команда выводит не только IP-адреса, как этого избежать?

# Примерно так:

find /etc -type f -exec cat '{}' \; | tr -c '.[:digit:]' '\n' \
 | grep '^[^.][^.]*\.[^.][^.]*\.[^.][^.]*\.[^.][^.]*$'
# [:digit:] -- один из символьных классов
# введен в стандарт POSIX 1003.2.

# Спасибо S.C.

Не следует путать опцию -exec команды find с внутренней командой Bash -- exec.

Пример 12-3. Badname, удаление файлов в текущем каталоге, имена которых содержат недопустимые символы и пробелы.

#!/bin/bash

# Удаление файлов в текущем каталоге, чьи имена содержат недопустимые символы.

for filename in *
do
badname=`echo "$filename" | sed -n /[\+\{\;\"\\\=\?~\(\)\\>\&\*\|\$]/p`
# Недопустимые символы в именах файлов: + { ; " \ = ? ~ ( )  > & * | $
rm $badname 2>/dev/null # Сообщения об ошибках "выстреливаются" в никуда.
done

# Теперь "позаботимся" о файлах, чьи имена содержат пробельные символы.
find . -name "* *" -exec rm -f {} \;
# На место "{}", find подставит полное имя файла.
# Символ '\' указывает на то, что ';' интерпретируется как обычный символ, а не как конец команды.

exit 0

#---------------------------------------------------------------------
# Строки, приведенные ниже, не будут выполнены, т.к. выше стоит команда "exit".

# Альтернативный вариант сценария:
find . -name '*[+{;"\\=?~()>&*|$ ]*' -exec rm -f '{}' \;
exit 0
# (Спасибо S.C.)

Пример 12-4. Удаление файла по его номеру inode

#!/bin/bash
# idelete.sh: Удаление файла по номеру inode.

# Этот прием используется в тех случаях, когда имя файла начинается с недопустимого символа,
#+ например, ? или -.

ARGCOUNT=1 # Имя файла должно быть передано в сценарий.
E_WRONGARGS=70
E_FILE_NOT_EXIST=71
E_CHANGED_MIND=72

if [ $# -ne "$ARGCOUNT" ]
then
 echo "Порядок использования: `basename $0` filename"
 exit $E_WRONGARGS
fi

if [ ! -e "$1" ]
then
 echo "Файл \""$1"\" не найден."
 exit $E_FILE_NOT_EXIST
fi

inum=`ls -i | grep "$1" | awk '{print $1}'`
# inum = номер inode (index node) файла
# Каждый файл имеет свой inode, где хранится информация о физическом расположении файла.

echo; echo -n "Вы совершенно уверены в том, что желаете удалить \"$1\" (y/n)? "
# Ключ '-v' в команде 'rm' тоже заставит команду вывести подобный запрос.
read answer
case "$answer" in
[nN]) echo "Передумали?"
 exit $E_CHANGED_MIND
 ;;
*) echo "Удаление файла \"$1\".";;
esac
	 
find . -inum $inum -exec rm {} \;
echo "Файл "\"$1"\" удален!"
	 
exit 0

Дополнительные примеры по использованию команды find вы найдете в Пример 12-25, Пример 3-4 и Пример 10-9. В страницах справочного ркуоводства (man find) вы найдете более подробную информацию об этой достаточно сложной и мощной команде.

xargs

Команда передачи аргументов указанной команде. Она разбивает поток аргументов на отдельные составляющие и поочередно передает их заданной команде для обработки. Эта команда может рассматриваться как мощная замена обратным одиничным кавычкам. Зачастую, когда команды, заключенные в обратные одиночные кавычки, завершаются с ошибкой too many arguments (слишком много аргументов), использование xargs позволяет обойти это ограничение. Обычно, xargs считывает список аргументов со стандартного устройства ввода stdin или из канала (конвейера), но может считывать информацию и из файла.

Если команда не задана, то по-умолчанию выполняется echo. При передаче аргументов по конвейеру, xargs допускает наличие пробельных символов и символов перевода строки, которые затем автоматически отбрасываются.

bash$ ls -l
total 0
-rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 file1
-rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 file2

bash$ ls -l | xargs
total 0 -rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 file1 -rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 file2

ls | xargs -p -l gzip -- упакует с помощью gzip все файлы в текущем каталоге, выводя запрос на подтверждение для каждого файла.

xargs имеет очень любопытный ключ -n NN, который ограничивает количество передаваемых аргументов за один "присест" числом NN.

ls | xargs -n 8 echo -- выведет список файлов текущего каталога в 8 колонок.

Еще одна полезная опция -- -0, в комбинации с find -print0 или grep -lZ позволяет обрабатывать аргументы, содержащие пробелы и кавычки.

find / -type f -print0 | xargs -0 grep -liwZ GUI | xargs -0 rm -f

grep -rliwZ GUI / | xargs -0 rm -f

Обе вышеприведенные команды удалят все файлы, содержащие в своем имени комбинацию символов "GUI". (Спасибо S.C.)

Пример 12-5. Использование команды xargs для мониторинга системного журнала

#!/bin/bash

# Создание временного файла мониторинга в текщем каталоге,
# куда переписываются несколько последних строк из /var/log/messages.

# Обратите внимание: если сценарий запускается обычным пользователем,
# то файл /var/log/messages должен быть доступен на чтение этому пользователю.
# #root chmod 644 /var/log/messages

LINES=5

( date; uname -a ) >>logfile
# Время и информация о системе
echo --------------------------------------------------------------------- >>logfile
tail -$LINES /var/log/messages | xargs | fmt -s >>logfile
echo >>logfile
echo >>logfile

exit 0

# Упражнение:
# --------
# Измените сценарий таким образом, чтобы он мог отслеживать изменения в /var/log/messages
#+ с интервалом в 20 минут.
# Подсказка: воспользуйтесь командой "watch".

Пример 12-6. copydir, копирование файлов из текущего каталога в другое место.

#!/bin/bash

# Копирует все файлы из текущего каталога
# в каталог, указанный в командной строке.

if [ -z "$1" ] # Выход, если каталог назначения не задан.
then
 echo "Порядок использования: `basename $0` directory-to-copy-to"
 exit 65
fi

ls . | xargs -i -t cp ./{} $1
# Этот сценария является точным эквивалентом
# cp * $1
# если в именах файлов не содержатся пробельные символы.

exit 0

Пример 12-7. Завершение работы процесса по его имени

#!/bin/bash
# kill-byname.sh: Завершение работы процесса по его имени.
# Сравните этот сценарий с kill-process.sh.

# Пример,
#+ Попробуйте запустить команду "./kill-byname.sh xterm" --
#+ и понаблюдайте как закроются все окна xterm.

# Внимание:
# --------
# Этот сценарий может представлять определенную угрозу.
# Запуск этого сценария (особенно с правами root)
#+ может привести к потере несохраненных данных и другим неожиданным эффектам.

E_BADARGS=66

if test -z "$1" # Проверка -- задано ли имя процесса
then
 echo "Порядок использования: `basename $0` останавливаемый(ые)_процесс(ы)"
 exit $E_BADARGS
fi


# ---------------------------------------------------------
# Примечание:
# Ключ -i команды xargs -- это "замена строки" .
# Фигурные скобки -- это замещаемая строка.
# 2&>/dev/null -- подавляет вывод сообщений об ошибках.
# ---------------------------------------------------------
PROCESS_NAME="$1"
ps ax | grep "$PROCESS_NAME" | awk '{print $1}' | xargs -i kill {} 2&>/dev/null

exit $?

Пример 12-8. Подсчет частоты встречаемости слов using xargs

#!/bin/bash
# wf2.sh: Грубый подсчет частоты встречаемости слова в текстовом файле.
# Команда 'xargs' используется для выделения отдельных слов из строки.
# Сравните этот сценарий с "wf.sh".


# Проверка -- задано ли имя файла из командной строки.
ARGS=1
E_BADARGS=65
E_NOFILE=66

if [ $# -ne "$ARGS" ]
# Передано корректное число аргументов?
then
 echo "Порядок использования: `basename $0` имя_файла"
 exit $E_BADARGS
fi

if [ ! -f "$1" ] # Проверка наличия файла.
then
 echo "Файл \"$1\" не найден."
 exit $E_NOFILE
fi



#######################################################
cat "$1" | xargs -n1 | \
# Вывод содержимого файла, по одному слову в строке. 
tr A-Z a-z | \
# Преобразование в нижний регистр.
sed -e 's/\.//g' -e 's/\,//g' -e 's/ /\
/g' | \
# Отбросить точки и запятые и
#+ заменить пробелы символами перевода строки,
 sort | uniq -c | sort -nr
 # В заключение -- подсчитать и отсортировать по частоте встречаемости.
 #######################################################
 
 # Этот сценарий выполняет те же действия, что и "wf.sh",
 #+ но он более "тяжелый" и работает значительно медленнее.
 
 exit 0

expr

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

expr 3 + 5

возвратит 8

expr 5 % 3

возвратит 2

expr 5 \* 3

возвратит 15

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

y=`expr $y + 1`

Операция инкремента переменной, то же самое, что и let y=y+1, или y=$(($y+1)). Пример подстановки арифметических выражений.

z=`expr substr $string $position $length`

Извлекает подстроку длиной $length символов, начиная с позиции $position.

Пример 12-9. Пример работы с expr

#!/bin/bash

# Демонстрация некоторых приемов работы с командой 'expr'
# =======================================

echo

# Арифметические операции
# -------------- --------

echo "Арифметические операции"
echo
a=`expr 5 + 3`
echo "5 + 3 = $a"

a=`expr $a + 1`
echo
echo "a + 1 = $a"
echo "(инкремент переменной)"

a=`expr 5 % 3`
# остаток от деления (деление по модулю)
echo
echo "5 mod 3 = $a"

echo
echo

# Логические операции
# ---------- --------

# Возвращает 1 если выражение истинноо, 0 -- если ложно,
#+ в противоположность соглашениям, принятым в Bash.

echo "Логические операции"
echo

x=24
y=25
b=`expr $x = $y` # Сравнение.
echo "b = $b" # 0 ( $x -ne $y )
echo

a=3
b=`expr $a \> 10`
echo 'b=`expr $a \> 10`, поэтому...'
echo "Если a > 10, то b = 0 (ложь)"
echo "b = $b" # 0 ( 3 ! -gt 10 )
echo

b=`expr $a \ 10`
echo "Если a  10, то b = 1 (истина)"
echo "b = $b" # 1 ( 3 -lt 10 )
echo
# Обратите внимание на необходимость экранирования операторов.

b=`expr $a \= 3`
echo "Если a = 3, то b = 1 (истина)"
echo "b = $b" # 1 ( 3 -le 3 )
# Существует еще оператор "\>=" (больше или равно).


echo
echo

# Операции сравнения
# -------- ---------

echo "Операции сравнения"
echo
a=zipper
echo "a is $a"
if [ `expr $a = snap` ]
then
echo "a -- это не zipper"
fi
 
echo
echo
 
 
 
# Операции со строками
# -------- -- --------
 
echo "Операции со строками"
echo
 
a=1234zipper43231
echo "Строка над которой производятся операции: \"$a\"."
 
# length: длина строки
b=`expr length $a`
echo "длина строки \"$a\" равна $b."
 
# index: позиция первого символа подстроки в строке
b=`expr index $a 23`
echo "Позиция первого символа \"2\" в строке \"$a\" : \"$b\"."
 
# substr: извлечение подстроки, начиная с заданной позиции, указанной длины
b=`expr substr $a 2 6`
echo "Подстрока в строке \"$a\", начиная с позиции 2,\
и длиной в 6 символов: \"$b\"."
 
 
# При выполнении поиска по шаблону, по-умолчанию поиск
#+ начинается с ***начала*** строки.
#
# Использование регулярных выражений
b=`expr match "$a" '[0-9]*'` # Подсчет количества цифр.
echo Количество цифр с начала строки \"$a\" : $b.
b=`expr match "$a" '\([0-9]*\)'` # Обратите внимание на экранирование круглых скобок
# == ==
echo "Цифры, стоящие в начале строки \"$a\" : \"$b\"."
 
echo
 
exit 0

Вместо оператора match можно использовать оператор :. Например, команда b=`expr $a : [0-9]*` является точным эквивалентом для b=`expr match $a [0-9]*` в примере, рассмотренном выше.

#!/bin/bash

echo
echo "Операции над строками с использованием конструкции \"expr \$string : \" "
echo "========================================================================"
echo

a=1234zipper5FLIPPER43231

echo "Строка, над которой выполняются операции: \"`expr "$a" : '\(.*\)'`\"."
# Экранирование круглых скобок в шаблоне == ==


# Если скобки не экранировать...
#+ то 'expr' преобразует строковый операнд в целое число.

echo "Длина строки \"$a\" равна `expr "$a" : '.*'`." # Длина строки

echo "Количество цифр с начала строки \"$a\" равно `expr "$a" : '[0-9]*'`."

# ------------------------------------------------------------------------- #

echo

echo "Цифры, стоящие в начале строки \"$a\" : `expr "$a" : '\([0-9]*\)'`."
# == ==
echo "Первые 7 символов в строке \"$a\" : `expr "$a" : '\(.......\)'`."
# ====== == ==
# Опять же, необходимо экранировать круглые скобки в шаблоне.
#
echo "Последние 7 символов в строке \"$a\" : `expr "$a" : '.*\(.......\)'`."
# ========= оператор конца строки ^^
# (фактически означает переход через любое количество символов, пока
#+ не будет найдена требуемая подстрока)

echo

exit 0

Этот пример демонстрирует необходимость экранирования оператора группировки -- $ ... $ в регулярных выражениях, при поиске по шаблону командой expr.

Perl, sed и awk имеют в своем распоряжении более мощный аппарат анализа строк. Коротенький скрипт на sed или awk, внутри сценария (см. Section 33.2) -- значительно более привлекательная альтернатива использованию expr при анализе строк.

Дополнительные примеры, по обработке строк, вы найдете в Section 9.2.