A Bash-ban szkriptek írásakor nem csak a tapasztalt programozók, hanem a Bash shell újoncainak is szembe kell nézniük a karakterláncokkal való munkavégzéssel. Erre leggyakrabban akkor van szükség, amikor a felhasználó által argumentumként megadott parancsokat olvassa be egy futtatható szkriptbe, valamint feldolgozáskor szöveges fájlok. És ebben az esetben az egyik szükséges trükk a szál-összehasonlítás.

Ez a cikk megvizsgálja a Bash karakterláncok összehasonlítását, valamint az összehasonlítási műveletek használatának és a gyakori hibák megoldásának néhány árnyalatát.

Ezek a műveletek lehetővé teszik annak meghatározását, hogy az összehasonlított karakterláncok megegyeznek-e:

• = - egyenlő például ha [ "$x" = "$y" ]
• == - például az "=" operátor szinonimája if [ "$x" == "$y" ]
• != - például nem ugyanaz if [ "$x" != "$y" ]

#!/bin/bash
testuser=anton
ha [ $USER = $tesztfelhasználó ]
akkor
echo "Üdvözöljük $tesztuser"
fi

A forgatókönyv eredménye:

A paranccsal való egyenlőség ellenőrzésekor teszt(a szögletes zárójel szinonimája ) az összehasonlított karakterláncok összes írásjelét és kis- és nagybetűs különbségét figyelembe veszik.

A zsinór mintákkal való egyeztetésének néhány jellemzője:

# igazat ad vissza, ha a $x-ben lévő karakterlánc "y"-vel kezdődik
[[ $x == y* ]]
# igazat ad vissza, ha a $x karakterlánca pontosan két karakterből áll "y*"
[[ $x == "y*" ]]
# igazat ad vissza, ha a $x tartalmazza az aktuális könyvtárban található fájl nevét, amely "y"-vel kezdődik.
[ $x == y* ]
# igazat ad vissza, ha a $x karakterlánc két "y*" karakterrel egyenlő
[ "$x" == "y*" ]

Például egy bash karakterlánc ellenőrzése, hogy y-vel kezdődik-e:

#!/bin/bash
x=yandex
[[ $x == y* ]]
echo $?

A kód végrehajtásának eredménye:

A szkript 0-t (nullát) ad ki, mert az utoljára végrehajtott utasítás hibakódját kértük. A 0-s kód azt jelenti, hogy a szkript hiba nélkül futott. Valóban, a változó $x tartalmazza a karakterláncot yandex, amely "y" karakterrel kezdődik. Ellenkező esetben "1" írható. Csinos kényelmes módja script hibakeresés.

Stringek ábécé szerinti összehasonlítása a Bash nyelven

A feladat bonyolultabbá válik, ha megpróbáljuk meghatározni, hogy egy karakterlánc egy másik karakterlánc elődje-e növekvő rendezési sorrendben. Azok, akik a bash shellben írnak szkripteket, gyakran két problémába ütköznek a Linux-karakterlánc-összehasonlításokkal kapcsolatos nagyobb és kisebb műveletekkel kapcsolatban, amelyeknek meglehetősen egyszerű megoldásai vannak:

Először is, a "nagyobb, mint" és a "kisebb, mint" karaktereket meg kell szökni egy fordított perjel (\) hozzáadásával, mert ellenkező esetben a shell átirányító karakterként, a karakterláncokat pedig fájlnévként kezeli. Ez azon esetek egyike, amikor a hiba felkutatása meglehetősen nehéz.

#!/bin/bash
# a karakterlánc-összehasonlító operátorok helytelen használata
val1=baseball
val2=hoki
ha [ $val1 > $val2 ]
akkor

más

fi

Mi történik, ha összehasonlítja a bash karakterláncokat:

