Linux xargs command

Параллельный запуск процессов

Xargs часто используется для параллельного запуска нескольких процессов. Вот так, например, можно одновременно cжать несколько директорий в tar.gz:

$ echo dir1 dir2 dir3 | xargs -P 3 -I NAME tar czf NAME.tar.gz NAME

В приведенном примере используется ключ -P. Он указывает максимальное количество процессов, которые будут выполняться одновременно. Предположим, что у нас на входе имеется 10 аргументов. Если мы введём команду xargs с ключoм -P 3, то будет запущено 3 экземпляра команды, следующей после xargs, с каждым из этих аргументов.

С помощью xargs можно также параллельно загружать из Интернета множество файлов:

$ wget -nv <ссылка> | egrep -o "http://]*.jpg" | xargs -P 10 -n 1 wget -nv

В приведенном примере с указанного адреса будут скачаны все графические файлы с расширением jpg; ключ -P указывает, что требуется скачивать по 10 файлов одновременно.

Вспоминаем основы

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

В общем виде синтаксис команды xargs можно представить так:

 | xargs  

Рассмотрим, как все это работает, на материале простых и хрестоматийных примеров.

Удаление файлов

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

Представим себе следующую ситуацию: имеется директория, в которой хранится большое количество файлов. Из нее нужно удалить файлы определенного типа (в нашем примере — файлы с расширением *.sh). Чтобы осуществить эту операцию, нужно передать xargs вывод команды find, и к файлам с указанным расширением будет применена команда -rm:

$ ls
one.sh one.py two.sh two.py

$ find . -name "*.sh"| xargs rm -rf

$ ls
one.py two.py

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

$ find . -name "*.sh" -exec rm -rf '{}' \

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

Проиллюстрируем это следующим примером:

$ ls
new file.sh one.sh one.py two.sh two.py

$ find . -name "*.sh"| xargs rm -rf

$ ls
new file.sh one.py two.py

Как видим, файл, в имени которого имеется пробел, не был удалён.

