Bash Xargs командва по трудния начин чрез пример

Когато започнете да научавате баш програмирането по трудния начин, никой не ви казва за командата xargs. Оттогава успяхте да вземете достатъчно xargs, за да се справите, без да счупите твърде много. Сега се оказвате да питате - Ами всички други опции? Мога ли да направя това? Ами ако искам да .. ?

Вече вероятно вече имате достатъчно добро разбиране за това как да изпълните командата в bash. Но какво, ако искате да изпълнявате потоци от команди последователно или понякога паралелно? Това е мястото, където се оказваме, използвайки xargs.

Тук се надяваме да отговорим на всички тези въпроси и повече за bash и командата xargs чрез пример.

Какво е xargs в bash?

xargs е външна команда, използвана за преобразува стандартния вход в аргументи от командния ред това се казва, че означава „разширени аргументи.”Той е създаден главно за използване с команди, които не са изградени за обработка на пиппи вход или стандартен вход като rm, cp, echo ¹ и други външни команди, които само приемат аргументи като параметри.

¹ Въпреки че повечето системи идват с команда echo, echo е вграден bash; Това е, освен ако не се извиква командно ехо, вграденото ехо се използва. По същия начин, bash вградените не знаят за въведени тръбопроводи.

Опции за Xargs с примери за bash

Нека да преминем през xargs и неговите опции с примери в bash. Заедно с конвенционалното третиране за опциите на командния ред, очаквани с xargs, опциите са групирани по обекти като получаване на информация или модифициране на поведението.

Информация за Xargs

Ето опции, предоставящи информация за xargs.

Xargs помагат

xargs --помощ
Употреба: xargs [ОПЦИЯ] ... КОМАНДА [ИНЦИАЛНИ АРГИ]
Изпълнете COMMAND с аргументи INITIAL-ARGS и повече аргументи, прочетени от входа.
Задължителни и незадължителни аргументи за дълги опции също са
задължително или незадължително за съответната кратка опция.
-0, --нулевите елементи са разделени с нула, а не с празно пространство;
деактивира обработката на кавички и обратна наклонена черта и
логическа обработка на EOF
-a, --arg-file = FILE чете аргументи от FILE, а не стандартен вход
-d, --delimiter = CHARACTER елементите във входния поток са разделени от CHARACTER,
не чрез празно пространство; деактивира кавичките и обратната наклонена черта
обработка и логическа обработка на EOF
-E END задава логически EOF низ; ако END се появява като линия
на входа, останалата част от входа се игнорира
(пренебрегва се, ако е посочено -0 или -d)
-e, --eof [= END] еквивалентно на -E END, ако е посочен END;
в противен случай няма низ в края на файла
-I R същото като --replace = R
-i, --replace [= R] заменете R в INITIAL-ARGS с прочетени имена
от стандартен вход; ако R е неуточнено,
приемете
-L, --max-lines = MAX-LINES използват най-много MAX-LINES непразни входни редове за
командна линия
-l [MAX-LINES] подобен на -L, но по подразбиране е най-много един не-
празен ред за въвеждане, ако не са посочени MAX-LINES
-n, --max-args = MAX-ARGS използва най-много MAX-ARGS аргументи на команден ред
-P, --max-procs = MAX-PROCS се изпълняват най-много MAX-PROCS процеси едновременно
-p, --интерактивен ред преди изпълнение на команди
--process-slot-var = VAR задава променлива среда VAR в дъщерни процеси
-r, --no-run-if-empty, ако няма аргументи, тогава не изпълнявайте COMMAND;
ако тази опция не е дадена, ще бъде COMMAND
тичайте поне веднъж
-s, --max-chars = MAX-CHARS ограничи дължината на командния ред до MAX-CHARS
--show-limit показва ограничения за дължината на командния ред
-t, --verbose команди за печат, преди да ги изпълните
-x, --exit изход, ако размерът (вижте -s) е надвишен
--помогнете да покажете тази помощ и да излезете
--версия извежда информация за версията и излиза

Обърнете се към помощта за xargs като бърза справка за използването и опциите на xargs.

Версия на Xargs

xargs --версия
xargs (GNU findutils) 4.6.0

Ограничения на Xargs

Дори xargs има своите граници. Опцията -show-limit за xargs показва ограниченията, използвани от xargs преди стартиране на командите. Действителните ограничения зависят от вашата среда. За повечето потребители обаче това е достатъчно. Ограниченията могат да бъдат коригирани в командния ред, вижте примери.

