Elekeza upya pato kwa faili. Inaelekeza upya mitiririko ya kawaida ya ingizo/towe

1403

Inaelekeza upya "2>&1", ">/dev/null" au mitiririko ya pato kwenye Unix (bash/sh)

Ukadiriaji wako: kazi bora ya ajabu nzuri sana nzuri ya kawaida Sijaisoma inayovumilika ya wastani mbaya mbaya sana usiisome.

Mitiririko ya pato

Ujumbe wa hati hutolewa kwa mitiririko iliyofafanuliwa vizuri - mitiririko ya pato. Hivyo kile sisi pato kupitia

echo "Halo, ulimwengu!"

Sio tu kuonyeshwa kwenye skrini, lakini, kutoka kwa mtazamo wa mfumo, na haswa wakalimani wa amri sh na bash, hutolewa kupitia mkondo maalum wa pato. Katika kesi ya echo, mkondo nambari 1 (stdout) ambayo skrini inahusishwa.

Programu zingine na maandishi pia hutumia mkondo tofauti wa pato - nambari 2 (stderr). Wanaonyesha ujumbe wa makosa hapo. Hii inafanya uwezekano wa kutenganisha taarifa za kawaida na ujumbe wa hitilafu kutoka kwa mitiririko na njia na kuzichakata kando.

Kwa mfano, unaweza kuzuia matokeo ya ujumbe wa habari, na kuacha ujumbe wa makosa tu. Au tuma ujumbe wa makosa kwa faili tofauti kwa ukataji miti.

">some faili" ni nini

Ingizo hili katika Unix (kwenye wakalimani wa bash na sh) linaonyesha kuelekezwa upya kwa mitiririko ya matokeo.

Katika mfano ufuatao, tutaelekeza upya ujumbe wote wa taarifa (wa kawaida) wa amri ya ls kwenye faili myfile.txt, hivyo basi kuwa na orodha ya ls kwenye faili hii:

$ ls > myfile.txt


Katika kesi hii, baada ya kushinikiza Ingiza, hutaona chochote kwenye skrini, lakini faili myfile.txt itakuwa na kila kitu ambacho kinapaswa kuonyeshwa kwenye skrini.

Walakini, wacha tufanye operesheni isiyofaa kwa makusudi:

$ ls /masdfasdf > myfile.txt


Basi nini kitatokea? Kwa sababu saraka ya masdfasdf haipo kwenye mzizi wa mfumo wa faili (nadhani hivyo - ikiwa utafanya hivyo?), basi amri ya ls itatoa kosa. Walakini, itatupa kosa hili sio kupitia mkondo wa kawaida wa stdout (1), lakini kupitia mkondo wa makosa stderr (2). Na uelekezaji kwingine umewekwa kwa stdout ("> myfile.txt pekee").

Kwa sababu hatukuelekeza upya mtiririko wa stderr(2) popote - ujumbe wa hitilafu utaonekana kwenye skrini na HAUTAKUA kwenye faili ya myfile.txt.

Sasa hebu tuendeshe ls amri ili data ya habari iandikwe kwa faili myfile.txt na ujumbe wa makosa uandikwe kwa faili myfile.err, bila kitu kinachoonekana kwenye skrini wakati wa utekelezaji:

$ ls >myfile.txt 2>myfile.err


Hapa tunakumbana kwa mara ya kwanza na kiashiria cha nambari ya mtiririko kama uelekezaji upya. Ingizo "2>myfile.err" linaonyesha kwamba mkondo nambari 2 (stderr) unapaswa kuelekezwa kwenye faili myfile.err.

Bila shaka, tunaweza kuelekeza mitiririko yote miwili kwa faili moja au kwa kifaa kimoja.

2>&1

Mara nyingi unaweza kupata ingizo kama hilo katika hati. Inamaanisha: "Elekeza upya nambari ya 2 ya mtiririko ili kutiririsha nambari 1", au "Tiririsha stderr - elekeza kupitia mkondo wa stdout". Wale. Tunapitisha ujumbe wote wa hitilafu kwa njia ambayo ujumbe wa kawaida, usio na makosa huchapishwa kwa kawaida.

$ ls /asfasdf 2>&1


Huu hapa ni mfano mwingine ambapo ujumbe wote huelekezwa kwenye faili myfile.txt:

$ ls /asfasdf >myfile.txt 2>&1


Katika kesi hii, ujumbe wote, wote wa makosa na wa kawaida, utaandikwa kwa myfile.txt, kwa sababu Kwanza tulielekeza mkondo wa stdout kwa faili, na kisha tukaashiria kuwa makosa yanapaswa kutupwa kwenye stdout - ipasavyo, kwenye faili myfile.txt.

/dev/null

Hata hivyo, wakati mwingine tunahitaji tu kuficha ujumbe wote - bila kuwahifadhi. Wale. zuia tu matokeo. Kifaa pepe /dev/null kinatumika kwa hili. Katika mfano ufuatao, tutaelekeza matokeo yote ya ujumbe wa kawaida kutoka kwa ls amri hadi /dev/null:

$ ls > /dev/null


Hakuna chochote isipokuwa ujumbe wa makosa utaonyeshwa kwenye skrini. Na katika mfano ufuatao, ujumbe wa makosa utazuiwa:

$ ls > /dev/null 2>&1


Zaidi ya hayo, rekodi hii ni sawa na rekodi ya fomu:

$ ls >/dev/null 2>/dev/null


Na katika mfano ufuatao tutazuia ujumbe wa makosa tu:

$ ls 2>/dev/null

Tafadhali kumbuka kuwa huwezi tena kubainisha “2>&1” hapa, kwa sababu mkondo (1) hauelekezwi popote na katika kesi hii ujumbe wa makosa utaonekana tu kwenye skrini.

Nini huja kwanza - yai au kuku?

Nitakupa mifano 2 hapa.

Mfano 1)

$ ls >/dev/null 2>&1


Mfano 2)

$ ls 2>&1 >/dev/null


Kwa mwonekano, jumla haibadiliki kwa kupanga upya maeneo ya silabi. Lakini mpangilio wa viashiria vya uelekezaji mwingine ni muhimu!

Jambo ni kwamba wakalimani husoma na kutumia maelekezo mengine kutoka kushoto kwenda kulia. Na sasa tutaangalia mifano yote miwili.

Mfano 1