Чтобы решить эту проблему, используется опция print0 для команды find и опция -0 для команды xargs. Она заменяет стандартный разделитель (перенос строки на нуль-символ (\x0), который и означает конец хранимой строки:

$ find . -name "*.sh" -print0 | xargs -0 rm -rf

Xargs может также помочь, например, быстро удалить все временные файлы, имеющие расширение tmp:

$ find /tmp -name "*.tmp"| xargs rm

Какие задачи разумно решать шеллом?

• интерактивная работа в терминале:
  • выполнение компиляции, запуск заданий через make;
  • сравнение текстовых файлов;
  • быстрый ad-hoc анализ данных (количество уникальных ip в логе, распределение записей по часам/минутам и т.п.);
  • разовые массовые действия (прибить много процессов; если работаете с системой контроля версий — ревертнуть или зарезолвить кучу файлов);
  • диагностика происходящего в системе (семафоры, локи, процессы, дескрипторы, место на диске и т.п.);
• скриптование:
  • установочные скрипты, для выполнения которых нельзя рассчитывать на наличие других интерпретаторов — это не для новичков;
  • функции для кастомизации интерактивного шелла (влияющие на приглашение, меняющие каталог, устанавливающие переменные окружения) — тоже не совсем для новичков;
  • одноразовые скрипты типа массового перекодирования файлов;
  • makefile-ы.

Фильтры

Если программа и вводит данные, и выводит, то её можно рассматривать как трубу, в которую что-то входит, а что-то выходит. Обычно смысл работы таких программ заключается в том, чтобы определённым образом обработать поступившие данные. В Linux такие программы называют фильтрами: данные проходят через них, причём что-то «застревает» в фильтре и не появляется на выходе, что-то изменяется, что-то проходит сквозь фильтр неизменным. Фильтры в Linux обычно по умолчанию читают данные со стандартного ввода, а выводят на страндартный вывод. Простейшим фильтром Мефодий уже пользовался много раз — это программа : собственно, никакой «фильтрации» данных она не производит, она просто копирует стандартный ввод на стандартный вывод.

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

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

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

Использование xargs с find

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

Что­бы избе­жать про­блем с име­на­ми фай­лов, кото­рые содер­жат сим­во­лы новой стро­ки или дру­гие спе­ци­аль­ные сим­во­лы, все­гда исполь­зуй­те пара­метр поис­ка, -print0 кото­рый заста­вит find печа­тать пол­ное имя фай­ла, за кото­рым сле­ду­ет нуле­вой сим­вол. Этот вывод мож­но пра­виль­но интер­пре­ти­ро­вать с помо­щью xargs, исполь­зуя опцию -0, ( –null).

В сле­ду­ю­щем при­ме­ре коман­да find рас­пе­ча­та­ет пол­ные име­на всех фай­лов в ката­ло­ге /var/www/.cache, а xargs пере­даст пути к фай­лам коман­де rm:

YAML

find /var/www/.cache -type f -print0 | xargs -0 rm -f

1	find/var/www/.cache-typef-print0|xargs-0rm-f

Использование тоннелей

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

С помощью утилиты xargs вы можете комбинировать команды таким образом, чтобы стандартный ввод передавался в параметры. Например, скопируем один файл в несколько папок:

Здесь параметр -n 1 задает, что для одной команды нужно подставлять только один параметр, а опция -v в cp позволяет выводить подробную информацию о перемещениях. Еще одна, полезная в таких случаях команда — это tee. Она читает данные из стандартного ввода и записывает в стандартный вывод или файлы. Например:

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

Работа с подмножеством аргументов за раз

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

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

$ echo {..9} | xargs -n 2
0 1
2 3
4 5
6 7
8 9

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

$ git log --format="%H %P" | xargs -L 1 git diff

Решение с GNU Parallel

Ниже перевод введения из мануала к утилите:

GNU Parallel — утилита командной строки для параллельного запуска задач на одном или нескольких компьютерах. Задача в данном контексте — это одна команда или скрипт, который должен быть запущен для каждого входящего аргумента. Типичный набор аргументов — это список файлов, хостов, пользователей, урлов или таблиц. Аргументы также могут быть переданы через пайп. GNU parallel может разделить аргументы и параллельно передать их командам.
 
Если вы используете xargs, то вы легко сможете использовать parallel, так как эта утилита поддерживает те же аргументы командной строки что и xargs. Если вы используете циклы в шелл-скриптах, то, вероятно, parallel поможет вам избавиться от них и ускорить выполнение за счет параллельного запуска команд.
 
GNU parallel возаращает результаты выполнения команд в том же порядке как если бы они были запущены последовательно. Это делает возможным использование результатов работы parallel как входных данных для других программ.
 
Для каждой входящей строки GNU parallel запустит команду и передаст ей эту строку в качетсве аргументов. Если команда не задана, то входящая строка будет исполнена. Несколько строк будут выполнены одновременно. GNU parallel может быть использована как замена для xargs и cat | bash.

У этой утилиты как минмум 2 видимых преимущества перед xargs:

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

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

time echo {1..20} | parallel -n 1 -P 4 ./do-something.sh -x
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 
real  0m0.562s
user  0m0.135s
sys 0m0.096s

Результат 4

Работает! Команда выполнилась примено за те же 0,5 секунд, что и и результат возвращен в правильной последовательности.

Теперь попробуем вернуть обратно случайную задержку, зменим в скрипте do-something.sh на и запустим еще раз. Результат будет возвращен опять в правильной последовательности, несмотря на то, что из-за разной задержки команды запущенные позже могут быть выполнены раньше предыдущих команд (это хорошо видно во втором результате выше).

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

Теперь испытаем еще одну киллер-фичу — возможность запустить команду на нескольких серверах сразу. Для этого воспользуемся примером из доки: .

# Добавим список серверов в конфиг. В моем случае сервера имеют имена dev и test
(echo dev; echo test) > .parallel/my_cluster
 
# Убедимся, что существует файл .ssh/config и забэкапим его
touch .ssh/config
cp .ssh/config .ssh/config.backup
 
# Временно отключим StrictHostKeyChecking
(echo 'Host *'; echo StrictHostKeyChecking no) >> .ssh/config
parallel --slf my_cluster --nonall true
 
# Откатываем назад изменения StrictHostKeyChecking в конфиге SSH
mv .ssh/config.backup .ssh/config

 
Теперь сервера из файла добавлены в .

Наконец, нужно скопировать скрипт do-something.sh в домашнюю директорию текущего пользователя на удаленных серверах (в моем примере test и dev).

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

Попробуем:

time echo {1..3200} | parallel -n 1 -P 4 --sshlogin test,dev ./do-something.sh -x
 
real  0m0.334s
user  0m0.080s
sys 0m0.032s

Результат 5

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

Ограничение пользователей

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

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

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

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

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

Следующая shell-процедура пересылает все файлы из каталога $1 в каталог $2 и сообщает о каждой пересылке перед тем, как ее выполнить:

ls 1 | xargs  -i -t mv 1/{} $2/{}

Следующая команда об единяет вывод команд, заключенных в скобки, в одну строку, которая затем добавляется в конец файла log:

(logname; date; echo $0 $*) | xargs  >>log

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

ls | xargs  -p -l ar r arch
ls | xargs  -p -l | xargs ar r arch

Следующая shell-процедура применяет команду diff к последовательным парам своих аргументов.

echo $* | xargs  -n2 diff

Использование xargs с несколькими командами

Мы можем использовать несколько команд с xargs, используя параметр -I (начальные аргументы).

Этот параметр определяет «заменяющую строку». Везде, где в командной строке появляется токен для строки замены, вставляются значения, которые были переданы в xargs.

Давайте воспользуемся командой tree для просмотра подкаталогов текущего каталога. Параметр -d (каталог) заставляет дерево игнорировать файлы и сообщать только о каталогах.

tree -d

Есть единственный подкаталог под названием «изображения».

В файле с именем «directoryies.txt» у нас есть имена некоторых каталогов, которые мы хотим создать. Мы можем посмотреть его содержимое с помощью cat.

cat directories.txt

Мы собираемся использовать это как входные данные для xargs. Мы собираемся использовать следующую команду:

cat directories.txt | xargs -I % sh -c 'echo %; mkdir %'

Это выглядит так:

cat directoryies.txt |: это помещает содержимое файла directrories.txt (все новые имена каталогов) в xargs.xargs -I%: определяет «заменяющую строку» с токеном «%».sh -c: запускает новую подоболочку. -C (команда) указывает оболочке читать команды из командной строки.‘echo%; mkdir% ‘: каждый токен «%» будет заменен именами каталогов, переданными xargs. Команда echo напечатает имя каталога; команда mkdir создаст каталог.

Каталоги перечислены один за другим.

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

tree -d

Как использовать команду xargs в Linux

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

Син­так­сис коман­ды xargs следующий:

YAML

xargs ]