Mint látható, a "nagyobb, mint" szimbólum önmagában, közvetlen formájában hibás eredményeket produkált, bár hiba nem keletkezett. BAN BEN ez az eset ez a karakter okozta a kimeneti adatfolyam átirányítását, így nem találtunk szintaktikai hibát, és ennek eredményeként egy fájl jégkorong:

A hiba kijavításához el kell hagynia a ">" karaktert, hogy a feltétel így nézzen ki:

...
ha [ $val1 \> $val2 ]
...

Ekkor a program eredménye helyes lesz:

Másodszor, a "nagyobb, mint" és a "kisebb, mint" operátorokkal rendezett karakterláncok másképpen vannak elrendezve, mint a paranccsal fajta. Itt a problémákat nehezebb felismerni, és előfordulhat, hogy egyáltalán nem találkozunk velük, ha az összehasonlítás nem érzékeny a kis- és nagybetűkre. Csapatban fajtaÉs teszt Az összehasonlítás más:

#!/bin/bash
val1=Tesztelés
val2=tesztelés
ha [ $val1 \> $val2 ]
akkor
echo "$val1 nagyobb, mint $val2"
más
echo "$val1 kisebb, mint $val2"
fi

A kód eredménye:

Csapatban teszt a nagybetűs karakterláncok először megelőzik a kisbetűs karakterláncokat. De ha ugyanazt az adatot egy fájlba írják, amelyre akkor alkalmazza a parancsot fajta, akkor a kisbetűs karakterláncok lesznek az elsők:

A különbség a munkájuk között az teszt a rendezési sorrend meghatározásához a karakterek ASCII tábla szerinti elrendezését veszik alapul. BAN BEN fajta a regionális beállítások nyelvi beállításaihoz megadott rendezési sorrendet is használja.

Üres érték keresése egy karakterláncban

Összehasonlítás operátorok használatával -zÉs -n annak meghatározására szolgál, hogy egy változó tartalmaz-e tartalmat. Így üres sorokat találhat a bash-ban. Példa:

#!/bin/bash
val1=tesztelés
val2=""
# ellenőrzi, hogy a karakterlánc üres-e
ha [ -n $érték1 ]
akkor
echo "A "$val1" karakterlánc nem üres"
más
echo "A "$val1" karakterlánc üres"
fi
# ellenőrzi, hogy a karakterlánc üres-e
ha [ -z $val2 ]
akkor
echo "A "$val2" karakterlánc üres"
más
echo "A "$val2" karakterlánc nem üres"
fi
ha [ -z $val3 ]
akkor
echo "A "$val3" karakterlánc üres"
más
echo "A "$val3" karakterlánc nem üres"
fi

A kód eredménye:

Ez a példa két karakterlánc-változót hoz létre - val1És val2. Művelet -n meghatározza, hogy van-e egy változónak val1 nem nulla hosszúságú, és -z ellenőrzi val2És val3 nullára. Figyelemre méltó, hogy ez utóbbit az összehasonlítás pillanatáig nem határozták meg, de az értelmező úgy ítéli meg, hogy hossza még mindig nulla. Ezt az árnyalatot figyelembe kell venni, amikor különféle ellenőrzések forgatókönyvek. És ha nem biztos abban, hogy milyen értéket tartalmaz a változó, és hogy egyáltalán be van-e állítva, akkor ellenőrizze az operátor segítségével -n vagy -zés csak ezután használja a rendeltetésének megfelelően.

Érdemes odafigyelni a funkcióra -n. Ha egy nem deklarált vagy üres változót adunk át neki a teszteléshez, akkor igazat ad vissza, nem hamis értéket. Ilyen esetekben mellékelni kell a bejelölt karakterláncot (változót). dupla idézőjelek hogy így nézzen ki:

...
ha [ -n "$érték1" ]
...

következtetéseket

A bemutatott Bash karakterlánc-összehasonlítási műveleteknek vannak bizonyos árnyalatai, amelyeket érdemes megérteni a parancsfájl-hibák megelőzése érdekében. De a gyakorlatban sok ilyen helyzet van, így mindenre emlékezni (és még inkább leírásra) nem fog működni.