1) ">/dev/null" - tunaelekeza mkondo 1 (stdout) kwa /dev/null. Barua pepe zote zinazoingia kwenye mkondo (1) zitatumwa kwa /dev/null.

2) "2>&1" - tunaelekeza upya mkondo 2 (stderr) ili kutiririsha 1 (stdout). Lakini, kwa sababu thread 1 tayari inahusishwa na /dev/null - ujumbe wote bado utaishia ndani /dev/null.

Matokeo: skrini ni tupu.

Mfano 2

1) "2>&1" - tunaelekeza upya mkondo wa makosa stderr (2) hadi mkondo wa stdout (1). Wakati huo huo, kwa sababu thread 1 inahusishwa na terminal kwa chaguo-msingi - tutafanikiwa kuona ujumbe wa makosa kwenye skrini.

2) ">/dev/null" - na hapa tunaelekeza upya thread 1 hadi /dev/null. Na hatutaona ujumbe wa kawaida.

Matokeo: Tutaona ujumbe wa makosa kwenye skrini, lakini hatutaona ujumbe wa kawaida.

Hitimisho: elekeza upya mtiririko kwanza, kisha uunganishe.

Ingawa programu kawaida hushughulikia mitiririko ya kawaida ya I/O, kama ilivyobainishwa, ganda lina vifaa maalum vya kuelekeza I/O.

5.5.1 Waendeshaji >,< и >>

Alama " hutumika kuashiria kuelekezwa kwingine > ", "< "Na" >> ". Matumizi ya kawaida ni kuelekeza pato la amri kwa faili. Huu hapa ni mfano:

$ ls -l > /home/jim/dir.txt

Amri hii itahifadhi katika faili /home/jim/dir.txt orodha ya faili na saraka ndogo za saraka ambayo ilikuwa ya sasa wakati amri inatekelezwa. ls; Aidha, ikiwa faili maalum haikuwepo, itaundwa; ikiwa ilikuwepo, itaandikwa tena; ikiwa unataka pato la amri kuongezwa hadi mwisho wa faili iliyopo, basi badala ya ishara unayohitaji > kutumia >> . Katika kesi hii, uwepo wa nafasi kabla au baada ya wahusika > au >> haina maana na hutumikia tu kwa urahisi wa mtumiaji.

Unaweza kutuma pato sio tu kwa faili, lakini pia kwa ingizo la amri nyingine au kwa kifaa (kama vile kichapishi). Kwa hivyo, kuhesabu idadi ya maneno katika faili ya /home/jim/report.txt, unaweza kutumia amri ifuatayo:

$ cat /home/jim/report.txt > wc -w

na kuchapisha faili, tumia amri:

$ cat /home/jim/report.txt > lpr

Kama unaweza kuona, operator > hutumika kuelekeza upya mkondo wa pato. Kuhusiana na mkondo wa uingizaji, kazi sawa inafanywa na operator < . Amri ya mfano hapo juu ya kuhesabu idadi ya maneno kwenye faili fulani inaweza kuandikwa tena kama ifuatavyo (kumbuka kutokuwepo kwa amri. paka):

$wc -w< /home/jim/report.txt

Chaguo hili la uelekezaji kwingine hutumiwa mara nyingi katika hati mbalimbali kwa amri ambazo kwa kawaida hukubali (au kutarajia) uingizaji wa kibodi. Katika hati inayoendesha shughuli zingine za kawaida, unaweza kutoa amri habari muhimu kutoka kwa faili ambayo kile kinachohitajika kuingizwa ili kutekeleza amri hii kimerekodiwa mapema.

Kutokana na ukweli kwamba alama < , > Na >> tenda kwa mitiririko ya kawaida, inaweza kutumika sio tu kwa njia ya kawaida, kama kawaida hufanyika, lakini pia kwa njia tofauti kidogo. Kwa hivyo, amri zifuatazo ni sawa:

$ paka > faili

$paka>faili

$ > paka faili

$ > paka faili

Walakini, peke yake (bila amri yoyote ambayo mito ya kawaida hufafanuliwa) ishara ya uelekezaji haiwezi kutumika, kwa hivyo mtu hawezi, kwa mfano, kwa kuandika.

$file1 > faili2

pata nakala ya faili. Lakini hii haipunguzi umuhimu wa utaratibu huu, kwa sababu nyuzi za kawaida zinafafanuliwa kwa amri yoyote. Katika kesi hii, unaweza kuelekeza sio tu pembejeo na pato la kawaida, lakini pia mitiririko mingine. Ili kufanya hivyo, taja nambari ya mkondo ulioelekezwa upya kabla ya ishara ya uelekezaji upya. Ingizo la kawaida la stdin ni nambari 0, stdout ya pato la kawaida ni nambari 1, ujumbe wa kawaida wa makosa stderr ni nambari 2. Hiyo ni, umbizo kamili la amri ya uelekezaji upya ni (kumbuka kuwa nafasi zilizo karibu > ni za hiari):

amri N>M

Wapi N Na M- nambari za mitiririko ya kawaida (0,1,2) au majina ya faili. Matumizi ya alama katika baadhi ya matukio < , > Na >> bila kutaja nambari ya kituo au jina la faili inawezekana tu kwa sababu 1 inabadilishwa kwa chaguo-msingi kwa nambari inayokosekana, i.e. pato la kawaida. Ndio, mwendeshaji > bila kutaja nambari inatafsiriwa kama 1 > .

Kando na kuelekeza upya mitiririko ya kawaida, inawezekana pia sio tu kuelekeza mtiririko kwenye kituo kimoja au kingine, lakini kutengeneza nakala ya maudhui ya mtiririko wa kawaida. Kuna ishara maalum kwa hili & , ambayo imewekwa mbele ya nambari ya kituo ambako mkondo unaelekezwa kwingine:

amri N > &M

Amri hii inamaanisha kuwa matokeo ya nambari ya kituo N hutumwa kwa pato la kawaida na kunakiliwa katika nambari ya kituo M. Kwa mfano, ili ujumbe wa makosa urudiwe kwenye pato la kawaida, unahitaji kutoa amri 2>&1, wakati 1>&2 nakala stdout kwa stderr. Kipengele hiki ni muhimu sana wakati wa kuelekeza pato kwa faili, kwani sisi sote tunaona ujumbe kwenye skrini na kuzihifadhi kwenye faili.

5.5.2 Opereta |