1

xargs

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

YAML

echo «file1 file2 file3» | xargs touch

1	echo»file1 file2 file3″|xargstouch

В при­ве­ден­ном выше при­ме­ре мы пере­да­ем стан­дарт­ный ввод в xargs, и коман­да touch запус­ка­ет­ся для каж­до­го аргу­мен­та, созда­вая три фай­ла. Это так же, как если бы вы запустили:

YAML

touch file1 file2 file3

1	touchfile1file2file3

Нетривиальные примеры

Баним IP-адреса из списка

Чтобы забанить IP-адреса из списка, нужно их добавить в IP tables c правилом DROP. Эта операция осуществляется при помощи команды:

$ cat bad_ip_list | xargs -I IP iptables -A INPUT -s IP -j DROP

Можно проделать и более сложную операцию и забанить все адреса по AS:

$ /usr/bin/whois -H -h whois.ripe.net -T route -i origin AS<номер>|egrep "^route"|awk '{print $2}' |xargs -I NET iptables -A INPUT -s NET -j DROP

Изменяем формат URL

Преобразовать URL вида «http%3A%2F%2Fwww.google.com» в «www,google.com» можно при помощи команды:

echo "http%3A%2F%2Fwww.google.com" | sed -e's/%\(\)/\\\\\x/g' | xargs echo -e

Сгенерировать надежный пароль можно при помощи команды вида:

$ tr -dc A-Za-z0-9_ < /dev/urandom | head -c 10 | xargs

Ищем бинарные файлы, установленные без использования dpkg

