Zeker, bijna alle lezers van Habr kennen sh- en bash-shells. Ook hebben de meesten van ons iets gehoord over zsh en tcsh. De lijst met bestaande shells houdt hier echter niet op. Het is voorwaardelijk mogelijk om ze in drie groepen te verdelen:

• Bourne shell-klonen (bash, zsh)
• C-schaal (csh, tcsh)
• Gebaseerd op populaire programmeertalen (psh, ipython, scsh)
• Exotisch, specifiek en al de rest

De interessantste zullen worden besproken.

Het doel van het schrijven van dit artikel was niet om alle bestaande opdrachtshells te beoordelen of te classificeren. Ik wil het alleen hebben over enkele interessante producten op dit gebied, om de horizon van de lezer te verbreden. Ik zal blij zijn. als ik hiermee iemand aanmoedig om het onderwerp in meer detail te bestuderen of zelfs over te schakelen naar een andere wandeling.
Eerst even kort wat het is. Een shell- of commando-interpreter is een applicatie die een gebruikersinterface biedt opdrachtregel waarin hij commando's afzonderlijk invoert of scripts uitvoert die uit een lijst met commando's bestaan. Mondeling en in informele teksten wordt het vaak "went" genoemd, van de Engelse shell - een shell.

De POSIX-compatibele shells die afstammen van de Bourne-shell worden het meest gebruikt, dus laten we daarmee beginnen.

Bourne shell en zijn klonen

Bourne-schaal, uitvoerbaar: sch. Een commandoshell genoemd naar de maker Stephen Bourne. De meeste operators zijn door hem geleend van de taal Algol 68. Het werd uitgebracht in de 7e editie van het UNIX-besturingssysteem, waar het de standaard shell was. Tot nu toe heeft de overgrote meerderheid van Unix-achtige systemen /bin/sh, een symbolische of harde link naar een sh-compatibele shell.

Bourne weer shell, uitvoerbaar: bashen. De naam kan worden vertaald als "Revived Bourne Walked". Waarschijnlijk de meest populaire shell tot nu toe. De facto standaard voor Linux. Ik zal er niet bij stilstaan, want. veel op internet goede artikelen over bash. Bijvoorbeeld hier en hier.

Z-schaal, uitvoerbaar: zsh. Een gratis moderne sh-compatibele shell. Het heeft een aantal voordelen ten opzichte van bash, voornamelijk gerelateerd aan het werken in interactieve modus. Ze schreven erover op Habré en
Daarnaast zijn er nogal wat schelpen die in deze groep vallen: Korn schelp (ksh) en Almquist schelp (ash) etc, maar daar gaan we niet in detail op in.

C-schaal

C-schaal, uitvoerbaar: csh Een opdrachtshell ontwikkeld door vi-auteur Bill Joy. Voor de basis voor scripttaal csh werd genomen, zoals de naam al aangeeft, de C-taal. in die tijd, in 1978, was het de meest populaire programmeertaal onder ontwikkelaars en gebruikers van BSD UNIX. Op dit moment is de meer populaire gratis implementatie van csh tcsh.

Tenex C-schaal, uitvoerbaar: tcsh. Het was in tcsh dat automatisch aanvullen voor het eerst verscheen. Het is de standaard shell in FreeBSD. U kunt er meer over lezen.
Om het verschil in syntaxis visueel te laten zien, zal ik verschillende voorbeelden geven van scripts die hetzelfde doen voor csh en sh-compatibele commando-interpreter.

Voorwaardelijke constructie:

Een lus die de eerste 10 machten van twee berekent:

#!/bin/sh i=2 j=1 terwijl [ $j -le 10 ]; doe echo "2 **" $j = $i i=`expr $i "*" 2` j=`expr $j + 1` klaar

#!/bin/csh set i = 2 set j = 1 terwijl ($j<= 10) echo "2 **" $j = $i @ i *= 2 @ j++ end

De lijst met functies die worden ondersteund door recente versies van bash, zsh en tcsh lijkt echter erg op elkaar en de keuze voor een bepaalde shell is meestal een kwestie van smaak. Met minder gebruikelijke schelpen is de situatie anders. Hier zijn de verschillen groter.

Opdrachtshells gebaseerd op populaire programmeertalen.

Perl Shell, uitvoerbaar: psh. Een shell die de kenmerken van de bovengenoemde shells combineert met de kracht van de Perl-taal. Omdat psh is geschreven in perl en kan zelfs op Windows draaien. Enkele voorbeelden van het gebruik van psh:
ls | s/y/k/ # Vervanging reguliere expressie ls | ( print ++$i, ": $_"; )q # Snelfilter. Tussen de accolades staat een perl-expressie waarbij $_ één regel uitvoer bevat. netstat | ($_>2; )g # grep-filters. Alleen die regels worden weergegeven waarvoor de expressie tussen haakjes true retourneert commando >[=FOO] # Redirect by descriptor open bestand commando > bestand # Gelijk aan commando 2> bestand in bash. Leidt de uitvoer- en foutenstroom van grep foo lib/**/*.pm om naar een bestand # Gebruik **, wat betekent de huidige map en alle submappen

Scsh, uitvoerbaar ssh. commando-interpreter met open source Schema 48 gebruiken als scripttaal.Ondersteunt geen standaardfuncties voor andere shells (commandogeschiedenis, tekstbewerking op de commandoregel, voltooiing van pad/commando). Scripting wordt aanbevolen, maar niet voor interactief werken. Misschien een hit bij fans functionele programmering. Het volgende is een voorbeeldscript dat de namen van alle uitvoerbare bestanden in mappen van de omgevingsvariabele PATH
#!/usr/local/bin/scsh -s !# (definieer (uitvoerbare map) (met-cwd map (filter bestand-uitvoerbaar? (directory-bestanden map #t)))) (definieer (writeln x) (weergeven x) (newline)) (for-each writeln (toevoegen-map uitvoerbare bestanden ((infix-splitter ":") (getenv "PATH"))))

IPython. Het is een interactieve verpakking voor de taal Python-programmering, die een aantal extra functies heeft. IPython heeft een speciaal profiel om als systeemshell te fungeren. Hoe deze modus te starten, hangt, zoals ik het begrijp, af van de versie, maar op mijn machine ziet het er zo uit:
ipython3 --profile=pysh

Er is al heel wat geschreven over IPython, ook in het Russisch (links aan het einde van het artikel). Ik zal proberen de belangrijkste kenmerken ervan op te sommen in termen van het gebruik ervan als een opdrachtshell:

• Cross-platform. Er is zelfs een versie voor Windows
• Python versie 2.x of 3.x als scripttaal, verbeterde introspectie
• Automatische aanvulling van Python-code, evenals bestandsnamen en systeemopdrachten.
• Opdrachtgeschiedenis en daarop gebaseerde macro's
• Een mechanisme dat directorynavigatie, bladwijzers en meer versnelt

Zoals je kunt zien, is IPython minstens zo interactief als bash. Wat betreft scripts, IPython zal handig zijn voor degenen die Python beter kennen dan bash. In feite zullen scripts op IPython alleen verschillen van pure python door een vereenvoudigde oproep naar systeemopdrachten. Hier zijn enkele voorbeelden van het integreren van python- en systeemopdrachten:
# Stel dat we de totale grootte van dpkg-logbestanden willen berekenen: In : cd /var/log/ /var/log In : log_files = !ls -l dpkg.log* In : log_files Out: "-rw-r-- r-- 1 root root 1824 Nov 3 16:41 dpkg.log" In : for line in log_files: ....: size += int(line.split()) ....: In : size Out: 1330009 # .. of ping achtereenvolgens tien hosts In : for i in range(100,110): ....: !ping -c 1 192.168.0.$i ....:

Rest

Natuurlijk niet volle lijst zelfs populaire schelpen. Naast de bovenstaande categorieën zijn er ook die hun eigen syntaxis gebruiken die niet compatibel zijn met sh en bestaande PL's niet kopiëren. Een voorbeeld is de vriendelijke interactieve shell (fish) . Maar uiteindelijk zou ik je er niet over willen vertellen, maar over een meer specifieke slaapschaal.

Slaap Dummy Shell, uitvoerbaar: slaapschelp. Strikt gesproken commando processor sleepshell kan geen naam krijgen, omdat het weet niet hoe het commando's moet verwerken. En het kan helemaal niets, behalve hoe periodiek sterretjes "*" naar de standaarduitvoer moeten worden geschreven. Het wordt echter juist gebruikt als een commando-shell, en dit is waarom: Laten we zeggen dat we iemand de mogelijkheid willen geven om ssh-tunnels te maken via onze server onder Linux-besturing of Unix. Lees meer over ssh-tunneling. Maar we hebben niet tegelijkertijd nodig dat deze iemand toegang heeft gekregen tot de opdrachtregel en bestandssysteem onze ober. Voor zo'n geval is sleepshell bedoeld. We maken een account op de server aan als shell ervoor, installeren sleepshell. De accounteigenaar kan poorten verbinden en doorsturen, maar kan geen opdrachten uitvoeren.

Dat is alles. Hoop dat het interessant was. Ik zal blij zijn met eventuele opmerkingen en advies over de tekst van het artikel.

Gerelateerde Links

www.faqs.org/faqs/unix-faq/shell/shell-differences- draaitabel shell verschillen en overeenkomsten
www.mariovaldez.net/software/sleepshell - Slaap Dummy Shell
ipython.org/ipython-doc/dev/interactive/shell.html - IPython als systeemschil
www.opennet.ru/base/dev/ipython_sysadmin.txt.html - IPython shell als tool voor systeembeheerder

• zelfstudie

Waarom en voor wie is het artikel?

In eerste instantie was dit een herinnering voor studenten die beginnen te werken met Unix-achtige systemen. Met andere woorden, het artikel is bedoeld voor diegenen die geen eerdere ervaring hebben met de Unix-opdrachtregel, maar om de een of andere reden willen of moeten leren hoe ze er effectief mee kunnen werken.