Chaguo maalum kwa uelekezaji wa pato ni kituo cha programu (wakati mwingine huitwa bomba au conveyor). Ili kufanya hivyo, amri mbili au zaidi, kama vile pato la awali hutumika kama pembejeo kwa ijayo, zimeunganishwa (au kutengwa, ikiwa unapendelea) na tabia ya wima ya bar - "|". Katika kesi hii, mkondo wa pato la kawaida la amri iko upande wa kushoto wa ishara | , inatumwa kwa pembejeo ya kawaida ya programu iko upande wa kulia wa ishara | . Kwa mfano:

$ paka myfile | grep Linux | wc -l

Mstari huu unamaanisha kuwa matokeo ya amri ni paka, i.e. maandishi kutoka kwa faili ya myfile, yatatumwa kwa pembejeo ya amri grep, ambayo itaangazia tu mistari iliyo na neno "Linux". Pato la amri grep itaelekezwa kwa pembejeo ya amri wc -l, ambayo itahesabu idadi ya mistari kama hiyo.

Mabomba ya programu hutumiwa kuchanganya programu kadhaa ndogo, ambayo kila mmoja hufanya mabadiliko maalum tu kwenye mkondo wake wa pembejeo, ili kuunda maelekezo ya jumla ambayo husababisha mabadiliko magumu zaidi.

Ikumbukwe kwamba ganda wakati huo huo huita amri zote zilizojumuishwa kwenye bomba la utekelezaji, ikizindua mfano tofauti wa ganda kwa kila amri, ili mara tu programu ya kwanza inapoanza kutoa kitu kwenye mkondo wake wa pato, amri inayofuata huanza kuichakata. Kwa njia hiyo hiyo, kila amri inayofuata hufanya kazi yake mwenyewe, kusubiri data kutoka kwa amri ya awali na kutoa matokeo yake kama pembejeo ya ijayo. Ikiwa unataka amri ikamilike kabisa kabla ya inayofuata kuanza, unaweza kuitumia kwenye mstari mmoja kama ishara ya bomba | , na nusu koloni ; . Kabla ya kila semicolon, ganda litasimama na kusubiri amri zote za awali zilizojumuishwa kwenye bomba ili kukamilisha utekelezaji.

Hali ya kutoka (thamani ya boolean iliyorejeshwa baada ya kukamilika kwa programu) kutoka kwa bomba ni sawa na hali ya kutoka iliyorejeshwa na amri ya mwisho kwenye bomba. Unaweza kuweka alama ya "!" mbele ya amri ya kwanza ya bomba, basi hali ya kutoka kutoka kwa bomba itakuwa ukataaji wa kimantiki wa hali ya kutoka kutoka kwa amri ya mwisho. Ganda husubiri amri zote za bomba zikamilike kabla ya kuweka thamani ya kurejesha.

5.5.3 Vichujio

Mfano wa mwisho hapo juu (na amri grep) inaweza kutumika kuonyesha dhana nyingine muhimu, yaani programu ya kichujio. Vichujio ni amri (au programu) ambazo huchukua mtiririko wa data ya ingizo, kufanya mabadiliko kadhaa juu yake, na kutoa matokeo hadi pato la kawaida (kutoka ambapo linaweza kuelekezwa kwingine kwa hiari ya mtumiaji). Amri za vichungi ni pamoja na amri zilizotajwa hapo juu paka, zaidi, kidogo, wc, cmp, tofauti, pamoja na amri zifuatazo.

Jedwali 5.1. Vichujio vya amri

Timu

Maelezo mafupi

grep, fgrep, mfano

Hutafuta faili ya ingizo au ingizo la kawaida kwa mistari iliyo na mchoro uliobainishwa na kuziandika kwa matokeo ya kawaida

Hubadilisha herufi zote zinazotokea katika mtiririko wa ingizo ulioorodheshwa katika orodha iliyotolewa na herufi zinazolingana kutoka kwa orodha ya pili iliyobainishwa.

comm

Inalinganisha faili mbili mstari kwa mstari na hutoa safu 3 kwa pato la kawaida: moja - mistari ambayo hutokea tu katika faili 1, ya pili - mistari ambayo hutokea tu katika faili ya 2: na ya tatu - mistari inayoonekana katika faili zote mbili.

Huumbiza faili ya maandishi au maudhui ya ingizo la kawaida kwa uchapishaji

sed

Kihariri cha mfuatano kinachotumiwa kufanya mabadiliko fulani kwenye mtiririko wa data ya ingizo (iliyochukuliwa kutoka kwa faili au kutoka kwa ingizo la kawaida)

Kichujio maalum ni amri tee, ambayo "hugawanya" mkondo wa pembejeo, kuielekeza kwa upande mmoja kwa pato la kawaida, na kwa upande mwingine kwa faili (ambalo jina lake lazima ueleze). Ni rahisi kuona kwamba kwa hatua yake amri tee sawa na mwendeshaji wa uelekezaji kwingine 1>&faili.

Uwezo wa vichungi unaweza kupanuliwa kwa kiasi kikubwa kupitia matumizi ya maneno ya kawaida, ambayo inakuwezesha kuandaa, kwa mfano, utafutaji kwa kutumia mifumo mbalimbali, mara nyingi ngumu sana.

Mengi yanaweza kusemwa kuhusu uelekezaji upya na vichungi. Lakini nyenzo hii inapatikana katika vitabu vingi vya UNIX na Linux, kwa mfano Petersen [P1.4] na Kelly-Bootle [P1.8]. Kwa hiyo, tutajiwekea kikomo kwa yale ambayo yamesemwa na kuendelea na kuzingatia kinachoitwa mazingira au mazingira yaliyoundwa na shell.

V. Kostromin (kos at rus-linux dot net) - 5.5. Uelekezaji kwingine wa I/O, chaneli na vichungi

Mpango wowote ni "mashine otomatiki" iliyoundwa kushughulikia data: kupokea habari moja kama pembejeo, hutoa nyingine kama matokeo ya kazi yake. Ingawa taarifa zinazoingia na/au zinazotoka zinaweza kuwa sufuri, yaani, kukosekana kwa urahisi. Data ambayo huhamishiwa kwenye programu kwa ajili ya usindikaji ni pembejeo yake, kile kinachozalisha kama matokeo ya kazi ni pato. Kupanga pembejeo na pato kwa kila programu ni kazi ya mfumo wa uendeshaji.