Такая операция может потребоваться в случае, если, например, машина стала жертвой хакерской атаки и на ней было установлено вредоносное программное обеспечение. Выявить, что за программы поставили злоумышленники, поможет следующая команда (она ищет запущенные «бинарники», установленные без использования менеджера пакетов dpkg):

$ сat /var/lib/dpkg/info/*.list > /tmp/listin ; ls /proc/*/exe |xargs -l readlink | grep -xvFf /tmp/listin; rm /tmp/listin

Удаляем устаревшие пакеты ядра

$ dpkg -l linux-* | awk '/^ii/{ print $2}' | grep -v -e `uname -r | cut -f1,2 -d"-"` | grep -e  | xargs sudo apt-get -y purge

Преобразуем скрипт в строку

Иногда возникает необходимость преобразовать большой скрипт в одну строку. Сделать это можно так:

$ (sed 's/#.*//g'|sed '/^ *$/d'|tr '\n' ';'|xargs echo) < script.sh

Description

xargs reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and executes the command (the default command is echo, located at /bin/echo) one or more times with any initial-arguments followed by items read from standard input. Blank lines on the standard input are ignored.

Because Unix file names can contain blanks and newlines, this default behaviour is often problematic; file names containing blanks or newlines are incorrectly processed by xargs. In these situations it is better to use the -0 option (that’s a zero, not a capital o), which prevents such problems. When using this option, you need to ensure that the program which produces the input for xargs also uses a null character as a separator. If that program is find for example, the -print0 option does this for you.

If any invocation of the command exits with a status of 255, xargs stops immediately without reading any further input. An error message is issued on stderr when this happens.

This documentation is specific to the GNU version of xargs, which is commonly distributed with most variants of Linux.

Команда xargs в Linux

Синтаксис команды немного запутанный, но в нём можно разобраться:

$ первая_команда | xargs опции вторая_команда аргументы

Сначала выполняется любая первая команда и весь её вывод по туннелю передается в xargs. Затем этот вывод разбивается на строки и для каждой строки вызывается вторая команда, а полученная строка передаётся ей в аргументах.

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

• -0, –null – использовать в качестве разделителя нулевой символ. Обычно он находится в конце строки. По умолчанию, в качестве разделителя используется пробел, перевод строки или табуляция;
• -a, –arg-file – прочитать аргументы, которые надо передать команде из файла;
• -d, –delimiter – использовать нестандартный разделитель строк;
• -E, -e, –eof – индикатор конца файла, все символы после вхождения этой строки игнорируются;
• -l, –max-lines – количество строк, передающихся в одну команду по умолчанию все;
• -n, –max-args – количество параметров, которые передаются в одну команду, по умолчанию все;
• -o, –open-tty – открывать новый терминал для дочерних процессов;
• -p, –interactive – спрашивать пользователя о запуске каждой следующей команды;
• -r, –no-run-if-empty – если входной поток данных пустой, команда не будет выполнена;
• –show-limits – посмотреть ограничения на длину параметров в командной строке;
• -t, –verbose – максимально подробный вывод утилиты.

Это далеко не все опции утилиты. Если вам нужны опции, которых нет в данной статье выполните команду:

man xargs

А теперь давайте рассмотрим примеры использования xargs в Linux. Программа ожидает данные из входного потока. Поэтому если мы запустим её без параметров и наберем несколько слов, она просто их выведет. Например:

xargs

Чтобы подробнее понять что происходит можно использовать опцию -t:

xargs -t

Как видите, по умолчанию выполняется команда echo и ей передается всё, что было прочитано из стандартного ввода. Выше мы работали только с одной строкой. Давайте выведем все имена изображений из папки ~/Изображения и отдадим их утилите xargs:

ls ~/Изображения | xargs -t echo

Как видите, одной команде echo были переданы все имена изображений. Если вам надо чтобы каждое изображение обрабатывала отдельно вызванная команда, надо использовать опцию -L или -n, Первая позволяет указать сколько строк надо передавать в одну команду. Вторая – сколько параметров. Различие существенное. В строке может быть несколько параметров разделённых пробелом. Сначала попробуем ограничиться одной строкой:

ls ~/Изображения | xargs -t -L1 echo

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

ls ~/Изображения | xargs -t -n1 echo

