Bash
Voorwaardelijke uitdrukkingen

Syntaxis

• [[-OP $ bestandsnaam]]
• [[$ file1 -OP $ file2]]
• [[-z $ string]]
• [[-n $ string]]
• [["$ string1" == "$ string2"]]
• [["$ string1" == $ patroon]]

Opmerkingen

Bestandsvergelijking

if [[ $file1 -ef $file2 ]]; then
  echo "$file1 and $file2 are the same file"
fi

"Zelfde bestand" betekent dat het wijzigen van een van de bestanden op de andere van invloed is. Twee bestanden kunnen hetzelfde zijn, zelfs als ze verschillende namen hebben, bijvoorbeeld als het harde koppelingen zijn, of als ze symbolische koppelingen met hetzelfde doel zijn, of als de ene een symbolische koppeling is die naar de andere verwijst.

Als twee bestanden dezelfde inhoud hebben, maar ze verschillende bestanden zijn (zodat het wijzigen van de ene de andere niet beïnvloedt), meldt -ef ze als verschillend. Als u twee bestanden byte voor byte wilt vergelijken, gebruikt u het hulpprogramma cmp .

if cmp -s -- "$file1" "$file2"; then
  echo "$file1 and $file2 have identical contents"
else
  echo "$file1 and $file2 differ"
fi

Gebruik het hulpprogramma diff om een voor mensen leesbare lijst met verschillen tussen tekstbestanden te maken.

if diff -u "$file1" "$file2"; then
  echo "$file1 and $file2 have identical contents"
else
  : # the differences between the files have been listed
fi

Toegangstests voor bestanden

if [[ -r $filename ]]; then
  echo "$filename is a readable file"
fi
if [[ -w $filename ]]; then
  echo "$filename is a writable file"
fi
if [[ -x $filename ]]; then
  echo "$filename is an executable file"
fi