Kila programu inafanya kazi na data ya aina fulani: maandishi, picha, sauti, n.k. Kama tayari imekuwa wazi, kiolesura kuu cha usimamizi wa mfumo katika Linux ni terminal, ambayo imeundwa kuhamisha habari ya maandishi kutoka kwa mtumiaji hadi kwenye mfumo na. nyuma. Kwa kuwa habari pekee ya maandishi inaweza kuingizwa na pato kutoka kwa terminal, pembejeo na matokeo ya programu zinazohusiana na terminal lazima pia kuwa maandishi. Hata hivyo, haja ya kufanya kazi na data ya maandishi haipunguzi uwezo wa usimamizi wa mfumo, lakini, kinyume chake, huwapanua. Mtu anaweza kusoma pato la programu yoyote na kujua kinachotokea katika mfumo, na programu tofauti zinageuka kuwa zinaendana na kila mmoja kwa sababu hutumia aina moja ya uwakilishi wa data - maandishi.

Amri na hati zinaweza kupokea pembejeo kwa njia mbili: kutoka kwa pembejeo ya kawaida (iliyounganishwa kwenye kibodi) au kutoka kwa faili. Utenganisho sawa upo kwa pato: matokeo ya amri au hati hutumwa kwa skrini ya mwisho kwa chaguo-msingi, lakini unaweza kuielekeza kwenye faili. Ikiwa makosa hutokea wakati wa operesheni. ujumbe kuhusu wao pia huonyeshwa kwenye skrini, na mkondo wa makosa pia unaweza kuelekezwa kwenye faili.

Hebu tuangalie kwanza amri kadhaa ambazo zinaweza kutumika kupanga I/O.

Amri za Pato kwa Kifaa Kawaida cha Pato

Linux hutoa amri kadhaa za kuchapisha ujumbe kwa pato la kawaida:

  • echo - Chapisha kamba hadi pato la kawaida.
  • printf - Chapisha maandishi yaliyoumbizwa hadi towe la kawaida.
  • ndio - Chapisha maandishi yanayorudiwa kwa pato la kawaida.
  • seq - Chapisha mlolongo wa nambari hadi pato la kawaida
  • futa Futa skrini au dirisha.

Kwa mfano, unapotumia amri ya echo, ikiwa unataja tabia ya kudhibiti \c, basi wakati matokeo yatakamilika, hakutakuwa na mpito kwa mstari mpya:

$ echo "Jina lako ni nani?\c"

Jina lako ni nani?$

Hapa $ ni ishara ya mwaliko.

Mstari pia unaweza kuhesabu maadili ya vijiti vya ganda na hata amri zingine. Kwa mfano, amri ifuatayo inakuambia saraka ya nyumbani ya mtumiaji wa sasa ni nini (utofauti wa mazingira wa $HOME) na ni terminal gani ameunganishwa nayo (amri ya tty imefungwa kwa nukuu za nyuma ili mkalimani aweke matokeo ya utekelezaji wake kwenye a. mstari).

$ echo "saraka yako ya nyumbani ni $HOME, umeunganishwa kwenye terminal - `tty` "

Saraka yako ya nyumbani ni /home/knoppix, umeunganishwa kwenye terminal - /dev/tty1

Kwa kuwa nukuu mbili zina kusudi maalum katika mkalimani wa ganda, ili kujumuisha nukuu mara mbili kwenye kamba ya pato, unahitaji kutengua kusudi lao maalum kwa kutumia backslash (\). Hii inaghairi utumaji wa herufi yoyote maalum.

Kwa mfano, ili kuonyesha kamba "/dev/tty1" unahitaji kuendesha:

$mwangwi “\”/dev/tty1\””

Amri za ingizo kutoka kwa kifaa cha kawaida cha kuingiza data

Amri ya kusoma inasoma mstari mmoja kutoka kwa pembejeo ya kawaida na huandika yaliyomo kwa vigezo maalum. Wakati wa kutaja vigezo kadhaa, neno la kwanza limeandikwa kwa la kwanza, neno la pili hadi la pili, nk. ya mwisho ina safu iliyobaki.

Hati ifuatayo inaita amri tofauti ya kusoma ili kusoma kila kigezo.


$ paka mtihani
#!/bin/bash
mwangwi “Jina: \c”
soma jina
mwangwi “Jina la ukoo: \c”
soma jina la ukoo
mwangwi “Jina la kwanza=” $name “Jina la mwisho=” $surname

Kisha ili kutekeleza hati hii, unahitaji kuipa faili ya jaribio haki ya utekelezaji: chmod 0755 test na uikimbie./test. Matokeo ya kunyongwa: Jina la kwanza: Ivan Jina la mwisho: Petrov Jina la kwanza=Ivan Jina la mwisho=Petrov

Ingizo SANIFU, ZILIZOTOA NA MFUKO WA MAKOSA

Kila mpango uliozinduliwa kutoka kwa mkalimani wa amri hupokea mitiririko mitatu ya I/O wazi:

Ingizo la kawaida (sldin) - pato la kawaida (sldout) - pato la kawaida la makosa (stderr)

Kwa chaguo-msingi, nyuzi hizi zinahusishwa na terminal. Wale. Programu yoyote ambayo haitumii mitiririko isipokuwa ile ya kawaida itasubiri ingizo kutoka kwa kibodi ya terminal; matokeo yote ya programu hiyo, pamoja na ujumbe wa makosa, yatatokea kwenye skrini ya terminal.

Zaidi ya hayo, kila mchakato (amri, hati, n.k.) unaotekelezwa kwenye mkalimani wa ganda unahusishwa na idadi ya faili zilizo wazi ambazo mchakato huo unaweza kusoma data yake na ambayo inaweza kuiandika. Kila moja ya faili hizi hutambulishwa na nambari inayoitwa kielezi cha faili, lakini faili tatu za kwanza ni mitiririko chaguomsingi ya I/O:

Kielezi cha Faili
Mtiririko wa kawaida wa kuingiza 0
Pato la Kawaida 1
Mtiririko wa kawaida wa makosa 2

Kwa kweli, faili 12 zilizo wazi zimeundwa, lakini faili zilizo na maelezo 0, 1, na 2 zimehifadhiwa kwa pembejeo za kawaida, matokeo, na makosa. Watumiaji wanaweza pia kufanya kazi na faili ambazo zina maelezo ya faili 3 hadi 9 (zimehifadhiwa).