По умолчанию строки разбиваются по символу перевода строки. С помощью опции -d можно указать свой разделитель. Разделитель должен быть совместим с функцией printf из Си. Это означает, что допускаются все символы, а также Escape последовательности вроде n, r, t и других. Например, давайте сделаем разделителем дефис:

ls ~/Изображения | xargs -t -L1 -d – echo

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

Удаление всех файлов, кроме одного типа файлов

Мы можем использовать find, xargs и rm для удаления всех файлов, кроме одного типа, который мы хотим сохранить. Это немного нелогично, но мы указываем имя типа файла, который хотим сохранить, а не имена тех, которые хотим удалить.

Параметр -not указывает find вернуть имена файлов, не соответствующих шаблону поиска. Мы снова используем параметр -I (начальные аргументы) с xargs. На этот раз определяемый нами токен строки замены — «{}». Это будет вести себя точно так же, как токен строки замены, который мы сгенерировали ранее, который оказался «%».

find . -type f -not - name "*.sh" -print0 | xargs -0 -I {} rm -v {}

Мы можем проверить с ls. В каталоге остались только файлы, соответствующие шаблону поиска «* .sh».

ls -l

Структурные единицы текста

Работая с текстом в Linux, нужно принимать во внимание, что текстовые данные, передаваемые в системе, структурированы. Большинство утилит обрабатывает не непрерывный поток текста, а последовательность единиц

В текстовых данных в Linux выделяются следующие структурные единицы:

Строки

Строка — основная единица передачи текста в Linux. Терминал передаёт данные от пользователя системе строками (командная строка), множество утилит вводят и выводят данные построчно, при работе многих утилит одной строке соответствует один объект системы (имя файла, путь и т. п.), сортирует строки. Строки разделяются символом конца строки «» (newline).

Поля

В одной строке может упоминаться и больше одного объекта. Если понимать объект как последовательность символов из определённого набора (например, букв), то строку можно рассматривать как состоящую из слов и разделителей.

Например, в командной строке разделителями являются символы пробела и табуляции (см. раздел Terminal..Слова и разделители).

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

Символы

Минимальная единица текста — символ. Символ — это одна буква или другой письменный знак. Стандартные утилиты Linux позволяют заменять одни символы другими (производить транслитерацию), искать и заменять в строках символы и комбинации символов.

Символ конца строки в кодировке ASCII совпадает с управляющей последовательностью «», «перевод строки», однако в других кодировках он может быть иным. Кроме того, на большинстве терминалов — но не на всех! — вслед за переводом строки необходимо выводить ещё символ возврата каретки («»). Это вызвало путаницу: некоторые системы требуют, чтобы в конце текстового файла стояло оба этих символа в определённом порядке. Чтобы путаницы избежать, в UNIX (и, как следствие, в Linux), было принято единственно верное решение: содержимое файла соответствует кодировке, а при выводе на терминал концы строки преобразуются в управляющие последовательности согласно настройке терминала.

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

Переименование файлов

С помощью xargs можно осуществлять массовое переименование файлов. Представим себе, что у нас есть группа файлов с расширением *.txt, и нам нужно заменить это расширение на *.sql. Это можно сделать при помощи xargs и потокового текстового редактора sed:

$ ls | sed -e "p;s/.txt$/.sql/" | xargs -n2 fmv

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

С помощью xargs можно также добавлять к дополнительные элементы к именам файлов (например, дату):

$ ls | xargs -I FILE mv {} <...>-{}

Вместо <..> можно подставить всё, что угодно.
Фигурные скобки {} в этом примере означают «текущий аргумент» (т.е. текущее имя файла).

Examples

find /tmp -name core -type f -print | xargs /bin/rm -f

core/tmp

find /tmp -name core -type f -print0 | xargs -0 /bin/rm -f

Find files named core in or below the directory /tmp and delete them, processing filenames in such a way that file or directory names
containing spaces or newlines are correctly handled.

find /tmp -depth -name core -type f -delete

Find files named core in or below the directory /tmp and delete them, but more efficiently than in the previous example (because we avoid the
need to use fork(2) and exec(2) to launch rm and we don’t need the extra xargs process).

cut -d: -f1 < /etc/passwd | sort | xargs echo