Пример) Вашата среда xargs ограничения

xargs --show-limit
Променливите на вашата среда заемат 6234 байта
POSIX горна граница на дължината на аргумента (тази система): 23718
POSIX най-малката допустима горна граница на дължината на аргумента (всички системи): 4096
Максимална продължителност на командата, която всъщност бихме могли да използваме: 17484
Размер на командния буфер, който всъщност използваме: 23718
Максимален паралелизъм (--max-procs не трябва да бъде по-голям): 2147483647

Изпълнението на xargs ще продължи сега и ще се опита да прочете командите за въвеждане и изпълнение; ако това не е това, което искате да се случи, моля, въведете натискане на клавиша в края на файла.

Предупреждение: ехото ще се изпълни поне веднъж. Ако не искате това да се случи, натиснете клавиша за прекъсване.

Обърнете внимание, че командата, която ще се изпълни в резултат на xargs, е echo, командата по подразбиране на xargs.

Пример) Ограничения на Xargs с коригиран лимит на команден буфер

xargs --show-limit -s 1
Променливите на вашата среда заемат 9479 байта
POSIX горна граница на дължината на аргумента (тази система): 20473
POSIX най-малката допустима горна граница на дължината на аргумента (всички системи): 4096
Максимална продължителност на командата, която всъщност бихме могли да използваме: 10994
Размер на командния буфер, който всъщност използваме: 1
Максимален паралелизъм (--max-procs не трябва да бъде по-голям): 2147483647
..
Предупреждение: ехото ще се изпълни поне веднъж. Ако не искате това да се случи,
след това натиснете клавиша за прекъсване.
xargs: не може да побере един аргумент в рамките на ограниченията за размер на списъка с аргументи

Имайте предвид, че грешките ще се появят в долната част след Предупреждения, ако има такива. Имаме грешка „xargs: не може да побере един аргумент в рамките на ограничението за размер на списъка с аргументи“, което просто означава, че се опитваме да работим извън разрешения размер на буфера на командата, който е зададен на символ.

Командният буфер съдържа командата, последвана от всички аргументи, включително интервали.
В случая на командата в този пример за опция xargs, буферът за команди е

"ехо"

който съдържа 4 знака.
И така, трябва да зададем размера на буфера на командата на стойност, по-голяма или равна на 5, както следва. Имайте предвид, че консумацията на команден буфер ще се равнява на length_of_command + length_args_including_spaces_plus_one + 1.

xargs --show-limit -s 5

# Няма повече "xargs: не може да побере един аргумент в рамките на ограничението за размер на списъка с аргументи" грешка

Но какво, ако нашата команда има аргументи?

да | xargs -t --show-limit -t -s 6 # ще работи със следния изход
ехо у
..

Xargs многословен

lhs | xargs -t други_xargs_options_if_any | rhs

Опцията -t може да се използва за показване на команди, изпълнявани от xargs като изход към fd2, стандартна грешка. Това е xargs -t може да бъде анулиран чрез пренасочване на стандартна грешка към / dev / null, както следва.

xargs -t 2> / dev / null

Пример) Да веднъж

да | глава -n 5 | xargs -t вярно
вярно y y y y y

Пример) Да 5 пъти

да | глава -n 5 | xargs -t -I вярно
вярно у
вярно у
вярно у
вярно y
вярно у

Поведение на Xargs

Нито една команда не е пълна без опции за промяна на поведението по време на изпълнение. Xargs не е по-различен. Ето опциите, които ви позволяват да промените поведението му.

Xargs null

lhs | xargs -0 други_xargs_options_if_any | rhs

Опцията -0 може да се използва, за да каже на xargs да използват null вместо празно пространство. Също така деактивира кавичките и изходните последователности.

да | глава -n 5 | sed "s /.* / cul- "de" - 'sac' / "| xargs -I echo -en" \ n \ x00 "
тупик
тупик
тупик
тупик
тупик
да | глава -n 5 | sed "s /.* / cul- "de" - 'sac' / "| xargs -0 -I echo -en" \ n \ x00 "
cul- "de" - "торбичка"
cul- "de" - "торбичка"
cul- "de" - "торбичка"
cul- "de" - "торбичка"
cul- "de" - "торбичка"