Faili ya kawaida ya ingizo (sldin) ina mpini 0. Kutoka kwa faili hii, michakato hutoa data yao ya ingizo. Kwa chaguo-msingi, mkondo wa pembejeo unahusishwa na kibodi (kifaa /dev/tty), lakini mara nyingi huja kupitia bomba kutoka kwa michakato mingine au kutoka kwa faili ya kawaida.

Faili ya pato la kawaida (stdout) ina kishughulikia 1. Toleo zote kutoka kwa mchakato umeandikwa kwa faili hii. Kwa chaguo-msingi, data hutolewa kwa skrini ya kulipia (kifaa/dev/tty), lakini pia inaweza kuelekezwa kwenye faili au kupitishwa kwa mchakato mwingine.

Faili ya kawaida ya mkondo wa makosa (siderr) ina kifafanuzi 2. Ujumbe wa hitilafu unaotokea wakati wa utekelezaji wa amri umeandikwa kwa faili hii. Kwa chaguo-msingi, ujumbe wa makosa hutolewa kwa skrini ya terminal (kifaa /dev/tty), lakini pia inaweza kuelekezwa kwenye faili. Kwa nini utenge faili maalum kwa makosa ya ukataji miti? Ukweli ni kwamba hii ni njia rahisi sana ya kutenganisha data halisi ya pato kutoka kwa matokeo ya kazi ya amri, pamoja na fursa nzuri ya kuandaa kwa ufanisi matengenezo ya aina mbalimbali za faili za logi.

Idadi kubwa ya huduma hutumia mitiririko ya kawaida pekee. Kwa programu kama hizo, ganda huruhusu mito ya I/O kuelekezwa kwa kujitegemea. Kwa mfano, unaweza kukandamiza ujumbe wa makosa, kuweka pembejeo au towe kutoka kwa faili.

Wale. Wakati wa kupiga amri, unaweza kutaja ambapo pembejeo inapaswa kupokelewa na wapi pato linapaswa kutumwa, pamoja na ujumbe wa makosa. Kwa chaguo-msingi, isipokuwa imeainishwa vinginevyo, kufanya kazi na terminal inadhaniwa: data imeingizwa kutoka kwa kibodi na kuonyeshwa kwenye skrini. Lakini mkalimani wa ganda ana utaratibu wa kuelekeza upya unaoruhusu mitiririko ya kawaida kuhusishwa na faili tofauti. Katika kesi hii, wakati wa kuelekeza mkondo wa makosa ya kawaida, kielezi cha faili (2) lazima kibainishwe. Hii sio lazima kwa mitiririko ya pembejeo na pato.

Kesi maalum muhimu ya kutumia utaratibu wa uelekezaji upya wa nyuzi ni kuelekeza kwa /dev/null, ambayo hukuruhusu kuondoa ujumbe usio wa lazima kwenye skrini. Kutumia utaratibu huo huo, unaweza kuunda faili tupu:

% cat myfile - itaunda faili tupu myfile kwenye saraka ya sasa.

/dev/null ni faili maalum ambayo inaitwa kinachojulikana. "kifaa tupu" Kuandika kwa hiyo hutokea kwa mafanikio, bila kujali kiasi cha habari "iliyorekodi". Kusoma kutoka /dev/null ni sawa na kusoma mwisho wa faili EOF.

Inaelekeza kwingine Mitiririko ya I/O inafanywa, kama DOS (Kwa usahihi zaidi, DOS OS ilipitisha syntax ya kuelekeza mitiririko kutoka UNIX) kwa kutumia alama:

- Elekeza mkondo wa pato la kawaida
- kuelekeza kwingine mkondo wa pato la kawaida katika hali ya nyongeza
- Elekeza upya mkondo wa kawaida wa ingizo
- Pokea data kutoka kwa pembejeo ya kawaida hadi kikomo kitakapokutana

Walakini, tofauti na DOS, wakati wa kuunda kituo cha programu kati ya michakato miwili, UNIX/Linux OS inazindua michakato yote miwili wakati huo huo na kuhamisha habari kupitia buffer ya mfumo (bila kurekodi kati kwa diski ngumu). Kwa hivyo, njia za programu katika UNIX/Linux OS ni njia nzuri sana ya kubadilishana. Ikiwa bafa ya mfumo itafurika (kwa mfano, ikiwa programu ya ``kutuma'' itatoa taarifa kwa chaneli kwa haraka zaidi kuliko programu ya ``kupokea'' inavyoweza kuichakata), Mfumo wa Uendeshaji husimamisha kiotomatiki mchakato unaoandika kwenye kituo hadi bafa. ni huru.

Waendeshaji Wengi wa Kawaida wa Kuelekeza Upya

Maelezo ya Sintaksia
Faili 1 ya amri Huelekeza pato la kawaida kwa faili mpya

2 amri faili 1 Huelekeza pato la kawaida kwa faili maalum

Amri ya faili 3 Inaelekeza pato la kawaida kwa faili iliyoainishwa (ambatisha modi)

4 amri faili 2&1 Inaelekeza pato la kawaida na kosa kwa faili maalum

5 amri faili 2 Inaelekeza kosa la kawaida kwa faili maalum

6 amri faili 2 Inaelekeza kosa la kawaida kwa faili iliyoainishwa (hali ya kuongeza)

Faili ya amri 7 2&1 Inaelekeza pato la kawaida na kosa kwa faili iliyoainishwa (ambatisha modi)

8 amri file1 file2 Inapokea ingizo kutoka kwa faili ya kwanza na kutuma towe kwa faili ya pili

9 kama ingizo la kawaida hupokea data kutoka kwa faili maalum

Amri ya kuweka mipaka 10 Hupokea data kutoka kwa uingizaji wa kawaida hadi kikomo kitakapokutana

11 amri &m Inapokea data kutoka kwa faili iliyo na kifafanuzi m kama ingizo la kawaida

12 amri &m Huelekeza pato la kawaida kwa kifafanuzi cha faili m

Opereta wa n&m huruhusu faili iliyo na kifafanuzi n ielekezwe kwenye eneo sawa na faili iliyo na kifafanuzi m. Kunaweza kuwa na waendeshaji kadhaa sawa kwenye mstari wa amri, kwa hali ambayo huhesabiwa kutoka kushoto kwenda kulia.

