Parancsok és argumentumok ebben a kurzusban:

A(z) Parancsok és argumentumok fogalomról

A shellek

A shell egy olyan program, amely lehetővé teszi, hogy parancsokat adj meg, és így az operációs rendszerrel lépj kapcsolatba. A shellek lehetnek grafikusak is; az asztali környezet, amelyet egérrel vagy trackpaddal használsz, szintén egy shell. Most a parancssori felületekre összpontosítunk, ahol parancsokat írsz be, és az eredmények (általában) a terminálban jelennek meg.

Sok különböző parancssori shell létezik. A Windows a cmd és a powershell lehetőségét kínálja. A Mac és a Linux „Unix shelleket” kínál, amelyekből sokféle van. A Mac alapértelmezett shelle a zsh. A csh egy örökölt shell, C-hez hasonló szintaxissal. A bash az egyik legnépszerűbb shell, különösen Linuxon.

Az egyik legkorábbi shell a Bourne-shell, a sh. Idővel ezt a shellt szabványosították, hogy minden Unix-szerű rendszeren elérhető legyen. Sok shell a Bourne-shellen alapul, és gyakran további interaktív vagy programozási funkciókat kínál.

A bash a Bourne-shellen alapul. Ezért hívják „Bourne-again shell”-nek. Sok Linux-rendszeren ez az alapértelmezett shell. A bash számos szolgáltatást kínál, amelyek kellemessé teszik interaktív shellként való használatát, többek között:

• teljesen testreszabható prompt,
• a korábbi parancsok előhívásának és módosításának lehetősége,
• a futó folyamatok kezelésének lehetősége,
• aliasok, amelyekkel kevesebbet kell gépelned,
• és még sok más.

Ez a kurzus nem arról szól, hogyan használd a basht interaktív shellként. Arról szól, hogy megtanulj programokat írni a bash segítségével. A hangsúly azon lesz, hogy csak a basht használd a problémák megoldására, bár semmi sem tiltja, hogy külső eszközöket hívj meg.

A bash alapjai: parancsok és argumentumok

A bash a bemenetéről olvassa a parancsokat (ez általában egy terminál vagy egy fájl). Minden beolvasott sort parancsként kezel, azaz egy végrehajtandó utasításként. (Néhány haladó esettel, például a több soron átívelő parancsokkal, később foglalkozunk.)

A bash minden sort szavakra bont, amelyeket whitespace-karakterek (szóközök és tabulátorok) választanak el. A sor első szava a végrehajtandó parancs neve. Az összes többi szó annak a parancsnak az argumentumaivá válik (opciók, fájlnevek stb.).

# Note: It is always a good idea to run `ls` before `rm`
# to make sure you know what you are deleting.

$ rm *            # Remove all files in the current directory.
                  # Make sure you run this in a temp directory or you can lose files!
$ ls              # List files in the current directory (no output, no files).
$ touch a   b c   # Create files 'a', 'b' and 'c'.
$ ls              # List files again; this time the outputs: 'a', 'b' and 'c'.
a  b  c

Az rm egy alkalmazás, amely törli a neki átadott fájlokat. A * egy glob karakter, egy „wildcard” minta, amely az aktuális könyvtár összes fájljára illeszkedik. A globokról később még beszélünk.

Észrevetted, hogy a és b között több szóköz van, b és c között pedig csak egy? Nem számít, mennyi whitespace van az argumentumok között! Például:

$ echo This is a test.
This is a test.
$ echo This    is    a    test.
This is a test.

Az echo egy parancs, amely a szabványos kimenetre írja az argumentumait (ami esetünkben a terminál). A bash öt szóra bontja a parancsot, majd négy argumentummal hívja meg az echo parancsot. A második példában lévő plusz szóközök semmit sem változtatnak. Az echo nem tudja, hogy eredetileg hogyan álltak a szóközök a szavak között.

Ha meg akarjuk őrizni a plusz whitespace-t, egyetlen argumentumként kell átadnunk a mondatot. Ezt úgy tehetjük meg, hogy idézőjeleket használunk:

$ echo "This    is    a    test."
This    is    a    test.

Az idézőjelek mindent, ami közéjük kerül, egyetlen argumentumba foglalnak. Az argumentum a This is a test., benne azokkal a konkrét szóközkarakterekkel. Az idézőjelek nem részei az argumentumnak: a bash eltávolítja őket, mielőtt átadná ezt az egyetlen argumentumot az echo-nak.