Xargs null case case

Предназначението, използвано за xargs null, е за обработка на случаи, например когато елементите съдържат интервали като файлове, съдържащи интервали или символи от нов ред.

Да предположим, че имате директория “a b c”, включваща интервали в името на директория.

е "a b c"
de / fg / h / 'i j k l' /

Искате да стартирате команда във всяка директория в „a b c“, като използвате командата find.

Можете да опитате следното:

намери "a b c" -тип d | xargs du -d 0 -h
du: няма достъп до 'a': Няма такъв файл или директория
du: няма достъп до 'b': Няма такъв файл или директория
du: няма достъп до 'c': Няма такъв файл или директория
du: няма достъп до 'a': Няма такъв файл или директория
du: няма достъп до 'b': Няма такъв файл или директория
du: няма достъп до 'c / de': Няма такъв файл или директория
du: няма достъп до 'a': Няма такъв файл или директория
du: няма достъп до 'b': Няма такъв файл или директория
du: няма достъп до 'c / fg': Няма такъв файл или директория
du: няма достъп до 'a': Няма такъв файл или директория
du: няма достъп до 'b': Няма такъв файл или директория
du: няма достъп до „c / h“: Няма такъв файл или директория
du: няма достъп до 'a': Няма такъв файл или директория
du: няма достъп до 'b': Няма такъв файл или директория
du: няма достъп до 'c / i': Няма такъв файл или директория
du: няма достъп до 'j': Няма такъв файл или директория
du: няма достъп до 'k': Няма такъв файл или директория
du: няма достъп до 'l': Няма такъв файл или директория

Работи неправилно, защото имената на директориите ни са осеяни с интервали. Това не беше вашето намерение.

Можете да поправите това, като добавите заместване на xargs, т.е.e -I както следва.

намери "a b c" -тип d | xargs -i du -d 0 -h
0 a b c
0 a b c / de
0 a b c / fg
0 a b c / h
0 a b c / i j k l

Работи правилно, когато се използва замяна на xargs. Имайте предвид, че използвахме -i, което е съкратено за -I .

Друг начин да постигнем същия резултат е използването на xargs null, -null, в комбинация с опцията find -print0, както следва.

намери "a b c" -тип d -print0 | xargs --null -i du -d 0 -h
0 a b c
0 a b c / de
0 a b c / fg
0 a b c / h
0 a b c / i j k l

Страхотен! Сега имаме повече от един начин да проникнем дълбоко във вселената на файловата система, без да се притесняваме от сблъсъка с космическото боклук при нашето пътуване. Точно на.

Xargs интерактивен

Може би нямате доверие на xargs да изпълнява всички команди без потвърждение. В този случай xargs interactive или -p е опцията, която трябва да контролирате кои команди се изпълняват от xargs, както следва.

намери "a b c" -тип d -print0 | xargs --null -i -p du -d 0 -h
du -d 0 -h a b c ?..
du -d 0 -h a b c / de ?..
du -d 0 -h a b c / fg ?... г
0 a b c / fg
du -d 0 -h a b c / h ?... Да
0 a b c / h
du -d 0 -h a b c / i j k l ?… не

Тук се изпълнява всяка команда, започваща с 'y' или 'Y'. В противен случай командите се игнорират.

Xargs файл

Вече имате файл, arg-файл, готов за четене в xargs. Вашата програма може да чака някъде около директория някой друг или друг екземпляр от вас да пусне arg-файл. В този случай можете да посочите файла като опция за xargs с помощта на -a arg-файл, вместо да се налага да използвате cat файл | xargs ... Следват примери за файлове на Xargs.

Само за забавление, нека превърнем процедурите за почистване на работния плот в arg-файл, който можем да използваме.

е почистване на работния плот | тройник arg-файл
190605_cleanup_desktop_files_sh.текст
190605_cleanup_desktop_lnk_files_sh.текст
190605_cleanup_desktop_un_files_sh.текст

Всеки файл съдържа рутина, която може да се изпълни с помощта на bash. Това означава, че командата, която ще използваме, е bash.

Нека да стартираме процедурите за почистване, използвайки xargs.

xargs -a arg-файл -i -P 99 bash -c 'ехо ; . почистване-работен плот / ; '
190605_cleanup_desktop_files_sh.текст
190605_cleanup_desktop_lnk_files_sh.текст
190605_cleanup_desktop_un_files_sh.текст