exec amri na kutumia maelezo ya faili

Amri ya exec inachukua nafasi ya ganda la sasa na amri maalum. Kawaida hutumiwa kufunga mkalimani wa sasa na kuanza mwingine. Lakini pia ina matumizi mengine.

Kwa mfano, amri kama

Faili ya Exec hufanya faili maalum kuwa pembejeo ya kawaida ya amri zote. Ifanye ndani
hakuna maana katika hali ya maingiliano - imekusudiwa kutumika katika maandishi,
ili amri zote zinazokuja baada ya kusoma data zao za kuingiza kutoka kwa faili. Kwa kesi hii
lazima kuwe na amri mwishoni mwa hati

Exec & - ambayo inafunga mkondo wa kawaida wa kuingiza (katika kesi hii faili). Mbinu sawa hutumiwa
haswa katika hati zinazoendeshwa unapotoka.

Amri ya kutekeleza ni kielekezi kwa faili iliyo na maelezo 0 (stdin). Kielekezi hiki kinaweza kurejeshwa tu baada ya hati kumaliza kufanya kazi.
Ikiwa hati inakusudia kuendelea kusoma data kutoka kwa kibodi, basi unahitaji kuhifadhi
pointer kwa mkondo wa awali wa ingizo. Chini ni hati fupi inayoonyesha jinsi ya kufanya hivyo.

$ paka f_desc
#!/bin/bash
kutekeleza 3&0 0 faili
soma mstari
soma mstari wa 2
kutekeleza 0&3
echo $1inel
echo $line2

Amri ya kwanza ya exec huhifadhi kielekezi kwa ingizo la kawaida (stdin) kwenye maelezo ya faili 3
(nambari kamili kati ya 3 na 9 inaruhusiwa) na kisha kufungua faili kwa ajili ya kusoma. Amri mbili zifuatazo za kusoma
soma mistari miwili ya maandishi kutoka kwa faili. Amri ya pili ya kutekeleza inarejesha pointer kwa pembejeo ya kawaida: sasa
inahusishwa na faili ya stdin, sio faili. Amri za mwisho za mwangwi zinaonyesha yaliyomo kwenye mistari iliyosomwa kwenye skrini,
ambazo zilihifadhiwa kwenye safu na anuwai za Iine2.

Matokeo ya hati:
$./f_desc
Habari!
Kwaheri!

Wakati mzuri, wasomaji wangu!
Katika nakala hii nataka kuratibu maarifa yangu kulingana na kanuni za msingi uendeshaji wa mitiririko ya programu na njia katika mkalimani na kwa ujumla katika Linux OS, na pia juu ya uwezekano inaelekeza kwingine data vijito.
Hapo mwanzo kabisa, ningependa kutambua kuwa mkalimani anafanya kazi na mitiririko mitatu ya kawaida:

  1. stdout Hii pato la kawaida, ambayo hutoa matokeo ya amri. Kifafanuzi cha mtiririko ni 1.
  2. stderr Hii utiririshaji wa makosa ya kawaida, ambayo huchapisha makosa ya amri. Maelezo yake ni 2.
  3. stdin Hii pembejeo ya kawaida, ambayo hutoa pembejeo kwa amri. Maelezo yake ni 0.

Sasa hebu tueleze kwa maneno rahisi maana ya nukta hizi tatu:

stdout- mkondo wa pato la kawaida. Hii, kwa maneno rahisi, ni habari ambayo tunaona katika mkalimani wakati wa kutekeleza amri. Hiyo ni, ujumbe wote (bila ujumbe wa makosa) ambayo amri iliyotekelezwa katika mkalimani inaripoti na kuonyesha kwenye terminal (soma: skrini). (matokeo kwenye skrini yamewekwa kwa chaguo-msingi, lakini unaweza pia kutaja pato, kwa mfano kwa faili au kuelekeza kwa amri nyingine; nitakuambia jinsi hii inafanywa hapa chini)

stderr- mkondo wa makosa. Hizi ni makosa wakati wa kutekeleza amri katika bash, ambayo kwa chaguo-msingi hutolewa kwa stdout, ambayo ni, kwa terminal (tena, isipokuwa pato la eneo lingine limeainishwa)

stdin- mkondo wa pembejeo. Hii, kwa maneno rahisi, ndio tunayoingiza kutoka kwa kibodi hadi kwa mkalimani kutekeleza amri.

Mtiririko huu umeonyeshwa vizuri sana kwenye takwimu iliyochukuliwa kutoka http://rus-linux.net/:

Katika picha hii: Stdin, iliyoonyeshwa kwa kijani kibichi, ina kushughulikia 0
Stdout, iliyoonyeshwa kwa nyekundu, ina mpini 1
Stderr, iliyoonyeshwa kwa bluu, ina mpini 2

Ifuatayo, nitakuambia jinsi mitiririko hii inaweza kuelekezwa/kutoka kwa faili. Hiyo ni, wakati wa kutekeleza amri, ili ujumbe au makosa hazionyeshwa kwenye skrini, lakini zimeandikwa kwa faili. Ni ya nini? Kweli, kwa mfano, unatekeleza amri ambayo matokeo yake hayafai kwenye dirisha la terminal. Unaiambia ihifadhi pato la kawaida kwa faili moja na kosa la kawaida kwa lingine. Kwa hivyo, makosa yote na ikiwa pato la kawaida linahitajika inaweza kutazamwa kwa undani kwa kufungua faili zilizohifadhiwa.

Kwa hivyo, uelekezaji wa nyuzi hufanywa kama hii:

$ amri n> faili

Mstari huu unaonyesha: utekelezaji wa amri amri na uelekezaji wa mtiririko (wapi n= mpini wa mkondo) kwa faili faili. Wakati wa kutekeleza uelekezaji huu kwingine, ikiwa faili lengwa lipo, litakuwa imeandikwa juu. Katika kesi hii, ikiwa n haijainishwa, basi pato la kawaida linachukuliwa.

$ amri n >> faili

Amri hii ina syntax sawa, lakini hapa ishara ">>" imebainishwa. Kwa uelekezaji huu, ikiwa faili lengwa lipo, matokeo ya amri yataongezwa kwa data iliyopo.

$amri< file

katika mfano huu amri amri inatekelezwa na hutumia faili kama chanzo cha ingizo faili, badala ya kuingiza kibodi