A Bash shell szkriptekben szám-összehasonlítást végezhetünk. Szám-összehasonlítási művelet végrehajtásához Bash-ban a "teszt" állapotot kell használnia egy if vagy cikluson belül. Ebben a bejegyzésben elmondjuk, hogyan lehet összehasonlítani a számokat bashban.

Operátorok a bash számok összehasonlításához

operátor	mit csinál	példa
-eq	Hasonlítsa össze a bash számjegyeit az egyenlőség érdekében, 0-t ad vissza, ha egyenlő	ha [ $a -eq $b ] akkor
-ge	a számok összehasonlítása bash-ban, ha nagyobb vagy egyenlő. Az eredmény 0-t ad vissza, ha nagyobb vagy egyenlő	ha [ $a -ge $b ] akkor
-gt	összehasonlítja a számokat bash-ban, ha nagyobb, mint.	ha [ $a -gt $b ] akkor
-le	összehasonlítja a számokat bash-ban, ha kisebb vagy egyenlő.	ha [ $a -le $b ] akkor
-lt	összehasonlítja a számokat bash-ban, ha kevesebb.	ha [ $a -lt $b ] akkor
-ne	összehasonlítja a számokat bash-ban, ha nem egyenlő vagy nem.	ha [ $a -ne $b ] akkor

Példák részletesen a Bash szám-összehasonlító operátoraira:

1. operátor-eq

Ez az operátor összehasonlítja a számokat, és ellenőrzi, hogy az érték egyenlő-e vagy sem. Ha egyenlő, akkor 0 kerül vissza.

# cat test.sh #!/bin/bash echo "adja meg a változó értékét" read a echo "adja meg a változó értékét" read b if [ $a -eq $b ] then echo "Visszatérési érték:: $?" echo "a és b egyenlő" else echo "Visszatérési érték::$?" echo "a és b nem egyenlőek" fi #

Végrehajtás:

# sh test.sh adja meg a változó értékét 2 adja meg a változó értékét 3. Visszatérési érték:: 1 a és b nem egyenlő # sh test.sh adja meg a változó értékét 2 adja meg a változó értékét 2. Visszatérési érték: 0 a és b egyenlő #

A fenti példában először vettük a 2-es és a 3-as számokat, és a rendszer 1-et adott vissza, azonban ha a és b-hez ugyanazt az értéket vettük, a változó nullát ad vissza.

2. operátor-ge

Ez az operátor összehasonlítja a számokat, és ellenőrzi a nagyobb vagy egyenlő értékeket. Ha az érték nagyobb vagy egyenlő, akkor a visszatérési értéke 0.

# cat test1.sh #!/bin/bash #diff program for -ge echo "adja meg a változó értékét" read a echo "adja meg a b változó értékét" read b if [ $a -ge $b ] then echo "visszatér : :$?" echo "a nagyobb vagy egyenlő, mint b" else echo "visszatérési érték::$?" echo "a nem nagyobb vagy egyenlő b-vel" fi #

3. operátor -gt

Ez a szám-összehasonlító operátor azt teszteli, hogy a szám nagyobb-e. Ha az érték nagyobb, akkor 0-t ad vissza.

# cat test2.sh #!/bin/bash #differ for -gt b=100 echo "Adjon meg 100-nál nagyobb értéket" read a if [ $a -gt $b ] then echo "Nagyon jó" else echo "Nem nagyon jó "fi

4. operátor-le

Ez a szám-összehasonlító operátor a kisebb vagy egyenlő értékeket teszteli. Ha kisebb vagy egyenlő, akkor a visszatérési érték 0.

#diff program -le b=5 echo "5-nél kisebb vagy egyenlő értéket adjon meg" beolvassa a if [ $a -le $b ] then echo "helyes" else echo "false" fi #

5. operátor-lt