И работи!
Само в случай, че трябва да посочим arg-файл, вместо да използваме входящ вход, опцията xargs файл е полезна.

Xargs замени

lhs_if_any | xargs -i other_args_etc | rhs_if_any

Не на последно място, xargs replace -i ви позволява да поемете пълен контрол над формата на командата, преди да бъде изпълнен. Може да се използва всеки символ. Въпреки това, след конвенцията повечето програмисти на bash използват този или този%. Имайте предвид, че по подразбиране е . -казвам на xargs, че ще бъдете използвани по подразбиране. И се счита за стенография. -Последван от заместващ символ по ваш избор казва на xargs какъв символ ще използвате. Избягвайте да използвате често срещани знаци като буквата а. Това ще счупи кода ви повече от всяко пространство или нов ред някога.

Xargs успоредни

lhs_if_any | xargs -P n_ge_1 other_args_etc | rhs_if_any

Xargs паралелно -P позволява командите да се изпълняват едновременно, вместо последователно. Обърнете се към xargs limit -show-limit за валидни аргументи за n_ge_1 или паралелност. Например, ако

Максимален паралелизъм (--max-procs не трябва да бъде по-голям): 2147483647

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

Следват примери, показващи как използването на паралелни xargs може да подобри производителността.

Пример) Преброяване в последователност спрямо паралел, използвайки xargs

Нека да видим какво се случва, когато броим времето последователно, използвайки xargs.

време ехо 1… 1000 | xargs '-d' -i bash -c 'ехо '
..
998
999
1000
истински 1м13.927 години
потребител 0m6.994s
sys 0m15.184 години

Сега вижте какво се случва, ако броим времето паралелно с помощта на xargs.

време ехо 1… 1000 | xargs -P 200 '-d' -i bash -c 'echo '
..
998
999
1000
реално 0m13.554 секунди
потребител 0m6.446s
sys 0m14.293s

Наблюдава се значително подобрение в производителността при използване на xargs паралелно за изпълнение на прости команди без споделени ресурси.

Пример) Сравняване на реда и времето на xargs паралелно

Нека да видим какво се случва, когато дадена команда отнема процесорно време.

време ехо 1… 10 | xargs '-d' -i bash -c 'sleep $ (($ СЛУЧАЙНО% 2)); ехо '
1
2
3
4
5
6
7
8
9
10
реално 0m5.601-те
потребител 0m0.180-те
sys 0m0.334 секунди

Имайте предвид, че всички команди са завършени по ред.

Сега вижте какво се случва, когато същата команда се изпълнява паралелно.

време ехо 1… 10 | xargs -P 10 '-d' -i bash -c 'sleep $ (($ СЛУЧАЙНО% 2)); ехо '
3
4
6
7
8
1
2
5
9
10
реално 0m1.257s
потребител 0m0.060-те
sys 0m0.225 секунди
Команди 1, 2, 5 и 9 заспаха. Успяхме обаче да намалим
време за завършване с цели 78 процента.

Паралелно заключение на Xargs

Простото добавяне на xargs паралелно като опция на командния ред може да подобри десетократно производителността. Трябва обаче да действате внимателно, когато използвате процедури, зависими от поръчката, или когато командите споделят ресурси.

Xargs разделител

lhs_if_any | xargs '-dc' other_args_etc | rhs_if_any

Xargs разделител -d ви позволява да зададете разделителя на елементи на произволен символ c по същия начин, по който се задават разделителите в командата cut.

По подразбиране -dc е зададено като празно пространство, създадено от символа за нов ред -d \ x0a.
При използване на xargs null -0, -dc е зададен на нулевия символ -d \ x00.

Например, можете да зададете разделителя на интервал, т.е.д. -dc е '-d' в командния ред или вашия bash скрипт.

Можете да зададете разделителя на запетая, т.е.д. -dc е '-d'.

Опцията за разделител в xargs -d ви позволява да зададете разделителя на елементи на всеки символ, който желаете.

Примери за Bash xargs

Тук обхващаме примерни употреби на командата xargs в bash, включително примерна употреба в командния ред, както и скриптове.

Примери за команди на Bash xargs

Тук обхващаме примерни приложения на командния ред на командата xargs в bash, включително примерна употреба със и без въведени тръбопроводи.

Пример) Направете свой собствен вход: забавлявайте се с xargs без вход