Er zal geen hervertelling van manas (documentatie) zijn, en het artikel annuleert of vervangt het lezen ervan op geen enkele manier. In plaats daarvan zal ik het hebben over de belangrijkste dingen (commando's, trucs en principes) die je vanaf het allereerste begin van het werken in de unix-shell moet begrijpen om effectief en plezierig te werken.

Het artikel gaat over volwaardige unix-achtige omgevingen, met een volledige shell (bij voorkeur zsh of bash) en een redelijk breed scala aan standaardprogramma's.

Wat is schil

Shell (shell, ook wel "command line", ook wel CLI, ook wel "console", ook wel "terminal", ook wel "zwart venster met witte letters" genoemd) is tekst-interface communiceren met het besturingssysteem (nou ja, strikt genomen dit programma, die zo'n interface biedt, maar nu is dit verschil niet significant).

Over het algemeen ziet het werken door de shell er als volgt uit: de gebruiker (d.w.z. jij) voert een commando in vanaf het toetsenbord, drukt op Enter, het systeem voert het commando uit, schrijft het resultaat van de uitvoering naar het scherm en wacht opnieuw op het volgende commando in te voeren.

Typische schelplook:

De shell is de belangrijkste manier om te communiceren met alle Unix-achtige serversystemen.

Waar worden opdrachtregelsystemen gevonden?

Waar een unix-shell op je kan wachten, populaire opties:

• macOS (beuk);
• externe toegang tot de server voor werk of voor een persoonlijk webproject;
• home-bestandsserver met toegang op afstand;
• Ubuntu, PC-BSD op laptop/desktop - Unix-achtige systemen zijn tegenwoordig eenvoudig te installeren en te gebruiken.

Welke taken zijn redelijk op te lossen met een shell?

Natuurlijke taken waarvoor de schaal geschikt, nuttig en onmisbaar is:

• interactief werken in de terminal:
  • compileren, taken uitvoeren via make;
  • vergelijking van tekstbestanden;
  • snelle ad-hoc data-analyse (aantal unieke ips in de log, verdeling van records in uren/minuten, etc.);
  • eenmalige massale acties (veel processen uitschakelen; als u met een versiebeheersysteem werkt, een aantal bestanden ongedaan maken of oplossen);
  • diagnostiek van wat er in het systeem gebeurt (semaforen, vergrendelingen, processen, descriptors, schijfruimte, enz.);
• scripten:
  • stel scripts in waarvan u niet op andere tolken kunt vertrouwen om ze uit te voeren - niet voor beginners;
  • functies voor het aanpassen van de interactieve shell (de prompt beïnvloeden, de map wijzigen, omgevingsvariabelen instellen) - ook niet helemaal voor beginners;
  • eenmalige scripts zoals het transcoderen van bulkbestanden;
  • makefiles.

Absoluut eerste stappen

Aan de slag: inloggen en uitloggen

Zorg ervoor dat u precies weet hoe u de shell moet starten en hoe u deze moet verlaten.

Als u zich op een computer bevindt waarop Ubuntu is geïnstalleerd, moet u het Terminal-programma starten. Aan het einde van het werk kunt u eenvoudig het raam sluiten.

Start op MacOS ook Terminal.

Om toegang te krijgen tot een externe server, gebruikt u ssh (als u MacOS, Ubuntu of een ander Unix-achtig systeem lokaal hebt) of putty (als u Windows hebt).

Wie ben ik, waar ben ik?

Voer de volgende opdrachten uit:

• hostnaam - geeft de naam weer van de machine (server) waarop u zich momenteel bevindt;
• whoami - toont uw login (uw naam in het systeem);
• tree -d / |less - pseudografische afbeelding van de mappenboom op de machine; stoppen met scrollen - q ;
• pwd - geeft de map weer waarin u zich momenteel bevindt; op de opdrachtregel kun je niet "zomaar" zijn, je bevindt je noodzakelijkerwijs in een map (=huidige map, werkmap). Waarschijnlijk wordt de huidige werkmap weergegeven in uw prompt (prompt).
• ls - lijst met bestanden in de huidige map; ls /home - lijst met bestanden in de opgegeven map;

Opdrachtgeschiedenis (geschiedenis)

Een belangrijke eigenschap van een volwaardige opdrachtregel is de geschiedenis van opdrachten.

Voer een paar opdrachten uit: hostnaam, ls, pwd, whoami. Druk nu op de omhoog-toets. Het vorige commando verscheen in de invoerregel. De toetsen omhoog en omlaag kunnen worden gebruikt om vooruit en achteruit door de geschiedenis te bladeren. Wanneer u naar hostnaam scrolt, drukt u op Enter - de opdracht wordt opnieuw uitgevoerd.

Commando's uit de historie kunnen niet alleen opnieuw worden uitgevoerd, maar ook worden bewerkt. Blader door de geschiedenis naar het ls-commando, voeg de -l-toets eraan toe (het bleek ls -l , er is een spatie voor de min, maar niet erna). Druk op Enter - de gewijzigde opdracht wordt uitgevoerd.

Door de geschiedenis bladeren, opdrachten bewerken en opnieuw uitvoeren zijn de meest typische acties bij het werken in de opdrachtregel, wen er maar aan.

kopiëren plakken

De opdrachtregel is erg tekstgericht: opdrachten zijn tekst, de invoergegevens voor de meeste standaardprogramma's zijn tekst, het resultaat van het werk is meestal ook tekst.

Het leuke van tekst is dat het kan worden gekopieerd en geplakt, en dit geldt ook voor de opdrachtregel.

Probeer datum +"%y-%m-%d, %A" uit te voeren
Heb je het helemaal met de hand ingevoerd of overgenomen uit het artikel? Zorg ervoor dat je het kunt kopiëren, in de terminal kunt plakken en uitvoeren.

Nadat u hebt geleerd hoe u man " moet gebruiken, moet u ervoor zorgen dat u de voorbeeldopdrachten uit de help kunt kopiëren en uitvoeren. Om dit te controleren, kijkt u in de help voor het datumprogramma voor de sectie VOORBEELDEN, kopieert en voert u het eerste gegeven voorbeeld uit (alleen in geval: het dollarteken maakt geen deel uit van de opdracht, dit is een voorwaardelijke afbeelding van de invoerprompt).

Hoe u precies tekst van de terminal kopieert en in de terminal plakt, hangt af van uw systeem en de instellingen ervan, dus geef universele instructie helaas gaat het niet lukken. Probeer dit op Ubuntu: kopiëren is slechts muisselectie, plakken is middelste muisknop. Als het niet werkt, of als je een ander systeem hebt, kijk dan op internet of vraag meer ervaren vrienden.

Toetsen en opties

Tijdens het onderzoeken van de commandogeschiedenis ben je al tegengekomen dat het ls-commando ten minste twee opties heeft. Als je het zo noemt, drukt het een eenvoudige lijst af:

[e-mail beveiligd]: ~/shell-survival-quide> ls Makefile shell-first-steps.md shell-first-steps.pdf shell-survival-quide.md shell-survival-quide.pdf
Als u de schakeloptie -l toevoegt, wordt voor elk bestand gedetailleerde informatie weergegeven:

[e-mail beveiligd]: ~/shell-survival-quide> ls -l totaal 332 -rw-rw-r-- 1 akira akira 198 feb 13 11:48 Makefile -rw-rw-r-- 1 akira akira 15107 feb 14 22:26 shell -first-steps.md -rw-rw-r-- 1 akira akira 146226 13 februari 11:49 shell-first-steps.pdf -rw-rw-r-- 1 akira akira 16626 13 februari 11:45 shell-survival -quide.md -rw-rw-r-- 1 akira akira 146203 13 februari 11:35 shell-survival-quide.pdf
Dit is een zeer typische situatie: als speciale modifiers (schakelaars, opties, parameters) worden toegevoegd aan de opdrachtoproep, verandert het gedrag van de opdracht. Vergelijk: tree / en tree -d / , hostname en hostname -f .

Bovendien kunnen opdrachten bestandsnamen, mappen of alleen tekenreeksen als parameters aannemen. Poging:

ls -ld /home ls -l /home grep root /etc/passwd

Mens

man - Help over de opdrachten en programma's die beschikbaar zijn op uw machine, evenals systeemoproepen en de C-standaardbibliotheek.

Probeer: man grep, man atoi, man chdir, man man.

Vooruit en achteruit scrollen doe je met de “up”, “down”, “PageUp”, “PageDown” knoppen, het verlaten van de helpweergave doe je met de q knop. Zoeken naar specifieke tekst in een helpartikel: druk op / (schuine streep naar voren), typ de zoektekst en druk op Enter. Ga naar volgende voorkomens - n-toets.

Alle helpartikelen zijn onderverdeeld in categorieën. Het belangrijkste:

• 1 - uitvoerbare programma's en shell-commando's (wc , ls , pwd, etc.);
• 2 - systeem oproepen(vork, dup2 enz.)
• 3 - bibliotheekfuncties (printf, scanf, cos, exec).

Het is noodzakelijk om aan te geven uit welke categorie de hulp moet worden getoond in geval van samenvallen van namen. Man 3 printf beschrijft bijvoorbeeld de functie from standaard bibliotheek C, en man 1 printf is het gelijknamige consoleprogramma.

U kunt een lijst bekijken van alle helpartikelen die beschikbaar zijn op de machine met de opdracht man -k. (de stip maakt ook deel uit van het team).

minder

Wanneer binnen klein raam de terminal moet heel goed worden bekeken lange tekst(de inhoud van een bestand, een lange man, enz.), gebruik speciale "pager" -programma's (van het woord pagina / pagina, dat wil zeggen paging). De meest populaire scroller is less , en dat zorgt ervoor dat je kunt scrollen als je aan het lezen bent.

Probeer en vergelijk gedrag:

cat /etc/bash.bashrc cat /etc/bash.bashrc |minder

U kunt het bestand onmiddellijk naar de scroller overbrengen in de parameters:

Minder /etc/bash.bashrc

Blader omhoog en omlaag - knoppen "omhoog", "omlaag", "PageUp", "PageDown", exit - knop q. Zoeken naar specifieke tekst: druk op / (schuine streep naar voren), voer de zoektekst in en druk op Enter. Ga naar volgende voorkomens - n-toets. (Herken je de instructie over de mens? Geen wonder, er wordt ook minder gebruikt om hulp te tonen.)

De rechten

Aan elk bestand of elke map is een set "rechten" gekoppeld: het recht om het bestand te lezen, het recht om naar het bestand te schrijven, het recht om het bestand uit te voeren. Alle gebruikers zijn onderverdeeld in drie categorieën: bestandseigenaar, groep bestandseigenaar, alle andere gebruikers.

U kunt bestandsrechten bekijken met ls -l . Bijvoorbeeld:

> ls -l Makefile -rw-r--r-- 1 akira studenten 198 feb 13 11:48 Makefile
Deze uitvoer betekent dat de eigenaar (akira) het bestand kan lezen en schrijven, de groep (studenten) kan alleen lezen en alle anderen in de gebruiker kunnen ook alleen lezen.

Als u tijdens het werken een bericht krijgt dat toestemming is geweigerd, betekent dit dat u niet genoeg machtigingen heeft voor het object waarmee u wilde werken.

Lees meer in man chmod.

STDIN, STDOUT, pijpleidingen (pijpen)

Aan elk uitvoerend programma zijn er 3 gekoppeld standaard schroefdraad gegevens: invoergegevensstroom STDIN, uitvoergegevensstroom STDOUT, fout uitvoerstroom STDERR.

Voer het wc-programma uit, typ Goede dag vandaag, druk op Enter, typ goede dag, druk op Enter, druk op Ctrl+d. Het wc-programma toont statistieken over het aantal letters, woorden en regels in uw tekst en sluit af:

> wc goede dag vandaag goede dag 2 5 24
BIJ deze zaak je gaf een tekst van twee regels aan STDIN van het programma en ontving drie nummers in STDOUT.

Voer nu het commando head -n3 /etc/passwd uit, het zou er ongeveer zo uit moeten zien:

> head -n3 /etc/passwd root:x:0:0:root:/root:/bin/bash daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin bin:x: 2:2:bin:/bin:/usr/sbin/nologin
In dit geval las het hoofdprogramma niets van STDIN, maar schreef het drie regels naar STDOUT.

Zie het zo: een programma is een pijp waar STDIN in stroomt en STDOUT uit.

Het belangrijkste eigendom Unix-opdrachtregel bestaat uit het feit dat "pipe" -programma's onderling kunnen worden verbonden: de uitvoer (STDOUT) van het ene programma kan als invoergegevens (STDIN) worden overgedragen naar een ander programma.

Zo'n constructie van verbonden programma's wordt in het Engels pipe (pipe) genoemd, in het Russisch - transportband of pipe.

Het combineren van programma's tot een pijplijn gebeurt met het symbool | (verticale balk)

Voer het commando head -n3 /etc/passwd |wc uit, je krijgt zoiets als dit:

> head -n3 /etc/passwd |wc 3 3 117
Dit is wat er gebeurde: het hoofdprogramma voerde drie regels tekst uit naar STDOUT, die onmiddellijk in de invoer van het wc-programma terechtkwamen, dat op zijn beurt het aantal tekens, woorden en regels in de ontvangen tekst telde.

U kunt zoveel programma's combineren als u wilt in een pijplijn. U kunt bijvoorbeeld een ander wc-programma toevoegen aan de vorige pijplijn, die zal tellen hoeveel woorden en letters er in de uitvoer van de eerste wc zaten:

> head -n3 /etc/passwd |wc |wc 1 3 24

Het compileren van pijplijnen (pipes) is heel gebruikelijk bij het werken op de opdrachtregel. Voor een voorbeeld van hoe dit in de praktijk wordt gedaan, zie de sectie Een éénlijnige pijplijn samenstellen.

I/O-omleiding

De uitvoer (STDOUT) van een programma kan niet alleen naar een ander programma worden doorgesluisd, maar kan eenvoudig naar een bestand worden geschreven. Deze omleiding gebeurt met > (groter dan teken):

Datum > /tmp/vandaag.txt
Als resultaat van het uitvoeren van deze opdracht zal het bestand /tmp/today.txt op de schijf verschijnen. Bekijk de inhoud met cat /tmp/today.txt

Als er al een bestand met dezelfde naam bestond, wordt de oude inhoud vernietigd. Als het bestand nog niet bestond, wordt het aangemaakt. De map waarin het bestand wordt gemaakt, moet bestaan ​​voordat de opdracht wordt uitgevoerd.

Als u het bestand niet wilt overschrijven, maar uitvoer aan het einde ervan wilt toevoegen, gebruikt u >> :

Datum >> /tmp/vandaag.txt
Controleer wat er nu in het bestand staat.

Bovendien kunt u elk bestand in plaats van STDIN doorgeven aan het programma. Poging:

wc

Wat te doen als iets niet duidelijk is

Als je systeemgedrag tegenkomt dat je niet begrijpt, of een bepaald resultaat wilt bereiken, maar niet weet hoe, raad ik je aan om in de volgende volgorde te werk te gaan (dit geldt trouwens niet alleen voor shells):

• formuleer de vraag of taak zo duidelijk mogelijk - er is niets moeilijker dan het oplossen van "Ik weet niet wat";
• onthoud of u hetzelfde of een soortgelijk probleem al bent tegengekomen - in dit geval is het de moeite waard om de oplossing te proberen die de vorige keer werkte;
• lees de juiste man-s (als u begrijpt welke man-s in uw geval geschikt zijn) - u kunt geschikte voorbeelden vinden van het gebruik van commando's, noodzakelijke opties of links naar andere commando's;
• denk er eens over na: is het mogelijk om de taak een beetje te veranderen? - misschien krijg je door de voorwaarden iets te veranderen een probleem waarvan je al weet hoe je het moet oplossen;
• stel uw goed gedefinieerde vraag in een zoekmachine - misschien is het antwoord te vinden op Stack Overflow of andere sites;

Als niets van het bovenstaande heeft geholpen, vraag dan advies aan een leraar, een ervaren collega of vriend. En wees niet bang om "domme" vragen te stellen - het is geen schande om het niet te weten, het is een schande om het niet te vragen.

Als je een moeilijk probleem hebt opgelost (in je eentje, via internet of andere mensen), schrijf dan je oplossing op voor het geval jij of je kameraden weer hetzelfde probleem hebben. U kunt opnemen in een eenvoudig tekstbestand, in Evernote, publiceren op sociale netwerken.

Werkwijzen

Knippen en plakken- van man-s, van artikelen op StackOverflow, enz. De opdrachtregel bestaat uit tekst, gebruik dit: kopieer en gebruik opdrachtvoorbeelden, schrijf succesvolle vondsten op voor geheugen, publiceer ze op Twitter en blogs.

Haal de vorige opdracht uit de geschiedenis, voeg nog een opdracht toe aan de pijplijn, voer uit, herhaal.Cm. Zie ook het gedeelte "Een pijpleiding met één regel samenstellen".

Basiscommando's

• map wijzigen: cd ;
• de inhoud van bestanden bekijken: kat, minder, kop, staart;
• bestandsmanipulatie: cp , mv , rm ;
• directorylijst: ls , ls -l , ls -lS ;
• directorystructuur: tree , tree -d (u kunt een directory doorgeven als parameter);
• bestand zoeken: vind . -naam ... ;

Analyse

• wc , wc -l ;
• sorteer -k - sorteer op het opgegeven veld;
• sorteer -n - numeriek sorteren;
• diff - vergelijk bestanden;
• grep , grep -v , grep -w , grep "\ ", grep -E - zoek naar tekst;
• uniq , uniq -c - unieke strings;
• awk - in de awk "(print $1)" variant, om alleen het eerste veld van elke regel over te laten, kan $1 veranderd worden in $2 , $3 , etc.;

Systeem diagnostiek

• ps axuww - informatie over processen (lopende programma's) die op de machine draaien;
• top - interactieve weergave van de meest resource-intensieve processen;
• df - gebruikte en vrije schijfruimte;
• du - totale grootte van bestanden in de map (recursief met submappen);
• strace , ktrace - welke systeemaanroepen het proces aan het maken is;
• lsof - welke bestanden het proces gebruikt;
• netstat -na , netstat -nap - welke poorten en sockets zijn open op het systeem.

Mogelijk hebt u sommige programma's niet, deze moeten extra worden geïnstalleerd. Bovendien zijn sommige opties van deze programma's alleen beschikbaar voor bevoorrechte gebruikers (root "y").

Bulk- en semi-automatische uitvoering

Sla deze sectie in eerste instantie over, je hebt deze commando's en constructies nodig als je aan eenvoudige shell-scripting begint.

• test - voorwaarden controleren;
• while read-cycle through lines STDIN;
• xargs - vervanging van strings van STDIN in de parameters van het gespecificeerde programma;
• seq - generatie van reeksen natuurlijke getallen;
• () - combineer de output van verschillende commando's;
• ; - doe de een na de ander;
• && - uitvoeren als de eerste opdracht succesvol is voltooid;
• || - uitvoeren als het eerste commando mislukt;
• tee - dupliceer programma-uitvoer naar STDOUT en naar een bestand op schijf.

Diversen

• datum - huidige datum;
• curl - downloadt het document op de gespecificeerde url en schrijft het resultaat naar STDOUT;
• touch - wijzigingsdatum bestand bijwerken;
• doden - stuur een signaal naar het proces;
• waar - doet niets, retourneert waar, handig voor het organiseren van eeuwige lussen;
• sudo - voer een commando uit als root "a.

Samenstellen van een one-liner pijplijn

Laten we eens kijken naar een voorbeeld van een echte taak: we willen alle taak-6-serverprocessen beëindigen die namens de huidige gebruiker worden uitgevoerd.

Stap 1.
Begrijp welk programma ongeveer de benodigde gegevens produceert, ook al is het niet in pure vorm. Voor onze taak is het de moeite waard om een ​​lijst te krijgen van alle processen in het systeem: ps axuww. Rennen.

Stap 2
Kijk met je ogen naar de ontvangen gegevens, bedenk een filter dat een deel van de onnodige gegevens weggooit. Vaak is dit grep of grep -v . Gebruik de "Omhoog" -toets om het vorige commando uit de geschiedenis te halen, er een verzonnen filter aan toe te wijzen en het uit te voeren.

Ps axuww |grep `whoami`
- alleen processen van de huidige gebruiker.

Stap 3
Herhaal stap 2 totdat u de gewenste schone gegevens krijgt.

"
- alle processen met de gewenste naam (plus misschien overbodige zoals vim task-6-server.c, etc.),

Ps axuww |grep `whoami` | grep "\ " | grep -v vim ps axuww |grep `whoami` | grep "\ " | grep -v vim | grep -v minder
- alleen processen met de gewenste naam

Ps axuww |grep `whoami` | grep "\ " | grep -v vim |grep -v less |awk "(print $2)"

Pids van de vereiste processen, stap 3 voltooid

Stap 4
Pas een geschikte laatste handler toe. Met behulp van de "Omhoog" -toets halen we de vorige opdracht uit de geschiedenis en voegen we verwerking toe die de oplossing van het probleem zal voltooien:

• |wc -l om het aantal processen te tellen;
• >pids om pids naar een bestand te schrijven;
• |xargs kill -9 kill-processen.

Taken voor opleiding

Wil je nieuwe vaardigheden oefenen? Probeer de volgende taken:

• krijg een lijst van alle bestanden en mappen in je thuismap;
• krijg een lijst van alle man-artikelen uit categorie 2 (systeemoproepen);
• tel hoe vaak het woord grep voorkomt in de grep man-pagina;
• tellen voor hoeveel processen er momenteel worden uitgevoerd root-gebruiker ;
• vinden welk commando voorkomt in het maximale aantal hulpcategorieën (man);
• tel hoe vaak het woord var voorkomt op de ya.ru-pagina.

Hint: je hebt find , grep -o , awk "(print $1)" , reguliere expressies in grep , curl -s nodig.

Wat ga je hierna studeren?

Als je de opdrachtregel leuk begint te vinden, stop dan niet, blijf je vaardigheden verbeteren.

Hier zijn enkele programma's die zeker van pas zullen komen als u op de opdrachtregel woont:

• vinden met complexe opties
• ter zake
• bevind zich
• telnet
• netkat
• tcpdump
• rsync
• scherm
• zgrep, zless
• zien
• crontab -e
• Verzend mail

Het is ook de moeite waard om na verloop van tijd een scripttaal te leren, zoals perl of python, of zelfs beide.

Wie heeft het nodig?

Is het de moeite waard om vandaag de opdrachtregel en shell-scripting te leren? Zeker de moeite waard. Ik zal slechts enkele voorbeelden geven van de eisen die Facebook stelt aan kandidaten die bij FB willen werken.

Deze sectie biedt documentatie om de programmeur te helpen in shell-talen (sh, bash, ksh en andere)

c-shell commando-interpreter

0. Inleiding

De commando-interpreter in de UNIX-omgeving vervult twee hoofdfuncties:

vertegenwoordigt een interactieve interface met de gebruiker, d.w.z. stuurt een uitnodiging uit en verwerkt de door de gebruiker ingevoerde opdrachten;
verwerkt en voert tekstbestanden uit die tolkopdrachten bevatten (batchbestanden);

In het laatste geval staat het besturingssysteem toe dat batchbestanden worden behandeld als een soort uitvoerbaar bestand. Dienovereenkomstig worden twee werkingsmodi van de tolk onderscheiden: interactief en commando.

In een UNIX-omgeving (in tegenstelling tot bijvoorbeeld DOS) zijn er verschillende shells beschikbaar. We zetten de meest populaire op een rij:

/bin/sh - Bourne-shell. Historisch gezien is dit de eerste opdrachtshell die is ontwikkeld voor de eerste versie van het UNIX-besturingssysteem. Deze shell is momenteel de hoofdshell in UNIX System V-versies.
/bin/csh - C-schil. Een shell waarvan de syntaxis van de commandotaal dicht bij de taal C ligt.Het is de hoofdshell voor de Berkeley-variëteit van het UNIX-besturingssysteem.
/bin/ksh - k-schil.
/bin/rsh - Beperkte shell. Het is sh met beperkte mogelijkheden (voornamelijk om het besturingssysteem te beschermen tegen ongeoorloofde gebruikersacties).

Het ConvexOS-besturingssysteem is een 4.3 BSD UNIX()BSD - Berkeley Series Distribution-variant en daarom is de basisshell csh.

1. Belangrijkste kenmerken

Werken met de opdrachtregel

De interpreter ziet de door de gebruiker getypte string als een commando (of meerdere commando's). Met de shell-syntaxis kunt u typen

meerdere commando's op één regel gescheiden door puntkomma's. Bijvoorbeeld

is gelijk aan twee opeenvolgende commando's:

Integendeel, indien gewenst kan de gebruiker dat wel

ga door met het typen van lange opdracht aan volgende regel, waarbij de huidige regel wordt afgesloten met \\. U ontvangt een ``secundaire prompt''> in plaats van de hoofdprompt (%) totdat de opdracht is voltooid. Bijvoorbeeld,

% tar tv Makefile star.o star.c star.dat main.o main.c

gelijk aan

% tar tv Makefile star.o \

> ster.c ster.dat \

I / O-streams worden op een vergelijkbare manier beheerd als DOS (meer precies, DOS heeft de stream-omleidingssyntaxis van UNIX overgenomen) met behulp van de symbolen > , > > ,

Een handig speciaal geval van het gebruik van het stream-omleidingsmechanisme is omleiden naar /dev/null, waarmee u onnodige berichten op het scherm kunt verwijderen. Met hetzelfde mechanisme kunt u lege bestanden maken:

maakt een leeg bestand myfile aan in de huidige directory.

Bovendien kunt u met C-shell opdrachten groeperen met behulp van haakjes. In dit geval wordt de hele structuur binnen de haakjes door de tolk behandeld als één opdracht. Dit is bijvoorbeeld handig in dergelijke constructies:

%(opdracht1|opdracht2)

Als u de haakjes weglaat, zal de shell niet kunnen bepalen welke commando's u wilt invoeren in het bestand myfile.

De volgende ``gemak'' bestaan ​​in deze C-shell-implementatie:

U kunt een lange opdracht niet tot het einde typen, maar probeer na een gedeeltelijke opdracht (of bestandsnaam) op de tab-toets te drukken. C-shell zal proberen de ontbrekende karakters zelf aan te vullen, of zal antwoorden met een piep als de keuze dubbelzinnig is.
Als je een commando hebt getypt maar de opties bent vergeten, typ dan de reeks H. C-shell geeft je een korte hulp. Bijvoorbeeld,

Typen voor-en achternaam bestand, gebruikt u de toetsencombinatie ^D. U kunt een lijst krijgen van de map die wordt getypt in de indeling van de opdracht lf.
De opdrachtbuffer onthoudt de laatste 20 opdrachten. In plaats van een commando te typen, kun je het vanuit de buffer aanroepen met behulp van het pijltjestoetsenbord (uiteraard alleen als dit commando in de buffer staat).

Commandoregel parseren

De tolk, die de opdrachtregel heeft ontvangen, voert er een aantal transformaties op uit, namelijk:

Vouwt aliassen uit (alias)
Breidt metatekens uit (*, ?, [, ], ~, (, ))
Vervangt shell-variabelen
Voert de opdracht uit als het een ingebouwde opdracht van de tolk is, of start het proces als de opdracht extern is.

Laten we deze stappen stap voor stap opsplitsen.

Aliassen (alias). Met de ingebouwde aliasopdracht kunt u opdrachtaliassen definiëren. Voorbeeld:

% alias mycat "kat | meer"

definieert mycat als een alias voor de string cat | meer. Daarom kunt u dan het mycat-commando gebruiken, dat door de interpreter wordt uitgebreid, waar u het ook gebruikt. Dit is een manier om korte namen te definiëren voor lange samengestelde commando's.

Het ingebouwde commando unalias mycat verwijdert de eerder ingevoerde mycat-alias.

Metatekens. Met metatekens kunt u beknopt hele woordenlijsten schrijven (voornamelijk bestandsnamen). Shell behandelt een woord dat metatekens bevat als een sjabloon voor het weergeven van bestandsnamen:

* in een patroon vervangt elke reeks tekens. Bijvoorbeeld m* zal uitbreiden naar een lijst van alle bestanden die beginnen met de letter m. Er is een kleine uitzondering op deze regel: gewoon * laat de bestanden in de lijst weg waarvan de naam met een punt begint.
? vervangt één teken. Bijvoorbeeld m? breidt zich uit tot een lijst met alle bestandsnamen die beginnen met de letter m en die uit precies twee letters bestaan.
Met [.-.] kunt u de spatiëring voor het vervangende teken specificeren. Bijvoorbeeld m zou worden uitgebreid tot ma mb mc me.
(...,...) stelt u in staat om woorden op te sommen ter vervanging. Dus bijvoorbeeld m(rood, blauw, groen) wordt uitgebreid naar mred mblue mgreen.

Ten slotte kunt u met de tilde de thuismap van de gebruiker specificeren:

~name/ is gelijk aan het specificeren van het volledige pad naar de homedirectory van de gebruikersnaam (Zeg /usr1/name/)
~/ is gelijk aan het geven van het volledige pad naar je eigen homedirectory.

shell-variabelen. Woorden die beginnen met het $-symbool worden door de shell geïnterpreteerd als variabelenamen. Variabelen zijn onderverdeeld in omgevingsvariabelen (ze zullen bekend zijn bij alle programma's die vanuit deze shell worden aangeroepen en zijn in deze zin globaal) en eenvoudige variabelen.

Met de ingebouwde opdracht set name=value kunt u een eenvoudige variabele met de naam name definiëren en deze de waarde value geven. Nadat de uitdrukking $name op de opdrachtregel is tegengekomen, zal de tolk deze vervangen door waarde. Bijvoorbeeld,

% ingestelde kleur=blauw

zal de tekenreeks blauw naar de terminal afdrukken. EN

% ingestelde kleur=blauw

% echo nieuwe$kleur

zal newblue geven. Eindelijk door binnen te komen

% ingestelde kleur=blauw

% echo $(kleur)nieuw

we krijgen kleurnieuw. Het laatste voorbeeld laat zien hoe je accolades gebruikt om een ​​variabelenaam uit een woord te extraheren (de interpreter zou op echo $colornew antwoorden dat de variabele colornew niet is gedefinieerd.

De opdracht unset vernietigt eerder gedefinieerde variabelen.

Om een ​​variabele als een string van meerdere woorden te definiëren, plaatst u deze tussen enkele aanhalingstekens. Voorbeeld

% set color="blauw of rood of groen"

Eenvoudige variabelen kunnen arrays van woorden zijn (die moeten worden onderscheiden van het zojuist beschouwde geval, wanneer de variabele een reeks van meerdere woorden bevat. Haakjes moeten worden gebruikt om een ​​array te declareren:

% ingestelde kleuren=(blauw rood groen)

Nu zal het commando echo $colors een reeks van drie kleuren produceren (probeer het!). U kunt echter ook werken aan individuele array-elementen (elementen worden genummerd vanaf nul), zoals:

(krijg groen). Het aantal elementen in de array is opgenomen in de variabele $#colors.

zal de terminal het nummer 3 geven.

Vrij complexe combinaties zijn mogelijk met behulp van patronen, bijvoorbeeld:

% ingestelde bestanden=(m*)

geeft het aantal bestanden in de huidige map terug, beginnend met de letter m.

Omgevingsvariabelen worden op precies dezelfde manier aangeroepen als eenvoudige variabelen. Het verschil zit in de manier waarop ze zijn gedefinieerd:

De opdracht % setenv name value stelt een omgevingsvariabele in met de naam name. Let op het vervelende verschil in syntaxis: u hoeft het =-teken niet te gebruiken bij het definiëren van een omgevingsvariabele.

Lijst van allemaal omgevingsvariabelen kan worden verkregen met behulp van de ingebouwde opdracht printenv.

U kunt een omgevingsvariabele ongedaan maken met unsetenv.

Ten slotte worden haakjes NIET gebruikt om een ​​array van omgevingsvariabelen te definiëren, maar dubbele punten worden gebruikt als arrayscheidingstekens:

% setenv MANPATH /usr/man/:/usr/local/man:/usr/man/X11:~/man

Ingebouwde opdrachten en variabelen

Lijst met de belangrijkste ingebouwde C-shell-commando's met korte uitleg:

alias definieert een alias

bg zet de taak in de uitvoeringsmodus op de achtergrond

chdir path-opdracht om te wijzigen in directorypad.

echo drukt al zijn argumenten af ​​naar standaarduitvoer

exec bestandsnaam voert het proces uit vanaf bestandsnaam in plaats van (d.w.z. bovenop) de huidige shell. Terug naar de shell is niet mogelijk.

exit verlaat de shell.

fg maakt een achtergrondproces synchroon.

bestand bestandsnaam geeft informatie over wat het besturingssysteem van dit bestand vindt.

ga naar label springt onvoorwaardelijk naar de regel in het batchbestand die is gelabeld met het label. Niet gebruikt in interactieve modus.

kill pid stuurt een abort-signaal naar de proces-pid, wat meestal resulteert in het beëindigen van het proces.

bron bestandsnaam leest en voert opdrachten uit bestand bestandsnaam uit.

set, setenv set interne en omgevingsvariabelen.

shift var verschuift de elementen van array var naar links. In dit geval wordt de grootte van de array met één verkleind en gaat het nul-element van de array verloren. De variabele var moet een array zijn.

time command voert het commando uit en geeft de tijd weer die nodig was om het uit te voeren op de terminal.

unset vernietigt de shell-variabele.

unalias verwijdert een eerder gedefinieerde opdrachtalias.

@name=expr zet het resultaat van de rekenkundige uitdrukking expr in de naamvariabele.

Lijst met de belangrijkste ingebouwde C-shell-variabelen met korte uitleg:

argv-array met opdrachtregelopties (gebruikt in opdrachtmodus)

cdpath is de directory waar de shell naartoe verandert wanneer het chdir-commando zonder argument wordt gegeven.

geschiedenisbuffergrootte voor het onthouden van opdrachten.

thuismap van de gebruiker

mail is de locatie op het bestandssysteem van de mailbox van de gebruiker.

pad zoekpad voor externe opdrachten.

prompt is de belangrijkste shell-prompt.

prompt1 secundaire prompt.

shell volledig pad van het huidige shell-uitvoerbare bestand (/bin/csh)

Controleverklaringen en lusverklaringen

Van de lijst met ingebouwde shell-commando's hebben we opzettelijk conditionele en lus-statements uitgesloten, die hier zullen worden besproken.

Voorwaardelijke uitvoering

De syntaxis van een voorwaardelijk if-statement in C-shell is als volgt

als (expr) commando

expr kan een rekenkundige uitdrukking zijn of een controle van bestandskenmerken. Voorbeeld:

if (-f /etc/hosts) kat /etc/hosts

Laten we het laatste geval in meer detail bekijken. De volgende controles van bestandskenmerken zijn mogelijk:

R is leesbaar

W is beschrijfbaar

X beschikbaar voor uitvoering

E controleer het bestaan ​​van het bestand

Controleer of u de eigenaar bent van dit bestand

Z-bestand heeft een grootte van nul

F-bestand is een normaal bestand

P-bestand is een benoemde programmapijp

D-bestand is een map

herhalingslus

De lus wordt uitgevoerd zolang de voorwaarde waar is. Voorbeeld:

terwijl ($#bestanden > 0)

voor elke lus

Dit is een uiterst handige operator waarmee u door de elementen van een reeks woorden kunt bladeren.

voor elke varname(lijst)

De hoofdtekst van de lus wordt net zo vaak uitgevoerd als er elementen in de lijstarray zijn. In dit geval bevat de variabele varname de volgende waarde van het array-element. Voorbeeld

voor elke kleur (blauw rood groen)

echo De kleur is $kleur

voor elk bestand (*.for)

echo Hernoemen van $file

mv $file `basisnaam $file .for`.f

Dit maakt gebruik van het standaard basisnaamcommando, dat het achtervoegsel in het tweede argument van het woord in het eerste argument afsnijdt en het resulterende woord afdrukt naar de standaarduitvoer. Het gebruik van backticks in de C-shell-taal zal later worden besproken.

Multivariate voorwaardelijke operator

De syntaxis van de voorwaardelijke instructie switch in C-shell is als volgt

case patroon1: ... breektw case (\it patroon2) :

De operator staat overdracht van besturing toe, afhankelijk van of de tekenreeksreeks voldoet aan een patroon van het ingestelde patroon1, patroon2, ... (in dit geval wordt de besturing overgebracht naar een blok gescheiden door hoofdletters ... breaksw) of niet (in dit geval , wordt de besturing overgebracht naar de branch default:... endsw Over het algemeen lijkt de switch-opdracht sterk op de analoge operator van de C-taal.

2. Shell-operatie in commandomodus

Er is al opgemerkt dat csh in opdrachtmodus kan worden uitgevoerd. Bovendien worden conditionele en loop-statements vaker gebruikt in batchbestanden. Hier zullen we de kenmerken van zulk ``teamwerk'' bekijken.

Identificatie van de tolk

De gemakkelijkste manier om de shell te starten in de uitvoeringsmodus van een bestand mycommand is om dit bestand het uitvoerbare attribuut te geven met het chmod-commando:

% chmod +x mijncommando

Nu is het voldoende om de opdracht mycommand vanaf het toetsenbord in te voeren en het besturingssysteem start automatisch de shell in de opdrachtmodus om dit bestand uit te voeren. Er is één valkuil op dit pad: er zijn veel commando-interpreters in het systeem en hun commando-syntaxis is anders. Hoe bepaalt het besturingssysteem wat je nodig hebt? Het antwoord is nee. U moet het besturingssysteem expliciet vertellen welke tolk u wilt uitvoeren om dit batchbestand uit te voeren. Om dit te doen, moet de eerste regel van uw bestand de volgende standaardvorm hebben:

waardoor het besturingssysteem het juiste kan doen. Als u deze informatie niet verstrekt, gaat het besturingssysteem (om historische redenen) ervan uit dat het bestand is geschreven in de Bourne-shelltaal en krijgt u waarschijnlijk veel syntaxisfoutmeldingen.

Let op een andere handige eigenschap van de shell in commandomodus: alle regels die beginnen met het #-teken worden genegeerd. Hiermee kunt u opmerkingen toevoegen aan de tekst van het batchbestand.

Door het volgende feit kunt u met de opdrachtregel werken met csh: wanneer u het batchbestand mycommand uitvoert, wordt automatisch een interne variabele met de naam argv gedefinieerd, die een reeks opdrachtregelopties vertegenwoordigt. Het volgende batchbestand drukt bijvoorbeeld eenvoudig alle argumenten en hun nummer af naar de terminal:

# Dit bestand voert gewoon zijn argumenten uit

# en het totale aantal argumenten

echo Argumenten: $argv

echo Aantal argumenten: $#argv

Expliciet begin

U kunt een directere maar minder handige manier gebruiken om een ​​batchbestand uit te voeren door de shell aan te roepen met de optie -c bestandsnaam. Voorbeeld:

% /bin/csh -c mijncommando arg1 arg2 arg3...

waarbij de sleutel onmiddellijk moet worden gevolgd door de naam van het bestand dat wordt uitgevoerd. Vereiste argumenten worden daarna opgegeven. Merk op dat met deze methode van starten het bestand mogelijk niet het uitvoerbare kenmerk heeft.

Citaten

Aanhalingstekens spelen een belangrijke rol in de syntaxis van de shell. Er zijn drie soorten aanhalingstekens: enkele ("), dubbele (") en backticks (`).

Enkele aanhalingstekens worden gebruikt om tekst te markeren die de shell letterlijk zou moeten nemen. Met andere woorden, de tekst tussen eenvoudige aanhalingstekens is niet onderhevig aan openbaarmaking en interpretatie. Voorbeeld:

echo "Dollar is $goed"

we krijgen letterlijk Dollar is $good, ook al is het dollarteken een shell-metateken.

Dubbele aanhalingstekens ontsnappen aan een reeks tekens die de shell als één woord zal behandelen. Voorbeeld:

kleuren instellen = "groen blauw rood"; echo $#kleuren

retourneert het getal 1, wat betekent dat de variabele Colors eenvoudig is, geen array. Alles binnen de dubbele aanhalingstekens is onderhevig aan interpretatie door de shell.

Met backticks kunt u een tekenreeks weergeven die bestaat uit het resultaat van een opdracht. Dus de teruggeciteerde uitdrukking wordt behandeld als een commando dat de shell aan het uitvoeren is, en wat dat commando afdrukt naar de standaarduitvoer wordt vervangen als een string op de plaats waar de teruggeciteerde tekens staan. Voorbeeld:

zal de variabele mytty instellen op de tekenreeks die het tty-commando produceert (namelijk de naam en het nummer van de huidige terminal).

De commandotaal shell (in vertaling - shell, shell) is eigenlijk een programmeertaal van een heel hoog niveau. In deze taal bestuurt de gebruiker de computer. Meestal begin je na het inloggen met een shell te communiceren. Een teken dat de shell (shell) klaar is om commando's te ontvangen, is de prompter die door hem naar het scherm wordt gestuurd. In het eenvoudigste geval is dit één dollar ("$"). Shell is geen noodzakelijke en enige commandotaal (hoewel het wel de taal is die gestandaardiseerd is binnen POSIX - de standaard voor mobiele systemen). De cshell-taal is bijvoorbeeld behoorlijk populair, er zijn ook kshell, bashell en andere. Bovendien kan elke gebruiker zijn eigen commandotaal creëren. Het kan tegelijkertijd werken met verschillende commandotalen op één instantie van het besturingssysteem. shell is een van de vele UNIX-commando's. Dat wil zeggen, de "shell"-commandoset bevat het "sh"-commando - waarbij de "shell"-interpreter wordt aangeroepen. De eerste "shell" wordt automatisch aangeroepen wanneer u zich aanmeldt en geeft de prompter weer. Daarna kun je alle commando's aanroepen voor uitvoering, ook weer de "shell" zelf, die een nieuwe shell voor je zal creëren binnen de oude. Dus als u bijvoorbeeld het bestand "file_1" in de editor voorbereidt:

Echo Hallo!

dan wordt het een gewoon tekstbestand met het commando "echo", dat, wanneer het wordt uitgevoerd, alles wat er rechts van staat op het scherm zal weergeven. U kunt het bestand "file_1" uitvoerbaar maken met het commando "chmod 755 file_1". Maar het kan worden gedaan door expliciet de opdracht "sh" ("shell") aan te roepen:

Sh-bestand_1

Sch< file1

Het bestand kan ook worden uitgevoerd in de huidige "shell"-instantie. Hiervoor is er een specifiek commando "." (punt), d.w.z.

Bestand_1

Aangezien UNIX een systeem voor meerdere gebruikers is, kunt u zelfs op een personal computer parallel werken, bijvoorbeeld op 12 schermen (verplaats van scherm naar scherm ALT / functietoets), met een nieuwe (of dezelfde) gebruiker op elk scherm met zijn commandoschaal. Je kunt ook een groot aantal vensters openen in de X-Window grafische modus, en elk venster kan zijn eigen gebruiker hebben met zijn eigen commando-shell... Het kernelement van de shell-taal is het commando.

Commandostructuren:

Shell-commando's hebben meestal het volgende formaat:

<имя команды> <флаги> <аргумент(ы)>

Bijvoorbeeld:

ls -ls /usr/bin

Waar ls de naam is van het commando voor het uitgeven van de inhoud van de map, -ls zijn vlaggen ("-" is een teken van vlaggen, l is een lang formaat, s is de grootte van bestanden in blokken), /usr/bin is de directory waarvoor het commando wordt uitgevoerd. Dit commando zal de inhoud van de /usr/bin directory in een lang formaat weergeven, en tegelijkertijd informatie toevoegen over de grootte van elk bestand in blokken. diversiteit in de presentatie van argumenten .Het aantal commando's met exotische formaten omvat dergelijke "lopende" commando's als cc - bel de C-compiler, tar - werk met archieven, dd - kopieer een bestand met transformatie, vind - zoek naar bestanden en een aantal andere In de regel , wordt het eerste woord van de shell behandeld als een commando, dus op de commandoregel

het eerste woord zal door de shell worden geïnterpreteerd als een (aaneenschakelings)commando, dat een bestand met de naam "cat" (het tweede woord) zal weergeven in de huidige map. Opdrachtomleiding Standaardinvoer (invoer) - "stdin" in UNIX OS wordt uitgevoerd vanaf het terminaltoetsenbord en standaarduitvoer (uitvoer) - "stdout" wordt naar het terminalscherm geleid. Er is ook een standaard diagnostisch berichtbestand - "stderr", dat later zal worden besproken. Het commando dat kan werken op standaard invoer en uitvoer wordt FILTER genoemd. De gebruiker heeft handige middelen om invoer en uitvoer om te leiden naar andere bestanden (apparaten). De symbolen ">" en ">>" duiden uitvoeromleiding aan. ls >file_1 De opdracht "ls" geeft een lijst van de bestanden in de huidige map en plaatst deze in bestand "file_1" (in plaats van deze op het scherm weer te geven). Als het bestand "file_1" al eerder bestond, wordt het overschreven door het nieuwe.

Pwd >>bestand_1

het pwd-commando vormt de volledig gekwalificeerde naam van de huidige map en plaatst deze aan het einde van het bestand "file_1", d.w.z. ">>" wordt toegevoegd aan het bestand als het niet leeg is. Symbolen "<" и "<<" обозначают перенаправление ввода.

Wc-l

zal het aantal regels in het bestand file_1 tellen en weergeven.

Ed-bestand_2<

maakt het bestand "file_2" met behulp van de editor, rechtstreeks vanuit de terminal. Het einde van de invoer wordt bepaald door het teken rechts "<<" (т. е. "!"). То есть ввод будет закончен, когда первым в очередной строке будет "!". Можно сочетать перенаправления. Так

Wc-l bestand_4

Wc -l >bestand_4

worden op dezelfde manier uitgevoerd: het aantal regels van het bestand "file_3" wordt geteld en het resultaat wordt in het bestand "file_4" geplaatst. Een tool die samenbrengt standaard uitvoer een commando met de standaardinvoer van een ander wordt een PIPELINE genoemd en wordt aangeduid met een verticale balk "|".

Ls | wc -l

de lijst met bestanden in de huidige map wordt doorgegeven aan de invoer van het "wc"-commando, dat het aantal regels in de map weergeeft. Een pijplijn kan ook meer dan twee commando's combineren, wanneer ze allemaal, mogelijk behalve de eerste en de laatste, filters zijn:

Kattenbestand_1 | grep -hresult | sorteren | kat -b > bestand_2

Deze pijplijn uit het bestand "file_1" ("cat") selecteert alle regels die het woord "result" ("grep") bevatten, sorteert ("sort") de resulterende regels en nummert ("cat -b") en voer het resultaat uit naar bestand "file_2". Omdat UNIX-apparaten worden vertegenwoordigd door speciale bestanden, kunnen ze worden gebruikt in omleidingen. De speciale bestanden bevinden zich in de map "/dev". Bijvoorbeeld "lp" - afdrukken; "console" - console; "ttyi" - i-de aansluiting; "null" - dummy (leeg) bestand (apparaat). Dan, bijvoorbeeld,

Ls > /dev/lp

drukt de inhoud van de huidige map af, en file_1< /dev/null обнулит файл "file_1".

sorteer bestand_1 | tee /dev/lp | staart -20

In dit geval wordt het bestand "file_1" gesorteerd en afgedrukt en worden de laatste 20 regels ook op het scherm weergegeven. Laten we teruggaan om de omleiding af te sluiten. Standaard bestanden zijn genummerd:

0 - stdin, 1 - stdout 2 - stderr. Als u geen foutmelding op het scherm wilt hebben, kunt u deze omleiden van het scherm naar het bestand dat u hebt opgegeven (of het helemaal "gooien" door het om te leiden naar het "lege apparaat"-bestand - /dev/null). Bijvoorbeeld bij het uitvoeren van de opdracht

Kat bestand_1 bestand_2

die de inhoud van de bestanden "file_1" en "file_2" opeenvolgend op het scherm zou moeten weergeven, geeft u bijvoorbeeld het volgende

111111 222222 cat: f2: niet zo'n bestand of map

waarbij 111111 222222 de inhoud is van bestand "file_1" en bestand "file_2" ontbreekt, zoals gerapporteerd door de opdracht "cat" in het standaard diagnostische bestand, evenals de standaarduitvoer die wordt weergegeven door het scherm. Als u zo'n bericht niet op het scherm wilt, kunt u het omleiden naar het bestand dat u hebt opgegeven:

Cat file_1 file_2 2>f-err

foutmeldingen worden verzonden (zoals aangegeven door de "2>"-omleiding) naar het "f-err"-bestand. Trouwens, je kunt alle informatie naar één "ff" -bestand sturen, in dit geval met behulp van de constructie

Cat bestand_1 bestand_2 >>ff 2>ff

U kunt niet alleen specificeren welke van de standaardbestanden u wilt omleiden, maar ook naar welk standaardbestand u wilt omleiden.

Cat bestand_1 bestand_2 2>>ff 1>&2

Hier wordt eerst "stderr" omgeleid (in append-modus) naar het bestand "ff", en vervolgens wordt de standaarduitvoer omgeleid naar "stderr", wat nu het bestand "ff" is. Dat wil zeggen, het resultaat zal vergelijkbaar zijn met het vorige. Constructie "1>&2" - betekent dat naast het nummer van het standaardbestand waarnaar moet worden omgeleid, het nodig is om "&" ervoor te plaatsen; de hele structuur is geschreven zonder spaties.<- закрывает стандартный ввод. >- sluit standaard uitvoer. opdracht bestanden. Om een ​​tekstbestand als commando te gebruiken zijn er verschillende mogelijkheden. Laat de editor een bestand met de naam "cmd" maken met daarin één regel van de volgende vorm:

datum; pwd; ls

Je kunt de shell aanroepen als een commando, aangeduid met "sh", en er een "cmd"-bestand aan doorgeven, ofwel als een argument of als een omgeleide invoer, d.w.z.

$sh cmd

$ sh

Al deze opdrachten printen de datum, vervolgens de naam van de huidige map en vervolgens de inhoud van de map. Een interessantere en handigere optie om met een batchbestand te werken, is om er een uitvoerbaar bestand van te maken, d.w.z. maak er gewoon een commando van, dat wordt bereikt door de beveiligingscode te wijzigen. Om dit te doen, moet u de uitvoering van dit bestand toestaan. Bijvoorbeeld,

Chmod 711cmd

maakt de beveiligingscode "rwx__x__x". Dan maar een simpel telefoontje

zal ertoe leiden dat dezelfde drie commando's worden uitgevoerd. Het resultaat is hetzelfde als het bestand met de inhoud

datum; pwd; ls

wordt weergegeven als: datum pwd ls omdat een regeleinde ook een scheidingsteken is in een reeks opdrachten. Uitvoerbare bestanden kunnen dus niet alleen bestanden zijn die zijn verkregen als resultaat van compilatie en assemblage, maar ook bestanden die erin zijn geschreven shell-taal. Ze worden uitgevoerd in interpretatiemodus met behulp van een shell-interpreter.

Batchbestanden debuggen

SHELL gebruikt twee mechanismen voor het debuggen van batchbestanden. De eerste: set -v drukt de regels van het batchbestand af terwijl ze worden gelezen. Deze modus wordt gebruikt bij het zoeken naar syntaxisfouten. Om het te gebruiken, hoeft u het batchbestand niet te wijzigen, bijvoorbeeld: sh -v proc... waarbij proc de naam is van het batchbestand. De schakeloptie -v kan worden gebruikt in combinatie met de schakeloptie -n, die de uitvoering van de volgende opdrachten verhindert (de opdracht set -n blokkeert de terminal totdat het EOF-teken wordt ingevoerd). De opdracht set -x drukt de opdrachten af ​​terwijl ze worden uitgevoerd, waarbij de programmaregels naar de terminal worden afgedrukt en hun waarden worden vervangen door de variabelen. Om de schakelaars -x en -v uit te schakelen, kunt u de opdracht set gebruiken - en om in te stellen - de juiste waarde toewijzen aan de macrovariabele. SHELL-OMGEVING (VARIABELEN EN PARAMETERS) U kunt batchbestanden schrijven in de shell-taal en ze uitvoerbaar maken met het "chmod"-commando. Daarna verschillen ze niet van andere UNIX OS-commando's.

Shell-variabelen

De naam van een shell-variabele is een letter-beginreeks van letters, cijfers en onderstrepingstekens. De waarde van een shell-variabele is een tekenreeks. Het feit dat er maar twee datatypes in de shell zitten: een tekenreeks en een tekstbestand, maakt het enerzijds gemakkelijk om eindgebruikers die nog nooit eerder hebben geprogrammeerd gemakkelijk bij het programmeren te betrekken en zorgt anderzijds voor enige intern protest onder veel programmeurs die gewend zijn aan meer variatie en grotere flexibiliteit van taalmiddelen. Het is echter interessant om te zien hoe eersteklas programmeurs, die de "spelregels" van de shell onder de knie hebben, er vele malen sneller programma's in schrijven dan in C, maar wat vooral interessant is, in sommige gevallen werken deze programma's zelfs sneller dan die geïmplementeerd in C. De naam van de variabele is vergelijkbaar met de traditionele notie van een identifier, d.w.z. de naam kan een reeks letters, cijfers en onderstrepingstekens zijn, beginnend met een letter of een onderstrepingsteken. De toewijzingsoperator "=" kan worden gebruikt om waarden aan variabelen toe te wijzen.

Var_1=13 - "13" is geen getal, maar een reeks van twee cijfers. var_2="UNIX OS" - Dubbele aanhalingstekens (" ") zijn hier nodig omdat er een spatie in de tekenreeks staat.

Er zijn andere manieren om waarden toe te wijzen aan shell-variabelen. Dus bijvoorbeeld de ingang

DAT=`datum`

zorgt ervoor dat het "date"-commando eerst wordt uitgevoerd (de aanhalingstekens achter geven aan dat het bijgevoegde commando eerst moet worden uitgevoerd), en het resultaat van de uitvoering wordt, in plaats van naar de standaarduitvoer te worden afgedrukt, toegewezen als de waarde van een variabele, in dit geval "DAT". U kunt ook een waarde toekennen aan een variabele met behulp van het "read"-commando, waarmee de waarde van een variabele kan worden ontvangen van het (toetsenbord)display in dialoogmodus. Gewoonlijk wordt het "lees"-commando in een batchbestand voorafgegaan door het "echo"-commando, waarmee u een soort bericht vooraf op het scherm kunt afdrukken. Bijvoorbeeld:

echo -n "Voer een getal van drie cijfers in:" lees x

Bij het uitvoeren van dit fragment van een batchbestand, na het weergeven van het bericht

Voer een driecijferig nummer in:

de tolk stopt en wacht tot er een waarde wordt ingevoerd vanaf het toetsenbord. Als u bijvoorbeeld "753" invoert, wordt dit de waarde van de variabele "x". Eén "lees" -opdracht kan waarden voor meerdere variabelen tegelijk lezen (toewijzen). Als er meer variabelen in "lezen" zijn dan ingevoerd (gescheiden door spaties), krijgen de resterende variabelen een lege string toegewezen. Als er meer doorgegeven waarden zijn dan variabelen in de opdracht "lezen", worden de extra waarden genegeerd. Wanneer u een shell-variabele benadert, moet u de naam laten voorafgaan door het "$"-symbool. Dus de commando's echo $var_2 echo var_2 zullen op het scherm worden weergegeven

UNIX OS var_2 Ontsnappen

Laten we de ontsnappingstechnieken die in de schaal worden gebruikt eens nader bekijken. De escape-tekens zijn dubbele aanhalingstekens (" "), enkele aanhalingstekens (" ") en backslashes (\). Hun werking wordt duidelijk uit de voorbeelden: U kunt meerdere opdrachten op één regel schrijven.

X=22 y=33 z=$x A="$x" B="$x" C=\$x D="$x + $y + $z" E="$x + $y + $z " F=$x\ +\ $y\ +\ $z

(de opdracht G=$x+$y zou vanwege spaties niet zijn uitgevoerd) Dan

echo A = $A B = $B C = $C echo D = $D E = $E F = $F eval echo-evaluatie A = $A eval echo-evaluatie B = $B eval echo-evaluatie C = $C

Weergegeven op het scherm

A = 22 B = $x C = $x D = 22 + 33 + 22 E = $x + $y + $z F = 22 + 33 + 22 geëvalueerd A = 22 geëvalueerd B = 22 geëvalueerd C = 22

Laten we nog enkele voorbeelden geven met betrekking tot het ontsnappen van regeleinden. Geef de variabele "string" de waarde van "array" 2x3: abc def Merk op dat om te voorkomen dat er extra spaties worden toegewezen, de tweede regel van de array begint vanaf de eerste positie van de volgende regel: string="abc def" zijn drie manieren om de variabele in het commando "echo" te schrijven echo $string echo "$string" echo "$string" zal respectievelijk drie verschillende resultaten geven: abc def $string abc def en de volgorde van commando's echo "str_1 str_2" > file_1 echo "str_1 str_2" > file_2 cat file_1 file_2 geeft uitvoer in volgorde identieke bestanden file_1 en file_2: str_1 str_2 str_1 str_2 Merk ook op dat de backslash (\) niet alleen het karakter dat erop volgt escaped, waardoor speciale karakters eenvoudig kunnen worden gebruikt als karakters die zichzelf vertegenwoordigen (het kan ook zichzelf escapen - \\), maar in een batchbestand kunt u met een backslash regels combineren tot één (escape aan het einde van de regel), bijvoorbeeld het eerder aangehaalde voorbeeld van de opdrachtregel:

Kattenbestand_1 | grep -hresult | sorteren | kat -b > bestand_2

kan in een batchbestand worden geschreven, bijvoorbeeld als

Kattenbestand_1 | grep -h \resultaat | sorteren | kat -b > bestand_2

Trouwens, het pijplijnsymbool biedt ook het effect van voortzetting van de opdrachtregel. In dit geval kan dit een mooier resultaat geven, bijvoorbeeld:

Kattenbestand_1 | grep -hresult | sorteren | kat -b > bestand_2

Manipulaties met shell-variabelen Hoewel shell-variabelen over het algemeen worden behandeld als strings, d.w.z. "35" is geen getal, maar een string van twee tekens "3" en "5", kunnen ze in sommige gevallen anders worden geïnterpreteerd, bijvoorbeeld als gehele getallen. Het commando "expr" heeft verschillende mogelijkheden. Laten we enkele illustreren met voorbeelden: Een batchbestand uitvoeren:

X=7 y=2 a=`expr $x + $y` ; echo a=$a a=`expr $a + 1` ; echo a=$a b=`expr $y - $x` ; echo b=$b c=`uitdr $x "*" $y`; echo c=$c d=`expr $x / $y` ; echo d=$d e=`expr $x % $y` ; echo e=$e

zal op het scherm verschijnen

A=9 a=10 b=-5 c=14 d=3 e=1

De vermenigvuldigingsbewerking ("*") moet worden vermeden, omdat dit pictogram in de shell wordt gezien als een speciaal teken, wat betekent dat elke reeks tekens deze plaats kan vervangen. Met het commando "expr", niet alleen (integer) rekenkundige bewerkingen, maar ook strings:

A=`expr "cocktail" : "haan"`; echo $A B=`uitdr "cocktail" : "staart"`; echo $B C=`uitdr "cocktail" : "koken"`; echo $C D=`expr "haan" : "cocktail"`; echo $D

Er worden getallen op het scherm weergegeven met het aantal overeenkomende tekens in de tekenreeksen (vanaf het begin). De tweede regel kan niet langer zijn dan de eerste:

4 0 0 0

Variabelen exporteren UNIX heeft het concept van een proces. Een proces vindt plaats wanneer een opdracht wordt uitgevoerd voor uitvoering. Bijvoorbeeld bij het typen van "r" op het toetsenbord " proces "p" wordt voortgebracht. Op zijn beurt kan "p" andere processen voortbrengen. Laten we zeggen dat "p" "p1" en "p2" aanroept, die achtereenvolgens de overeenkomstige processen voortbrengen. Elk proces heeft zijn eigen omgeving - een set Bijvoorbeeld, voordat "p" werd uitgevoerd, bestond er al een omgeving waarin enkele variabelen al waren gedefinieerd. Door "p" uit te voeren, wordt een nieuwe omgeving gegenereerd, waarin "p1" en "p2" worden voortgebracht. Variabelen zijn local binnen het proces waarin ze worden gedeclareerd, d.w.z. waar ze waarden krijgen toegewezen. Om ervoor te zorgen dat ze beschikbaar zijn voor andere voortgebrachte processen, moeten ze expliciet worden doorgegeven. Hiervoor wordt de ingebouwde opdracht "exporteren" gebruikt.

Parameters

Parameters kunnen worden doorgegeven aan het batchbestand. De shell gebruikt positionele parameters (d.w.z. de volgorde waarin ze verschijnen is significant). In een batchbestand beginnen de variabelen die overeenkomen met de parameters (vergelijkbaar met shell-variabelen) met het "$"-teken, gevolgd door een van de cijfers van 0 tot 9: Laat "examp-1" worden aangeroepen met de "cock" en "staart" parameters. Deze parameters komen de nieuwe omgeving binnen onder de standaardnamen "1" en "2". De (standaard) variabele met de naam "0" zal de naam van de aangeroepen berekening bevatten. Bij toegang tot parameters wordt het dollarteken "$" voor het cijfer geplaatst (zoals bij toegang tot variabelen): $0 komt overeen met de naam van het gegeven batchbestand; $1 eerste parameter; $2 is de tweede parameter, enzovoort. Aangezien het aantal variabelen waaraan parameters kunnen worden doorgegeven, beperkt is tot één cijfer, d.w.z. 9e ("0", zoals reeds opgemerkt heeft een speciale betekenis), dan voor de verzending meer parameters, wordt een speciaal "shift"-commando gebruikt. De opdracht "set" geeft een eigenaardige benadering van parameters. Fragmenten bijvoorbeeld

Stel a b in met echo eerste=$1 tweede=$2 derde=$3

zal op het scherm verschijnen

Eerste=a Tweede=b Derde=c

die. het "set" commando stelt de parameterwaarden in. Dit blijkt erg handig te zijn. De opdracht "date" geeft bijvoorbeeld de huidige datum weer, zeg "Mon May 01 12:15:10 2000", bestaande uit vijf woorden, en

Stel `datum` echo in $1 $3 $5

zal op het scherm verschijnen

ma 01 2000

Met het "set"-commando kunt u ook de uitvoering van het programma regelen, bijvoorbeeld: set -v voert regels uit die leesbaar zijn voor de shell naar de terminal. set +v annuleert de vorige modus. set -x print commando's naar de terminal voordat ze worden uitgevoerd. set +x annuleert de vorige modus. Het "set"-commando zonder parameters print de status van de softwareomgeving naar de terminal.

Vervangingen van Shell-tolken

Voordat commando's in batchbestanden direct worden geïnterpreteerd en uitgevoerd, voert de shell uit verschillende soorten vervangingen: 1. VERVANGING VAN RESULTATEN. Alle commando's tussen aanhalingstekens worden uitgevoerd en het resultaat wordt op hun plaats gezet. 2. VERVANGING VAN DE WAARDEN VAN PARAMETERS EN VARIABELEN. Dat wil zeggen, woorden die beginnen met "$" worden vervangen door de overeenkomstige waarden van variabelen en parameters. 3. INTERPRETATIE VAN GAPS. Ontsnapte spaties worden genegeerd. 4. GENEREREN VAN BESTANDSNAMEN. Woorden worden gecontroleerd op de aanwezigheid van speciale tekens ("*", "?", "") en de overeenkomstige generaties worden uitgevoerd. Softwareomgeving Elk proces heeft een omgeving waarin het draait. Shell gebruikt een aantal omgevingsvariabelen. Als u de opdracht "set" typt zonder parameters, zal het scherm informatie weergeven over een aantal standaardvariabelen die bij het inloggen zijn gemaakt (en doorgegeven aan al uw nieuwe processen "door overerving"), evenals variabelen die door uw processen zijn gemaakt en geëxporteerd . Het specifieke type en de inhoud van de weergegeven informatie hangt in grote mate af van welke versie van UNIX wordt gebruikt en hoe het systeem is geïnstalleerd.

Het resultaat van het uitvoeren van het set-commando zonder parameters (niet volledig):

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

Laten we iets zeggen over de waarden van de variabelen. HOME=/root is de naam van de homedirectory waar de gebruiker terechtkomt na het inloggen. Dat wil zeggen, door de gebruikersnaam en het wachtwoord correct te typen, kom ik in de map "/ root". PATH=/bin:/usr/bin:.:/usr/local/bin:/usr/bin/X11 - deze variabele bepaalt de volgorde van bestanden die "shell" zoekt naar een opdracht. Bestandsnamen worden hier gescheiden door dubbele punten. De bladervolgorde komt overeen met de volgorde van de namen in het spoor. Maar in eerste instantie vindt het zoeken plaats tussen de zogenaamde ingebouwde commando's. De ingebouwde commando's bevatten de meest gebruikte commando's, zoals "echo", "cd", "pwd", "date". Daarna kijkt het systeem in de directory "/bin", die de opdrachten "sh", "cp", "mv", "ls", enz. kan bevatten. Dan de directory "/usr/bin" met de commando's "cat", "cc", "expr", "nroff", "man" en vele anderen. Verder vindt de zoekopdracht plaats in de huidige map ("".", of een andere aanduiding "leeg", d.w.z. ""), waar de commando's die u hebt geschreven zich hoogstwaarschijnlijk bevinden. Na het typen van de opdrachtregel en het indrukken van "shell" (na het maken van de nodige vervangingen) herkent de naam die overeenkomt met het commando en zoekt ernaar in de mappen die worden vermeld in het PATH. Als de opdracht buiten deze mappen wordt geplaatst, wordt deze niet gevonden. Als er meerdere commando's met dezelfde naam zijn, wordt degene die zich in de eerst bekeken directory bevindt, aangeroepen. PATH kan, net als andere variabelen, eenvoudig worden gewijzigd door mappen toe te voegen, te herschikken of uit te sluiten. IFS= (Internal Field Separator) somt de tekens op die worden gebruikt om woorden (velden) te scheiden. Dit zijn "spatie", "tab" en "line feed", hier is dus links van de opdracht niets zichtbaar en zijn twee regels bezet. LOGNAME=root - inlognaam ("gebruikersnaam"). MAIL=/var/spool/mail/root is de naam van het bestand dat (e-mail)mail ontvangt. PWD=/root - huidige mapnaam PS1=$(PWD):" " - type promter. In dit geval zal de prompter de naam van de huidige map, een dubbele punt en een spatie weergeven. Dat wil zeggen, "/ root:" zal hier zijn. PS2=> - deze prompter (hier ">") wordt gebruikt als een uitnodiging om door te gaan met het typen (op de volgende regel) van een onvoltooide opdracht. Typ bijvoorbeeld het openingshaakje "(" en druk daarna op op de volgende regel ziet u deze prompter. Als u nog niet weet wat u vervolgens moet doen, typt u het haakje sluiten ")" en het zal verdwijnen. SHELL=/bin/sh - Deze variabele specificeert de shell die de gebruiker gebruikt. In dit geval wordt de standaard shell ("sh") gebruikt. De initiële omgeving wordt automatisch ingesteld bij het inloggen met behulp van bestanden zoals "/etc/rc" en "/etc/.profile". Een manier om eenvoudig de omgeving te wijzigen (bijv. opdrachtzoekpad, prompterweergave, shellweergave, schermkleur, enz.) is door deze informatie in uw thuismap te plaatsen in een gespecialiseerd ".profile"-bestand ($(HOME)/.profile ) door toewijzen gewenste waarden omgevingsvariabelen. Dat wil zeggen, roep dit bestand in de editor en schrijf wat je wilt). Elke keer dat u zich aanmeldt, wordt dit bestand automatisch uitgevoerd en wordt een nieuwe omgeving opgezet. Dit bestand MOET in uw HOME-directory (login-directory) worden geplaatst. Merk op dat bestandsnamen die met een punt beginnen over het algemeen een speciale status hebben. Ze worden dus niet op het scherm weergegeven met een simpele "ls" -opdracht - u moet deze opdracht aanroepen met de "-a" -vlag. Overigens worden ze niet zonder onderscheid vernietigd door het commando "rm *". De shell-interpreter wijst zelf automatisch waarden toe aan de volgende variabelen (parameters): ? de waarde geretourneerd door de laatste opdracht; $ procesnummer; ! achtergrondprocesnummer;

1. het aantal positionele parameters dat aan de shell is doorgegeven;

• parameterlijst als één regel;

@ lijst met opties als een verzameling woorden; - vlaggen doorgegeven aan de schaal. Wanneer u deze variabelen benadert (dat wil zeggen, wanneer u ze gebruikt in een batchbestand - een shell-programma), moet u "$" ervoor plaatsen. Een belangrijke rol bij het maken van unieke bestanden wordt gespeeld door de speciale variabele "$$", waarvan de waarde overeenkomt met het nummer van het proces dat deze berekening uitvoert. Elke nieuwe berekening die door de computer wordt uitgevoerd, initieert een of meer processen die automatisch getallen op volgorde ontvangen. Door het procesnummer als bestandsnaam te gebruiken, kan men er dus zeker van zijn dat elk nieuw bestand krijgt een nieuwe naam (wordt niet geschreven in plaats van een bestaande). Het voordeel is meteen ook het grootste nadeel van deze manier van bestanden benoemen. Het is niet bekend welke namen aan de bestanden worden toegekend. En als binnen dit proces u kunt het bestand vinden "zonder te kijken", d.w.z. door ernaar te verwijzen met $$, dan kunnen dergelijke bestanden later gemakkelijk verloren gaan. Dit zorgt voor extra problemen bij het debuggen van programma's. De tolk bellen Nadat de gebruiker zich heeft aangemeld bij het systeem (met behulp van de login-opdracht), wordt de SHELL-taaltolk gebeld. Als de inlogdirectory van de gebruiker een .profile-bestand bevat, voert de interpreter dit bestand uit voordat er ook maar één commando van de terminal is ontvangen (er wordt aangenomen dat het .profile-bestand commando's bevat). De volgende schakelopties kunnen worden opgegeven tijdens de aanroep: -c string Commando's worden gelezen uit de opgegeven string. -s Commando's worden gelezen uit standaardinvoer. Tolkberichten worden naar het standaarddiagnosebestand geschreven. -i Interactieve modus. Als het eerste teken van de parameter "0" - is, worden de opdrachten uit het .profile-bestand gelezen.

PROGRAMMASTRUCTUREN===

Zoals in elke programmeertaal, kunnen er opmerkingen in de tekst in de shell-taal staan. Hiervoor wordt het "#"-teken gebruikt. Alles wat in de regel (in het batchbestand) links van dit symbool staat, wordt door de tolk gezien als commentaar. Bijvoorbeeld,

# Dit is een opmerking.

Zoals in elke procedurele taal programmeren in de shell-taal heeft operators. Met een aantal operators kunt u de volgorde van uitvoering van opdrachten bepalen. Bij dergelijke operatoren is het vaak nodig om de voorwaarde te controleren, die de richting van de voortzetting van de berekeningen bepaalt.

test(") commando

Het testcommando controleert of aan een bepaalde voorwaarde wordt voldaan. Met behulp van dit (ingebouwde) commando worden commando's voor shell-taal selecteren en herhalen gevormd. Twee mogelijke opdrachtformaten:

test conditie

[ voorwaarde ]

we zullen de tweede optie gebruiken, d.w.z. in plaats van het woord "test" voor de voorwaarde te schrijven, plaatsen we de voorwaarde tussen haakjes, wat meer bekend is bij programmeurs. In feite zal de shell dit commando van de openingshaak "[" herkennen als het woord dat overeenkomt met het commando "test". Er moeten spaties zijn tussen de haakjes en de voorwaarde die erin staat. Er moeten ook spaties zijn tussen de waarden en het vergelijkingsteken of de bewerking.De shell gebruikt voorwaarden van verschillende "types". BESTANDSCONTROLE VOORWAARDEN: -f bestand "bestand" is een normaal bestand; -d bestand bestand "bestand" - map; -c bestand "bestand" is een speciaal bestand; -r bestand heeft toestemming om bestand "bestand" te lezen; -w bestand heeft toestemming om naar bestand "bestand" te schrijven; -s bestand "bestand" is niet leeg.

STRING CONTROLEER VOORWAARDEN: str1 = str2 tekenreeksen "str1" en "str2" komen overeen; str1 != str2 strings "str1" en "str2" komen niet overeen; -n str1 string "str1" bestaat (niet leeg); -z str1 string "str1" bestaat niet (leeg). Voorbeelden.

x="wie is wie"; x exporteren; [ "wie is wie" = "$x" ]; echo $? 0 x=abc ; x exporteren; [abc = "$x"]; echo $? 0 x=abc ; x exporteren; [ -n "$x" ] ; echo $? 0x="" ; x exporteren; [ -n "$x" ] ; echo $? een

Daarnaast zijn er twee standaardwaarden voor voorwaarden die kunnen worden gebruikt in plaats van de voorwaarde (haakjes zijn niet nodig). VOORWAARDEN VOOR VERGELIJKING VAN GETALLEN: x -eq y "x" is gelijk aan "y", x -ne y "x" is niet gelijk aan "y", x -gt y "x" is groter dan "y", x -ge y "x" is groter dan of gelijk aan "y", x -lt y "x" is kleiner dan "y", x -le y "x" is kleiner dan of gelijk aan "y". COMPLEXE OMSTANDIGHEDEN: Geïmplementeerd met typische logische operaties: ! (niet) keert de waarde van de afsluitcode om. -o (of) komt overeen met logische "OF". -a (and) komt overeen met logische AND.

Voorwaardelijke "als"-verklaring

Over het algemeen heeft de "if" -instructie de structuur

als voorwaarde dan lijst

Hier is "elif" een afkorting voor "else if" en kan samen met de volledige worden gebruikt, d.w.z. het nesten van een willekeurig aantal "if"-statements (evenals andere statements) is toegestaan. Natuurlijk moet "lijst" in elk geval zinvol en toelaatbaar zijn in de gegeven context. De meest afgekapte structuur van deze operator

Als voorwaarde, vermeld dan fi

als aan de voorwaarde is voldaan (in de regel is dit degene die de voltooiingscode "0" heeft ontvangen, dan wordt de "lijst" uitgevoerd, anders wordt deze overgeslagen. Voorbeelden. Laat "if-1" schrijven

Als [$1 -gt $2]

dan pwd else echo $0: Hallo!

Dan bellen als-1 12 11 geeft /home/sae/STUDY/SHELL en als-1 12 13 geeft als-1: Hallo!

Oproepverklaring ("zaak")

De selectieopdracht "zaak" heeft de structuur:

Hoofdletterreeks erin

patroon) lijst met opdrachten;; patroon) lijst met opdrachten;; ... patroon) lijst met commando's;;

Hier zijn "case", "in" en "esac" hulpwoorden. Een "string" (het kan een enkel teken zijn) wordt vergeleken met een "patroon". Vervolgens wordt de "commandolijst" van de geselecteerde rij uitgevoerd. Kijk ongewoon naar het einde van de selectieregels ";;", maar schrijf hier ";" het zou een vergissing zijn. Voor elk alternatief kunnen verschillende commando's worden uitgevoerd. Als deze commando's op één regel zijn geschreven, dan is het teken ";" wordt gebruikt als opdrachtscheidingsteken. Gebruikelijk laatste lijn select heeft het patroon "*", wat in de "case"-structuur "elke waarde" betekent. Deze tekenreeks wordt geselecteerd als de waarde van de variabele (hier $z) niet overeenkomt met een van de eerder geschreven patronen die worden begrensd door het haakje ")". De waarden worden opgezocht in de volgorde waarin ze zijn geschreven.

Opsommingslus-instructie ("for")

De "for"-lusoperator heeft de structuur:

Voor naam

doen lijst met uitgevoerde opdrachten waarbij "voor" een functiewoord is dat het type cyclus definieert, "doen" en "klaar" zijn servicewoorden die de kern van de cyclus markeren. Laat het "lsort" commando worden vertegenwoordigd door een batchbestand

Voor i in file_1 file_2 file_3 doe proc_sort $i klaar

In dit voorbeeld speelt de naam "i" de rol van een lusparameter. Deze naam kan worden beschouwd als een shell-variabele, waaraan de vermelde waarden (i=file_1, i=file_2, i=file_3) achtereenvolgens worden toegewezen, en de opdracht "proc_sort" wordt in een lus uitgevoerd. De vorm "voor i in *" wordt vaak gebruikt, wat betekent "voor alle bestanden in de huidige directory". Laat "proc_sort" op zijn beurt worden weergegeven door een batchbestand

Kat $1 | sorteren | tee /dev/lp > $(1)_gesorteerd

die. opeenvolgend gesorteerd opgegeven bestanden, sorteerresultaten worden afgedrukt ("/dev/lp") en verzonden naar bestanden file_1_sorted file_2_sorted en file_3_sorted

Loop-instructie met ware voorwaarde ("while")

De "while"-structuur, die ook berekeningen levert, heeft de voorkeur wanneer de exacte lijst met parameterwaarden niet van tevoren bekend is of deze lijst moet worden verkregen als resultaat van berekeningen in een lus. De lusopdracht "while" heeft de volgende structuur:

terwijl conditie

doe lijst met uitgevoerde opdrachten waarbij "terwijl" een functiewoord is dat het type lus definieert met een voorwaarde waar. De lijst met opdrachten in de lusbody (tussen "do" en "done") wordt herhaald totdat de voorwaarde waar is (d.w.z. de afsluitcode van de laatste opdracht in de lusbody is "0") of de lus wordt onderbroken vanaf de binnen door speciale commando's ("break", "continue" of "exit"). De eerste keer dat u de lus betreedt, moet aan de voorwaarde zijn voldaan. Met het commando "break [n]" kunt u de lus verlaten. Als "n" afwezig is, dan is het gelijk aan "break 1". "n" geeft het aantal geneste lussen aan waaruit moet worden afgesloten, bijvoorbeeld "break 3" - verlaten van drie geneste lussen. In tegenstelling tot het commando "break", beëindigt het commando "continue [n]" alleen de uitvoering van de huidige lus en keert terug naar het BEGIN van de lus. Het kan ook met een parameter. Bijvoorbeeld, "continue 2" betekent verlaten naar het begin van de tweede (indien geteld vanaf de diepte) geneste lus. Met de opdracht "exit [n]" kunt u de procedure helemaal afsluiten met een retourcode van "0" of "n" (als de parameter "n" is opgegeven). Deze opdracht kan niet alleen in lussen worden gebruikt. Zelfs in een lineaire volgorde van instructies kan het bij het debuggen nuttig zijn om de uitvoering van de (huidige) berekening op een bepaald punt te stoppen.

Loop-instructie met valse voorwaarde ("until")

De lusoperator "until" heeft de structuur:

tot voorwaarde

do lijst met uitgevoerde commando's waarbij "until" een functiewoord is dat het type lus definieert met de voorwaarde onwaar. De lijst met commando's in de body van de lus (tussen "do" en "done") wordt herhaald totdat de voorwaarde onwaar is of de lus van binnenuit wordt onderbroken door speciale commando's ("break", "continue" of "exit") . De eerste keer dat u de lus invoert, mag de voorwaarde niet waar zijn. Het verschil met de "while"-operator is dat de lusvoorwaarde wordt gecontroleerd op onwaarheid (voor een niet-nul exitcode van het laatste commando van de lusbody) wordt gecontroleerd NA elke (inclusief de eerste!) uitvoering van de commando's van de lus lichaam. Voorbeeld.

tot vals doen

lees x als [ $x = 5 ] echo dan voldoende ; break else echo wat meer fi

Hier is het programma met eindeloze cirkel wacht op het invoeren van woorden (herhaalt de zin "nog wat" op het scherm) totdat "5" wordt ingevoerd. Daarna wordt "genoeg" gegeven en het commando "break" beëindigt de uitvoering van de lus.

Lege verklaring

De lege verklaring heeft het formaat

:

Niks doen. Retourneert de waarde "0".".

Shell-functies

Met de functie kunt u een lijst opstellen shell-commando's voor latere executie. De functiebeschrijving ziet er als volgt uit:

Naam() (lijst met opdrachten)

waarna de aanroep van de functie op naam plaatsvindt. Wanneer de functie wordt uitgevoerd, wordt er geen nieuw proces gemaakt. Het wordt uitgevoerd in de omgeving van het corresponderende proces. De argumenten van de functie worden de positionele parameters; de naam van de functie is de null-parameter. U kunt de uitvoering van een functie onderbreken met het statement "return [n]", waarbij (optioneel) "n" de returncode is.

Afhandeling onderbreken ("trap")

Soms is het nodig om de uitvoering van het programma te beschermen tegen onderbrekingen. De meest voorkomende onderbrekingen zijn de volgende, overeenkomend met signalen: 0 uitgang van de tolk, 1 vrijgave (verbreken van de abonnee op afstand), 2 onderbreking van , 9 doden (niet onderschept), 15 beëindigen executie. Ter bescherming tegen onderbrekingen is er een "trap"-opdracht, die de volgende indeling heeft:

Vang "commandolijst" signalen op

Als er onderbrekingen optreden in het systeem, waarvan de signalen worden weergegeven met een spatie in "signalen", dan wordt de "lijst met commando's" uitgevoerd, waarna (als het "exit" -commando niet werd uitgevoerd in de lijst met commando's), de besturing keert terug naar het breekpunt en de uitvoering van het batchbestand gaat door. Als u bijvoorbeeld de bestanden in "/tmp" wilt verwijderen voordat u de uitvoering van een batchbestand onderbreekt, kunt u dit doen met de opdracht "trap":

Trap "rm /tmp/* ; exit 1" 1 2 15

die voorafgaat aan andere opdrachten in het bestand. Hier wordt na het verwijderen van de bestanden "afsluiten" gedaan vanuit het batchbestand.

    Besturingssystemen Linux-families, evenals elk ander besturingssysteem, gaan uit van de aanwezigheid van een interface voor interactie tussen de componenten van het computersysteem en de eindgebruiker, d.w.z. de aanwezigheid van een softwareniveau dat zorgt voor invoer van opdrachten en parameters om de gewenste resultaten te verkrijgen. Zo een programma niveau Was genaamd "schelp" of bij de Engelse taal - schelp.

Wat is een schil?

opdrachtshell ( schelp) zorgt voor interactie tussen de gebruiker en de Linux-besturingssysteemomgeving. Ze is gespecialiseerd softwareproduct, dat zorgt voor de uitvoering van opdrachten en het verkrijgen van de resultaten van hun uitvoering, of, als het erg vereenvoudigd is, een shell is een programma dat is ontworpen om de uitvoering van andere programma's op verzoek van de gebruiker te garanderen. Een voorbeeld van een shell is bijvoorbeeld een commando-interpreter commando. com MS DOS-besturingssysteem of shell bashen operatiekamers Unix-systemen/ linux.

Alle shells hebben vergelijkbare functies en eigenschappen, in overeenstemming met hun hoofddoel - het uitvoeren van gebruikerscommando's en het weergeven van de resultaten van hun uitvoering:

Commandoregelinterpretatie.

Toegang tot opdrachten en hun resultaten.

Ondersteuning voor variabelen, speciale tekens en Gereserveerde woorden.

Bestanden verwerken, standaard invoer- en uitvoerbewerkingen.

Implementatie speciale taal shell-programmering.

    Voor besturingssystemen van de Unix / Linux-familie is het mogelijk om verschillende shells te gebruiken die verschillen in eigenschappen en manieren van interactie met het systeem. De meest voorkomende schelpen zijn

sch- schelp Bourne, klassieke Unix-shell

bashen schelp Nogmaals Bourne(GNU Bourne-Again Shell). Misschien wel de meest voorkomende op dit moment, de shell in de omgeving van de Linux-familie van besturingssystemen.

ksh- schelp Korn, ontworpen als een shell-ontwikkeling Bourne met opdrachtregelgeschiedenis en de mogelijkheid om opdrachten te bewerken.

csh- schelp C, gebruikmakend van de syntaxis van een populaire programmeertaal C

tcsh- shell-versie C met interactieve opdrachtregelbewerking.

Er kunnen verschillende shells op het systeem worden geïnstalleerd en het is voor elke gebruiker mogelijk om zijn eigen standaard shell te gebruiken. Dit gebeurt natuurlijk allemaal automatisch tijdens het downloaden en registreren van een gebruiker.

    Tijdens het laden van besturingssystemen van de Linux-familie wordt na het laden van de systeemkernel een overgang gemaakt naar de interactieve modus - de modus van interactie tussen de gebruiker en het besturingssysteem. Op Linux is het eerste proces dat start tijdens het opstarten het initialisatieprogramma. in het, die de inhoud van het configuratiebestand leest /etc/inittab, bepaalt de lijst en kenmerken van de beschikbare terminals in het systeem en roept het interactieve login-programma op getty A die de gebruikersnaamprompt weergeeft. Na het invoeren van de gebruikersnaam en het wachtwoord, wordt het programma getty roept het programma op Log in, die de geldigheid controleert account, verandert in de thuismap van de gebruiker en draagt ​​de controle over aan het initiële opstartprogramma van de sessie, meestal het shell-programma van de gebruiker, waarvan de specifieke variant wordt bepaald door de inhoud van het bestand /etc/wachtwoord voor deze rekening. Bijvoorbeeld:

gebruiker1:x:508:511::/home/gebruiker1:/bin/sh
interbase:x:510:511::/home/interbase:/bin/csh
apb:x:511:513:apb:/home/apb:/bin/bash

Zoals je kunt zien aan de inhoud van het bestand /etc/wachtwoord, voor de gebruiker gebruiker1 shell wordt gelanceerd sch(Bourne-shell), per gebruiker tussenbasis- schelp csh(C shell) en voor de gebruiker apb- schelp bashen(Opnieuw Bourne). Nadat de shell is gestart, wordt een opdrachtprompt op het scherm weergegeven (meestal in de vorm van een dollarteken $ indien de werkzaamheden worden uitgevoerd in het kader van een standaard gebruikersaccount, of lb # als de shell wordt gebruikt onder een bevoorrechte gebruikersaccount ( wortel).

Bij het verlaten van de shell geeft de systeemkernel de besturing terug aan het programma in het, waarmee het aanmeldingsproces opnieuw wordt gestart en de gebruikersnaam op de terminal wordt weergegeven. Het verlaten van de shell kan op twee manieren:

Via de ploeg Uitgang uitgevoerd door de gebruiker

Wanneer het shell-proces een signaal ontvangt doden verzonden door de kernel, bijvoorbeeld wanneer het systeem opnieuw wordt opgestart.

Commandoregelinterpretatie.

    Gebruikersinvoer als reactie op een shell-prompt wordt gewoonlijk aangeduid als opdrachtregel of team. Een Linux-opdracht is een tekenreeks van de opdrachtnaam en argumenten gescheiden door spaties. Argumenten voorzien de opdracht van extra opties die het gedrag ervan bepalen. De meest gebruikte argumenten zijn opties en namen bestanden en mappen. Bijvoorbeeld opdrachtregel

ls -l bestand01 bestand02

Bevat de opdracht ls, de optie -l en de twee bestandsnamen file01 file02 .

Bij gebruik van meerdere opties kunnen deze gecombineerd worden. De varianten van de volgende opdrachten zijn bijvoorbeeld identiek:

Ls-l-d
ls-ld

De commando's die deel uitmaken van de shell worden aangeroepen ingebouwd. Zulke commando's zijn bijvoorbeeld cd, if, case, enz. Uiteraard kunnen ingebouwde commando's verschillen voor verschillende shells. Naast ingebouwde commando's is het mogelijk om te gebruiken softwaremodules, dit zijn afzonderlijke uitvoerbare bestanden of bestanden scripts of scenario's- gewone tekstbestanden die achtereenvolgens uitgevoerde regels bevatten met shell-commando's. Sommige scripts (scripts) kunnen worden uitgevoerd Linux-processen zoals taakplanner kroon. De taakplanner is meestal ontworpen om automatische uitvoering geplande systeembeheertaken. Taken kroon zijn commando's of scripts en worden automatisch uitgevoerd, zonder enige menselijke tussenkomst en kunnen worden uitgevoerd in de context van verschillende gebruikersaccounts. In het geval dat de plannertaak de uitvoering van een script inhoudt, is er een probleem bij het kiezen van een shell die moet worden gestart als een onderliggend proces kroon voor het verwerken van opdrachten uit het scriptbestand - de shell kan immers elke shell zijn, en de syntaxis van het script omvat in de regel het gebruik van een specifieke shell waarvoor het is geschreven. Om dit probleem op te lossen, is het in de Linux-familie van besturingssystemen gebruikelijk om in de eerste regel van het script het type shell aan te geven dat nodig is voor de uitvoering ervan, in de vorm:

#!/bin/bash- voor schelp bashen

#!/bin/sh- voor schelp sch

Teken # is een teken van een opmerking en de tekens die erop volgen worden niet geïnterpreteerd als een opdracht. Met deze techniek kunt u expliciet specificeren welke shell moet worden gebruikt om de daaropvolgende inhoud van het bestand te verwerken. Als het script geen item bevat dat expliciet de vereiste shell definieert, dan zullen de instellingen van het account worden gebruikt in de context waarvan het gegeven script wordt uitgevoerd. In dit geval is het mogelijk dat een script dat is geschreven voor een shell, bijvoorbeeld tch zal worden doorgegeven aan de shell voor uitvoering bashen, waardoor het onmogelijk wordt om uit te voeren.

Bij het uitvoeren van opdrachten of scripts, de omgevingsvariabelen(in Engels - omgeving, wiens waarden kenmerkend zijn software-omgeving waar commando's worden uitgevoerd. Dergelijke variabelen kunnen algemene systeeminstellingen, grafische of opdrachtshell-opties, uitvoerbare bestandspaden, enzovoort bevatten. Waarden voor omgevingsvariabelen worden ingesteld op systeemniveau (voor alle gebruikers) en op het niveau van een bepaalde gebruiker. Om omgevingsvariabelen op systeemniveau in te stellen, wordt de inhoud van de bestanden gebruikt:

/etc/profiel- stelt alleen variabelen in voor shells. Kan alle scripts uitvoeren in shells die compatibel zijn met Bourne-shells.

/etc/bash.bashrc- stelt alleen variabelen in voor interactieve shells. Het voert ook bash-scripts uit.

/etc/omgeving- gebruikt door de PAM-env-module. In dit bestand kunnen alleen paren worden opgegeven. naam=waarde.

Elk van deze bestanden heeft zijn eigen toepassing, dus u moet zorgvuldig degene kiezen die bij uw doeleinden past. Als u bijvoorbeeld een aangepaste map wilt toevoegen ~/bak in een variabele PAD plaats voor alle gebruikers de volgende code in een van de initialisatiebestanden van de systeemomgeving (/etc/profile of /etc/bash.bashrc):

# Als de gebruikers-ID groter is dan of gelijk is aan 1000 en de map ~/bin bestaat en deze

#was niet eerder toegevoegd aan de variabele PATH,

# exporteer ~/bin naar $PATH.

Als [[ $UID -ge 1000 && -d $HOME/bin && -z $(echo $PATH | grep -o $HOME/bin)

Exporteer PATH=$HOME/bin:$(PATH)

Meestal in operatiekamers Linux-systemen, gebruikers-ID minder dan 1000 of minder dan 500 wordt gebruikt voor serviceaccounts. BIJ dit voorbeeld, wordt de omgevingsvariabele ingesteld voor alle lokale systeemgebruikers met een ID van 1000 of meer.

Als u de omgeving voor een bepaalde gebruiker moet wijzigen, wijzigt u de inhoud van de gebruikersomgeving:

- ~/.bash_profiel, ~/.bash_login enzovoort. - shell-initialisatiebestanden uit de thuismap van de gebruiker.

- ~/.profiel- initialisatiebestand voor gebruikersprofielen. Wordt door veel shells gebruikt om omgevingsvariabelen te definiëren.

~/.pam_omgeving- een aangepast equivalent van het bestand /etc/environment, dat wordt gebruikt door de PAM-env-module.

Om bijvoorbeeld de map ~/bin van de gebruiker toe te voegen aan het zoekpad voor de uitvoerbare bestanden die zijn opgegeven door de variabele PAD bijvoorbeeld in een bestand ~/.profiel zet de lijn:

export PATH="$(PATH):/home/gebruiker/bin"

Om omgevingsvariabelen voor grafische toepassingen in te stellen, wordt de inhoud van de configuratiebestanden van de grafische omgeving van de gebruiker gebruikt. ~/.xinitrc

Het komt veel vaker voor dat omgevingsvariabelen worden ingesteld voor de huidige gebruikerssessie. Bijvoorbeeld om een ​​aangepaste map toe te voegen ~/bak in het uitvoerbare zoekpad:

exporteer PATH=~/bin:$PATH

Nieuwe variabele waarde PAD duurt slechts tot het einde van de huidige gebruikerssessie.

Om de waarde van een variabele te bekijken, kunt u de opdracht gebruiken echo $ variabele, bijv.:

echo $PAD

Momenteel is de meest voorkomende shell, zoals hierboven vermeld, dat wel bashen. Dit komt voornamelijk door het feit dat de schaal bashen is een sch- een compatibele opdrachtshell die is toegevoegd handige functies van Korn-schelpen ( ksh) en C-schaal ( csh). schelp bashen kan de meeste shell-scripts uitvoeren zonder enige wijziging sch en probeert zo dicht mogelijk bij de standaard te komen POSIX, wat heeft geleid tot veel verbeteringen, zowel voor de programmering als voor interactief gebruik. In moderne uitvoering bashen er is een bewerkingsmodus voor de opdrachtregel, een onbeperkte grootte van de opdrachtgeschiedenis, hulpmiddelen voor taakbeheer, de mogelijkheid om aliassen te gebruiken, een uitgebreide lijst met ingebouwde opdrachten, shell-functies, enz. Over het algemeen, bashen voldoet het best aan de behoeften van de gemiddelde gebruiker, waardoor het het meest gebruikt werd in de Linux-omgeving.

In de beginfase bashen zonder opdrachtregelopties start de shell in interactieve modus, waarbij een opdrachtprompt op het scherm wordt weergegeven. Een interactieve shell leest doorgaans gegevens van de terminal van de gebruiker en schrijft gegevens naar dezelfde terminal, het standaardinvoerapparaat is het toetsenbord en het standaarduitvoerapparaat is het beeldscherm. De gebruiker voert opdrachten in op het toetsenbord en het resultaat van de uitvoering ervan wordt weergegeven op het display.