Ez a szám-összehasonlító operátor alacsonyabb áron teszteli az értékeket. Ha a szám kisebb, akkor a visszatérési érték 0.

ha-más feltétel BASH szkriptekben használják Gyakran. Magának a feltételnek van egy kissé furcsa formája [[ feltétel ]]. Ügyeljen a behúzásokra. Ezek nélkül az állapot nem fog működni. hozom a listát logikai operátorok feltételhez [[ ? ]]:

Azon logikai operátorok listája, amelyek
az if-then-else-fi konstrukcióhoz használjuk

#!/bin/bash, ha [[ $1 > 2 ]], akkor #, ha [[ ? ]] echo $1" nagyobb, mint 2" else # ha nem igaz echo $1" kisebb, mint 2 vagy 2" fi

Néhányan furcsának találják az egyenlőség operátort -eq. Próbáljon ismerős > operátorokat használni

Tegyük fel, hogy van egy szkriptje, és felhasználói ellenőrzés szükséges. Ha a felhasználó nem root, akkor a szkript leáll.

#!/bin/bash if [ "$(whoami)" != "root" ]; majd echo "Nincs engedélye a $0 futtatására." kilépés1; fi

Gyakran egy változót kell ellenőriznie egy értékhez. Ha a változóban nincs semmi, akkor leállíthatja a szkriptet.

#!/bin/bash if [ -n "$szám" ]; akkor "a változóban van valami, és elindíthat egy másik folyamatot" else echo "üres változó, állítsa le a szkriptet" exit 0; fi

Ha a változó üres, akkor kitölthető.

#!/bin/bash if [ -z "$szám" ]; akkor echo "változó üres" num=1 else echo "num="$num fi

Egy üres változóhoz alapértelmezett érték rendelhető. Ez a bejegyzés rövidebb, mint az előző példában.

#!/bin/bash # Írjon DEFAULT ha argumentumot parancs sor hiányzik [ -z "$arg1" ] && arg1=DEFAULT echo $arg1

A karakterláncok összehasonlítása a Bash-ban nem okoz gondot mindaddig, amíg fel nem merül a feladat, hogy két karakterláncot a kis- és nagybetűk megkülönböztetése nélkül hasonlítsanak össze. Több lehetőséget adok a probléma megoldására, amelyeket magam is használok. Ezen megoldások egyik jellemzője, hogy csak a Bash shell beépített szolgáltatásait használják.

Először létrehozok két str1 és str2 változót, amelyek az összehasonlítandó karakterláncokat tartalmazzák. A következő kódpéldákban ezeket fogjuk használni.

#!/bin/bash str1 = "Összehasonlítandó karakterlánc" str2 = "összehasonlítandó karakterlánc"

A kis- és nagybetűket nem érzékeny karakterlánc-összehasonlítás első verziója, amelyet javasolni szeretnék, a shell opciók vezérlését használja a beépített shopt paranccsal.

shopt -s nocasematch [[ $str1 == $str2 ]] && echo "match" || echo "nem egyezik" shopt -u nocasematch

A kis- és nagybetűket nem érzékeny karakterlánc-összehasonlítás következő verziója a karakterláncok közös esetbe öntésének elvén alapul. Ez a kódváltozat a Bash 4-es és újabb verzióin működik. Többre használja korai változat A Bash hibát fog dobni.

Tehát a kisbetűs karakterláncok összehasonlításához használhatja a következő kódot.

[[ " $( str1 , ) " == " $( str2 , ) " ]] && echo "egyezik" || echo "nem egyezik"

Ha át szeretné adni az összehasonlított karakterláncokat nagybetűs, akkor használhatja a következő kódot.

[[ " $( str1 ^^ ) " == " $( str2 ^^ ) " ]] && echo "egyezik" || echo "nem egyezik"

Mint alternatív, a karakterláncok egyetlen esetre kényszerítése végrehajtható a változók deklarálásakor. Ez a beépített deklarációs shell paranccsal történik.