Какво прави xargs у дома сам?

xargs
Здравейте, има ли някой вкъщи?
..
(Ctrl-D)
Здравейте, има ли някой вкъщи?..

Изглежда, че получихме въпроса си обратно като отговор, но изглежда, че е просто ехо.

Защо?

Както може би сте чели в какво става въпрос за xargs, той преобразува стандартния вход в аргументи на командния ред. Ако не са предоставени опции и аргументи, той се държи като ехо команда, която знае. Това е:

xargs
Здравейте, има ли някой вкъщи?
..
(Control-D) 2

Произвежда еквивалентен израз на команден ред на ехо имплицитно

echo Здравейте, има ли някой вкъщи?..
2 В сценарий heredoc може да се използва, както следва.
xargs << EOF
Здравейте, има ли някой вкъщи?
..
EOF
echo Здравейте, има ли някой вкъщи?..

Пример) Използвайте xargs като заместител за интерактивни тръби

Използването на xargs от лявата страна на тръбата е парадоксално⁴така че нека пуснем bash в супер ограничен режим⁵.

⁴ Командите, осъзнаващи тръбите, не се нуждаят от xargs. Командите, които не знаят, не знаят за xargs

⁵ Ограничен режим, който нулира всеки ред. Други ограничения могат да бъдат добавени по-късно.

xargs -I bash -cr ""
i = 1
ехо $ i
ехо Здравейте!
Здравейте!
!!
баш: !!: командата не е намерена
i = 1; ехо $ i
1
cd ..
bash: ред 0: cd: ограничен

Пример) Използвайте xargs като заместител за интерактивни аргументи

Според отчета за уменията на разработчиците на HackerRank за 2019 г³, „Калкулаторите са новите игри.„Още разработчици под 38 години натискат калкулаторите като първия си проект за кодиране. ³ Статистика, базирана на 71 281 разработчици

И така, нека изградим калкулатор, използвайки xargs!

_ () ехо $ (("$ @")); # калкулатор
докато :
направете
_ $ (xargs)
Свършен
1 + 2 + 3 + 4
(Ctrl-D)
10
1 - 2 + 3 - 4 + 5
(Ctrl-D)
3
1 ** 2 + 2 ** 2
(Ctrl-D)
3
1+
2+
3+
4+
5
(Ctrl-D)
15

Пример) Статичен генератор на сайт

Да предположим, че имате няколко хиляди обикновени текстови файлове, които искате да използвате, за да генерирате статичен сайт, и никой от файловете не е именуван индекс. Имената на файловете включват малки букви ascii и тире, ако има такива.

Ето как би изглеждал ред или два в терминала на теоретична машина, работеща с bash. Машината ще има други външни команди, включително findutils и pandoc. Можете да използвате всяка еквивалентна команда по ваш избор.

# ние сме в директорията
# вижте много файлове

тест -d "html" || mkdir -v $ _
намирам . -mindepth 1 -maxdepth 1-type f \
| xargs -P 6000 -i bash -c "echo ; cat | sed -e 's / $ / /' |
pandoc -thtml -o .html "

# вижте два пъти повече файлове сега, включително html файлове
# Свършен

Примери за скриптове на Bash xargs

Пример) Използвайте xargs за генериране на квадратни матрици

Ето скрипт, който приготвих, за да генерирам квадратни матрици, използвайки xargs. По-конкретно, той се възползва от поведението, използвайки опцията -n и използва командата seq за поредици от числа, които да се използват в матрици.

#!/ bin / bash
## квадратна матрица
## - генерира квадратни матрици
## версия 0.0.1 - начален
####################################################
квадратна матрица-помощ ()

котка << EOF
квадратна матрица
1 - поръчка
ПРИМЕРИ
> квадратна матрица 1
1
> квадратна матрица 2
12
3 4
> квадратна матрица 3
1 2 3
4 5 6
7 8 9
EOF

квадратна матрица () локален -i ред; поръчка = $ 1;
тест "$ поръчка" || $ FUNCNAME -помощ; връщане;
тест $ order -gt 0 || $ FUNCNAME -помощ; връщане;
_ ()
sql $ (($ 1 ** 2)) | xargs -n $ 1

_ $ поръчка