Wakati mwingine ni muhimu kuchanganya mtiririko wa hitilafu wa kawaida na mtiririko wa kawaida wa matokeo ili hitilafu na matokeo ya kawaida ya programu yaweze kuchakatwa pamoja. Kwa madhumuni haya, mchanganyiko na ishara hutumiwa: &. Mfano wa kitendo hiki:

Tafuta / -name .name_file > /path/to/file 2>&1

Wakati amri hii inatekelezwa, faili hutafutwa kutoka kwa mzizi wa mfumo wa faili na jina .jina_faili na kuelekeza matokeo ya utaftaji (stdout na stderr) kwa faili /path/to/file. Kubuni > /path/to/file 2>&1 inaelekeza pato la kawaida hadi /path/to/file na makosa ya uchapishaji kwa pato la kawaida. Hiyo ilisema: kuandika 2>&1 before > haitafanya kazi, kwa sababu mkalimani anaposoma 2>&1 , bado hajui ni wapi mkondo wa pato wa kawaida unaelekezwa kwingine, kwa hivyo makosa na mtiririko wa matokeo hautaunganishwa.

$ amri > faili 2>&1

sawa na kuandika:

$ amri &> faili

$ amri 2>&faili

Ikiwa pato linahitaji kupuuzwa, linaweza kuelekezwa kwa /dev/null kifaa, hii ni aina ya "shimo nyeusi" ambayo inachukua kiasi chochote cha habari na kuibadilisha kuwa kitu.

Nadhani maelezo yaliyotolewa kuhusu uelekezaji upya wa mtiririko yatatosha kuelewa kiini, sasa nitakuambia kuhusu uhamisho wa conveyor.

Bomba katika Linux ni uwezo wa programu kadhaa kufanya kazi pamoja wakati matokeo ya programu moja yanahamishwa moja kwa moja kwa pembejeo ya mwingine bila matumizi ya faili za muda za kati. Syntax ya kutumia bomba ni kama ifuatavyo.

$command1 | amri2

Katika mfano huu, amri inatekelezwa amri1, mtiririko wake wa pato hutumika kama mkondo wa ingizo wakati wa kutekeleza amri2.

Ni hayo tu kwa leo. Nitafurahi kupokea maoni na nyongeza. Asante.

Hongera sana, McSim!

Waendeshaji wa uelekezaji kwingine wa amri hutumiwa kubadilisha maeneo chaguomsingi ya ingizo la amri na mitiririko ya kutoa hadi eneo lingine. Mahali pa mitiririko ya pembejeo na pato inaitwa mpini.

Jedwali lifuatalo linaelezea waendeshaji wa uingizaji wa amri na pato.

Opereta wa uelekezaji kwingine

Maelezo

Huandika matokeo ya amri badala ya safu ya amri kwenye faili au kifaa kama vile kichapishi.

Husoma mtiririko wa kuingiza amri kutoka kwa faili badala ya kutoka kwa kibodi.

Inaongeza pato la amri hadi mwisho wa faili bila kuondoa habari iliyopo kutoka kwa faili.

Husoma matokeo ya kifafanuzi kimoja kama ingizo kwa kifafanuzi kingine.

Husoma ingizo la mpini mmoja kama pato la mpini mwingine.

Husoma matokeo ya amri moja na kuiandika kwa ingizo la amri nyingine. Utaratibu huu unajulikana kama chaneli.

Kwa chaguo-msingi, pembejeo ya amri (STDIN kushughulikia) inatumwa kutoka kwa kibodi hadi kwa mkalimani wa amri Cmd.exe, kisha Cmd.exe hutuma pato la amri (kushughulikia STDOUT) kwenye dirisha la amri ya amri.

Jedwali lifuatalo linaonyesha maelezo yanayopatikana.

Nambari 0 hadi 9 zinawakilisha vifafanuzi 10 vya kwanza. Mkalimani wa amri ya Cmd.exe hutumiwa kuendesha programu na kuelekeza upya yoyote kati ya vipini 10. Ili kutaja kipini kinachohitajika, ingiza nambari yake kabla ya mwendeshaji wa uelekezaji upya. Ikiwa mpini haujafafanuliwa, basi kwa chaguo-msingi opereta wa uelekezaji wa pembejeo "<» будет ноль (0), а оператором перенаправления вывода «>" itakuwa moja (1). Baada ya kuingia operator "<» или «>"Ni muhimu kuonyesha mahali pa kusoma na mahali pa kuandika data. Unaweza kutaja jina la faili au maelezo yoyote yaliyopo.

Ili kutaja uelekezaji upya kwa vishikizo vilivyopo, tumia ampersand (&) ikifuatiwa na nambari ya mpini unaotaka (kwa mfano, & nambari_ya_kushughulikia) Kwa mfano, ili kuelekeza kwingine 2 (STDERR) ili kushughulikia 1 (STDOUT), ingiza:

Vifafanuzi rudufu

Opereta ya uelekezaji kwingine "&" inarudufisha pato au ingizo kutoka kwa mpini mmoja uliobainishwa hadi mpini mwingine maalum. Kwa mfano, kutuma pato la amri dir kwa File.txt na kutuma matokeo ya hitilafu kwa File.txt, ingiza:

dir>c:\file.txt 2>&1

Wakati wa kunakili kifafanuzi, sifa zake zote za asili zinakiliwa. Kwa mfano, ikiwa mpini ni wa kuandika tu, basi nakala zake zote zitakuwa za kuandika tu. Huwezi kunakili kipini cha kusoma pekee kwenye kipini cha kuandika pekee.

Uelekezaji wa ingizo la amri (<)

Ili kuelekeza ingizo la vitufe vya nambari kwa faili au kifaa, tumia "<». Например, для ввода команды aina kutoka kwa List.txt faili ingiza:

aina

Yaliyomo kwenye File.txt yataonekana kwenye safu ya amri kama orodha katika mpangilio wa alfabeti.

Opereta"<» открывает заданное имя файла с доступом только для чтения. Поэтому с его помощью нельзя записывать в файл. Например, при запуске программы с оператором <&2 все попытки прочитать дескриптор 0 ни к чему не приведут, так как изначально он был открыт с доступом только для записи.

Kumbuka

  • Hushughulikia 0 ndio chaguo-msingi kwa opereta wa uelekezaji upya wa ingizo "<».

Elekeza upya pato la amri (>)