Kisbetűs szöveget tartalmazó változó deklarálásához használja a következő kódot.

#!/bin/bash deklar -l str = "Camel Case String"

Ennek a kódnak a végrehajtása következtében az str változó kisbetűs karakterláncot fog tartalmazni, annak ellenére, hogy a hozzárendelt karakterlánc tevebetűvel íródott. A változóban már beállított karakterlánc kis- és nagybetűjét az alábbiak szerint módosíthatja.

#!/bin/bash str = "Camel Case String" deklarál -l str str = $str echo $str

Egy karakterlánc nagybetűssé alakításához a fenti kódpéldában módosítsa a hívást a deklarációs parancsra, a -l kapcsoló helyett a -u kapcsolóval.

Most egy kis- és nagybetűt nem érzékeny karakterlánc-összehasonlítás a deklarációs paranccsal a következőképpen végezhető el.

deklarál -l str1_l = $str1 deklarál -l str2_l = $str2 [[ $str1_l == $str2_l ]] && echo "egyezik" || echo "nem egyezik"

A kis- és nagybetűket nem érzékeny karakterlánc-összehasonlítások bármelyike ​​használható a Bash-szkriptekben. Ezért ha a Bash 4-es vagy újabb verzióját használja, kiválaszthatja azt, amelyik a legjobban tetszik. Ha a Bash verzió kisebb, mint 4, akkor az első opciót kell használni, megadva a nocasematch opciót a beépített shopt shell használatával.

Ez a téma a bash shell nyelvi sorozat negyedik témája. Beszélni fog a nyelv olyan szabályozási struktúráiról, mint a feltételes állításokról. De mielőtt a leírásukhoz folytatnánk, meg kell határozni néhány árnyalatot, amelyek érthetőbbé teszik az alábbi anyag megfontolását.
Először is nézzük meg, mi az a parancslista. A parancslista egyetlen parancs, folyamatsor vagy parancsok/folyamatok sorozata, amelyet a következő operátorok egyike választ el egymástól: ";", "&&", "||", pontosvesszővel végződik.
; - több parancs szekvenciális végrehajtásának operátora. Minden további parancs végrehajtása csak az előző befejezése után indul el (akár sikeres, akár nem);
&& - parancs végrehajtási operátor csak az előző sikeres végrehajtása után;
|| - utasítás egy parancs végrehajtására csak az előző hibás végrehajtása után.
Kód sikeres teljesítés 0, és hibás - nem nulla (a hiba típusától függően). Nem tévesztendő össze az általános programozási nyelvekkel, amikor az 1 igaz és a 0 hamis.
Most folytathatjuk a feltételes állítások közvetlen figyelembevételét.

esetváltozat operátor

Az esetleírás általános szintaxisa a következő:

eset értéke in
sablon1) lista1;;
minta2 | sablon3) lista2;;
esac