####################################################
ако [ ! ]
тогава
вярно
друго
изход 1 # грешни аргументи
fi
####################################################
квадратна матрица $ @
####################################################
## генерирано от create-stub2.sh v0.1.2
## в сряда, 29 май 2019 13:44:06 +0900
## виж
####################################################

Източник: квадратна матрица.ш

Включих и тестова програма за показване на скрипта в действие, генерирайки всички квадратни матрици до 10 х 10.

#!/ bin / bash
## тест-квадрат-матрица
## - генерира квадратни матрици до 10 x 10
## версия 0.0.1 - начален
####################################################
тест-квадрат-матрица ()
тест -f "квадратна матрица.ш "
. $ _ 1> / dev / null
местни i
за i в 1… 10
направете
ехо "квадратна матрица ($ i)"
квадратна матрица $ i
Свършен

####################################################
ако [$ # -eq 0]
тогава
вярно
друго
изход 1 # грешни аргументи
fi
####################################################
тест-квадрат-матрица
####################################################
## генерирано от create-stub2.sh v0.1.2
## в сряда, 29 май 2019 13:40:08 +0900
## виж
####################################################

Източник: тест-квадрат-матрица.ш

Ето какво да очаквате:

bash тест-квадрат-матрица.ш | глава
квадратна матрица (1)
1
квадратна матрица (2)
12
3 4
квадратна матрица (3)
1 2 3
4 5 6
7 8 9
..

Упражнение: Подобрете дисплея в терминала, като приложите подплънки към числа

Когато се опитаме да генерираме квадратната матрица от порядък 10 на 10, получаваме следния изход:

bash квадратна матрица.sh 10
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100

Като упражнение разширете квадратна матрица.sh, за да се даде възможност за извеждане, както следва.

bash квадратна матрица.sh 10
001 002 003 004 005 006 007 008 009 010
011 012 013 014 015 016 017 018 019 020
021 022 023 024 025 026 027 028 029 030
031 032 033 034 035 036 037 038 039 040
041 042 043 044 045 046 047 048 049 050
051 052 053 054 055 056 057 058 059 060
061 062 063 064 065 066 067 068 069 070
071 072 073 074 075 076 077 078 079 080
081 082 083 084 085 086 087 088 089 090
091 092 093 094 095 096 097 098 099 100

Bash xargs примери за практическо използване

Пример) Търсете файлове за шаблон с помощта на xargs grep

списъчни файлове¹ | xargs grep -e модел

¹ list-files е команда, връщаща кандидат-пътеки към файл, която да бъде взета като вход за grep чрез командата xargs

Като пример за практическа употреба на xargs в bash, изкопах xargs от тайна кодова база.

намери -тип f -име \ *.ш | wc -l
994

Има 994 bash скрипта. Нека видим колко команди xargs.

намери -тип f -име \ *.ш | xargs grep -e xargs изброява всички случаи
на xargs в кодовата база.
..
намери -тип f -име \ *.ш | xargs grep -e xargs | wc -l
18

В кодовата база има 18 съвпадения за xargs. Сега може да искаме да разберем колко скриптове използват xargs.

Страхотен! В кодовата база има 10 скрипта с xargs. Да видим какви са те.

намери -тип f -име \ *.ш | xargs grep -e xargs | изрязване '-d:' '-f1' | сортиране | uniq
vim $ ( !! )

Обобщение на констатациите

- Търсете и унищожавайте файлове, съдържащи шаблон в името на файла

намерете $ path -type f -name \ * $ pattern \ * | xargs rm -vf

- Списък на информация за файлове на lhs на тръба

намиране на файлове | xargs ls -al

- Направете файловете изпълними

намиране на файлове | xargs chmod + x

- Списък на файловите имена

намиране на файлове | xargs -I речево име ""

- Пречистете всички

пътища за прочистване | xargs rm -rvf

- Zip файлове

find-files-to-zip | xargs -I архив - $ (дата +% s)

- Списък на базовите имена на файлове

намиране на файлове | xargs -I базово име

Пример) Инсталирайте софтуер от списък, използвайки apt-get в Ubuntu

Когато надстройвате Ubuntu, след архивиране на вашата система може да се наложи да инсталирате нов софтуер. Да предположим, че имате списък със софтуер, който да инсталирате с помощта на apt-get в Ubuntu.

sudo dpkg --get-selections | grep '[[: space:]] инсталиране на $' |
\ awk 'print $ 1'> install_software
# ..
cat install_software | xargs sudo apt-get install

