Nagu eespool mainitud, on suvaliste algoritmide koostamiseks vaja seisukorra kontrollimise operaatoreid. Kest bash toetab valikulauseid kui…siis…muu ja juhtum, samuti silmusoperaatorid jaoks,samas, kuni, mille tõttu see muutub võimas keel programmeerimine.
5.8.1 Operaatorid kui Ja test(või )
Disain tingimuslik operaator veidi lihtsustatud kujul näeb see välja järgmine:
if list1 then list2 else list3 fi
Kus nimekiri1, nimekiri2 ja loend3 on käskude jadad, mis on eraldatud komadega ja lõpevad semikooloni või reavahetuse märgiga. Lisaks võib need järjestused olla sisse lülitatud traksid: (loetelu).
Operaator kui kontrollib käskudega tagastatud väärtust nimekiri1. Kui selles loendis on mitu käsku, siis kontrollitakse loendi viimase käsu tagastatud väärtust. Kui see väärtus on 0, siis käsud alates nimekiri2; kui see väärtus ei ole null, siis käsud alates nimekiri3. Sellise liitoperaatori tagastatud väärtus kui, on sama, mis täidetava jada viimase käsuga loodud väärtus.
Täielik käsuvorming kui on kujul:
if list then list [ elif list then list ] ... [ else list ] fi
(siin tähendavad nurksulud ainult seda, et neis sisalduv ei pruugi operaatoris esineda).
Väljendina, mis tuleb kohe pärast kui või elif, sageli kasutatav käsk test, mida saab tähistada ka nurksulgudega. Meeskond test hindab mõnda avaldist ja tagastab 0, kui avaldis on tõene, ja 1 muul juhul. Avaldis edastatakse programmile test argumendina. Kirjutamise asemel
test väljend,
Avaldise saate lisada nurksulgudesse:
[väljend].
Pange tähele, et test ja [ on ühe ja sama programmi kaks nime, mitte mingi maagiline teisendus, mille kest teeb bash(ainult [ süntaks nõuab sulgevate sulgude lisamist). Pange tähele ka seda, et selle asemel test disainis kui mis tahes programmi saab kasutada.
Kokkuvõtteks toome näite operaatori kasutamisest kui:
if [ -e textmode2.htm ] ; siis
ls text mode*
muidu
pwd
Operaatori kohta test(või […]) peame pidama spetsiaalse vestluse.
5.8.2 Operaator test ja tingimuslikud
Avalduses kasutatud tingimusväljendid test, põhinevad kontrollimisel faili atribuudid, stringide võrdlused ja tavalised aritmeetilised võrdlused. Komplekssed väljendid on üles ehitatud järgmistest ühe- või kahendtehtetest (“elementaartellised”):
Fail
Tõene, kui fail nimega fail on olemas.
B fail
Tõsi, kui faili on olemas ja on spetsiaalne fail seadme blokeerimine.
C-fail
Tõsi, kui faili on olemas ja see on erimärkide seadmefail.
D fail
Tõsi, kui faili on olemas ja on kataloog.
E fail
Tõene, kui faili nimi on faili on olemas.
F-fail
Tõene, kui faili nimi on faili on olemas ja on tavaline fail.
G-fail
Tõene, kui faili nimi on faili on olemas ja selle rühma muutmise bitt on määratud.
H-fail või -L-fail
Tõene, kui faili nimi on faili on olemas ja on sümboolne lüli.
K fail
Tõene, kui faili nimi on faili on olemas ja selle "kleepuv" bitt on seatud.
P fail
Tõene, kui faili nimi on faili eksisteerib ja on nimega toru(FIFO).
R-fail
Tõene, kui faili nimi on faili on olemas ja sellel on lugemisõigused
S-fail
Tõene, kui faili nimi on faili on olemas ja selle suurus on suurem kui null.
Tfd
Tõsi, kui faili deskriptor fd on avatud ja osutab terminalile.
U fail
Tõene, kui faili nimi on faili on olemas ja selle kasutaja muutmise bitt on määratud.
W-fail
Tõene, kui faili nimi on faili on olemas ja sellel on kirjutamisõigused.
X fail
Tõene, kui faili nimi on faili on olemas ja on käivitatav.
O fail
Tõene, kui faili nimi on faili on olemas ja kuulub kasutajale, kellele viitab kehtiv kasutajatunnus.
G-fail
Tõene, kui faili nimi on faili on olemas ja kuulub kehtiva rühma ID-ga tuvastatud rühma.
S-fail
Tõene, kui faili nimi on faili on olemas ja on pistikupesa.
N fail
Tõene, kui faili nimi on faili on olemas ja on pärast viimast lugemist muutunud.
fail1 -nt fail2
Tõsi, kui fail fail1 on hilisem muutmisaeg kui fail2.
fail1 -ot fail2
Tõsi, kui fail fail1 vanem kui fail2.
fail1 -ef fail2
Tõsi, kui failid fail1 Ja fail2neil on samad seadme ja inode numbrid(inode).
O optname
Tõene, kui shellisuvand on lubatud optname. Selgituseks vaadake bashi man-lehte.
Z string
Tõene, kui stringi pikkus on null.
N string
Tõene, kui stringi pikkus ei ole null.
string1 == string2
Tõsi, kui paelad klapivad. Selle asemel == saab kasutada = .
string1 !== string2
Tõsi, kui stringid ei ühti.
string1< string2
Tõsi, kui joon string1 leksikograafiliselt eelneb stringile string2(praeguse lokaadi jaoks).
string1 > string2
Tõsi, kui joon string1 leksikograafiliselt tuleb rea järel string2(praeguse lokaadi jaoks).
arg1 OP arg2
Siin OP- uh seejärel üks aritmeetilisest võrdlustehtest: -ekv(võrdub), - ei(pole võrdne), -lt(vähem kui), -le(vähem või võrdne), -gt(rohkem), -ge(enam või võrdne). Argumentidena saab kasutada positiivseid või negatiivseid täisarve.
Nendest elementaarsetest tingimusavaldistest saate ehitada nii keerulisi kui soovite, kasutades tavalisi loogilisi toiminguid NEGATION, AND ja OR:
!(väljend)
Boole'i eituse operaator.
avaldis1 -avaldis2
Boole'i operaator JA(JA). Tõene, kui mõlemad avaldised on tõesed.
avaldis1 -o avaldis2
Boole'i operaator VÕI(VÕI). Tõene, kui üks kahest avaldisest on tõene.
Samu tingimusavaldisi kasutatakse ka operaatorites samas Ja kuni, mida me allpool vaatleme.
5.8.3 Operaator juhtum
Operaatori formaat juhtum on:
käändesõna [ [(] muster [ | muster ] ...) loendis ;; ]...esac
Meeskond juhtum esmalt toodab sõna laienduse sõna ja proovib tulemust iga prooviga sobitada musterükshaaval. Pärast esimese vaste leidmist ei teostata enam kontrolle, mis järgivad vaste leitud mustrit. Operaatori tagastatav väärtus on 0, kui mustri vasteid ei leitud. Vastasel juhul tagastatakse vastava loendi viimase käsuga loodud väärtus.
Järgmine juhtumilause kasutamise näide on võetud süsteemiskriptist /etc/rc.d/rc.sysinit.
juhtum "$UTC" sisse
jah | tõsi)
CLOCKFLAGS="$CLOCKFLAGS -u";
CLOCKDEF="$CLOCKDEF (utc)";
ei|vale)
CLOCKFLAGS="$CLOCKFLAGS --kohalik aeg";
CLOCKDEF="$CLOCKDEF (kohalik aeg)";
esac
Kui muutuja väärtus on jah või true, siis täidetakse esimene käskude paar ja kui selle väärtus on no või false, siis täidetakse teine paar.
5.8.4 Operaator vali
Operaator vali võimaldab korraldada interaktiivset suhtlust kasutajaga. Sellel on järgmine formaat:
vali nimi [sõnas; ] do list ; tehtud
Esiteks mallist sõna luuakse mustrile vastavate sõnade loend. See sõnade kogum väljastatakse standardveaga, kusjuures igale sõnale järgneb seerianumber. Kui muster sõna välja jäetud, tuletatakse asukohaparameetrid samal viisil. Seejärel väljastatakse standardne PS3 viip ja kest ootab, kuni standardsisendisse sisestatakse rida. Kui sisestatud string sisaldab ühele kuvatud sõnale vastavat numbrit, siis muutuja nimi on antud selle sõnaga võrdne väärtus. Kui sisestatakse tühi rida, kuvatakse uuesti numbrid ja vastavad sõnad. Kui sisestatakse mõni muu väärtus, siis muutuja nimi määratud nullväärtus. Kasutaja sisestatud string salvestatakse muutujasse VASTA. Käskude loend nimekirja käivitatakse valitud muutuja väärtusega nimi.
Siin on väike skript:
#!/bin/sh
echo "Millist operatsioonisüsteemi sa eelistad?"
vali var in "Linux" "Gnu Hurd" "Tasuta BSD" "Muu"; teha
murda
tehtud
echo "Sa valiksid $var"
Millist OS-i eelistate?
1) Linux
2) Gnu Hurd
3) Tasuta BSD
4) muu
#?
Vajutage ühte neljast soovitatud numbrist (1,2,3,4). Kui sisestate näiteks 1, näete teadet:
"Kas valiksite Linuxi"
5.8.5 Operaator jaoks
Operaator jaoks töötab veidi teisiti kui tavalistes programmeerimiskeeltes. Selle asemel, et mõne muutuja väärtust ühe võrra suurendada või vähendada iga kord, kui see tsüklit läbib, määrab see muutujale iga kord, kui see tsüklit läbib, järgmise väärtuse antud sõnade loendist. Üldiselt näeb disain välja umbes selline:
nime jaoks sõnades tee nimekiri tehtud.
Reeglid käsuloendite koostamiseks ( nimekirja) on samad, mis operaatoris kui.
Näide.
Järgmine skript loob failid foo_1, foo_2 ja foo_3:
a kohta 1 2 3 ; teha
tehtud
puudutage foo_$a Üldiselt avalduse jaoks
on vormingus:
nime jaoks [sõnaga; ] do list ; tehtud sõna Esiteks ilmub sõna nimi vastavalt ülaltoodud väljendi avalikustamise reeglitele. Siis muutuja saadud väärtused määratakse ükshaaval ja iga kord, kui käivitatakse käskude loend l ist . kui " sõnas nimekirja" puudub, seejärel käskude loend
käivitatakse üks kord iga määratud asukohaparameetri jaoks. Linuxil on programm järg jaoks, mis võtab argumentidena kaks arvu ja loob kõigi antud numbrite vahel asuvate arvude jada. Selle käsuga saate sundida bash V jaoks töötavad täpselt samamoodi nagu sarnane operaator tavapärastes programmeerimiskeeltes. Selleks kirjutage lihtsalt tsükkel
järgmisel viisil:
a jaoks $ (järg 1 10) ; teha
tehtud
kassifail_$a " See käsk kuvab 10 faili sisu:
fail_1", ..., "fail_10". 5.8.6 Operaatorid Ja samas
Operaator samas kuni kui töötab nagu nimekiri2, ainult loendis olevad operaatorid
tsükkel jätkub seni, kuni tingimus on tõene ja katkeb, kui tingimus pole tõene. Disain näeb välja selline:
samas list1 do list2 tehtud.
while [ -d my directory ] ; teha
ls -l minu kataloog >> logifail
kaja -- SEPARATOR -- >> logifail
tehtud
magama 60
Operaator kuni Selline programm logib kataloogi "minukataloog" sisu iga minut, kuni kataloog on olemas. samas:
sarnane operaatoriga
kuni list1 do list2 valmis. nimekiri1 Erinevus seisneb selles, et tulemus tagastati avalduste loendi täitmisel nimekiri2, võetud eitusega: nimekiri1 käivitatakse, kui loendis on viimane käsk
tagastab nullist erineva väljumisoleku.
5.8.7 Funktsioonid
Süntaks bash Kest võimaldab kasutajal luua. Funktsioonid käituvad ja neid kasutatakse täpselt nagu tavalised shellikäsud, mis tähendab, et saame ise uusi käske luua. Funktsioonid on üles ehitatud järgmiselt:
funktsiooni nimi() (loend)
Ja sõna funktsiooni ei ole vajalik, nimi määrab funktsiooni nime, millega sellele juurde pääseb ja funktsiooni põhi koosneb käskude loendist nimekirja, mis asub ( ja ) vahel. Seda käskude loendit täidetakse iga kord, kui nimi nimi määratud käivitatava käsu nimena. Pange tähele, et funktsioone saab defineerida rekursiivselt, seega on lubatud funktsiooni, mille me määratleme, kutsuda enda sees.
Funktsioone täidetakse praeguse kesta kontekstis: funktsiooni tõlgendamiseks ei käivitata uut protsessi (erinevalt shelliskriptide täitmisest).
Argumendid
Kui funktsioon kutsutakse täitmiseks, muutuvad funktsiooni argumendid positsioonilised parameetrid(positsiooni parameetrid) funktsiooni kestuse ajaks. Neid nimetatakse $n, Kus n— argumendi number, millele soovime juurde pääseda. Argumentide nummerdamine algab 1-st, seega $1 - see on esimene argument. Samuti saame kõik argumendid korraga kätte $* ja kasutatud argumentide arv $# . Positsiooniparameeter 0 ei muutu.
Kui funktsiooni kehas esineb sisseehitatud käsk tagasi, funktsiooni täitmine katkeb ja juhtimine läheb pärast funktsiooni kutset üle käsule. Kui funktsioon on täitmise lõpetanud, asukohaparameetrid ja eriparameeter # tagastatakse väärtused, mis neil olid enne funktsiooni käivitamist.
Kohalikud muutujad (kohalikud)
Kui tahame luua kohalik parameeter, võite kasutada märksõna kohalik. Selle määramise süntaks on täpselt sama, mis tavaliste parameetrite puhul, ainult definitsioonile eelneb märksõna kohalik: kohalik nimi=väärtus.
Siin on näide ülalmainitud käsku rakendava funktsiooni määramisest Linuxil on programm:
seq()
kohalik I=$1;
samas [ $2 != $I ]; teha
echo -n "$I";
I=$(($I + 1))
tehtud;
kaja $2
Pange tähele valikut -n operaator kaja, see tühistab ülemineku uus rida. Kuigi see pole siin silmas peetud eesmärkide jaoks hädavajalik, võib see olla kasulik funktsiooni kasutamiseks muudel eesmärkidel.
Faktorilise arvutuse funktsioon fakt
Veel üks näide:
fakt ()
kui [$1 = 0]; siis
kaja 1;
muidu
kaja $(($1 * $(fakt $(($1 - 1)))))
See on faktoriaalfunktsioon, rekursiivse funktsiooni näide. Märkige aritmeetiline laiendamine ja käsu asendamine.
V. Kostromin (kos at rus-linux dot net) - 5,8. Shell kui programmeerimiskeelOperatsioonisüsteemid Linuxi perekond, nagu ka iga teine OS, nõuab arvutisüsteemi komponentide ja lõppkasutaja vahelise interaktsiooniliidese olemasolu, st tarkvarataseme olemasolu, mis annab soovitud tulemuste saavutamiseks käskude ja parameetrite sisestamise. Sellised programmi tasemel sai nime "kest" või inglise keeles - kest.
Mis on kest?
Käsu kest ( kest) pakub suhtlust kasutaja ja Linuxi operatsioonisüsteemi keskkonna vahel. Ta on spetsialiseerunud tarkvaratoode, mis tagab käskude täitmise ja nende täitmise tulemuste saamise ehk väga lihtsustatult öeldes on shell programm, mis on mõeldud kasutaja soovil teiste programmide täitmise tagamiseks. Shelli näide võib olla näiteks käsutõlk command.com operatsioonisüsteem MS DOS ehk shell bash operatsiooniruumid Unixi süsteemid/Linux.
Kõigil kestadel on sarnased funktsioonid ja omadused, vastavalt nende põhieesmärgile - kasutaja käskude täitmiseks ja nende täitmise tulemuste kuvamiseks:
Käsurea tõlgendus.
Juurdepääs käskudele ja nende täitmise tulemustele.
Tugi muutujatele, erimärkidele ja reserveeritud sõnad.
Failide töötlemine, standardsed sisend- ja väljundoperatsioonid.
Spetsiaalse shell-programmeerimiskeele juurutamine.
Unixi / Linuxi perekonna operatsioonisüsteemide jaoks on võimalik kasutada mitut erinevat kesta, mis erinevad süsteemiga suhtlemise omaduste ja meetodite poolest. Kõige tavalisemad kestad on
sh- kest Bourne , klassikaline kest Unix OS jaoks
bash kest Bourne jälle(GNU Bourne-Again SHell). Võib-olla praegu kõige levinum kest Linuxi OS-i keskkonnas.
ksh- kest Korn, mis on loodud kesta arendusena Bourne käsurea ajaloo ja käskude redigeerimise võimalusega.
csh- kest C, kasutades süntaksit populaarne keel programmeerimine C
tcsh- kesta versioon C interaktiivse käsurea redigeerimisega.
Süsteemi saab installida mitu erinevat kesta ja iga kasutaja saab kasutada oma vaikekestat. Kõik see toimub loomulikult automaatselt allalaadimise ja kasutaja registreerimisprotsessi käigus.
Linuxi perekonna operatsioonisüsteemide laadimise ajal lülitub süsteem pärast süsteemituuma laadimist interaktiivsele režiimile - kasutaja ja operatsioonisüsteemi vahelisele suhtlusrežiimile. Linuxis on esimene alglaadimise ajal käivitatav protsess init-programm. selles, mis loeb konfiguratsioonifaili sisu /etc/inittab, määrab süsteemis saadaolevate terminalide loendi ja omadused ning kutsub välja interaktiivse sisselogimisprogrammi Getty, mis palub teil sisestada oma kasutajanimi. Pärast kasutajanime ja parooli sisestamist programm Getty kutsub programm välja Logi sisse, mis kontrollib kehtivust konto, navigeerib kasutaja kodukataloogi ja annab juhtimise üle programmile esialgne käivitamine session, mis on tavaliselt kasutaja shellprogramm, mille konkreetse tüübi määrab faili sisu /etc/passwd selle konto jaoks. Näiteks:
user1:x:508:511::/home/user1:/bin/sh
interbase:x:510:511::/home/interbase:/bin/csh
apb:x:511:513:apb:/home/apb:/bin/bash
Nagu faili sisust näha /etc/passwd, kasutaja jaoks kasutaja1 kest käivitatakse sh(Bourne'i kest), kasutajale baasidevaheline- kest csh(C kest) ja kasutaja jaoks apb- kest bash(Bourne Again) Pärast kesta käivitumist kuvatakse ekraanile käsuviip (tavaliselt dollarimärgi kujul $ kui tööd tehakse tavakasutajakonto ehk naela kontekstis # , kui shelli kasutatakse root kasutajakonto all ( juur).
Shellist väljumisel tagastab süsteemituum programmi juhtimise selles, mis taaskäivitab sisselogimisprotsessi ja kuvab terminalis kasutajanime viipa. Kestast väljumist saab teha kahel viisil:
Meeskonna kaudu väljuda teostab kasutaja
Kui shell-protsess võtab vastu signaali tappa, mille saadab kernel, näiteks süsteemi taaskäivitamisel.
Käsurea tõlgendus.
Tavaliselt kutsutakse välja kasutaja sisend vastuseks shelli viipale käsurida või meeskond. Linuxi käsk on käsu nime ja argumentide märgijada, mis on eraldatud tühikutega. Argumendid annavad käsule täiendavaid parameetreid, mis määravad selle käitumise. Enamasti kasutatakse argumentidena valikuid Ja nimed failid ja kataloogid. Näiteks käsurida
ls -l fail01 fail02
Sisaldab käsku ls, suvandit -l ja kahte failinime fail01 fail02.
Mitme valiku kasutamisel saab neid kombineerida. Näiteks järgmised käsusuvandid on identsed:
Ls -l -d
ls -ld
Kutsutakse käske, mis on kesta osa sisseehitatud. Selliste käskude hulka kuuluvad näiteks cd, if, case jne. Sisseehitatud käsud võivad loomulikult erineda erinevaid valikuid kestad. Lisaks sisseehitatud käskudele on võimalik kasutada programmimooduleid, mis on eraldi käivitatavad failid ehk failid skriptid või stsenaariumid- tavalised tekstifailid, mis sisaldavad järjestikku täidetavaid ridu koos shellikäskudega. Mõningaid skripte (skripte) saab käivitada Linuxi protsessid, näiteks ülesannete ajakava cron. Tööülesannete planeerija on tavaliselt loodud selleks automaatne täitmine ajastatud süsteemihaldusülesanded. Ülesanded cron on käsud või skriptid ja täidetakse automaatselt, ilma inimese sekkumiseta ning neid saab käivitada erinevate kasutajakontode kontekstis. Juhul kui planeerija ülesanne hõlmab skripti täitmist, tekib probleem kesta valimisel, mis tuleks käivitada alamprotsessina cron skriptifaili käskude töötlemiseks - lõppude lõpuks võib kest olla mis tahes ja skripti süntaks nõuab reeglina konkreetse kesta kasutamist, mille jaoks see on kirjutatud. Selle probleemi kõrvaldamiseks on Linuxi operatsioonisüsteemides tavaks märkida skripti esimesele reale selle täitmiseks vajaliku kesta tüüp järgmisel kujul:
#!/bin/bash- kesta jaoks bash
#!/bin/sh- kesta jaoks sh
Sign # on märk kommentaarist ja sellele järgnevaid märke ei tõlgendata käsuna. See meetod võimaldab teil selgesõnaliselt määrata, millist kesta tuleks järgneva faili sisu töötlemiseks kasutada. Kui skript ei sisalda kirjet, mis määratleb selgesõnaliselt nõutava kesta, kasutatakse selle konto sätteid, mille kontekstis seda käivitatakse. see skript. Sel juhul on võimalik, et näiteks shelli jaoks kirjutatud skript tch antakse täitmiseks kestale bash, mis muudab selle täitmise võimatuks.
Käskude või skriptide täitmisel kasutage keskkonnamuutujad (inglise keeles - keskkond, mille väärtused iseloomustavad tarkvarakeskkonda, milles käske täidetakse. Sellised muutujad võivad sisaldada Üldised seaded süsteemi, graafilise või käsukesta parameetrid, teed käivitatavad failid ja nii edasi. Keskkonnamuutujate väärtused määratakse süsteemi tasemel (kõigile kasutajatele) ja konkreetne kasutaja. Keskkonnamuutujate määramiseks süsteemi tasemel kasutatakse failide sisu:
/etc/profile- määrab muutujad ainult käsukestade jaoks. Saab käivitada mis tahes skripte kestades, mis ühilduvad Bourne'i kestaga.
/etc/bash.bashrc- määrab muutujad ainult interaktiivsete kestade jaoks. Samuti käitab see bash-skripte.
/etc/environment- kasutab PAM-env moodul. Selles failis saab määrata ainult paare nimi=väärtus.
Igal neist failidest on oma rakendus, nii et peaksite hoolikalt valima oma eesmärkidele sobiva faili. Näiteks kui teil on vaja lisada kohandatud kataloog ~/bin muutujaks PATH kõigi kasutajate jaoks asetage järgmine kood ühte süsteemifailid keskkonna lähtestamine (/etc/profile või /etc/bash.bashrc):
# Kui kasutaja ID on suurem või võrdne 1000 ja seal on ~/bin kataloog ja see
#pole varem PATH muutujale lisatud,
# eksportida ~/bin asukohta $PATH.
Kui [[ $UID -ge 1000 && -d $HOME/bin && -z $(echo $PATH | grep -o $HOME/bin)
Ekspordi PATH=$HOME/bin:$(PATH)
Tavaliselt operatsioonisaalides Linuxi süsteemid, teenusekontode puhul kasutatakse kasutaja ID-d alla 1000 või alla 500. Selles näites määratakse keskkonnamuutuja kõigile kohalikud kasutajad süsteemid, mille ID on 1000 või rohkem.
Kui teil on vaja konkreetse kasutaja keskkonda muuta, muutke kasutaja keskkonna sisu:
- ~/.bash_profile, ~/.bash_login ja nii edasi. - kesta lähtestamisfailid kodukataloog kasutaja.
- ~/.profiil- kasutajaprofiili lähtestamisfail. Paljud kestad kasutavad seda keskkonnamuutujate määratlemiseks.
~/.pam_environment- faili /etc/environment kohandatud analoog, mida kasutab moodul PAM-env.
Näiteks kasutajakataloogi ~/bin lisamiseks muutujaga määratud käivitatavate failide otsinguteele PATH, näiteks faili ~/.profiil pane rida:
eksport PATH="$(PATH):/home/user/bin"
Keskkonnamuutujate määramiseks graafilised rakendused, kasutatakse kasutaja graafilise keskkonna konfiguratsioonifailide sisu ~/.xinitrc
Sagedamini määratakse praeguse kasutajaseansi jaoks keskkonnamuutujate väärtused. Näiteks kohandatud kataloogi lisamiseks ~/bin käivitatavate failide otsinguteel:
eksport PATH=~/bin:$PATH
Uus muutuja väärtus PATH kestab vaid praeguse kasutajaseansi lõpuni.
Muutuja väärtuse vaatamiseks võite kasutada käsku kaja $muutuja, Näiteks:
kaja $PATH
Praegu on kõige levinum kest, nagu eespool mainitud bash. Selle põhjuseks on eelkõige asjaolu, et kest bash on sh- ühilduv käsu kest, millele on lisatud kasulikud funktsioonid Korni kestadest ( ksh) ja C kest ( csh). Kest bash suudab käivitada enamikke shell-programmeerimiskeele all kirjutatud skripte ilma muudatusteta sh ja püüab jõuda standardile võimalikult lähedale POSIX, mis tõi kaasa palju täiustusi nii programmeerimisel kui ka interaktiivsel kasutamisel. Kaasaegses teostuses bash seal on käsurea redigeerimisrežiim, piiramatu käsuajaloo suurus, ülesannete haldamise tööriistad, varjunimede kasutamise võimalus, ulatuslik sisseehitatud käskude loend, käsukesta funktsioonid jne. Üldiselt bash sobib kõige paremini tavakasutaja vajadustega, mistõttu on see Linuxi keskkonnas enim kasutatud.
Alglaadimisel bash ilma käsurea parameetriteta käivitub kest interaktiivses režiimis, kuvades ekraanil käsuviiba. Interaktiivne kest loeb tavaliselt andmeid kasutaja terminalist ja kirjutab andmeid samasse terminali, standardseade Sisendseade on klaviatuur ja standardne väljundseade on ekraan. Kasutaja sisestab käsud klaviatuuril ja nende täitmise tulemus kuvatakse ekraanil.
Käsukeele kest (tõlkes shell, shell) on tegelikult väga kõrgetasemeline programmeerimiskeel. Selles keeles juhib arvutit kasutaja. Tavaliselt alustate pärast sisselogimist käsukestaga suhtlemist. Märk, et kest on käskude vastuvõtmiseks valmis, on ekraanil kuvatav viip. Lihtsamal juhul on see üks dollar ("$"). Shell pole vajalik ja ainus käsukeel (kuigi see on mobiilsüsteemide standardi POSIX-i raames standarditud). Näiteks cshelli keel on üsna populaarne, seal on ka kshell, bashell jt. Lisaks saab iga kasutaja ise luua käsukeel. Võib üheaegselt töötada erinevate käsukeeltega operatsioonisüsteemi ühel eksemplaril. shell on üks paljudest UNIX-i käskudest. See tähendab, et käsukomplekt "shell" sisaldab käsku "sh" - "shell" tõlgi kutsumine. Esimene "shell" kutsutakse automaatselt sisse, kui logite sisse ja kuvab programmeerija. Pärast seda saate käivitamiseks kutsuda mis tahes käske, sealhulgas "shelli", mis loob teile vana kesta sees uue kesta. Näiteks kui valmistate redaktoris ette faili "file_1":
Kaja Tere!
siis läheb normaalseks tekstifail, mis sisaldab käsku "kaja", mille täitmisel kuvatakse ekraanil kõik sellest paremale kirjutatud. Saate muuta faili "fail_1" käivitatavaks, kasutades käsku "chmod 755 fail_1". Kuid seda saab teha, kutsudes selgesõnaliselt välja käsu "sh" ("shell"):
Sh fail_1
Sh< file1
Faili saab käivitada ka praeguses shelli eksemplaris. Selle "." jaoks on spetsiaalne käsk. (punkt), st.
Fail_1
Kuna UNIX on mitme kasutajaga süsteem, saate isegi personaalarvuti töötada paralleelselt näiteks 12 ekraanil (muutuda ekraanilt ekraanile ALT/funktsioonklahv), kus igal ekraanil on uus (või sama) kasutaja oma käsukestaga. X-Window'i saate avada ka graafilises režiimis suur number windows ja igal aknal võib olla oma kasutaja oma käsukestaga... Shelli keele põhielement on käsk.
Käsustruktuurid:
Shelli käsud on tavaliselt järgmises vormingus:
<имя команды> <флаги> <аргумент(ы)>
Näiteks:
Ls -ls /usr/bin
Kus ls on väljastava käsu nimi sisukataloog, -ls - lipud ("-" - lippude märk, l - pikk formaat, s - failide maht plokkides), /usr/bin - kataloog, mille jaoks käsk täidetakse See käsk kuvab kataloogi sisu Pikas vormingus /usr/bin lisab info iga faili suuruse kohta plokkides. Kahjuks ei järgne sellele käsustruktuurile alati miinusmärki ja eksootiliste vormingutega lipud ei ole alati ühesõnalised Käskude käivitamine cc-na - C-keele kompilaatori kutsumine, tar - arhiividega töötamine, dd - faili kopeerimine koos teisendamisega, leidmine - failide otsimine ja palju muud Reeglina võtab kest vastu esimese sõna. , meeskonnana. käsurida
esimese sõna dekrüpteerib kest käsuna (konkatenatsioon), mis kuvab faili nimega "cat" (teine sõna), mis asub praeguses kataloogis. Käskude ümbersuunamine Standardsisend (sisend) - "stdin" UNIX OS-is toimub terminali klaviatuurilt ja standardväljund(väljund) - "stdout" suunatakse terminali ekraanile. On olemas ka standardfail diagnostilised teated - "stderr", mida arutatakse veidi hiljem. Käsku, mis võib töötada standardse sisendi ja väljundiga, nimetatakse FILTERiks. Kasutajal on mugavad vahendid sisendi ja väljundi ümbersuunamiseks teistele failidele (seadmetele). Sümbolid ">" ja ">>" tähistavad väljundi ümbersuunamist. ls >file_1 Käsk "ls" genereerib aktiivses kataloogis olevate failide loendi ja asetab selle faili "file_1" (selle asemel, et see ekraanile printida). Kui fail "file_1" oli varem olemas, kirjutatakse see uuega üle.
Pwd >> fail_1
käsk pwd moodustab aktiivse kataloogi täisnime ja asetab selle faili "fail_1" lõppu, st. ">>" lisatakse failile, kui see pole tühi. Sümbolid "<" и "<<" обозначают перенаправление ввода.
WC -l loendab ja kuvab ridade arvu failis file_1. Ed fail_2< loob redaktori abil otse terminalist faili "file_2". Sisestuse lõpu määrab paremal olev märk "<<" (т. е. "!"). То есть ввод будет закончен, когда первым в очередной строке будет "!".
Можно сочетать перенаправления. Так WC -l Wc -l > fail_4 sooritatakse samal viisil: loendatakse ridade arv failis "fail_3" ja tulemus paigutatakse faili "fail_4". Vahendeid, mis ühendavad ühe käsu standardväljundi teise käsu standardsisendiga, nimetatakse PIPELINE'iks ja seda tähistab vertikaalne riba "|". ls | wc -l käsu "wc" sisendisse saadetakse praeguses kataloogis olevate failide loend, mis kuvab ridade arvu kataloogis. Konveier võib kombineerida ka rohkem kui kahte käsku, kui need kõik, välja arvatud esimene ja viimane, on filtrid: Kassifail_1 | grep -h tulemus | sorteerida | kass -b > fail_2 See failist "file_1" ("cat") pärit torujuhe valib kõik read, mis sisaldavad sõna "result" ("grep"), sorteerib ("sorteerib") saadud read ning seejärel nummerdab ("cat -b") ja printige tulemus failis "fail_2". Kuna UNIX-seadmeid esindavad spetsiaalsed failid, saab neid kasutada ümbersuunamisel. Spetsiaalsed failid asuvad kataloogis "/dev". Näiteks "lp" - print; "konsool" - konsool; "ttyi" - i-s terminal; "null" on näiv (tühi) fail (seade). Siis näiteks Ls > /dev/lp prindib praeguse kataloogi sisu ja faili_1< /dev/null
обнулит файл "file_1". Sordi fail_1 | tee /dev/lp | saba -20 Sel juhul sorteeritakse ja prinditakse fail "fail_1" ning ekraanile trükitakse ka viimased 20 rida. Läheme tagasi väljundi ümbersuunamise juurde. Standardfailid on nummerdatud: 0 - stdin, 1 - stdout 2 - stderr. Kui te ei soovi, et ekraanil oleks veateade, saate selle ekraanilt ümber suunata teie määratud faili (või visata see täielikult minema, suunates selle "tühja seadme" faili - /dev/null). Näiteks käsu täitmisel Kassi fail_1 fail_2 mis peaks kuvama ekraanil järjestikku failide "fail_1" ja "fail_2" sisu, annab see teile näiteks järgmise 111111 222222 cat: f2: sellist faili või kataloogi pole kus 111111 222222 on faili "fail_1" sisu ja fail "fail_2" puudub, mille käsk "cat" edastas vaikimisi standardsele diagnostikafailile, nagu ka ekraanil kuvatav standardväljund. Kui te sellist teadet ekraanile ei soovi, saate selle ümber suunata enda määratud faili: Kassifail_1 fail_2 2>f-err veateated saadetakse (nagu näitab "2>" ümbersuunamine) "f-err" faili. Muide, kasutades saate saata kogu teabe ühte faili "ff". sel juhul disain Kassifail_1 fail_2 >>ff 2>ff Saate määrata mitte ainult, millist standardfaili ümber suunata, vaid ka seda, millisesse standardfaili ümber suunata. Kassifail_1 fail_2 2>>ff 1>&2 Siin suunatakse kõigepealt "stderr" (lisamisrežiimis) faili "ff" ja seejärel suunatakse standardväljund ümber "stderr", mis on selleks hetkeks fail "ff". See tähendab, et tulemus on sarnane eelmisele. Konstruktsioon "1>&2" tähendab, et lisaks ümbersuunatava standardfaili numbrile tuleb ette panna "&"; kogu struktuur on kirjutatud ilma tühikuteta.<-
закрывает стандартный ввод.
>- sulgeb standardväljundi. Käsufailid. Tekstifaili käsuna kasutamiseks on mitu võimalust. Loome redaktori abil faili nimega "cmd", mis sisaldab ühte sellist rida: Kuupäev; pwd; ls Shelli saab kutsuda käsuna, tähisega "sh" ja edastada see "cmd" faili argumendina või ümbersuunatud sisendina, st. $ sh cmd $sh Nende käskude täitmise tulemuseks on kuupäev, seejärel praeguse kataloogi nimi ja seejärel kataloogi sisu. Huvitavam ja mugavam variant pakkfailiga töötamiseks on muuta see käivitatavaks, s.t. muuda see lihtsalt käsuks, mis saavutatakse turvakoodi muutmisega. Selleks peate lubama selle faili käivitamise. Näiteks, Chmod 711 cmd teeb turvakoodi "rwx__x__x". Siis lihtne kõne täidab samad kolm käsku. Tulemus on sama, kui fail koos sisuga Kuupäev; pwd; ls on esindatud kujul: date pwd ls kuna üleminek teisele reale on ühtlasi eraldajaks käskude jadas. Seega võivad käivitatavad failid olla mitte ainult kompileerimise ja kokkupanemise tulemusena saadud failid, vaid ka shellkeeles kirjutatud failid. Neid täidetakse tõlgendusrežiimis shell-tõlgi abil Pakettfailide silumine SHELL kasutab pakkfailide silumiseks kahte mehhanismi. Esimene on: set -v prindib read partiifail kui sa neid loed. Seda režiimi kasutatakse süntaksivigade otsimisel. Selle kasutamiseks pole vaja käsufaili muuta, näiteks: sh -v proc... siin on proc käsufaili nimi. Lülitit -v saab kasutada koos lülitiga -n, mis takistab järgnevate käskude täitmist (käsk set -n blokeerib terminali kuni EOF lipu sisestamiseni). Käsk set -x kuvab käsud nende täitmise ajal ja programmiread väljastatakse terminali ja nende väärtused asendatakse muutujate asemel. Lülitite -x ja -v tühistamiseks võite kasutada käsku set - ja installimiseks määrata makromuutujale vastav väärtus. SHELLI KESKKOND (MUUTUVAD JA PARAMEETRID) Shelli keeles saab kirjutada pakkfaile ja kasutada käsku "chmod", et muuta need käivitatavaks. Pärast seda ei erine need teistest UNIX OS-i käskudest. Shelli muutujad Shelli muutuja nimi on tähtede, numbrite ja allkriipsude jada, mis algab tähega. Shelli muutuja väärtus on tähemärkide jada. Asjaolu, et kestas on ainult kahte tüüpi andmeid: ühelt poolt tähemärkide jada ja tekstifail, on lihtne kaasata programmeerimisse lõppkasutajaid, kes pole varem programmeerimisega tegelenud, ja teisest küljest, põhjustab teatud sisemist protesti paljudes programmeerijates, kes on harjunud keeleliste vahendite oluliselt suurema mitmekesisuse ja paindlikkusega. Siiski on huvitav jälgida, kuidas kõrgelt kvalifitseeritud programmeerijad, olles tutvunud kesta "mängureeglitega", kirjutavad sinna programme mitu korda kiiremini kui C-s, kuid mis on eriti huvitav, mõnel juhul kirjutavad need programmid. töötavad isegi kiiremini kui C-s rakendatud. Muutuja nimi sarnaneb traditsioonilise identifikaatori ideega, st. nimi võib olla tähtede, numbrite ja alakriipsude jada, mis algab tähe või alakriipsuga. Määramisoperaatorit "=" saab kasutada muutujatele väärtuste määramiseks. Var_1=13 – "13" ei ole arv, vaid kahekohaline jada. var_2="UNIX OS" – siin on nõutavad jutumärgid (" "), kuna stringis on tühik. Võimalikud on ka muud viisid kestamuutujatele väärtuste määramiseks. Näiteks salvestus DAT = "kuupäev". põhjustab käsu "date" käivitamise esimesena (tagurpidi märgid näitavad, et suletud käsk tuleb esmalt täita) ja selle täitmise tulemus, selle asemel, et väljastada standardväljundisse, määratakse muutuja väärtuseks, sel juhul "DAT". Muutujale saab väärtuse määrata ka käsuga "read", mis tagab muutuja väärtuse vastuvõtmise dialoogirežiimis (klaviatuuri)kuvalt. Tavaliselt eelneb pakkfailis käsule "lugemine" käsk "kaja", mis võimaldab ekraanile eelkuvada mõne teate. Näiteks: Echo -n "Sisestage kolmekohaline arv:" loe x Käsufaili selle osa täitmisel pärast teate kuvamist Sisestage kolmekohaline number: tõlk peatub ja ootab, kuni klaviatuurilt sisestatakse väärtus. Kui sisestasite näiteks "753", saab sellest muutuja "x" väärtus. Üks "lugemiskäsk" võib lugeda (määrata) väärtusi mitmele muutujale korraga. Kui "loetud" muutujaid on rohkem kui sisestatud (eraldatud tühikutega), omistatakse ülejäänud muutujatele tühi string. Kui käsus "loe" on edastatud väärtusi rohkem kui muutujaid, siis lisaväärtusi ignoreeritakse. Shelli muutujale juurde pääsedes peate nime ette eelnema sümbol "$". Nii kuvatakse ekraanil käsud echo $var_2 echo var_2 UNIX OS var_2 Põgenemine Vaatame lähemalt kestas kasutatavaid põgenemisvõtteid. Topeltjutumärke (" "), üksikjutumärke (" ") ja kaldkriipse (\) kasutatakse paovahenditena. Nende tegevus on näidetest ilmne: Ühele reale saate kirjutada mitu ülesannet. X=22 y=33 z=$x A="$x" B="$x" C=\$x D="$x + $y + $z" E="$x + $y + $z " F=$x\ +\ $y\ +\ $z (ülesanne G=$x+$y ebaõnnestuks tühikute tõttu) Siis Kaja A = $A B = $B C = $C kaja D = $D E = $E F = $F eval kaja hinnatud A = $A eval kaja hinnatud B = $B eval kaja hinnatud C = $C Kuvatakse ekraanil A = 22 B = $x C = $x D = 22 + 33 + 22 E = $x + $y + $z F = 22 + 33 + 22 hinnatud A = 22 hinnatud B = 22 hinnatud C = 22 Toome veel mõned näited, mis on seotud reavahetustest põgenemisega. Olgu muutujale "string" omistatud 2x3 "massiivi" väärtus: abc def Pange tähele, et lisatühikute määramise vältimiseks algab massiivi teine rida järgmise rea esimesest positsioonist: string="abc def" Seejärel on kolm võimalust kirjutada muutuja "kaja" kajakäskluses $string kaja "$string" kaja "$string" annab vastavalt kolm erinevat tulemust: abc def $string abc def ja käskude jada echo "str_1 str_2" > fail_1 kaja "str_1 str_2" > fail_2 kassi fail_1 fail_2 annab järjestikku identsed failid file_1 ja file_2: str_1 str_2 str_1 str_2 Pange tähele ka seda, et kaldkriips (\) ei kasuta mitte ainult sellele järgnevat märki, mis võimaldab kasutada Erisümbolid samamoodi nagu iseennast esindavad märgid (see võib ka põgeneda - \\), kuid käsufailis võimaldab kaldkriips ühendada ridu üheks (rea lõpust põgenemise näide). Kassifail_1 | grep -h tulemus | sorteerida | kass -b > fail_2 võiks kirjutada pakkfaili, öelge nagu Kassifail_1 | grep -h\result | sorteerida | kass -b > fail_2 Muide, konveieri sümbol annab ka käsurea jätkamise efekti. Sel juhul võib see anda ilusama tulemuse, näiteks: Kassifail_1 | grep -h tulemus | sorteerida | kass -b > fail_2 Manipulatsioonid shell-muutujatega Hoolimata asjaolust, et shell-muutujaid tajutakse üldiselt stringidena, st "35" ei ole arv, vaid kahest märgist koosnev jada "3" ja "5", saab neid paljudel juhtudel erinevalt tõlgendada, näiteks täisarvudena. Käsul "expr" on mitmesuguseid võimalusi. Illustreerime mõnda näidetega: Pakkfaili käivitamine: X=7 y=2 a=`avaldis $x + $y` ; kaja a=$a a=`avaldis $a + 1` ; kaja a=$a b=`avaldis $y - $x` ; kaja b=$b c=`avaldis $x "*" $y` ; kaja c=$c d=`avaldis $x / $y` ; kaja d=$d e=`avaldis $x % $y` ; kaja e=$e kuvatakse ekraanil A = 9 a = 10 b = -5 c = 14 d = 3 e = 1 Korrutustehte ("*") tuleb paotada, kuna kestas tajutakse seda ikooni erimärgina, mis tähendab, et selles kohas saab asendada mis tahes märgijada. Käsuga "expr" on võimalikud mitte ainult (täisarvulised) aritmeetilised toimingud, vaid ka stringid: A=`ekspr "kokteil" : "kukk"` ; kaja $A B=`expr "kokteil" : "saba"` ; kaja $B C=`expr "kokteil" : "kokk"` ; kaja $C D=`expr "kukk" : "kokteil"` ; kaja $D Ekraanil kuvatakse numbreid, mis näitavad ahelates sobivate märkide arvu (algusest peale). Teine rida ei tohi olla pikem kui esimene: 4
0
0
0
Muutujate eksportimine UNIX OS-il on protsessi kontseptsioon. Protsess toimub siis, kui käsk täidetakse. Näiteks klaviatuuril "p" tippimisel Valikud Parameetrid saab edastada käsufaili. Kest kasutab positsiooniparameetreid (st nende ilmumise järjekord on oluline). Käsufailis algavad parameetritele vastavad muutujad (sarnaselt shelli muutujatele) sümboliga "$", millele järgneb üks numbritest vahemikus 0 kuni 9: Olgu "examp-1" kutsutud parameetritega "cock" ja "saba". Need parameetrid kuuluvad uude keskkonda standardsed nimed"1" ja "2". (Standardne) muutuja nimega "0" salvestab kutsutud arvutuse nime. Parameetritele juurde pääsedes eelneb numbrile dollari sümbol "$" (nagu ka muutujatele juurdepääsul): $0 vastab selle käsufaili nimele; $1 on järjekorras esimene parameeter; $2 sekundit parameeter jne. Kuna muutujate arv, millele saab parameetreid edasi anda, on piiratud ühekohalise numbriga, s.o. 9. ("0", nagu juba märgitud, omab erilist tähendust), siis edastamiseks rohkem parameetrid, kasutatakse spetsiaalset käsku "shift". Käsk "set" pakub parameetritele ainulaadset lähenemist. Näiteks fragment Määra a b kajaga esimene=$1 teine=$2 kolmas=$3 kuvatakse ekraanil Esimene=a teine=b kolmas=c need. käsk "set" määrab parameetrite väärtused. See võib olla väga mugav. Näiteks kuvatakse käsk "kuupäev". tänane kuupäev, öelge "Mon May 01 12:15:10 2000", mis koosneb viiest sõnast, seejärel Määra "kuupäev" kaja $ 1 $ 3 $ 5 kuvatakse ekraanil Esmaspäev 01 2000 Käsk "set" võimaldab juhtida ka programmi täitmist, näiteks: terminali väljastatakse read set -v, mida loeb shell. set +v tühistab eelmise režiimi. set -x prindib käsud terminali enne täitmist. set +x tühistab eelmise režiimi. Ilma parameetriteta käsk "set" kuvab terminalile tarkvarakeskkonna oleku. Shelli asendused Enne pakkfailides sisalduvate käskude otsest tõlgendamist ja täitmist käivitub kest erinevat tüüpi asendused: 1. TULEMUSTE ASENDAMINE. Kõik tagasijutumärkides olevad käsud täidetakse ja tulemus asendatakse nende asemel. 2. PARAMEETRITE JA MUUTUJATE VÄÄRTUSTE ASENDAMINE. See tähendab, et "$" algavad sõnad asendatakse muutujate ja parameetrite vastavate väärtustega. 3. LÜNKE TÕLGENDAMINE. Põgenenud tühikuid eiratakse. 4. FAILINIMIDE GENERATSIOON. Sõnades kontrollitakse erimärkide olemasolu ("*", "?","") ja sooritatakse vastavad põlvkonnad. Tarkvarakeskkond Igal protsessil on keskkond, milles see töötab. Shell kasutab mitmeid neid keskkonnamuutujaid. Kui sisestate käsu "set" ilma parameetriteta, kuvatakse ekraanil teave mitmete sisselogimisel loodud standardmuutujate kohta (ja seejärel edastatakse kõigile teie uutele protsessidele "päritud"), samuti teie protsesside loodud ja eksporditud muutujate kohta. . Teabeväljundi konkreetne tüüp ja sisu sõltub suurel määral sellest, millist UNIX-i versiooni kasutatakse ja kuidas süsteem on installitud. Täitmise tulemus seadke käske ilma parameetriteta (pole täielik): HOME=/root PATH=/usr/local/bin:/usr/bin:/bin:.:/usr/bin/X11: IFS= LOGNAME=sae MAIL=/var/spool/mail/sae PWD=/home/ sae/STUDY/SHELL PS1=$(PWD):" " PS2=> SHELL=/bin/bash Kommenteerime muutujate väärtusi. HOME=/root on kodukataloogi nimi, kuhu kasutaja pärast sisselogimist jõuab. See tähendab, et pärast nime ja parooli õigesti sisestamist leian end kataloogist “/root”. PATH=/bin:/usr/bin:.:/usr/local/bin:/usr/bin/X11 – see muutuja määrab failide jada, mida shell käsu otsimisel otsib. Failide nimed on siin eraldatud koolonitega. Vaatamise järjekord vastab rajal olevate nimede järjekorrale. Kuid esialgu toimub otsing niinimetatud sisseehitatud käskude hulgast. Sisseehitatud käsud sisaldavad kõige sagedamini kasutatavaid käske, nagu "kaja", "cd", "pwd", "date". Pärast seda vaatab süsteem läbi kataloogi “/bin”, mis võib sisaldada käske “sh”, “cp”, “mv”, “ls” jne. Seejärel kataloog "/usr/bin" käskudega "cat", "ss", "expr", "nroff", "man" ja paljud teised. Järgmisena toimub otsing praeguses kataloogis (.), või muus tähises "tühi", st ""), kus teie kirjutatud käsud tõenäoliselt asuvad. Pärast käsureale tippimist ja vajutamist @ parameetrite loend sõnade komplektina; - lipud edasi kestale. Nendele muutujatele ligipääsemisel (st kasutades neid käsufailis – shellprogrammis) tuleks ette panna "$". Unikaalsete failide loomisel mängib olulist rolli spetsiaalne muutuja "$$", mille väärtus vastab seda arvutust teostava protsessi numbrile. Iga arvuti sooritatud uus arvutus käivitab ühe või mitu protsessi, mis saavad automaatselt numbreid järjekorras. Seega, kasutades failinimena protsessi numbrit, võite olla kindel, et iga uus fail saab uue nime (ei kirjutata olemasoleva asemele). Selle failide nimetamise meetodi eeliseks on ka peamine puudus. Mis nimed failidele omistatakse, pole teada. Ja kui selle protsessi raames leiate faili "ilma otsimata", st pääsete sellele juurde $$ abil, võivad sellised failid kergesti kaduda. See loob lisaprobleeme programmide silumisel. Tõlgi kutsumine Pärast kasutaja registreerimist süsteemis (kasutades sisselogimiskäsku) kutsutakse välja SHELL keeletõlk. Kui kasutaja registreerimiskataloog sisaldab .profile faili, siis enne vähemalt ühe käsu saamist terminalist käivitab tõlk selle faili (eeldatakse, et .profile fail sisaldab käske). Helistamisel saab määrata järgmised klahvid: -c string Käsud loetakse etteantud stringist. -s Käsud loetakse standardsisendist. Tõlgi teated kirjutatakse standardsesse diagnostikafaili. -i Interaktiivne töörežiim. Kui parameetri "0" esimene märk on - märk, siis loetakse käsud .profile failist. PROGRAMMI STRUKTUURID=== Nagu iga programmeerimiskeele puhul, võib kesta tekst sisaldada kommentaare. Selleks kasutatakse sümbolit "#". Tõlk tajub kommentaarina kõike, mis asub real (käsufailis) sellest märgist vasakul. Näiteks, # See on kommentaar. Nagu igal protseduurilisel programmeerimiskeelel, on ka shellkeelel operaatorid. Mitmed operaatorid võimaldavad teil juhtida käsu täitmise järjekorda. Selliste operaatorite puhul on sageli vaja kontrollida seisukorda, mis määrab, millises suunas arvutused jätkuvad. Test ("") käsk Testkäsk kontrollib teatud tingimuse täitmist. Selle (sisseehitatud) käsu abil genereeritakse kestakeele valiku- ja tsüklilaused. Kaks võimalikku käsuvormingut: Katse seisukord [tingimus] kasutame teist võimalust, st. Selle asemel, et kirjutada tingimuse ette sõna "test", paneme tingimuse sulgudesse, mis on programmeerijate jaoks tavalisem. Tegelikult tunneb kest selle käsu ära avasulu "[" järgi kui sõna, mis vastab käsule "test". Sulgude ja nendes sisalduva tingimuse vahel peavad olema tühikud. Samuti peavad väärtuste ja võrdlus- või operatsioonisümboli vahel olema tühikud. Kest kasutab erinevat tüüpi tingimusi. FAILIDE KONTROLLIMISE TINGIMUSED: -f faili fail "file" on tavaline fail; -d fail fail "fail" - kataloog; -с fail fail "fail" on spetsiaalne fail; -r failil on õigus lugeda faili "fail"; -w failil on õigus kirjutada faili "fail"; -s faili fail "file" ei ole tühi. STREETIDE TESTIMISE TINGIMUSED: str1 = str2 stringid "str1" ja "str2" sobivad; str1 != str2 stringid "str1" ja "str2" ei ole samad; -n str1 string "str1" on olemas (mitte tühi); -z str1 stringi "str1" pole olemas (tühi). Näited. X="kes on kes"; eksport x; [ "kes on kes" = "$x" ]; kaja $? 0 x = abc ; eksport x ; [ abc = "$x" ] ; kaja $? 0 x = abc ; eksport x ; [ -n "$x" ] ; kaja $? 0 x="" ; eksport x ; [ -n "$x" ] ; kaja $? 1 Lisaks on kaks standardtingimuste väärtust, mida saab tingimuse asemel kasutada (selleks pole sulgu vaja). TÄISARVDE VÕRDLUSE TINGIMUSED: x -eq y "x" on võrdne "y", x -ne y "x" ei ole võrdne "y", x -gt y "x" on suurem kui "y", x - ge y "x" on suurem või võrdne "y", x -lt y "x" väiksem kui "y", x -le y "x" väiksem kui "y" või sellega võrdne. KEERULISED TINGIMUSED: Rakendatakse standardsete loogiliste operatsioonide abil: ! (mitte) pöörab väljumiskoodi väärtuse ümber. -o (või) vastab loogilisele "OR". -a (ja) vastab loogilisele "JA". Tingimuslik väide "kui" Üldiselt on lausel "if" struktuur Kui tingimus, siis nimekiri Siin saab "elif" kasutada lühendatud versiooni "muselt kui" koos täisversiooniga, st. kinnitus lubatud suvaline number"kui" avaldused (nagu ka muud väited). Loomulikult peab "loetelu" igal juhul olema tähenduslik ja antud kontekstis vastuvõetav. Selle operaatori kõige kärbitud struktuur Kui seisund, siis loend fi kui tingimus on täidetud (tavaliselt on see koht, kus saab lõpukoodi "0"), siis käivitatakse "loend", vastasel juhul jäetakse see vahele Näited: kirjutatakse "if-1". Kui [ $ 1 - gt $ 2 ] siis pwd else echo $0: Tere! Siis helistades numbrile if-1 12 11 produtseeritakse /home/sae/STUDY/SHELL ja if-1 12 13 if-1: Tere! Helista operaatorile ("juhtum") Juhtumivaliku operaatoril on järgmine struktuur: Juhtme string sisse mall) käskude loend;; mall) käskude loend;; ... mall) käskude loend;; Siin on "case", "in" ja "esac" funktsioonisõnad. "Stringi" (see võib olla üks märk) võrreldakse "mustriga". Seejärel käivitatakse valitud rea "käsuloend". ";;" valikuridade lõpus tundub ebatavaline, kuid kirjutage siia ";". see oleks viga. Iga alternatiivi jaoks saab käivitada mitu käsku. Kui need käsud on kirjutatud ühele reale, siis sümbol ";" kasutatakse käsu eraldajana. Tavaliselt viimane rida valikul on muster "*", mis "case" struktuuris tähendab "mis tahes väärtust". See rida valitakse juhul, kui muutuja väärtus (siin $z) ei vasta ühelegi varem kirjutatud mustrile, mis on piiritletud sulguga ")". Väärtusi vaadatakse nende kirjutamise järjekorras. Loetletud tsükli operaator ("for") Silmuse operaatori "for" struktuur on järgmine: Nime pärast do käskude loend done, kus "for" on abisõna, mis määrab tsükli tüübi, "do" ja "done" on abisõnad, mis tõstavad esile tsükli põhiosa. Olgu käsk "lsort" esitatud partiifailina i jaoks failis_1 fail_2 fail_3 tehke proc_sort $i done Selles näites toimib nimi "i" tsükliparameetrina. Seda nime võib pidada shellmuutujaks, millele on järjestikku määratud loetletud väärtused (i=file_1, i=file_2, i=file_3) ja käsk "proc_sort" täidetakse tsüklina. Sageli kasutatakse vormi "i in *", mis tähendab "kõigi failide jaoks praeguses kataloogis". Olgu "proc_sort" omakorda esindatud pakkfailina Kass $1 | sorteerida | tee /dev/lp > $(1)_sorted need. määratud failid sorteeritakse järjestikku, sortimistulemused prinditakse ("/dev/lp") ja saadetakse failidesse file_1_sorted file_2_sorted ja file_3_sorted Silmuslause tõese tingimusega ("while") Struktuur "while", mis teeb ka arvutusi, on eelistatud juhul, kui parameetri väärtuste täpne loend pole eelnevalt teada või see loend tuleb saada arvutuste tulemusena tsüklis. Silmuslause "while" struktuur on järgmine: Kuigi tingimus do nimekiri tehtud käskudest, kus "while" on abisõna, mis määrab tõese tingimusega tsükli tüübi. Tsükli kehas olevate käskude loendit ("do" ja "done" vahel) korratakse, kuni tingimus jääb tõeseks (st viimase käsu lõpukood tsükli kehas on "0") või tsüklit ei katkestata. seestpoolt spetsiaalsete käskude abil ("break", "continue" või "exit"). Esmakordsel tsüklisse sisenemisel peab tingimus olema tõene. Käsk "break [n]" võimaldab tsüklist välja murda. Kui "n" puudub, on see samaväärne "break 1". "n" näitab pesastatud silmuste arvu, millest väljuda, näiteks "break 3" - väljumine kolmest pesastatud tsüklist. Erinevalt käsust "break" peatab käsk "continue [n]" ainult praeguse tsükli täitmise ja naaseb tsükli ALGUSEsse. See võib olla ka parameetriga. Näiteks "jätka 2" tähendab väljumist teise (sügavusest loendades) pesastatud tsükli algusesse. Käsk "exit [n]" võimaldab protseduurist täielikult väljuda tagastamiskoodiga "0" või "n" (kui parameeter "n" on määratud). Seda käsku saab kasutada mitte ainult tsüklites. Isegi lineaarse käskude jada korral võib silumisel olla kasulik (praegune) arvutus antud punktis peatada. Väärtingimusega silmuslause ("kuni") Silmuse operaatoril "kuni" on struktuur: Kuni tingimuseni do nimekiri tehtud käskudest, kus "kuni" on abisõna, mis määrab väärtingimusega tsükli tüübi. Tsükli kehas olevate käskude loendit ("do" ja "done" vahel) korratakse seni, kuni tingimus jääb vääraks või tsükkel katkestatakse seestpoolt spetsiaalsete käskudega ("break", "continue" või "exit"). ). Esmakordsel tsüklisse sisenemisel ei tohiks tingimus tõene olla. Erinevus operaatorist "while" seisneb selles, et tsükli tingimust kontrollitakse vääruse suhtes (tsükli keha viimase käsu nullist erineva väljumiskoodi korral) ja seda kontrollitakse PÄRAST iga (kaasa arvatud esimene!) käskude täitmist tsüklis. silmuse korpus. Näide. Kuni vale teha loe x kui [ $x = 5 ] siis kaja piisavalt ; murda muidu kaja veel mõni fi Siin on programm koos lõputu silmus ootab sõnade sisestamist (korrates ekraanil fraasi "veel"), kuni sisestatakse "5". Pärast seda väljastatakse "piisavalt" ja käsk "break" lõpetab tsükli täitmise. Tühi operaator Tühjal lausel on vorming Mitte midagi tegemata. Tagastab väärtuse "0". Funktsioonid kestas Funktsioon võimaldab koostada shellikäskude loendi järgnevaks täitmiseks. Funktsiooni kirjeldus näeb välja selline: Nimi() (käsuloend) mille järel kutsutakse funktsioon nimepidi. Funktsiooni käivitamisel uut protsessi ei looda. See töötab vastava protsessi keskkonnas. Funktsiooni argumendid muutuvad selle asukohaparameetriteks; funktsiooni nimi on selle nullparameeter. Funktsiooni täitmise saate katkestada operaatori "tagasi [n]" abil, kus (valikuline) "n" on tagastuskood. Katkestuste käsitlemine ("lõks") Võib osutuda vajalikuks kaitsta programmi täitmist katkestuste eest. Kõige sagedamini esinevad signaalidele vastavad katkestused: 0 tõlgist väljumine, 1 kõne katkestamine (kaugabonendi ühenduse katkestamine), 2 katkestust Püüdke "käsuloendi" signaalid kinni Kui süsteemis tekivad katkestused, mille signaalid on loetletud "signaalides" tühikuga eraldatuna, siis käivitatakse "käsuloend", misjärel (kui käskluse loendis käsku "exit" ei täidetud) toimub juhtimine. naaske katkestuspunkti ja käsufaili täitmine jätkub. Näiteks kui enne käsufaili täitmise katkestamist on vaja failid kaustast “/tmp” kustutada, saab seda teha käsuga “trap”: Lõks "rm /tmp/* ; väljumine 1" 1 2 15 mis eelneb faili muudele käskudele. Siin pärast failide kustutamist suletakse käsufailist. Mana (dokumentatsiooni) ümberjutustamist ei toimu ja artikkel ei tühista ega asenda mingil viisil nende lugemist. Selle asemel räägin peamistest asjadest (käsklused, võtted ja põhimõtted), mida pead mõistma juba töötamise algusest peale. unixi kest et töö sujuks tõhusalt ja meeldivalt. Artikkel käsitleb täisväärtuslikke unix-laadseid keskkondi, millel on täielikult toimiv kest (eelistatavalt zsh või bash) ja üsna lai valik standardprogrammid. Üldiselt näeb shellis töötamine välja järgmine: kasutaja (st teie) sisestab klaviatuurilt käsu, vajutab sisestusklahvi, süsteem täidab käsu, kirjutab täitmise tulemuse ekraanile ja ootab jälle järgmist käsku sisestada. Tüüpiline vaade shella: Kest on peamine viis kõigi Unixi-laadsete serverisüsteemidega suhtlemiseks. Kui töötate masinaga, kuhu on installitud Ubuntu, peate käivitama programmi Terminal. Kui olete lõpetanud, saate lihtsalt akna sulgeda. MacOS-is - käivitage ka terminal. Ligi pääsema kaugserver- kasutage ssh-d (kui teil on kohapeal MacOS, Ubuntu või mõni muu unixilaadne süsteem) või kitt (kui teil on Windows). Käivitage mitu käsku: hostname, ls, pwd, whoami. Nüüd vajutage üles klahvi. Eelmine käsk ilmub sisestusreale. Üles- ja allaklahvide abil saate ajaloos edasi ja tagasi liikuda. Kui jõuate hostinime juurde, vajutage sisestusklahvi - käsk täidetakse uuesti. Ajaloost pärit käske ei saa mitte ainult korduvalt täita, vaid ka redigeerida. Kerige ajalugu käsu ls juurde, lisage sellele lüliti -l (selgub, et ls -l , miinuse ees on tühik, pärast mitte). Vajutage sisestusklahvi - muudetud käsk täidetakse. Ajaloo kerimine, käskude redigeerimine ja uuesti täitmine on käsureal töötamisel kõige levinumad toimingud, seega harjuge sellega. Teksti suurepärane asi on see, et seda saab kopeerida ja kleepida ning see kehtib ka käsureal. Proovige käsu kuupäeva +"%y-%m-%d, %A" Kui olete õppinud kasutama meest, veenduge, et saate spikrist näidiskäske kopeerida ja käivitada. Kontrollimiseks otsige kuupäevaprogrammi spikrist üles jaotis NÄITED, kopeerige ja käivitage esimene antud näide (igaks juhuks: dollarimärk ei ole käsu osa, see on sisendviipa sümboolne kujutis). See, kuidas täpselt terminalist teksti kopeerida ja terminali kleepida, sõltub teie süsteemist ja selle seadistustest, mistõttu pole kahjuks võimalik universaalseid juhiseid anda. Ubuntus proovige seda: kopeeri - lihtsalt vali hiirega, kleebi - hiire keskmine nupp. Kui see ei tööta või kui teil on mõni muu süsteem, vaadake Internetist või küsige kogenumatelt sõpradelt. Akira@latitude-e7240: ~/shell-survival-quide> ls Makefile shell-first-steps.md shell-first-steps.pdf shell-survival-quide.md shell-survival-quide.pdf Akira@latitude-e7240: ~/shell-survival-quide> ls -l kokku 332 -rw-rw-r-- 1 akira akira 198. veebruar 13 11:48 Makefile -rw-rw-r-- 1 akira akira 15107 veebr. 14 22:26 shell-first-steps.md -rw-rw-r-- 1 akira akira 146226 13. veebruar 11:49 shell-first-steps.pdf -rw-rw-r-- 1 akira akira 16626 13. veebruar 11 :45 shell-survival-quide.md -rw-rw-r-- 1 akira akira 146203 13. veebruar 11:35 shell-survival-quide.pdf Lisaks võivad käsud võtta failinimesid, kataloogide nimesid või lihtsalt tekstistringid. Proovige: Ls -ld /home ls -l /home grep juur /etc/passwd Proovige: man grep , man atoi , man chdir , man man . Edasi-tagasi kerimine toimub nuppudega “üles”, “alla”, “PageUp”, “PageDown”, abivaatest väljumine toimub nupuga q. Otsing konkreetne tekst abiartiklis: vajutage / (kaldkriips), sisestage otsimiseks tekst, vajutage sisestusklahvi. Liikumine järgmiste esinemiste juurde – klahv n. Kõik abiartiklid on jagatud kategooriatesse. Kõige tähtsam: Saate vaadata kõigi teie arvutis saadaolevate abiartiklite loendit, kasutades käsku man -k. (täpp on ka osa komadast). Proovige käitumist võrrelda: Kass /etc/bash.bashrc kass /etc/bash.bashrc |vähem Saate faili piiparile üle kanda otse parameetrites: Vähem /etc/bash.bashrc Üles ja alla kerimine - nupud "üles", "alla", "PageUp", "PageDown", väljumine - nupp q. Otsige konkreetset teksti: vajutage / (kaldkriips), sisestage otsitav tekst ja vajutage sisestusklahvi. Liikumine järgmiste esinemiste juurde – klahv n. (Kas tunnete ära juhised inimese kohta? Pole ime, et abi kuvamiseks kasutatakse ka vähem.) Failide õigusi saate vaadata ls -l abil. Näiteks: > ls -l Makefile -rw-r--r-- 1 akira õpilased 198. veebruar 13 11:48 Makefile Kui saate töötamise ajal teate loa keelamisest, tähendab see, et teil pole piisavalt õigusi objektile, millega soovite töötada. Loe lähemalt man chmodist. Käivitage wc programm, sisestage tekst Good day today, vajutage Enter, sisestage tekst good day, vajutage Enter, vajutage Ctrl+d. WC programm näitab statistikat tähtede, sõnade ja ridade arvu kohta teie tekstis ja lõpus: > wc hea päev täna hea päev 2 5 24 Nüüd käivitage käsk head -n3 /etc/passwd, see peaks välja nägema umbes selline: > head -n3 /etc/passwd root:x:0:0:root:/root:/bin/bash deemon:x:1:1:deemon:/usr/sbin:/usr/sbin/nologin bin:x: 2:2:bin:/bin:/usr/sbin/nologin Võite seda ette kujutada nii: programm on toru, millesse voolab STDIN ja välja voolab STDOUT. Unixi käsurea kõige olulisem omadus on see, et "toru" programme saab omavahel ühendada: ühe programmi väljundit (STDOUT) saab edastada sisendandmetena (STDIN) teisele programmile. Sellist ühendatud programmide konstruktsiooni nimetatakse inglise keeles toruks või vene keeles konveieriks või toruks. Programmide ühendamine konveieriks toimub sümboliga | (vertikaalne riba) Käivitage käsk head -n3 /etc/passwd |wc , see näeb välja umbes selline: > head -n3 /etc/passwd |wc 3 3 117 Saate ühendada nii palju programme kui soovite. Näiteks saate eelmisele torujuhtmele lisada veel ühe wc-programmi, mis loeb, mitu sõna ja tähte oli esimese wc väljundis: > head -n3 /etc/passwd |wc |wc 1 3 24 Konveierite (torude) loomine on käsureal töötamisel väga levinud ülesanne. Näide selle kohta, kuidas seda praktikas tehakse, leiate jaotisest "Ühe voodri torujuhtme loomine". Kuupäev > /tmp/today.txt Kui sama nimega fail oli juba olemas, siis selle vana sisu hävitatakse. Kui faili ei eksisteerinud, luuakse see. Kataloog, kuhu fail luuakse, peab enne käsu täitmist olemas olema. Kui te ei soovi faili üle kirjutada, vaid pigem lisada väljundi selle lõppu, kasutage >> : Kuupäev >> /tmp/today.txt Lisaks saate STDIN-i asemel programmile edastada mis tahes faili. Proovige: Tualett Kui lahendate keerulise probleemi (ise, Interneti või teiste inimeste abiga), kirjutage oma lahendus üles juhuks, kui teil või teie sõpradel peaks sama probleem uuesti ilmnema. Saate selle salvestada lihtsas tekstifailis, Evernote'is või avaldada selle sotsiaalvõrgustikes. Tõmmake ajaloost eelmine käsk, lisage konveierile veel üks käsk, käivitage, korrake.Cm. Vaata ka jaotist “Ühe voodri torujuhtme loomine”. Teil ei pruugi olla mõnda programmi, mida tuleb täiendavalt installida. Lisaks on mõned nende programmide valikud saadaval ainult privilegeeritud kasutajatele (root). Samm 1. 2. samm. Ps axuww |grep `whoami` 3. samm. Ps axuww |grep `whoami` | grep "\ Ps axuww |grep `whoami` | grep "\ Nõutavate protsesside pid, etapp 3 on lõpetatud 4. samm. Siin on mõned programmid, mis tulevad kindlasti kasuks, kui elate käsureal: ===================================================== LABORITÖÖ nr 1 (valmimisaeg - 3 tundi) Teema: "Sissejuhatuskest”
1. Sissejuhatus shelli Shell on käsutõlk (käsuprotsessor), mis toimib kasutaja ja Unixi kerneli vahelise liidesena. Solaris pakub kolme peamist käsuprotsessorit: Bourne'i vaikeshell on /sbin/sh C Käsuprotsessor -- /bin/csh Korn kest -- ./bin/ksh Lisaks loetletutele pakub Solaris täiendavaid kestasid: J kest -- /sbin/jsh Piiratud Korn l -- / usr/ bin/rsh T-shell -- /usr/bin/tcsh GNU Bourne Again -- /usr/bin/bash Z-shell – usr/bin/zsh Käsuprotsessori valik on isiklike eelistuste küsimus. 2. Käivita käsud Iga Unixi käsk koosneb käivitatava programmi nimest (käsk), suvanditest (klahvidest) ja programmile edastatavatest argumentidest. Käsurea on piiritletud tühikute või tabeldusmärkidega. Näide $
/bin/ping –t 10 192.168.2.13 argument kesta kutse Kui programmi käivitamisel täitmisfaili teed ei täpsustata, vaatab OS järjestikku PATH muutujas määratud katalooge. Kui vaadatavas kataloogis on sama nimega programm, siis käivitatakse see täitmiseks. Praegust töökataloogi ei otsita programmide otsimisel, välja arvatud juhul, kui see on määratud muutujas PATH. !
Turvalisuse huvides on soovitav, et administraator ei lisa muutuja PATH hulka kasutaja praegust kataloogi ja koduseid (isiklikke) katalooge. Näited Käivitage programm, mis määrab kogu tee $ /
usr/
kohalik/
prügikast/
minu_
programm Programmi käivitamine kõrgemast (ema)kataloogist $ ../
kohalik/
prügikast/
minu_
programm Programmi käivitamine praegusest kataloogist $ ./
minu_
programm 3. Erimärgid kestas Mõnel kestategelasel on eriline tähendus. 3.1. Failinimede genereerimise mallid
? (küsimärk) sobib mis tahes märgiga, välja arvatud esimene punkt; (nurksulud) määratlege sümbolite rühm (rühmast valitakse üks sümbol); - (miinusmärk") määrab kehtivate märkide vahemiku; ! (Hüüumärk) lükkab tagasi järgmise tegelaste rühma; * (tärni sümbol) vastab suvalisele arvule tähemärkidele, välja arvatud esimene punkt. 3.2. I/O ümbersuunamise sümbolid
<
- sisendi ümbersuunamine; >, >>
- väljundi ümbersuunamine; 2>, 2>>
- veateadete ümbersuunamine; |
- konveier. 3.3. Asendusmärgid
$nimi_muutujaq
-
muutuv asendus; $(käsk) või `meeskond` - käsu asendamine; ~ - tilde asendus. 4. Otsi Failide ja kataloogide kiireks otsimiseks kasutage sügavama otsingu jaoks käsku whereis, kasutage käsku find (otsige faile, mis vastavad määratud nõuetele;). 5. Tekstiredaktor vi Tekstiredaktor vi on universaalne redaktor, mis on olemas igas Unixis. Lisaks tekstifailide redigeerimisele saab vi-redaktorit kasutada käsurea redigeerimiseks. Vi-redaktoril on 3 töörežiimi (vt joonist). Logige sisse vi redaktorisse Välju vi Esimesel positsioonil olev märk “~” (tilde) tähistab faili tühje (olematuid) ridu. Põhirežiim on käsurežiim, kus käsklused sisestatakse teatud klahvijada vajutamisega (neid ei kuvata ekraanil mitte mingil moel). Tekstis liikumine käsurežiimis toimub noolte ja klahvide abil Mõned vi käsud on loetletud tabelis. Praeguse rea kustutamine Praeguse rea kopeerimine puhvrisse Kursori liikumine Kursoriga märgitud märkide sisestamine puhvrisse Sisestage allosas uus rida Uue rea lisamine ülaossa Lisamine kursori järel Lisa praeguse rea järele Sisesta enne kursorit Sisesta enne praegust rida Märgi asendamine klaviatuurilt sisestatud tähemärgiga Teksti kleepimine lõikelaualt .
(punkt) Korrake viimast käivitatud käsku Tühista viimane käsk Võta tagasi kõik praegusel real tehtud muudatused Kursori kohal oleva märgi kustutamine Sisestusrežiimis sisestatakse teksti kõik klaviatuuril sisestatud märgid. Viimase rea režiimis kuvatakse sisestatud käsk ekraani viimasel real. 6. Abi Unixil on elektrooniline kataloog, mis sisaldab käskude eesmärgi kirjeldust, nende süntaksit, kasutusnäiteid jne. Kataloogi kutsutakse välja käsuga man: 7. Põhilised shellikäsud WHO– aktiivsete kasutajate kohta teabe kuvamine; kaja– väljastada terminali teateid; bänner– väljastada terminali teated suurtähtedega; mees– online-abisüsteemi helistamine; kuupäev
– jooksva kuupäeva väljund; kirjutada– sõnumite edastamine teise kasutaja terminali; sõnum– teiste kasutajate sõnumite kuvamise lubamine/keelamine; mail– posti saatmine/vastuvõtmine; uudised– tutvumine süsteemiuudistega; pwd– aktiivse töökataloogi marsruudi absoluutse nime kuvamine; CD– töökataloogi muutmine; ls– kataloogi sisu kohta teabe kuvamine; mkdir– kataloogi koostamine; rmdir– kataloogi kustutamine; puudutada– faili ajatempli värskendamine; cp– failide kopeerimine; kass– failide sisu kombineerimine ja kuvamine; rohkem– faili sisu lehekülgede kaupa vaatamine. mv
– faili teisaldamine või ümbernimetamine; rm- faili kustutamine; teise nimega– pseudonüümi loomine; tr– märkide teisendamine; väljuda– voolu lõpetamine kest-A; tee– torujuhtme tulemuste pealtkuulamine; lõigatud
– reast väljade valimine; grep- otsi malli järgi; pr– väljastage fail kindlas vormingus standardväljundisse; sorteerida– sorteerimine; pea– faili esimeste ridade väljund; saba– faili viimaste ridade väljund; tualett– märkide, sõnade ja ridade loendamine; lugeda,
kaja
-
muutuvate väärtuste lugemine ja väljastamine; test- väljendi tähenduse hindamine; avald,
lase- aritmeetiliste avaldiste arvutamine; 8.
Kest- programmid Shell võimaldab teil salvestada faili käskude jada ja seejärel seda käivitada. Shelli programmiga faili käivitamiseks peate juurdepääsuõigustele lisama täitmisõiguse: $ chmod +x programmi_faili_nimi Shellprogrammides hargnemist korraldatakse järgmiste operaatorite abil: kui-siis-muidu Silmusoperaatorid: HARJUTUSED 1. Milliste järgmistest käskudest kuvatakse ekraanil tervitussõnum? Millised ei ole? Miks? $echo tere $ echo tere $ echo TERE, MAAILM
$
bänner
Tere $
BANNER
TERE, MAAILM 2. Printige sõnum käskude abil mitmele reale kaja Ja bänner. 3. Trüki kuupäev kahes reas: esimesele reale päev, kuu, aasta, teisele reale praegune kellaaeg, lisades väljundile kommentaari. 4. Kasutades käsku kirjutada, saatke konsooli sõnum. Saatke sõnumeid korraga mitmele terminalile. 5. Kasutades käsku sõnum, määrake, kas sõnumid on teie terminalis lubatud. Keela sõnumid. Milline on süsteemi reaktsioon, kui keegi üritab teile sõnumit saata? 6. Määrake oma nimi KODU- kataloog. 7. Sirvige käskude abil kataloogi alampuud alustades kataloogist /export/home cd, ls Ja pwd. 8.. Loo oma KODU- kataloog vormi alamkataloogidega: puuvilja lilled õun pirn viinamarjad roosvioletne võilill tumeroheline 9. Omas olemine KODU-kataloogis looge ühe käsurea abil järgmised alamkataloogid: A/B/C/D 10. Omas olemine KODU-kataloog, kustutage kõik kataloogi alamkataloogid A. 11. Olles sees KODU-kataloogis, looge fail macintosh
olemasolevas kataloogis õun ja mitu faili kataloogides tume Ja roheline. Logige kataloogi sisse falandab. Kataloogis olles falandab,
kopeerige kõik alamkataloogid fruits koos neis sisalduvate failidega spetsiaalselt loodud kataloogi korv.
12. Kataloogis olles falandab, kustutage kataloog fruits.
13. Lugege faili .profiil käskude abil kass Ja rohkem. 14. Loo sisse KODU-kataloogi tekstifail minu fail mitmelt realt, kasutades käsku kass. Loo tekstifail MyFile, kirjutades sinna samad read. Mitu faili sa said? Miks? 15. Vaadake ülesandes 2.2 loodud faili sisu minu fail. Kopeerige fail minu fail viilima mükoopia. Vaadake mõlema faili sisu. 16. Teisaldage fail mükoopia kataloogi lilled. 17. Sees olles KODU-kataloog, loo link mylink faili kohta mükoopia asub kataloogis lilled. Vaadake lingifaili. 18. Lisa faili rida minulink.
Milline failidest minulink, minukopeerida, minufaili
muutunud? Miks? 19. Millise käsuga saab määrata linkide arvu? Määrake failide linkide arv minulink, minukopeerida, minufaili.
Kustuta fail mükoopia. Mis juhtus lingifailiga? Määrake failide linkide arv minulink, minufaili.
20. Looge alias rež, mis prindib praeguse kataloogi sisu laiendatud vormingus. 21. Logi välja ja uuesti sisse. Kas alias töötab? rež? Mida tuleks teha, et hüüdnimi seansside vahel kaotsi ei läheks? 22. Loo alias punkt, mis prindib töökataloogis olevate failide loendi, mille nimed algavad punktiga. 23. Käsu kasutamine puudutada, looge failid uude kataloogi selliste nimedega, mis samal ajal: Mall a*
5 faili sobitatud; Mall *
a vastas 4 failile; Mall ??.?
sobitatud 3 faili; Mall *
aa*
vastas 2 failile; Mall??? sobis 1 failiga. 24. Millise käsu peaksite sisestama, et teha järgmist: a) kuvab kõigi failide nimed, mis algavad punktiga; b) kuvab kõigi failide nimed, mis lõppevad tähega ".txt"; c) kuvab kõigi seda sõna sisaldavate failide nimed "minu"; 25. Asenda ühes failis kõik väiketähed suurtähtedega ja teises kõik suurtähed väiketähtedega. Eemaldage failist kõik dubleerivad tühikud. 26. Looge fail nimega *
. Kustuta ainult see fail. Olge failinimede genereerimise märkide kasutamisel ettevaatlik! 27. Loo fail, mille nimes on tühik. Kuidas sellist faili kustutada? 28. Käskluse kasutamine kass kahekordistada faili sisu, lisades sama faili lõppu algse sisu. Minge kataloogi lilled. Lisa faili spisok kataloogi sisu loend lilled. Vaadake faili sisu 29. Proovige lugeda käsuga kass olematu fail. Milline on süsteemi reaktsioon? Tehke sama, suunates veateated faili myerror. Mida sa ekraanil näed? Vaadake faili myerror. 30. Looge konveier, et loetleda ainult praegu teie töökataloogis olevate failide nimed ja õigused. 31. Muutke ehitatud torujuhet nii, et loend salvestatakse faili spisok Sinu oma KODU-kataloogis ja ekraanil kuvati ainult loendis olevate failide arv. 32. Kuvage faili sisu /etc/passwd, sorteeritud kasutajanime välja järgi. 33. Loo alias logitudpeal, mis kuvab tähestikulises järjestuses süsteemis töötavate kasutajate nimede loendi. 33. Kuvage praegune kuupäev suurtähtedega, kasutades käske kuupäev Ja bänner. 34. Määra muutujale MA OLEN. Teie registreerimisnimi. Alusta teist kest. Kas näete seda muutujat? Mida peate tegema, et seda genereeritud failis näha kest? Muutke muutuja väärtust MA OLEN. loodud kest. Tulge välja sündinud kest.
Vaadake selle muutuja väärtust allikas kest. Selgitage tulemust. 35. Kirjutage kest- programm info, mis palub kasutajal sisestada nimi, aadress, kuupäev, sünnikuu ja aasta ning kuvada need andmed sisestatud vastupidises järjekorras 36. Kirjutage kest- programm, mis kuvab viipa numbri sisestamiseks ja salvestab sisestatud numbri muutujasse Y ja printige sõnum "Y on suurem kui 7", kui väärtus Y rohkem kui 7 ja "Y onmitte
suurem
kui
7”
muidu. 37. Kirjutage shellprogramm, mis kuvab järgmise statistika: a) teie nimi; b) argumentide arv, millega see käivitatakse; c) trükib iga oma argumendi ja argumendi pikkuse tähemärkides; 38. Kirjutage kest- programm, mis määrab käsureal olevate argumentide arvu ja kuvab veateate, kui argumentide arv ei ole kolm, või argumendid ise, kui nende arv on kolm. 39. Kirjuta kest- programm, mis palub teil sisestada kasutajatunnuse, võrrelda seda süsteemis kasutatavatega ja kuvada täisnime KODU-kataloogi või kehtetu identifikaatori korral kuvada veateade. 40. Kirjutage shellprogramm Tere, mis annab käsurea argumentidele järgmise vastuse: Argument "-d"- programm täidab käsu kuupäev; Argument "-l"- programm kuvab aktiivse kataloogi sisu; Kui käsureal pole argumente või kehtetuid argumente, prindib programm oma valikute kohta abi. 41. Kirjutage programm sõnad, mis palub kasutajal sisestada ühe sõna korraga, kuni ta sõna sisestab “
lõpp”
. Pidage meeles kõiki sisestatud sõnu. Pärast sõna sisestamist “
lõpp”
kuvada ekraanil kõik sisestatud sõnad. 42. Muutke süsteemiviipa nii, et see sisaldaks praeguse töökataloogi täielikku teenime .
43. Kirjutage programm viirus, mis loob endast teise nimega käivitatava koopia ja seejärel kustutab end. 44. Kirjutage programm viirus2
, mis otsib praegusest kataloogist käsukeele programme ja lisab nende tekstile käsu sõna kuvamiseks “
Nakatunud!”.
45. Kirjutage programm viirus3
, mis lisab teiste programmide nakatamiseks leitud käsukeele programmidele oma koodi. 46. Kirjutage programm viirus4
, muutes oma viirust nii, et nakatumisel eemaldatakse nakatav kood nakatavast programmist. 47. Kirjutage programm viirusetõrje, mis leiaks kõik teie viirusega nakatunud shell-programmid. 48. Muutke arendatud programmi nii, et see mitte ainult ei leiaks nakatunud programme talle määratud kataloogist, vaid ka "raviks" neid, salvestades nakatunud versiooni uude faili, mille nimele on lisatud lõpp .
vir ja sellisest failist täitmise atribuudi eemaldamine. 49. Kirjutage programm viirus5
, mis: a) nakatab praeguses kataloogis ja selle alamkataloogides olevaid shellprogramme viirusega ainult siis, kui kasutaja sisestab käsu ls; b) käituks nagu meeskond ls, avaldamata midagi oma töö kohta terminalis. 50. Kirjutage programmide põhjal viirus6 programm viirus2
-viirus5
, mille nakatavat koodi ei suutnud teie arendatud programm tuvastada viirusetõrje, ja nakatumine toimuks muutuja mis tahes väärtuse korral PATH. 51. Kirjutage programm superviirus, mille käivitamisel nakatatakse sinu failid eelmises ülesandes arendatud viirusega ning iga kord, kui süsteemi sisse logid, üritatakse nakatada ka sinu sõprade faile. Programm superviirus
kustutab end pärast esimest käivitamist. 52. Kirjutage programm superviirusetõrje, mis tuvastab ja täielikult "ravib" (kui vastav valik on määratud) kõik failid määratud kataloogis ja selle alamkataloogides kõigist arendatud viirustest., 9 hävitamine (ei peatatud), 15 hukkamise lõpp. Katkestuste eest kaitsmiseks on käsk "trap", mille vorming on:Miks ja kellele artikkel on mõeldud?
Algselt oli see meeldetuletus õpilastele, kes hakkavad töötama Unixi-laadsete süsteemidega. Teisisõnu, artikkel on mõeldud neile, kellel puudub varasem Unixi käsureaga töötamise kogemus, kuid ühel või teisel põhjusel soovivad või peavad õppima sellega tõhusalt suhtlema. Mis on kest
Shell (shell, teise nimega "käsurida", teise nimega CLI, teise nimega "konsool", teise nimega "terminal", teise nimega "must aken valgete tähtedega") on tekstiliides suhtlemiseks operatsioonisüsteem(Noh, rangelt võttes, see on programm, mis pakub sellise liidese, kuid nüüd on see erinevus tähtsusetu). Kust leidub käsureasüsteeme?
Kui unixi kest võib teid oodata, on populaarsed valikud: Milliseid probleeme on mõistlik kestaga lahendada?
Looduslikud ülesanded, mille jaoks kest sobib, kasulik ja asendamatu: Absoluutselt esimesed sammud
Alustame: logige sisse ja välja
Veenduge, et teate täpselt, kuidas kesta käivitada ja kuidas sellest väljuda. Kes ma olen, kus ma olen?
Käivitage järgmised käsud: Käskude ajalugu (ajalugu)
Täisväärtusliku käsurea oluline omadus on käsuajalugu. Kopeeri kleebi
Käsurida on väga tekstikeskne: käsud on tekst, enamiku standardprogrammide sisendandmed on tekst ja väljundiks on enamasti tekst.
Kas sisestasite selle täielikult käsitsi või kopeerisite selle artiklist? Veenduge, et saate selle kopeerida, terminali kleepida ja käivitada.Klahvid ja valikud
Käskude ajalugu uurides olete juba kohanud, et käsul ls on vähemalt kaks võimalust. Kui nimetate seda niisama, väljastab see lihtsa loendi:
Kui lisate lüliti -l, kuvatakse iga faili kohta üksikasjalik teave:
See on väga tüüpiline olukord: kui käsukutsele lisatakse spetsiaalsed modifikaatorid (klahvid, valikud, parameetrid), muutub käsu käitumine. Võrdle: puu / ja puu -d / , hostinimi ja hostinimi -f .mees
mees – abi teie masinas saadaolevate käskude ja programmide ning süsteemikutsete ja standardse C-teegi osas.
Nimede kokkulangevuse korral on vaja märkida, millisest kategooriast tunnistust näidata. Näiteks man 3 printf kirjeldab funktsiooni from standardne raamatukogu C ja man 1 printf on samanimeline konsooliprogramm. vähem
Kui sisse väike aken terminali tuleb väga palju vaadata pikk tekst(mingi faili sisu, pikk mees vms), kasutavad nad spetsiaalseid “piileri” programme (sõnast leht ehk lehekestad). Kõige populaarsem kerimisseade on väiksem ja see pakub teile manlehtede lugemisel kerimist. Õigused
Iga fail või kataloog on seotud “õiguste” kogumiga: faili lugemise õigus, faili kirjutamise õigus, faili täitmise õigus. Kõik kasutajad on jagatud kolme kategooriasse: failiomanik, failiomanike rühm ja kõik teised kasutajad.
See väljund tähendab, et omanik (akira) saab faili lugeda ja kirjutada, rühm (õpilased) ainult lugeda ja kõik teised kasutajad saavad samuti ainult lugeda.STDIN, STDOUT, konveierid (torud)
Iga töötava programmiga on seotud 3 standardne vool andmed: sisendandmevoog STDIN, väljundandmevoog STDOUT, veaväljundvoog STDERR.
Sel juhul sisestasite programmi STDIN-i kaherealise teksti ja saite STDOUT-is kolm numbrit.
Sel juhul ei lugenud peaprogramm STDIN-ist midagi, vaid kirjutas kolm rida STDOUT-i.
Juhtus nii: head programm väljastas STDOUT-is kolm tekstirida, mis läksid kohe wc programmi sisendisse, mis omakorda luges kokku märkide, sõnade ja ridade arvu saadud tekstis.I/O ümbersuunamine
Programmi väljundit (STDOUT) ei saa mitte ainult konveieri kaudu teise programmi üle kanda, vaid ka lihtsalt faili kirjutada. See ümbersuunamine toimub kasutades > (suurem kui märk):
Selle käsu täitmise tulemusena ilmub kettale fail /tmp/today.txt. Vaadake selle sisu failiga cat /tmp/today.txt
Kontrollige, mis on nüüd failis kirjutatud.Mida teha, kui midagi on ebaselge
Kui puutute kokku süsteemi käitumisega, millest te aru ei saa, või soovite saavutada teatud tulemuse, kuid ei tea, kuidas, soovitan teil tegutseda järgmises järjekorras (muide, see ei kehti ainult kestade kohta):
Kui ükski ülaltoodust ei aita, küsi nõu õpetajalt, kogenud kolleegilt või sõbralt. Ja ärge kartke küsida "rumalaid" küsimusi – häbi pole mitte teada, vaid häbi pole küsida. Töömeetodid
Kopeeri ja kleebi- man-lehtedelt, StackOverflow artiklitest jne. Käsurea koosneb tekstist, kasutage seda ära: kopeerige ja kasutage näidiskäske, kirjutage õnnestunud leiud mälestuseks üles, avaldage need Twitteris ja blogides. Põhilised käsud
Analüütika
Süsteemi diagnostika
Mass- ja poolautomaatne täitmine
Algul jätke see jaotis vahele, kui jõuate lihtsa shelliskriptimiseni, vajate neid käske ja konstruktsioone. Mitmesugust
Ühe voodri torujuhtme loomine
Vaatame reaalse ülesande näidet: peame hävitama kõik praeguse kasutajana töötavad Task-6-serveri protsessid.
Saate aru, milline programm toodab ligikaudu vajalikke andmeid, isegi kui mitte puhtal kujul. Meie ülesande jaoks tasub hankida kõigi süsteemi protsesside loend: ps axuww. Käivitage.
Vaadake saadud andmeid silmaga, leidke filter, mis viskab osa mittevajalikke andmeid välja. See on sageli grep või grep -v . Kasutage klahvi "Üles", et eemaldada ajaloost eelmine käsk, määrata sellele leiutatud filter ja käivitada.
- ainult praeguse kasutaja protsessid.
Korrake sammu 2, kuni saate vajalikud puhtad andmed.
- kõik vajaliku nimega protsessid (pluss võib-olla ka lisatoimingud, nagu vim task-6-server.c jne),
- ainult nõutava nimega protsessid
Rakenda sobiv lõppkäitleja. Klahvi „Üles” abil tõmbame ajaloost välja eelmise käsu ja lisame töötlemise, mis viib probleemi lahendamise lõpule:Koolitusülesanded
Kas soovite uusi oskusi harjutada? Proovige järgmisi ülesandeid.
Vihje: vajate find , grep -o , awk "(print $1)" , grep regulaaravaldisi , curl -s . Mida edasi õppida?
Kui käsurida hakkab meeldima, siis ära lõpeta, vaid täienda oma oskusi.
Lisaks tasub aja jooksul omandada mingisugune skriptikeel, näiteks perl või python või isegi mõlemad. Kellele seda vaja on?
Kas tänapäeval tasub üldse käsurida ja shelliskriptimist õppida? Kindlasti seda väärt. Toon vaid mõned näited Facebooki nõuetest kandidaatidele, kes soovivad FB-s tööd saada. 