Az eset utasítás végrehajtásának logikai sorrendje:
a) megkeresi az értéknek megfelelő első mintát;
b) ha megtalálják, akkor a hozzá tartozó parancsok listája végrehajtásra kerül, ";;"-vel zárva;
c) az irányítás átadásra kerül az üzemeltetőkre az esetkonstrukciót követően.
A mintát és a listát a ")" karakter választja el. Egy parancslistának több feltétel is megfelelhet, ebben az esetben ezeket a "|" szimbólummal kell elválasztani.
A sablonokban használhatja a "*", "?", "" karaktereket, amelyeket a ciklus második témakörében ismertettünk. Segítségükkel olyan utasítást valósíthat meg, amely alapértelmezettként működik az olyan nyelvek switch utasításában, mint a C, PHP.
Mondok egy példát az eset használatára:
echo -n "[Universal Viewer] Fájlnév megadása: "; olvassa el a fájl kis- és nagybetűjét "$File" a *.jpg|*.gif|*.png-ben) eog $File ;; *.pdf) evince $File ;; *.txt) kevesebb $Fájl ;; *.html) firefox $Fájl ;; /dev/*) echo "Nos, ezek ijesztő fájlok." ;; *) echo "Ok, ok - nem olyan sokoldalú." echo "Nem ismerem ezt a fájltípust. Nem tudom, hogyan kell megnézni." ;; esac
Egy másik példa az esetkonstrukció használatára:
echo "Hiba. Kinek küldjem el az üzenetet?" echo "Főnöknek: b" echo "Kollégáknak: c" echo "Senkinek: bármilyen kulcs" read válasz eset $válasz b|B) mail –s "hibanapló" boss< error.log;; c|C) mail –s "Help! error log" –c denis nick < error.log;; *) echo "error"; exit;; esac

Feltételes operátor ha

Az if utasítás általános szintaxisa a következő:

ha lista1 akkor
lista2

fi

A szögletes zárójelek az opcionális konstrukciókat jelölik. Az eset utasítás végrehajtásának logikai sorrendje:
a) a lista1 végrehajtásra kerül;
b) ha hiba nélkül fut le, akkor a lista2 kerül végrehajtásra. Ellenkező esetben a list3 végrehajtásra kerül, és ha hiba nélkül fejeződik be, akkor a list4. Ha a list3 is hibakódot ad vissza, a list5 végrehajtásra kerül;
c) az irányítás átadásra kerül az operátorokhoz az if konstrukciót követően.
Mondok egy példát a használatára, ha:
if grep -q Bash fájl akkor echo "A fájl legalább egy Bash szót tartalmaz." fi
Ha az if és akkor egy sorban vannak, akkor az if és akkor konstrukcióknak pontosvesszővel kell végződniük. Például:
$if[$? –ne0]; majd echo "Error"; fi
Most, tudva, hogy az if és akkor is ugyanabba a sorba kerülhet, írjuk át a fenti példát:
if grep -q Bash fájl; majd echo "A fájl tartalmazza a Bash szót." fi

teszt utasítás és feltételes kifejezések

A fenti példában a kilépési kód elemzése helyett állapotellenőrzést használunk. Egy ilyen teszt két formája egyenértékű: a teszt beépített parancs és a [feltétel]. Például annak ellenőrzéséhez, hogy létezik-e fájl, a következőket kell írnia:
teszt -e<файл>
vagy
[-e<файл> ]
Ha szögletes zárójelet használunk, akkor azokat szóközzel kell elválasztani egymástól, mert a „[” a parancs neve, a „]” pedig a parancs befejezéséhez szükséges utolsó argumentum.
A feltétel sikeres ellenőrzése esetén 0-t ad vissza, ha pedig hamis, a hibakód 1.
A tesztparancs ellenőrizheti, hogy egy karakterlánc üres-e. A nem üres karakterlánc 0 kilépési kódot eredményez. Üres, illetve - 1. Például:
$ teszt $USER; echo $? 0
A "" konstrukció sokoldalúbb, mint a "". A tesztparancsnak ez a kiterjesztett változata. Ezen a konstrukción belül nem történik meg a fájlnevek további értelmezése, és az argumentumok külön szavakra való felosztása, de a paraméterek és parancsok helyettesítése megengedett. Például:
file=/etc/passwd if [[ -e $file ]] akkor echo „Jelszófájl található”. fi
A "" konstrukció előnyösebb, mint a "", mert segít elkerülni néhány logikai hibát. Például az "&&", "||", "" operátorok<" и ">"belül "" tökéletesen érvényes, míg a "" belsejében hibaüzeneteket generál.
A "(())" konstrukció lehetővé teszi a benne lévő számtani kifejezések kiszámítását. Ha a számítás eredménye nulla, akkor hibakódot ad vissza. A számítás nullától eltérő eredménye 0 visszatérési kódot ad. Vagyis a fent tárgyalt teszt és "" utasítások pont az ellenkezője.
Az if utasítás lehetővé teszi a beágyazott ellenőrzéseket:
if echo "A következő *if* az első *if*-on belül van." if [[ $összehasonlítás = "egész szám" ]] then ((a< b)) else [[ $a < $b ]] fi then echo "$a меньше $b" fi

A feltételes kifejezések kombinálhatók reguláris kifejezésekkel. logikai műveletek:
! <выражение>- tagadás;
<выражение1>-a<выражение2>- logikai ÉS;
<выражение1>–o<выражение2>- logikai VAGY.

Elemi feltételes kifejezések fájlokhoz:
-e - fájl létezik;
-f - normál fájl (nem könyvtár- vagy eszközfájl);
-s - nem nulla fájlméret;
-d - a fájl egy könyvtár;
-b - a fájl egy blokkeszköz (floppy, cdrom stb.);
-c - a fájl egy karaktereszköz (billentyűzet, modem, hangkártya stb.);
-p - a fájl egy cső;
-h - a fájl szimbolikus hivatkozás;
-L - a fájl egy szimbolikus hivatkozás;
-S - a fájl egy socket;
-t - a fájl termináleszközhöz van társítva;
-r - a fájl olvasható (a szkriptet elindító felhasználó számára);
-w - a fájl írható (a parancsfájlt futtató felhasználó számára);
-x - a fájl végrehajtható (a szkriptet elindító felhasználó számára);
-g - (sgid) a fájl vagy könyvtár jelzője be van állítva;
-u - (suid) a fájl jelzője be van állítva;
-k - ragadós bitjelző be van állítva;
-O - ​​Ön a fájl tulajdonosa;
-G - ugyanabba a csoportba tartozol, mint a fájl;
-N - a fájl az utolsó olvasás óta módosult;
fájl1 -nt fájl2 – a fájl1 újabb, mint a fájl2;
fájl1 -ot fájl2 – a fájl1 régebbi, mint a fájl2;
fájl1 -ef fájl2 - fájl1 és fájl2 kemény hivatkozások ugyanahhoz a fájlhoz.

Elemi feltételes kifejezések karakterláncok összehasonlításához:
-z string – a karakterlánc hossza 0;
-n string – a karakterlánc hossza nem egyenlő 0-val;
string1 == string2 – a karakterláncok egyeznek (hasonlóan a „=”-hez);
sor1 !== sor2 – a sorok nem egyeznek (hasonlóan a „!=”-hoz);
sor1< строка2 – строка1 предшествует строке2 в лексикографическом порядке;
sor1 > sor2 - az 1. sor lexikográfiai sorrendben követi a 2. sort.
Egy aritmetikai feltételes kifejezés formátuma:
argument1 művelet argumentum2, ahol az argumentumok egész számok, és a következő műveletek engedélyezettek:
-eq - egyenlő;
-ne - nem egyenlő;
-lt - kevesebb;
-le - kisebb vagy egyenlő;
-gt - több;
-ge - nagyobb vagy egyenlő;
< - меньше (внутри двойных круглых скобок);
<= - меньше или равно (внутри двойных круглых скобок);
> - nagyobb, mint (kettős zárójelben);
>= - nagyobb vagy egyenlő (kettős zárójelben).

Írjuk át az előző példát if utasítással:
echo "Hiba. Kinek küldjem el az üzenetet?" echo "Főnöknek: b" echo "Kollégáknak: c" echo "Senkinek: bármilyen kulcs" read válasz if [ "$answer" == "b" –o "$answer" == "B" ]; majd mail –s "hibanapló" főnök< error.log; elif [ "$answer" == "c" –o "$answer" == "C" ]; then mail –s "Help! error log" –c denis nick < error.log; else echo "error"; exit; fi

A következő témakörben továbbra is a bash shell vezérlési struktúráival foglalkozom. Nevezetesen a hurokoperátorokat veszik figyelembe. És most várom a kommenteket és a kritikákat :).

UPD: Köszönet a felhasználónak