Пример) Curl seige с помощта на xargs в bash

Да предположим, че имате куп URL адреси, водещи до един възел някъде в интернет и бихте искали да поставите seige с помощта на curl в bash. За предпочитане това е един от вашите възли, а seige не е във вашата производствена среда. Ето как полагаме seige с помощта на xargs в bash.

#declare -f филтър
филтър ()

grep -o -e 'loc [^<]*' | cut '-d>"-f2"

get-arg-file ()

curl https: // linuxhint.com / карта на сайта.xml --silent \
| филтър \
| xargs -i curl --silent \
| филтър \
| xargs -i echo > arg-файл

#declare -f curl
къдрица ()

ехо (фалшив) $ FUNCNAME "$ @"

декларирам -xf curl
полезен товар ()

test -f "arg-файл" || връщане
xargs -P 1000 -a arg-файл -i echo curl | bash 1> / dev / null

Seige ()

test -f "arg-файл" || вземете - $ _
полезен товар

seige

Отстраняване на грешки в Bash xargs

Когато седите пред терминала, вие сте шефът. Когато обаче нещо се обърка, помага, ако знаете как всъщност да отстранявате грешки в bash скриптове като шеф.

Играта на сигурно, наличието на метод за потвърждаване на успеха при използване на xargs в bash, вместо сляпо очакване всичко да е наред, е силно препоръчително. Тоест, трябва да се уверите, че всички команди, завършени с успех и неуспех, не остават непроверени.

Методи

Размер на стандартния изход за грешка
Ако стандартната грешка съдържа 1 или повече знака, нещо се обърка
Сума от кодове за изход на команди
Ако сумирането на изходните кодове е по-голямо от 0, нещо се обърка
Проверка на полезния товар
Ако част от полезния товар липсва, нещо се обърка
Край на валидирането на скрипта
Изпълнение на команди xargs като скрипт, ако не се стигне до края на скрипта, нещо се обърка. Имайте предвид, че е зададен errexit и командите се изпълняват от функцията.
Друг метод
Ако резултатът се различава от очаквания, тогава нещо може да се е объркало

Пример) Отстраняване на грешки в xargs с използване на размера на стандартния изход за грешка

Ето една анонимна функция, която тестваме за отстраняване на грешки в xargs, използвайки грешка stardart.

# декларирам -f _, т.е.д. Не написах кода по-долу
# ако установите, че сте малко ръждясали, обявете, че написах още един урок
#
как командата за деклариране работи в bash
_ ()

rm -vf грешка;
докоснете $ _;
ехо 1… 10 | xargs -x -P 10 '-d' -i bash -c "тест $ (($ СЛУЧАЙНО% $ 1)) -eq 0 ||
ехо 1> & 2; изход; ; echo "2> грешка;
тест ! $ (wc < errout -c ) -gt 0 || echo something went wrong…

## тест
_ 1 # вероятност за отказ (= 1-1 / 1 = 0%)
_ 2 # вероятност за повреда (= 1-1 / 2 = 1/2 = 50%)
_ 3 # вероятност за повреда (= 1-1 / 3 = 2/3 = 60%)
..

Ако не използвате стандартна грешка за нещо друго, като използвате размера на стандартната грешка за отстраняване на грешки на xargs е един метод, който може да работи за вас.

Bash xargs функции

Понякога това, което искате да направите, е да използвате функции, които сте дефинирали в xargs. За целта трябва да направим функцията достъпна за xargs. Ето как.

#declare -f _
_ ()

echo $ @ ^^

ехо a… z 1… 9 | xargs '-d' -i bash -c "_ "
bash: _: командата не е намерена
..
декларирам -xf _
ехо a… z 1… 9 | xargs '-d' -i bash -c "_ "
А1
А2
A3
..
# или
ехо a… z 1… 9 | xargs '-d' -i echo "_ " | баш
..
Z7
Z8
Z9

Имайте предвид, че горният пример за интерактивна сесия може да се ускори, като се използва паралелно с bash xargs.

Заключение

Xargs е една от многото външни команди, които е по-добре да знаете в bash. При написването на това ръководство по командата xargs, аз самият научих няколко допълнителни опции. Преглеждайте всеки толкова често се препоръчва. Само тогава ще можете да използвате xargs до истинския му потенциал. Дотогава кодирайте.