Deze tests houden rekening met machtigingen en eigendom om te bepalen of het script (of programma's die vanuit het script zijn gestart) toegang hebben tot het bestand.

Pas op voor race-omstandigheden (TOCTOU) : alleen omdat de test nu slaagt, betekent niet dat deze nog steeds geldig is op de volgende regel. Het is meestal beter om te proberen toegang te krijgen tot een bestand en de fout af te handelen, in plaats van eerst te testen en dan de fout toch af te handelen voor het geval het bestand ondertussen is gewijzigd.

Numerieke vergelijkingen

Numerieke vergelijkingen maken gebruik van de -eq operators en vrienden

if [[ $num1 -eq $num2 ]]; then
  echo "$num1 == $num2"
fi
if [[ $num1 -le $num2 ]]; then
  echo "$num1 <= $num2"
fi

Er zijn zes numerieke operatoren:

• -eq gelijk
• -ne gelijk
• -le minder of gelijk
• -lt Minder dan
• -ge groter of gelijk
• -gt groter dan

Merk op dat de operatoren < en > in [[ … ]] tekenreeksen vergelijken, geen getallen.

if [[ 9 -lt 10 ]]; then
  echo "9 is before 10 in numeric order"
fi
if [[ 9 > 10 ]]; then
  echo "9 is after 10 in lexicographic order"
fi

De twee zijden moeten getallen zijn die in decimalen zijn geschreven (of in octaal met een voorloopnul). U kunt ook de syntaxis van de ((…)) rekenkundige uitdrukking gebruiken, die gehele berekeningen uitvoert in een C / Java / ... -achtige syntaxis.

x=2
if ((2*x == 4)); then
  echo "2 times 2 is 4"
fi
((x += 1))
echo "2 plus 1 is $x"

Stringvergelijking en matching

Stringvergelijking gebruikt de operator == tussen aanhalingstekens . De operator != Negeert de vergelijking.

if [[ "$string1" == "$string2" ]]; then
  echo "\$string1 and \$string2 are identical"
fi
if [[ "$string1" != "$string2" ]]; then
  echo "\$string1 and \$string2 are not identical"
fi

Als de rechterkant niet wordt geciteerd, is dit een jokerteken waarmee $string1 wordt vergeleken.

string='abc'
pattern1='a*'
pattern2='x*'
if [[ "$string" == $pattern1 ]]; then
  # the test is true
  echo "The string $string matches the pattern $pattern"
fi
if [[ "$string" != $pattern2 ]]; then
  # the test is false
  echo "The string $string does not match the pattern $pattern"
fi

De operatoren < en > vergelijken de reeksen in lexicografische volgorde (er zijn geen reeksen kleiner of gelijk of groter of gelijk voor reeksen).

Er zijn unaire tests voor de lege string.

if [[ -n "$string" ]]; then
  echo "$string is non-empty"
fi
if [[ -z "${string// }" ]]; then
  echo "$string is empty or contains only spaces"
fi
if [[ -z "$string" ]]; then
  echo "$string is empty"
fi

Hierboven kan de -z check betekenen dat $string is ingesteld, of is ingesteld op een lege string. Gebruik het volgende om onderscheid te maken tussen leeg en uitgeschakeld.

if [[ -n "${string+x}" ]]; then
    echo "$string is set, possibly to the empty string"
fi
if [[ -n "${string-x}" ]]; then
    echo "$string is either unset or set to a non-empty string"
fi
if [[ -z "${string+x}" ]]; then
    echo "$string is unset"
fi
if [[ -z "${string-x}" ]]; then
    echo "$string is set to an empty string"
fi

waar x willekeurig is. Of in tabelvorm :

                        +-------+-------+-----------+
            $string is: | unset | empty | non-empty |
+-----------------------+-------+-------+-----------+
| [[ -z ${string} ]]    | true  | true  | false     |
| [[ -z ${string+x} ]]  | true  | false | false     |
| [[ -z ${string-x} ]]  | false | true  | false     |
| [[ -n ${string} ]]    | false | false | true      |
| [[ -n ${string+x} ]]  | false | true  | true      |
| [[ -n ${string-x} ]]  | true  | false | true      |
+-----------------------+-------+-------+-----------+

Als alternatief kan de status worden gecontroleerd in een case-statement:

case ${var+x$var} in
  (x) echo empty;;
  ("") echo unset;;
  (x*[![:blank:]]*) echo non-blank;;
  (*) echo blank
esac

Waar [:blank:] locale-specifieke horizontale spatietekens zijn (tab, spatie, enz.).

Bestandstests

De voorwaardelijke operator -e test of een bestand bestaat (inclusief alle bestandstypen: mappen, enz.).

if [[ -e $filename ]]; then
  echo "$filename exists"
fi

Er zijn ook tests voor specifieke bestandstypen.

if [[ -f $filename ]]; then
  echo "$filename is a regular file"
elif [[ -d $filename ]]; then
  echo "$filename is a directory"
elif [[ -p $filename ]]; then
  echo "$filename is a named pipe"
elif [[ -S $filename ]]; then
  echo "$filename is a named socket"
elif [[ -b $filename ]]; then
  echo "$filename is a block device"
elif [[ -c $filename ]]; then
  echo "$filename is a character device"
fi
if [[ -L $filename ]]; then
  echo "$filename is a symbolic link (to any file type)"
fi

Voor een symbolische link, behalve -L , zijn deze tests van toepassing op het doel en worden false geretourneerd voor een verbroken link.

if [[ -L $filename || -e $filename ]]; then
  echo "$filename exists (but may be a broken symbolic link)"
fi

if [[ -L $filename && ! -e $filename ]]; then
  echo "$filename is a broken symbolic link"
fi

Test op exitstatus van een opdracht

Exit status 0: success
Andere status dan 0: fout

Om de uitgangsstatus van een opdracht te testen:

if command;then
    echo 'success'
else
    echo 'failure'
fi

Eén voeringstest

Je kunt dit soort dingen doen:

[[ $s = 'something' ]] && echo 'matched' || echo "didn't match"
[[ $s == 'something' ]] && echo 'matched' || echo "didn't match"
[[ $s != 'something' ]] && echo "didn't match" || echo "matched"
[[ $s -eq 10 ]] && echo 'equal' || echo "not equal"
(( $s == 10 )) && echo 'equal' || echo 'not equal'

Eén voeringstest voor uitgangsstatus:

command && echo 'exited with 0' || echo 'non 0 exit'
cmd && cmd1 && echo 'previous cmds were successful' || echo 'one of them failed'
cmd || cmd1 #If cmd fails try cmd1