Matokeo ya karibu amri zote huonyeshwa kwenye dirisha la amri ya haraka. Hata amri zinazotoa data kwenye diski au kichapishi hutoa ujumbe na maongozi katika dirisha la Amri Prompt.

Ili kuelekeza upya matokeo ya amri kutoka kwa dirisha la Amri Prompt hadi kwa faili au kifaa, tumia ">" opereta. Opereta hii inatumiwa na amri nyingi. Kwa mfano, kuelekeza pato la amri dir katika faili ya Dirlist.txt ingiza:

dir>dirlist.txt

Ikiwa faili ya Dirlist.txt haipo, mkalimani wa amri ya Cmd.exe ataiunda. Ikiwa faili iko, Cmd.exe itachukua nafasi ya habari katika faili na data iliyopokelewa kutoka kwa amri dir.

Ili kuendesha amri netsh routing dampo na kisha kutuma matokeo ya kazi yake kwa Route.cfg, ingiza:

netsh routing dampo>c:\njia.cfg

Opereta ">" hufungua faili iliyobainishwa na ufikiaji wa kuandika pekee. Kwa hiyo, faili haiwezi kusomwa kwa kutumia operator huyu. Kwa mfano, wakati wa kuendesha programu na mwendeshaji wa uelekezaji upya<&0 все попытки записать дескриптор 1 ни к чему не приведут, так как изначально дескриптор 0 был открыт с доступом только для чтения.

Kumbuka.

  • Hushughulikia 1 ndio chaguo-msingi kwa opereta wa uelekezaji upya wa pato ">".

Kwa kutumia operator "<&» для перенаправления ввода и дублирования

Ili kutumia kiendeshaji cha uelekezaji upya wa ingizo, faili inayotajwa lazima iwe tayari kuwepo. Ikiwa faili ya ingizo ipo, mkalimani wa amri ya Cmd.exe huifungua kwa ufikiaji wa kusoma tu na kutuma yaliyomo kwa amri kana kwamba ni ingizo la vitufe vya nambari. Wakati mpini umebainishwa, mkalimani wa amri ya Cmd.exe huiga nakala hiyo kwenye mpini uliopo kwenye mfumo.

Kwa mfano, ili kusoma File.txt kwenye kifafanuzi cha ingizo 0 (STDIN), ingiza:

< faili.txt

Ili kufungua faili ya File.txt, panga yaliyomo, kisha uitume kwa kidirisha cha amri (STDOUT), andika:

aina< faili.txt

Ili kupata File.txt na uelekeze upya mpini 1 (STDOUT) na kushughulikia 2 (STDERR) hadi Search.txt, ingiza:

findfile file.txt>search.txt 2<&1

Ili kuiga kifafanuzi kilichofafanuliwa na mtumiaji 3 kama ingizo kwa kifafanuzi 0 (STDIN), ingiza:

Kwa kutumia ">&" Kiendeshaji Kuelekeza Upya Ingizo na Nakala

Unapoelekeza pato kwa faili na kutaja jina la faili lililopo, mkalimani wa amri ya Cmd.exe hufungua faili kwa ufikiaji wa maandishi tu na kufuta yaliyomo. Ikiwa mpini umebainishwa, mkalimani wa amri ya Cmd.exe hunakili faili kwenye mpini uliopo.

Ili kuiga kifafanuzi kilichofafanuliwa na mtumiaji 3 kwenye kifafanuzi 1, ingiza:

Ili kuelekeza matokeo yote, ikiwa ni pamoja na descriptor 2 output (STDERR), amri ipconfig kwenye kushughulikia 1 (STDOUT) na kisha kuelekeza pato kwa Output.log, ingiza:

ipconfig.exe >>output.log 2>&1

Kwa kutumia ">>" Kiendeshaji Kuongeza Towe

Kuongeza matokeo ya amri hadi mwisho wa faili bila kupoteza habari iliyohifadhiwa ndani yake, tumia herufi kubwa mara mbili (>>). Kwa mfano, amri ifuatayo inaongeza orodha ya saraka iliyoundwa na amri dir, kwa faili ya Dirlist.txt:

dir >> dirlist.txt

Ili kuongeza pato la amri netstat mwishoni mwa faili ya Tcpinfo.txt ingiza:

netstat>>tcpinfo.txt

Kwa kutumia kiendesha kituo (|)

Opereta ya bomba la mstari wa wima (|) huchukua pato la amri moja (STDOUT chaguo-msingi) na kuielekeza kwa ingizo la amri nyingine (STDIN chaguomsingi). Kwa mfano, amri ifuatayo hupanga saraka:

bwana | aina

Katika mfano huu, amri zote mbili zinaendeshwa wakati huo huo, lakini amri aina inasimama hadi pato la amri lipokewe dir. Timu aina hutumia pato la amri dir kama ingizo lake na kisha kutuma matokeo yake kwa maelezo 1 (STDOUT).

Kuchanganya Amri na Waendeshaji wa Uelekezaji Upya

Kwa kuchanganya amri za vichungi na amri zingine na majina ya faili, unaweza kuunda amri maalum. Kwa mfano, ili kuhifadhi majina ya faili yaliyo na kamba "LOG", tumia amri ifuatayo:

wimbo /b | pata "LOG" > loglist.txt

Pato la amri dir imetumwa kwa amri ya kichungi tafuta. Majina ya faili yaliyo na mfuatano "LOG" yanahifadhiwa katika faili ya Loglist.txt kama orodha (kwa mfano, NetshConfig.log, Logdat.svd, na Mylog.bat).

Unapotumia chujio zaidi ya moja kwa amri moja, lazima zitenganishwe kwa kutumia bomba (|). Kwa mfano, amri ifuatayo hutafuta kila saraka kwenye kiendeshi C kwa faili zilizo na kamba "Ingia" katika majina yao na kuzionyesha ukurasa kwa ukurasa:

dir c:\ /s /b | pata "LOG" | zaidi

Uwepo wa bomba (|) unaonyesha kwa Cmd.exe kwamba pato la amri dir inahitaji kutumwa kwa amri ya kichungi tafuta. Timu tafuta huchagua tu majina ya faili ambayo yana kamba "LOG". Timu zaidi huonyesha majina ya faili yaliyopatikana kwa amri tafuta kwa kusitisha baada ya kila skrini kujazwa.



MAKALA INAYOHUSIANA