xargs sh -c 'emacs "$@" < /dev/tty' emacs

xargs-o

Команды для управления правами на файлы и директории

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

• sudo — выдает права суперпользователя. Используется перед любой другой командой в терминале, если нужно выполнить ее от имени администратора. Многие программы и операции запускаются исключительно при наличии этих прав, так что sudo используется часто. Например, чтобы обновить список пакетов в Ubuntu, введем: sudo apt-get update. При этом система запросит пароль администратора.
• sudo su — переводит терминал в режим суперпользователя. В нем каждая введенная команда будет восприниматься системой так, будто перед ней ввели sudo. Помогает запускать несколько скриптов и утилит, требующих права администратора, без необходимости постоянно корректировать их или вводить пароль от учетной записи.
• sudo gksudo — используется для запуска графических утилит от имени администратора. В Windows для этого есть специальная кнопка в контекстном меню, а в Linux — префикс. Синтаксис такой:

​sudo gksudo название приложения, нуждающееся в запуске от имени администратора

• sudo !! — запускает предыдущую команду от имени администратора. Используется, если до этого была неудачная попытка запустить программу. Помогает не тратить время на повторный ввод большого количества символов.
• chmod — корректирует права доступа к выбранному файлу. Применяется исключительно с набором аргументов, обозначающих список прав. Допустим, я хочу выдать права на чтение и запись файла Timeweb.html на рабочем столе. Для этого введу в терминал: chmod 777 ~/Desktop/timeweb.html. Теперь его можно открывать и редактировать. Аналогичным образом пользователи поступают с системными файлами, когда приходит время что-то в них менять. По умолчанию большая их часть защищена от записи.
• chown — назначает владельца для выбранной директории, документа, картинки или любого другого элемента в файловой системе. Синтаксис следующий:

chown имя учетной записи, которому надо передать права путь до файла, права на который нужно передать

Предварительные итоги

Подведём предварительные итоги и сформулируем несколько правил работы с xargs.

1. Xargs не работает с файлами, в имени которых присутствует пробел. Для решения этой проблемы с командой xargs используется опция −0. Пробел в имени файла можно обойти также следующим образом:

   $ xargs -I FILE my_command “FILE”

2. Команда xargs принимает команды из со стандартного ввода, разделенные пробелом или переводом строки. Чтобы группировать эти команды, можно использовать двойные или одинарные кавычки. Можно также указать разделитель с помощью опции -d;
3. Если команде xargs не передать вообще никаких аргументов, то по умолчанию будет выполнена команда /bin/echo;
4. Во многих случаях команду xargs можно заменить циклом for. Например, команда

   $ find . -type f -and -iname "*.deb" | xargs -n 1 dpkg -I

   полностью эквивалента циклу

   $ for file in `find . -type f -and -iname "*.deb"`; do dpkg -I "$file"; done

Перенаправить вывод в файл

Все очень просто. Вы можете перенаправить вывод в файл с помощью символа >. Например, сохраним вывод команды top:

Опция -b заставляет программу работать в не интерактивном пакетном режиме, а n — повторяет операцию пять раз, чтобы получить информацию обо всех процессах. Теперь смотрим что получилось с помощью cat:

Символ «>» перезаписывает информацию из файла, если там уже что-то есть. Для добавления данных в конец используйте «>>». Например, перенаправить вывод в файл linux еще для top:

По умолчанию для перенаправления используется дескриптор файла стандартного вывода. Но вы можете указать это явно. Эта команда даст тот же результат:

Как работает перенаправление ввода вывода

Все команды, которые мы выполняем, возвращают нам три вида данных:

• Результат выполнения команды, обычно текстовые данные, которые запросил пользователь;
• Сообщения об ошибках — информируют о процессе выполнения команды и возникших непредвиденных обстоятельствах;
• Код возврата — число, которое позволяет оценить правильно ли отработала программа.

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

• STDIN или 0 — этот файл связан с клавиатурой и большинство команд получают данные для работы отсюда;
• STDOUT или 1 — это стандартный вывод, сюда программа отправляет все результаты своей работы. Он связан с экраном, или если быть точным, то с терминалом, в котором выполняется программа;
• STDERR или 2 — все сообщения об ошибках выводятся в этот файл.

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