Az argumentumokat a parancs nevétől és egymástól is whitespace választja el. Ezt fontos megjegyezni. Például a következő hibás:

$ [-f file]
bash: [-f: command not found

Ez azt hivatott ellenőrizni, hogy létezik-e file nevű fájl. Ésszerű azt feltételezni, hogy a [ és ] körüli whitespace nem számít, pedig a [ valójában egy parancs, és az utolsó argumentumának ]-nek kell lennie. (A [ parancsról később részletesebben is szót ejtünk.) Ezért a [-t el kell választanunk a -f-től, a ]-t pedig a file-tól. Különben a bash azt hiszi, hogy egy [-f nevű parancsot próbálunk futtatni egyetlen file] argumentummal. A helyes parancsban minden argumentumot whitespace választ el:

$ [ -f file ]

(Sok embert látunk, akit összezavar ez a viselkedés; azt hiszik, hogy a [...] „csak szintaxis”, és elhagyhatják a szóközöket; pedig a [ egy parancs, és a whitespace kötelező.)

Ha a fájlnevünk whitespace-t vagy más speciális karaktert tartalmaz, azt is idézőjelbe kell tennünk:

$ [ -f "my file" ]

A parancsok típusai

A bash többféle parancstípust ismer: aliasokat, függvényeket, beépített parancsokat, kulcsszavakat és futtatható fájlokat. Ezek mind parancsok, és mind nagyon hasonló módon viselkednek.

Alapértelmezés szerint az aliasok csak interaktív shellekben vannak engedélyezve, shell-scriptekben nem. Ezekkel itt nem foglalkozunk.

Függvények

A függvény shell-parancsokat tartalmaz, és nagyon hasonlít egy kis scripthez; akár argumentumokat is fogadhat, és létrehozhat helyi változókat. Amikor meghívunk egy függvényt, a benne lévő parancsok lefutnak. A függvényekkel később részletesen foglalkozunk.

Beépített parancsok

A bashbe néhány alapvető parancs van beépítve, például: cd (könyvtárváltás), echo (kimenet írása) és így tovább. Úgy tekinthetők rájuk, mint eleve biztosított függvényekre.

Kulcsszavak

A kulcsszavak hasonlítanak a beépített parancsokra, a fő különbség az, hogy a kulcsszavak valójában a bash szintaxisának részei, és speciális szabályok szerint értelmeződnek. Például a [ egy bash-beépített parancs, míg a [[ egy bash-kulcsszó; mindkettőt különféle feltételek vizsgálatára használjuk. A [[ kulcsszó azonban néhány plusz funkcióval rendelkezik. Például biztosítja a =~ operátort, amely reguláris kifejezésekkel való illesztést végez.

$ [[ "hello world" =~ e.*o ]]   # returns a "success" status
$ [ "hello world" =~ e.*o ]
bash: [: =~: binary operator expected

A < és > string-összehasonlító operátorok egy másik példája annak, hogy a kulcsszavak másképp értelmezik a kódot. A [[...]]-n belül ezek az operátorok nem igényelnek különleges kezelést.

$ if [[ "$USER" < "n" ]]; then
    echo "$USER is in the first half of the alphabet"
fi
# => glennj is in the first half of the alphabet

A [...]-n belül viszont idézőjelbe kell tenned vagy escape-elned kell őket, hogy a shell ne átirányítási operátorként értelmezze őket.

$ if [ "$USER" < "n" ]; then
    echo "$USER is in the first half of the alphabet"
fi
# => bash: n: No such file or directory

$ if [ "$USER" \< "n" ]; then
    echo "$USER is in the first half of the alphabet"
fi
# => glennj is in the first half of the alphabet

Futtatható fájlok

Az utolsó parancstípus, amit a bash végrehajthat, a futtatható fájl. Ezek a számítógéped fájlrendszerén található futtatható fájlok (programok), amelyeket le tudsz futtatni. (A futtatható fájlokat külső parancsoknak vagy alkalmazásoknak is nevezik.) A futtatható fájlokat általában elég csak a nevük beírásával meghívni; a fájl teljes elérési útjára jellemzően nincs szükség. Ez azért lehetséges, mert a bash egy előre definiált változót használ, amely segít megtalálni a gyakori futtatható fájlok helyét. Ezt a változót PATH-nak hívják. Ez könyvtárnevek halmaza, amelyeket kettőspontok választanak el (pl. /usr/bin:/bin). Amikor egy parancsot fájlútvonal nélkül adunk meg (pl. myprogram vagy ls), és az nem alias, függvény, beépített parancs vagy kulcsszó, a bash végigkeresi a PATH-ban szereplő könyvtárakat. A könyvtárakat balról jobbra, sorrendben keresi végig, hogy megnézze, tartalmaznak-e futtatható fájlt a megadott névvel.

Ha a futtatható fájl egy ismert útvonalon kívül van, meg kell adni a fájl elérési útját. Az aktuális könyvtárban lévő myprogram futtatható fájlhoz a ./myprogram utat használd; ha a /opt/somedirectory könyvtárban van, akkor a /opt/somedirectory/myprogram utat.

Tipp: A type paranccsal részleteket tudhatsz meg a parancsról:

$ type rm
rm is hashed (/bin/rm)
# or it might return: `rm is /bin/rm`

$ type cd
cd is a shell builtin

Scriptek

A script egy fájlban tárolt parancssorozat. A bash beolvassa a fájlt, és sorrendben feldolgozza a parancsokat. Csak akkor lép tovább a következő parancsra, amikor az aktuális befejeződött. Kivétel ez alól, ha egy parancsot aszinkron (a háttérben) való futtatásra adtunk meg. Ezzel az esettel még ne foglalkozz túl sokat; később megtanuljuk, hogyan működik.

Az ebben az útmutatóban szereplő bármelyik parancssori példa használható scriptben is.

Scriptet készíteni egyszerű. Kezdd azzal, hogy létrehozol egy új fájlt, és az első sorába ezt írod:

#!/bin/bash

Ezt a sort értelmeződirektívának nevezik (más néven hashbang vagy shebang). Ez megadja, hogy a /bin/bash-t kell értelmezőként használni, amikor a fájlt egy parancsban futtatható fájlként használjuk. Amikor az operációs rendszer kernelje végrehajt egy nem bináris fájlt, beolvassa a fájl első sorát. Ha a sor #!-tal kezdődik, a kernel ezt a sort használja annak meghatározására, hogy melyik értelmezőnek adja tovább a fájlt. (Erre más érvényes módok is vannak, lásd alább.) A #!-nak a fájl legelején kell lennie, előtte nem lehet szóköz vagy üres sor. A scriptünk parancsai ez alatt, külön sorokban következnek.

Tipp: A #!/bin/bash helyett ezt is használhatod:

#!/usr/bin/env bash

Az env az első argumentumában megnevezett futtatható fájlt keresi meg a $PATH-ban (esetünkben a „bash”-t). A technika részletesebb magyarázatáért és ahhoz, hogy miben tér el a jó öreg #!/bin/bash-tól, lásd ezt a StackOverflow-kérdést.

Ne hagyd, hogy megtévesszenek az interneten található olyan scriptek vagy példák, amelyek a /bin/sh-t használják értelmezőként. A sh nem bash! A bash maga egy „sh-kompatibilis” shell, ami azt jelenti, hogy a legtöbb sh scriptet le tudja futtatni, és sok azonos szintaktikai elemet hordoz. Ez azonban fordítva nem igaz; a bash néhány funkciója elromlik vagy váratlan viselkedést okoz a sh-ban. Valójában nincs egyetlen sh shell sem. Sok olyan shell-implementáció létezik, amely támogatja a POSIX-sh szintaxist. Attól függően, hogy milyen operációs rendszered van, amikor a sh-t futtatod, valójában lehet, hogy bash, ash, dash vagy valamilyen más shell fut le.

Miután a scriptfájl elkészült, így futtathatod:

$ bash myscript

Ebben a példában a bash parancsot futtatjuk, és megmondjuk neki, hogy olvassa be a argumentumként megadott scriptet. Amikor így teszünk, a #! sor csupán egy komment.

Másik lehetőség, hogy futtatható jogosultságot adunk a scriptjeinknek. Ezzel a módszerrel úgy futtathatjuk a scriptet, mint bármely más futtatható fájlt, ahelyett hogy kézzel hívnánk meg a basht:

$ chmod +x myscript  # Mark the file as executable.
$ ./myscript         # Now, myscript can be executed directly
                     # instead of having to specify bash.

Amikor így futtatjuk a parancsot, az operációs rendszer a #! sor alapján határozza meg, melyik értelmezőt használja a script futtatásához.

Forrásmegjelölés

Ennek a leckének a tartalma a Bash Guide Commands and Arguments oldaláról származik.