xargs- utiliit argumentide loendi genereerimiseks ja käsu täitmiseks. See tähendab, et xargs võimaldab kutsuda mis tahes argumentidega käsku. Käsk xargs koosneb kahest komponendist. Esiteks peate määrama teile huvi pakkuvad failid. Teiseks peate määrama käsu või skripti, mida soovite kõigile nendele failidele rakendada.
xargs – jagab sisendvoo argumentideks ja edastab nende täitmise mis tahes käsule (vaikimisi kaja). Loeb kas standardsisendist või toru kaudu.
xargs töötlemisrežiimid sissetulevate andmete jaoks
Vaikimisi on argumentide eraldajaks mis tahes tühimärk: tühik, tabeldusmärk, vertikaalne tabeldusmärk või reavahetus. Aga nagu ikka käsu kest argumentide tükeldamise vältimiseks võite kasutada märki "" või \.
Režiim on lubatud parameetri -L abil. Peaaegu identne eelmisega, välja arvatud see, et xargs jätab meelde, milline argument millisel real asub. Veelgi enam, kui rida lõpeb tühiku või tabeldusmärgiga, järgmine rida peetakse praeguse jätkuks.
Rea kaupa. Lubatud, kui kasutate suvandit -I või -0. Sel juhul peetakse kogu stringi üheks tervikuks argumendiks, hoolimata tühikutest ja tabeldusmärkidest. -I puhul on rea lõpp märk "\n" ja -0 jaoks märk "\0"
Näide: otsige /home/user1 kõigist failidest, mille nimed lõpevad ".txt", ja kopeerige need teise kataloogi. leida /kodu/kasutaja1 nimi "*.txt" | xargs cp -av --target-directory=/home/backup/ --parents
Otsige kõigist kataloogis /etc/samba asuvatest failidest üles fraasi sisselogimise kodu esinemine. $ leia /etc/samba | xargs grep -ni "logi koju"
Kustutage failide loend. Failiteed kirjutatakse ridade kaupa faili delfiles.txt xargs rm< delfiles.txt
Utiliidist xargs on palju kirjutatud – mida saab veel kirjutada? Aga kui, nagu öeldakse, süveneda, selgub, et paljudes väljaannetes on välja toodud ainult põhitõed, kuid puudub peamine: nad ei selgita, kuidas xargi saab reaalses praktikas kasutada. Artiklid, mis analüüsivad selle väga kasuliku keerulisi ja mittetriviaalseid rakendusi süsteemiadministraator Kahjuks on tööriistu väga vähe. Seetõttu kirjutasime oma artikli ja püüdsime lisada võimalikult palju näiteid. kasutades xargs erinevate probleemide lahendamiseks.
Kõigepealt vaatame, kuidas xargs töötab ja analüüsime lihtsamaid näiteid ning seejärel liigume edasi keeruliste ja huvitavate juhtumite analüüsimise juurde.
Meenutagem põhitõdesid
Xargs'i toimimisviisi saab kirjeldada järgmiselt: programm võtab andmeid standardsisendist või failist, jagab need vastavalt määratud parameetrid ja seejärel edastab selle argumendina teisele programmile.
IN üldine vaade Käsu xargs süntaksit saab esitada järgmiselt:
[loendi_generaatori_käsk] | xargs [xargs_options] [käsk]
Vaatame lihtsate ja õpikunäidete abil, kuidas see kõik käib.
Failide kustutamine
Üks levinumaid olukordi, kus xargs kasutatakse, on käsuga find abil leitud failide kustutamine.
Kujutame ette järgmine olukord: seal on kataloog, kuhu see on salvestatud suur hulk failid. Peate sellest failid kustutama teatud tüüpi(meie näites - failid laiendiga *.sh). Selle toimingu tegemiseks peate käsule xargs edastama käsu find väljundi ja käsku -rm rakendatakse määratud laiendiga failidele:
$ ls one.sh one.py two.sh two.py $ find . -nimi "*.sh"| xargs rm -rf $ ls one.py two.py
Pange tähele, et failide kustutamist saab teha ilma xargsita, kuid kasutades käsku
$leida. -nimi "*.sh" -exec rm -rf "()" \
Kirjeldatud meetod ei tööta, kui ühe kustutatava faili nimi sisaldab tühikut. Nime, mis koosneb kahest tühikuga eraldatud sõnast, ei aktsepteerita ühtse tervikuna.
Illustreerime seda järgmise näitega:
$ ls uus fail.sh one.sh one.py two.sh two.py $ find . -nimi "*.sh"| xargs rm -rf $ ls uus fail.sh one.py two.py
Nagu näete, ei kustutatud faili, mille nimes on tühik.
Selle probleemi lahendamiseks kasutage otsingukäsu jaoks suvandit print0 ja käsu xargs jaoks suvandit -0. See asendab standardse eraldaja (reavahetus nullmärgiga (\x0), mis tähendab salvestatud stringi lõppu:
$leida. -nimi "*.sh" -print0 | xargs -0 rm -rf
Xargs võib aidata ka näiteks kõike kiiresti eemaldada ajutised failid tmp laiendiga:
$ leia /tmp -nimi "*.tmp"| xargs rm
Failide tihendamine
Kõiki praeguses kataloogis olevaid faile saate gzipi abil tihendada, sisestades järgmise käsu:
$ls | xargs -p -l gzip
Vaatame veel ühte näidet: kõigi *.pl laiendiga failide tihendamine tar abil:
$leida. -nimi "*.pl" | xargs tar -zcf pl.tar.gz
Failide ümbernimetamine
Xargsiga saate seda teha massiline ümbernimetamine failid. Kujutagem ette, et meil on rühm faile laiendiga *.txt ja me peame selle laiendi asendama *.sql-ga. Seda saab teha xargi ja teksti voogesituse abil sed toimetaja:
$ls | sed -e "p;s/.txt$/.sql/" | xargs -n2 fmv
Selle täitmise tulemusena kuvatakse konsoolil ümbernimetatud failide loend.
Xargsiga saate ka lisada lisaelemendid failinimedele (näiteks kuupäev):
$ls | xargs -I FILE mv()<...>-{}
Selle asemel<..>võite asendada kõike, mida soovite.
Selles näites tähistavad lokkis sulgud () "praegust argumenti" (st praegust failinime).
Kaustade ja failide õiguste muutmine
Xargs-i abil saate kiirendada ka failide ja kaustade õiguste muutmise protsessi konkreetne kasutaja või rühmad. Oletame, et peame leidma kõik kaustad kasutaja juur ja asendada nende omanik temp. See toiming viiakse läbi käsuga:
$leida. -group root -print | xargs chown temp
Juurrühma kõigi kaustade leidmiseks ja rühma asendamiseks temp-iga kasutage käsku:
$leida. -group root -print | xargs chgrp temp
Xargs ja leia: keerulised toimingud
Keerulisemaid toiminguid saate teha, kasutades käske find ja xargs. Nii saate näiteks kustutada ajutisi faile, mis on loodud rohkem kui 7 päeva tagasi:
$ find /tmp -type f -name "*" -mtime +7 -print0 | xargs -0 rm -f
Ja siin on, kuidas jõuliselt peatada protsesse, mis on juba töötanud üle 7 päeva:
$ leia /proc -kasutaja minukasutaja -maxdepth 1 -type d -mtime +7 -exec basename() \; | xargs tapavad -9
Xargs ja lõika
Xargs kasutatakse üsna sageli koos käsuga cut, mis võimaldab teil ridu lõigata tekstifailid. Vaatame mõnda praktilisi näiteid. Kasutades allolevat käsku, kuvatakse konsoolil kõigi süsteemi kasutajate loend:
$ lõigatud -d: -f1< /etc/passwd | sort | xargs echo
Ja meeskond näeb välja
Fail * | grep ASCII | lõika -d":" -f1 | xargs -p vim
avab failid järjestikku vimis muutmiseks.
Pöörame tähelepanu valikule -p. Tänu sellele täidetakse käsk sisse interaktiivne režiim: Enne iga faili avamist küsitakse kinnitust (jah/ei).
Kokkuvõtteks on siin veel üks kompleks ja huvitav näide- failide rekursiivne otsing ise suur suurus mõnes kataloogis:
$leida. -type f -printf "%20s %p\n" | sort -n | lõika -b22- | tr "\n" "\000" | xargs -0 ls -laSr
Protsesside paralleelne kulgemine
Xargsi kasutatakse sageli mitme protsessi paralleelseks käitamiseks. Näiteks saate korraga mitu kataloogi tar.gz-sse tihendada:
$ kaja kataloog1 kataloog2 kataloog3 | xargs -P 3 -I NIMI tar czf NIMI.tar.gz NIMI
Allolevas näites kasutatakse lülitit -P. Ta osutab maksimaalne summa protsessid, mis töötavad samaaegselt. Oletame, et meil on sisendiks 10 argumenti. Kui sisestame käsu xargs lülitiga -P 3, käivitatakse xargsile järgneva käsu 3 eksemplari koos kõigi nende argumentidega.
Xargsiga saate paralleelselt alla laadida ka mitu faili Internetist:
Toodud näites koos määratud aadress kõik laaditakse alla graafilised failid Koos jpg laiendus; Lüliti -P näitab, et peate korraga alla laadima 10 faili.
Esialgsed tulemused
Võtame esialgsed tulemused kokku ja sõnastame mõned reeglid xargsiga töötamiseks.
- Xargs ei tööta failidega, mille nimes on tühik. Selle probleemi lahendamiseks käsuga xargs kasutage suvandit −0. Samuti saate failinimes olevast tühikust mööda minna järgmiselt: $ xargs -I FILE my_command “FILE”
- Käsk xargs aktsepteerib standardsisendi käske, mis on eraldatud tühiku või reavahetusega. Nende käskude rühmitamiseks võite kasutada topelt- või üksikud jutumärgid. Eraldaja saab määrata ka võtmega -d;
- Kui xargsile argumente ei edastata, käivitatakse vaikimisi käsk /bin/echo;
- Paljudel juhtudel saab käsu xargs asendada for-tsükliga. Näiteks käsk $find. -tüüp f -ja -nimi "*.deb" | xargs -n 1 dpkg -I
tsükliga täiesti samaväärne
$ faili jaoks in `leida . -tüüp f -ja -nimi "*.deb"`; do dpkg -I "$ fail"; tehtud
Mittetriviaalsed näited
Jäime põhitõed meelde tüüpilised valikud kaalutud kasutusalasid... Liigume nüüd keerukamate ja mittetriviaalsete näidete juurde. Mõned neist mõtlesime välja iseseisvalt, tehes igapäevaseid ülesandeid, ja mõned õppisime saidilt http://www.commandlinefu.com (kõigile, kes soovivad õppida nendega töötamise keerukust). käsurida Soovitame seda aeg-ajalt külastada – sealt võib vahel väga kasulikke nõuandeid leida).
Keelake loendist IP-aadressid
IP-aadresside loendist keelamiseks peate need DROP-reegliga IP-tabelitesse lisama. See toiming viiakse läbi käsuga:
$ cat bad_ip_list | xargs -I IP iptables -A SISEND -s IP -j DROP
Saate teha rohkem keeruline operatsioon ja keelata kõik AS-i aadressid:
$ /usr/bin/whois -H -h whois.ripe.net -T marsruut -i origin AS<номер>|egrep "^route"|awk "(prindi $2)" |xargs -I NET iptables -A SISEND -s NET -j DROP
URL-i vormingu muutmine
Saate teisendada URL-i, näiteks „http%3A%2F%2Fwww.google.com” aadressiks „http://www,google.com”, kasutades käsku:
Echo "http%3A%2F%2Fwww.google.com" | sed -e"s/%\(\)/\\\\\x\1/g" | xargs echo -e
10-kohalise parooli genereerimine
Genereeri tugev parool saab teha sellise käsuga nagu:
$ tr -dc A-Za-z0-9_< /dev/urandom | head -c 10 | xargs
Saate luua paroole ilma xargs abita: selleks on spetsiaalne utiliit pwgen. Kirjeldatakse ka teisi paroolide genereerimise meetodeid.
Otsin binaarfaile, mis on installitud ilma dpkg-d kasutamata
Selline operatsioon võib osutuda vajalikuks, kui näiteks auto on ohvriks langenud häkkerite rünnak ja sellele installiti pahavara tarkvara. Järgmine käsk aitab teil tuvastada, millised programmid ründajad installisid (see otsib installitud kahendfaile ilma dpkg paketihalduri kasutamata):
$ cat /var/lib/dpkg/info/*.list > /tmp/listin ; ls /proc/*/exe |xargs -l readlink | grep -xvFf /tmp/listin; rm /tmp/listin
Vananenud kernelipakettide eemaldamine
$ dpkg -l linux-* | awk "/^ii/( print $2)" | grep -v -e `uname -r | lõika -f1,2 -d"-"` | grep -e | xargs sudo apt-get -y purgeVanade tuumade eemaldamise probleemist on Habrel juba juttu olnud – vaata (samal lingil leiad huvitavaid näiteid käskudest).
Teisendage skript stringiks
Mõnikord on vajadus suure skripti teisendamiseks üheks reale. Saate seda teha järgmiselt:
$ (sed "s/#.*//g"|sed "/^ *$/d"|tr "\n" ";"|xargs echo)< script.sh
Järeldus
Nagu ülevaatest näha, on xargi võimalused palju laiemad, kui esmapilgul tunduda võib. Loodame, et selles artiklis toodud näited on teile kasulikud. Kui teate xargi jaoks muid huvitavaid kasutusviise, olete teretulnud kommentaaridesse.
Pikkadel talveõhtutel istusin ja mõtlesin, et "kui päevavalgus tuleb, istun maha ja tegelen selle salapärase xargi utiliidiga korralikult." Tundub, et aeg on kätte jõudnud – ma istusin maha, et seda välja mõelda. Esimene asi, mis mulle silma jäi, oli see, et mees oli selle jaoks üsna salapärane ja ei teinud esimese korraga asju selgeks. Wikipedia ei lisanud ka mingit arusaama, vaid ajas mind isegi segadusse, nii et otsustasin oma uurimise läbi viia ja sellest kirjutada väike käsiraamat poisike Nagu sa tead, nii kaua, kui seletad, saad aru :)
Niisiis, xargs.
xargs on käsurea utiliit, mis võimaldab kutsuda mis tahes käsku argumentidega, mis on võetud standardne sisend. Lisaks saab argumendid edastada korraga või rühmitada mitmeks osaks. Uurime xargs versiooni 4.4.0 ja vastavalt mehe soovitusele kasutame ainult uusi argumente, mis pole deprekadena märgitud (parem on kohe harjuda õigesti töötama).
Seega tuleb kõigepealt mõista, kuidas xargs töötleb sissetulevat voogu ja jagab selle argumentideks. Olenevalt suvanditest on mitu režiimi:
1. Tavaline. Vaikimisi on argumentide eraldajaks mis tahes tühimärk: tühik, tabeldusmärk, vertikaalne tabeldusmärk või reavahetus. Kuid nagu käsukesta puhul, saate argumentide tükeldamise vältimiseks kasutada "" või \.
2. Regulaarne, rühmitamisega. Režiim on lubatud parameetri -L abil. Peaaegu identne eelmisega, välja arvatud see, et xargs jätab meelde, milline argument millisel real asub. Veelgi enam, kui rida lõpeb tühiku või tabeldusmärgiga, loetakse järgmist rida praeguse rea jätkuks.
3. Rida rea haaval. Lubatud, kui kasutate suvandit -I või -0. Sel juhul peetakse kogu stringi üheks tervikuks argumendiks, hoolimata tühikutest ja tabeldusmärkidest. -I puhul on rea lõpp märk "\n" ja -0 jaoks märk "\0"
Teeme paar testi, et seda kõike paremini mõista. Loome järgmise sisuga failitesti (== faili pole vaja sisestada):
==
arg1
arg2 tühik
"arg3 tsiteeritud"
arg4\ pääses
arg5 koos
jätka
==
("arg5 with" järel peab olema tühik)
Kirjutame ka väikese tp-skripti, mis väljastab oma argumendid, eraldades need sümboliga ":" ja kogusega:
==
#!/bin/bash
echo -n "@$#"
samas [[ $1 != "" ]]; tee echo -n ":$1"; nihe; tehtud
kaja
==
Tavarežiim (argumentide valimine tühikud):
x $ kassi test | xargs ./tp
@8:arg1:arg2:space:arg3 tsiteeritud:arg4 põgenes:arg5:with:continue
Fail jagati tühikute abil argumentideks, kuid märgiga "\" tsiteeritud ja paotatud read jäid puutumata.
Tavarežiim ridade kaupa rühmitamisega ei erine praeguses etapis eelmisest.
Joone poolitamine. Loome teise testfaili järgmise käsuga:
x $ cp test testz && printf "\0arg6" >> testz
Kontrollime
x $ kass testz | xargs -0 ./tp
@2:arg1
arg2 tühik
"arg3 tsiteeritud"
arg4\ pääses
arg5 koos
jätka
:arg6
Nagu näete, on ainult 2 argumenti, millest esimene on pikk, säilitades reavahetused, jutumärgid ja \, ja teine on arg6. Failis on need eraldatud nullmärgiga.
Parameetrite eraldamise kohta võime öelda ka -d valiku kohta, mis määrab uue eraldaja. Näiteks proovime kasutada eraldajana "3".
x $ kassi test | xargs -d 3 ./tp
@2:arg1
arg2 tühik
"arg: tsiteeritud"
arg4\ pääses
arg5 koos
jätka
Fail on sümboli "3" asukohas jagatud kaheks osaks. Tähelepanuväärne on see, et sel viisil saate emuleerida suvandit -0
x $ kassi testz | xargs -d "\x00" ./tp
@2:arg1
arg2 tühik
"arg3 tsiteeritud"
arg4\ pääses
arg5 koos
jätka
:arg6
Tundub, et oleme sisendvoo argumentideks jaotamise korda ajanud, liigume edasi parameetrite asendamise juurde.
Seega ootab xarg pärast oma suvandeid käsku, mille ta täidab. Kõik sissetulevad argumendid jagatakse rühmadesse, mille järel antud käsk kutsutakse iga rühma jaoks ja kõik selle rühma argumendid edastatakse sellele.
Nüüd vaatame, kuidas rühmad moodustatakse.
1. Kui valikuid pole, siis on ainult üks grupp, sinna langevad kõik sisendvoo argumendid. Niiöelda lõpmatu suurusega seltskond :)
2. Valik -L n määrab rühmitamise ridade järgi. Käsk edastatakse argumendid n real. Ma demonstreerin näidetega.
Rühmitamine 1 rea järgi:
x $ kassi test | xargs -L 1 ./tp
@1:arg1
@2:arg2:space
@1:arg3 tsiteeritud
@1:arg4 põgenes
@3:arg5:with:continue
Näete, et teine rida sisaldab 2 argumenti, kuna need on mõlemad samal real. Ja viimane on tegelikult 3, kuna eelviimane rida on lõpus oleva tühiku tõttu “pikenenud”.
Nüüd rühmitage 2 rea kaupa. Käsk sisaldab ridu 1 ja 2; 3 ja 4; ja orb 5:
x $ kassi test | xargs -L 2 ./tp
@3:arg1:arg2:tühik
@2:arg3 tsiteeritud:arg4 põgenes
@3:arg5:with:continue
3. Rühmitamine argumentide järgi, mis on määratud võtmega -n x. Siin on kõik läbipaistev: argumendid rühmitatakse x tükiks ja edastatakse käsule.
Ühe argumendi jaoks:
x $ kassi test | xargs -n 1 ./tp
@1:arg1
@1:arg2
@1:tühik
@1:arg3 tsiteeritud
@1:arg4 põgenes
@1:arg5
@1:koos
@1:jätka
2 argumenti:
x $ kassi test | xargs -n 2 ./tp
@2:arg1:arg2
@2:space:arg3 tsiteeritud
@2:arg4 põgenes:arg5
@2:with:continue
3. Asendusrežiim - valik -I. Alustuseks peame seda meelde tuletama see režiim Sisendvoo argumendid sõelutakse erinevalt. Iga rida on üks terve argument. Teiseks on suvandil -I parameeter - string, mis asendatakse käsus argumendiga:
x $ kaja -e "A B\nC D" | xargs -I _ ./tp =_+_=
@1:=A B+A B=
@1:=C D+C D=
Lihtne on märgata, et märk _ on määratud argumendi asendusstringina, mida käsus kasutatakse 2 korda. Samuti näete, et argumendid jaotatakse tervete ridadena ja tühik ei mõjuta sõelumist. Käsk kutsutakse iga argumendi jaoks.
See on kõik asendamisega. Vaatame ülejäänud olulisi võimalusi
-r - ärge käivitage käsku, kui argumente pole:
x $ cat /dev/null | xargs ./tp
@0
x $ cat /dev/null | xargs -r ./tp
x$
Nagu näete, teisel juhul käsku ei täidetud.
P - xargs küsib iga käsu täitmiseks kinnitust.
See lõpetab lühikese õpetuse. See ei tulnud küll väga lühike, aga loodan, et oli arusaadav ;)
Vältige halbu UNIX-i tavasid
Sageli mis tahes süsteemi kasutades harjume teatud töömustritega. Kuid need mallid ei ole alati optimaalsed. Mõnikord tekivad meil isegi halvad harjumused, mis toovad kaasa segaduse ja kohmakuse tööl. Üks neist parimad viisid Selliste puuduste parandamine arendab harjumust kasutada häid tehnikaid, mis takistavad segadust. See artikkel pakub 10 meetodit meeskonnatööga töötamiseks UNIX string väärilised harjumused, mis aitavad vältida paljusid levinud puudujääke ja parandada töö efektiivsust. Täpsem kirjeldus Kõik meetodid on toodud loendi järel.
Õpime 10 head harjumust
Kümme head meetodit, millega harjuda:
Looge kataloogipuud ühe käsuga
Loetelu 1 illustreerib üht kõige levinumat UNIX-i tõrget: kataloogipuu määramine samm-sammult.
Loetelu 1. Halva tava nr 1 näide: Samm-sammult määratlus kataloogipuu
~ $ mkdir tmp ~ $ cd tmp ~/tmp $ mkdir a ~/tmp $ cd a ~/tmp/a $ mkdir b ~/tmp/a $ cd b ~/tmp/a/b/ $ mkdir c ~/tmp /a/b/ $ cd c ~/tmp/a/b/c $Palju kiirem on kasutada suvandit -p mkdir ning luua kõik vanem- ja alamkataloogid ühe käsuga. Kuid isegi administraatorid, kes sellest valikust teavad, töötavad samm-sammult, luues käsureal iga alamkataloogi eraldi. Säästke oma aega – harjuge sellega häid meetodeid:
Nimekiri 2. Hea töömeetodi näide nr 1: Kataloogipuu määratlemine ühe käsuga
~ $ mkdir -p tmp/a/b/cSelle valiku abil saate luua mitte ainult lihtsa hierarhia, vaid ka keerukaid kataloogipuid, mida on skriptides väga mugav kasutada. Näiteks:
Loetelu 3. Veel üks näide heast töömeetodist #1: Keerulise kataloogipuu määratlemine ühe käsuga
~ $ mkdir -p project/(lib/ext,bin,src,doc/(html,info,pdf),demo/stat/a)Varem oli kataloogipuust läbi astumiseks ainult üks põhjus – mkdiri juurutamine seda võimalust ei toetanud, kuid enamiku süsteemide puhul pole see enam asjakohane. IBM, AIX, mkdir, GNU mkdir ja teised süsteemid, mis vastavad UNIX-i spetsifikatsioonile, saavad nüüd selle võimaluse.
Nende väheste süsteemide puhul, millel seda funktsiooni pole, peaksite kasutama skripti mkdirhier (vt ), mis mähib mkdir ja täidab sama funktsiooni.
~ $ mkdirhier project/(lib/ext,bin,src,doc/(html,info,pdf),demo/stat/a)Muutke teid; ärge teisaldage arhiivi
Teine halb viis töötamiseks on teisaldada arhiivi .tar-fail kindlasse kataloogi, kui soovite arhiivi sellesse kataloogi ekstraktida. Sa ei tohiks seda teha. Saate lahti pakkida mis tahes arhiivifail.tar mis tahes kataloogi – selleks on suvand -C. Kasutage suvandit -C lahtipakkitava kataloogi määramiseks:
4. loend: hea lahenduse näide nr 2: suvandi -C kasutamine .tar-arhiivifaili lahtipakkimiseks
~ $ tar xvf -C tmp/a/b/c newarc.tar.gzSuvandi -C kasutamine on parem kui arhiivifaili teisaldamine soovitud kataloogi, kataloogi muutmine ja faili sisu ekstraktimine – eriti kui arhiivifail ise asub kusagil mujal.
Kombineerige oma käsud juhtlausetega
Tõenäoliselt teate juba, et enamikus kestades saate kombineerida käske samal käsureal, kasutades nende vahel semikoolonit (;). Semikoolon on shelli juhtoperaator ja kuigi selle eesmärk on aheldada mitu erinevat käsku ühele käsureale, ei ole selle kasutamine alati võimalik. Oletame näiteks, et kasutate semikoolonit kahe käsu ühendamiseks, mille puhul teise käsu täitmine sõltub täielikult esimese edukast täitmisest. Kui esimene käsk ei tööta ootuspäraselt, siis teine käsk ikka jookseb – ja ebaõnnestub. Selle asemel kasutage rohkem sobiv operaator juhtnupud (mõned on kirjeldatud käesolevas artiklis). Kui teie kest neid toetab, kulub neil veidi harjumist.
Käivitage käsk ainult siis, kui mõni muu käsk tagastab nullväärtuse
Kasutage && juhtoperaatorit kahe käsu kombineerimiseks nii, et teist käsku täidetakse ainult siis, kui esimene tagastatakse nullväärtus. Teisisõnu, kui esimene käsk õnnestub, jookseb ka teine käsk. Kui esimest käsku ei täideta, siis teist käsku ei käivitata üldse. Näiteks:
Loetelu 5. Hea tava näide nr 3: Kombineeri käske juhtlausetega
~ $ cd tmp/a/b/c && tar xvf ~/archive.tarSee näide ekstraktib arhiivi sisu kataloogi ~/tmp/a/b/c, kui see kataloog on olemas. Kui kataloogi pole, siis käsk tar ei käivitu ja arhiivist ei ekstraheerita midagi.
Käivitage käsk ainult siis, kui mõni muu käsk tagastab nullist erineva väärtuse
Samamoodi kontrolli operaator || eraldab need kaks käsku ja käivitab teise käsu ainult siis, kui esimene käsk tagastas nullist erineva väärtuse. Teisisõnu, kui esimene käsk oli edukas, siis teist käsku ei käivitata. Kui esimene käsk ebaõnnestub, siis teine algab. Seda operaatorit kasutatakse sageli selleks, et testida, kas antud kataloog on olemas, ja kui ei, siis see loob selle:
Loetelu 6. Veel üks hea tava nr 3 näide: Kombineerige käsud juhtlausetega
~ $ cd tmp/a/b/c || mkdir -p tmp/a/b/cSamuti saate kombineerida selles jaotises kirjeldatud juhtlauseid. Igaüks neist viitab viimasele käivitatud käsule:
Nimekiri 7. Hea tava kombineeritud näide nr 3: käskude kombineerimine juhtlausetega
~ $ cd tmp/a/b/c || mkdir -p tmp/a/b/c &&Olge muutujatega töötamisel jutumärkide kasutamisel ettevaatlik
Ole alati ettevaatlik kesta laiendamise ja muutujate nimedega. Tegelikult see on hea mõte- lisage viited muutujatele jutumärkidesse ainult siis, kui puuduvad erilised põhjused, miks seda mitte teha. Samamoodi, kui muutuja nimele järgneb kohe tähtnumbriline tekst, tuleb muutuja nimi lisada traksid(()), et eristada seda ümbritsevast tekstist. Vastasel juhul tõlgendab kest lõputeksti muutuja nime osana – ja kõige tõenäolisem tulemus on null kood tagasi. Loendis 8 on näited muutujate nimedega jutumärkide kasutamisest ja tulemused.
Loetelu 8. Hea tava näide nr 4: Jutumärkide kasutamine (ja mitte kasutamine) muutujatega töötamisel
~ $ ls tmp/ a b ~ $ VAR="tmp/*" ~ $ kaja $VAR tmp/a tmp/b ~ $ kaja "$VAR" tmp/* ~ $ kaja $VARa ~ $ kaja "$VARa" ~ $ kaja "$(VAR)a" tmp/*a ~ $ echo $(VAR)a tmp/a ~ $Kasutage pika stringi sisestamiseks paojärjestust
Tõenäoliselt olete näinud näiteid koodist, kus kaldkriips (\) jätkab pikka rida, ja teate, et enamik kestasid käsitleb seda, mida kirjutate järgnevatele ridadele, mis on ühendatud kaldkriipsuga, ühe pika reana. Siiski võite saada rohkem kasu sellest funktsioonist käsureal, kasutades seda sagedamini. Kaldkriips on eriti kasulik, kui teie terminal ei käsitle mitmerealisi katkestusi korralikult või kui käsurida on tavapärasest lühem (näiteks kui teil on pikk tee). Kaldkriips on kasulik ka tähendusosade esiletõstmiseks. pikk rida, nagu järgmises näites:
Loetelu 9. Hea tava näide nr 5: kaldkriipsude kasutamine pikkadel stringidel
~ $ cd tmp/a/b/c || \ > mkdir -p tmp/a/b/c && \ > tar xvf -C tmp/a/b/c ~/archive.tarAlternatiivina on siin veel üks toimiv konfiguratsioon:
Loetelu 10. Hea tava alternatiivne näide nr 5: kaldkriipsude kasutamine pikkadel stringidel
~ $ cd tmp/a/b/c \ > || \ > mkdir -p tmp/a/b/c \ > && \ > tar xvf -C tmp/a/b/c ~/archive.tarKui jagate stringi mitmeks reaks, käsitleb kest seda alati ühe terve stringina, eemaldades saadud pikalt stringilt kõik kaldkriipsud ja lisatühikud.
Märge: Enamikus kestades kuvatakse ülesnoole vajutamisel kogu mitmerealine rida ühe pika reana.
Kombineerige käsud loendisse
Enamik kestasid võimaldab kombineerida käskude komplekte loendiks; Nii saate tööd ühest meeskonnast teise torustada või muul viisil ümber suunata. Tavaliselt saate seda teha, käivitades käskude loendi alternatiivses või praeguses kestas.
Käskude loendi käivitamine täiendavas kestas
Kasutage käskude loendi ühte rühma lisamiseks sulgusid. See võimaldab teil käivitada käske täiendavas kestas ja suunata või muul viisil koguda nende väljundit, nagu on näidatud järgmises näites:
Loetelu 11. Hea tava näide nr 6: Käskude loendi käivitamine täiendavas kestas
~ $ (cd tmp/a/b/c/ || mkdir -p tmp/a/b/c && \ > VAR=$PWD; cd ~; tar xvf -C $VAR arhiiv.tar) \ > | mailx admin -S "Arhiivi sisu"See näide ekstraktib arhiivi sisu kataloogi tmp/a/b/c, samal ajal kui rühmitatud käskude väljund, sealhulgas ekstraktitud failide loend, saadetakse administraatorile.
Täiendavate ümbriste kasutamine on kasulik juhtudel, kui alistate Keskkonnamuutujad käsuloendis ja ei taha neid muudatusi oma praeguses kestas aktsepteerida.
Käivitage praeguses kestas käskude loend
Käivitavate käskude loendi lisamiseks kasutage lokkis sulgusid (()). praegune kest. Lisage sulgude ja käskude vahele kindlasti tühikud, sest... vastasel juhul võib kest sulgusid valesti tõlgendada. Veenduge ka, et loendi viimasele käsule järgneb semikoolon (;), nagu järgmises näites.
Loetelu 12. Veel üks näide heast tavast nr 6: Käskude loendi käivitamine praeguses shellis
~ $ ( cp $(VAR)a . && chown -R guest.guest a && \ > tar cvf newarchive.tar a; ) | mailx admin -S "Uus arhiiv"Otsingutulemuste leidmiseks rakendage xargs
Kasutage käsku xargs filtrina, et töötada failide loendiga, mis tagastatakse otsimise käsuga. Tavaliselt leidke käsk tagastab teatud kriteeriumidele vastavate failide loendi. See loend edastatakse süsteemile xargs, mis teostab muid toiminguid, kasutades argumentidena failide loendit, nagu järgmises näites:
Loetelu 13. Näide käsu xargs klassikalisest kasutamisest
~$leia | \>xargsKuid ärge arvake, et xargs on lihtsalt leidmise lisand; See on üks neist tööriistadest, millega pärast harjumist soovite sellega pidevalt töötada, näiteks järgmistel juhtudel:
Tühikutega eraldatud loendi edastamine
Sellel lihtsal illustratsioonil on xargs nagu filter, mis võtab sisendiks loendi (iga element eraldi real) ja asetab selle elemendid ühele reale, eraldades need tühikutega:
Loetelu 14. Käsu xargs näidisväljund
~ $ xargsabc a b c ~ $Saate saata mis tahes failinimesid väljastava tööriista väljundi läbi xargs, et saada argumentide loend mõnele teisele tööriistale, mis võtab argumendina failinimesid, nagu järgmises näites:
Loetelu 15. Näide käsu xargs kasutamisest
~/tmp $ ls -1 | xargs December_Report.pdf LOE ME a archive.tar mkdirhier.sh ~/tmp $ ls -1 | xargs fail December_Report.pdf: PDF dokument, versioon 1.3 README: ASCII tekst a: kataloog arhiiv.tar: POSIX tar arhiiv mkdirhier.sh: Bourne shelliskripti teksti käivitatav ~/tmp $Käsk xargs on kasulik rohkem kui lihtsalt failinimede edastamiseks. Kasutage seda iga kord, kui peate teksti ühele reale filtreerima:
Loetelu 16. Hea lahenduse näide nr 7: tööriista xargs kasutamine teksti ühele reale filtreerimiseks
~/tmp $ ls -l | xargs -rw-r--r-- 7 joe joe 12043 27. jaanuar 20:36 detsember_Report.pdf -rw-r--r-- 1 \ juurjuur 238 dets 03 08:19 LOEME drwxr-xr-x 38 joe joe 354082 2. nov \ 16:07 a -rw-r--r-- 3 joe joe 5096 14. detsember 14:26 archive.tar -rwxr-xr-x 1 \ joe joe 3239 30. september 12:40 msh ~/hier. tmp$Olge xargi kasutamisel ettevaatlik
Tehniliselt on harvad juhud, kus xargi kasutamine võib olla problemaatiline. Vaikimisi on faili lõpu märk alakriips (_); kui see märk oli ainsa argumendina edasi antud, ignoreeritakse kõike pärast seda. Ettevaatusabinõuna kasutage lippu -e, mis ilma argumentideta keelab faililõpu märgi.
Tea, millal kasutada loendamiseks grep-i ja millal seda vältida
Vältige wc -l kasutamist pärast grep-i vastuvõetud ridade loendamiseks. Suvand -c grep võimaldab teil lugeda ridade arvu, mis vastavad antud mustritele ja on üldiselt kiirem kui kombinatsioon "wc after grep", nagu järgmises näites:
Loetelu 17. Hea meetodi näide nr 8: ridade loendamine grepiga ja ilma
~ $ aeg grep ja tmp/a/longfile.txt | wc -l 2811 päris 0m0.097s kasutaja 0m0.006s sys 0m0.032s ~ $ aeg grep -c ja tmp/a/longfile.txt 2811 päris 0m0.013s kasutaja 0m0.006s sys 0m0.005s ~ $Valik -c on heas mõttes loendamine ei tulene ainult kiirustegurist. Mitme faili kasutamisel tagastab grep võtmega -c iga faili jaoks eraldi väärtuse, igale reale ühe, samas kui wc väljundsuund annab üldine tulemus kõigi failide jaoks.
See näide pole aga huvitav mitte ainult jõudluse seisukohalt – see illustreerib veel üht levinud viga. See loendusmeetod annab ainult ridade arv, millelt leiti vasteid mustriga- ja hea, kui see on see, mida otsite. Kuid juhtudel, kui stringidel võib teatud mustriga olla mitu vastet, ei anna need meetodid tegelikke tulemusi mustri vastete arv. Tikkude arvu loendamiseks kasutage wc . Alustuseks käivitage grep võtmega -o, kui teie versioon seda toetab. See valik kuvatakse ainult mustri vasted, üks iga rea jaoks, kuid mitte rida ise. Seda ei saa kasutada koos võtmega -c, seega kasutage ridade arvu loendamiseks wc -l, nagu järgmises näites:
Hea tava näide nr 8: vastete arvu loendamine mustrile grep-iga
~ $ grep -o ja tmp/a/longfile.txt | wc -l 3402 ~ $Sel juhul on wc kutsumine veidi kiirem kui grep teistkordne kutsumine näiva mustriga, mis võimaldab iga rida võrrelda ja loendada (nagu grep -c).
Konkreetsete väljundväljade, mitte ainult stringide võrdlemine
Tööriista nagu awk on eelistatav grepile, kui soovite sobitada mustri ainult sisse konkreetsed väljad väljundi read, mitte kogu rida.
Järgmine lihtsustatud näide näitab, kuidas sortida ainult neid faile, mida detsembris muudeti:
Loetelu 19. Näide halvast tavast nr 9: grepi kasutamine teatud väljade mustri leidmiseks
~/tmp $ ls -l /tmp/a/b/c | grep dets. -rw-r--r-- 7 joe joe 12043 27. jaanuar 20:36 detsember_Report.pdf -rw-r--r-- 1 juurjuur 238 detsember 03 08:19 LOE -rw-r--r- - 3 joe joe 5096 14. detsember 14:26 archive.tar ~/tmp $Selles näites filtreerib grep read ja prindib kõik failid, mille nimes või muutmiskuupäevas on Dets. Nii et selline fail nagu December_Report.pdf on hea, isegi kui seda pole jaanuarist saadik muudetud. See ei pruugi olla see, mida soovite. Konkreetsel väljal oleva mustri sobitamiseks on parem kasutada awk-i, milles suhteline operaator vastab konkreetsele väljale, nagu on näidatud järgmises näites
Loetelu 20. Hea lahenduse näide nr 9: awk kasutamine mustri leidmiseks teatud väljadel
~/tmp $ ls -l | awk "$6 == "Dec"" -rw-r--r-- 3 joe joe 5096 14. detsember 14:26 arhiiv.tar -rw-r--r-- 1 juurjuur 238. detsember 03. 08:19 LOE ME ~ /tmp$Lisateavet selle kohta kasutades awk saab lugeda rubriigist.
Ärge kasutage kassi väljundi möödumist
Peamine ja levinud viga grepi kasutamisel on sisu otsimiseks käsu cat väljundi grep edasi andmine grepile eraldi fail. See on täiesti tarbetu ajaraiskamine, sest sellised tööriistad nagu grep võtavad argumentidena failinimesid. Seetõttu pole selles olukorras absoluutselt vajadust kassi kasutada, nagu järgmises näites:
Loetelu 21. Hea meetodi näide nr 10: grepi kasutamine kassiga ja ilma.
~ $ aeg cat tmp/a/longfile.txt | grep ja 2811 päris 0m0.015s kasutaja 0m0.003s sys 0m0.013s ~ $ aega grep ja tmp/a/longfile.txt 2811 päris 0m0.010s kasutaja 0m0.006s sys 0m0.004s ~ $Seda viga tehakse paljudel juhtudel. Kuna enamik tööriistu saavad standardne sisend argumendina, kasutades sidekriipsu (-), ei kehti sageli isegi argument cat'i kasutamise kohta arvukate failide mitmekesistamiseks stdinist. Tegelikult on vaja enne konkatenatsiooni teha kasutades kassiühega mitmest filtreerimisvalikust.
Järeldus: harjuge heaga
Vaatasime mitmeid käsureal töötamise meetodeid. Halvad harjumused aeglustavad tööd ja põhjustavad sageli ootamatud vead. See artikkel räägib 10 uuest viisist, mis aitavad teil vabaneda paljudest enamlevinud vigadest. Harjuge nende heade tehnikatega ja parandage oma Unixi käsurea oskusi.
