Använd Bash if…else Statement

Grenar i Bash kör ofta fel sökväg när strängjämförelser använder den numeriska operatorn-eqeller när variabler lämnas utan citat. Byter till Bash's[[ ]]test med rätt operatörer fixar dessa logiska fel och gör skript lättare att underhålla.

Metod 1: Skriv om ... annat med Bash[[ ]](strängar, siffror och filer)

Steg 1:Skapa ett nytt skript och lägg till ett minimalt villkor med den moderna Bash-testsyntaxen[[ ]]. Denna form undviker oavsiktlig globexpansion och orddelning, vilket minskar överraskande beteende jämfört med enkla parenteser.

#!/usr/bin/env bash
set -euo pipefail

read -r -p "Enter a value: " val

if [[ "$val" == "admin" ]]; then
  echo "Welcome, admin."
else
  echo "Access limited."
fi

Steg 2:Jämför strängar med==eller!=. Citera variabler för att förhindra att tomma värden och mellanslag bryter dina tester. Detta förhindrar oavsiktliga matchningar orsakade av expansioner utan citat.

user="alice"
target="alice"

if [[ "$user" == "$target" ]]; then
  echo "Usernames match."
else
  echo "Usernames differ."
fi

Steg 3:Använd numeriska operatorer för heltal inuti[[ ]]:-eq,-ne,-gt,-ge,-lt,-le. Dessa fungerar endast på siffror och undviker lexikografiska jämförelser.

read -r -p "Enter a number: " n

if [[ "$n" -gt 10 ]]; then
  echo "Greater than 10."
elif [[ "$n" -eq 10 ]]; then
  echo "Equal to 10."
else
  echo "Less than 10."
fi

Steg 4:Kontrollera filer med filtestoperatörer. Dessa hjälper dig att förgrena dig baserat på filsystemets tillstånd utan att köra externa kommandon.

• -f path: vanlig fil finns.
• -d path: katalogen finns.
• -e path: sökväg finns (vilken typ som helst).
• -x path: körbar fil finns.
• -r path/-w path: läsbar / skrivbar.

path="./data.txt"

if [[ -f "$path" ]]; then
  echo "File exists."
else
  echo "Creating file..."
  : > "$path"
fi

Steg 5:Kombinera villkor med&&(OCH),||(ELLER), och!(INTE). Gruppera dem med parenteser för tydlighet och korrekt företräde.

file="./report.log"
size=5

# True when the file exists AND size is at least 5
if [[ -f "$file" ]] && [[ "$size" -ge 5 ]]; then
  echo "Process report."
fi

# True when user is admin OR staff
role="staff"
if [[ "$role" == "admin" || "$role" == "staff" ]]; then
  echo "Privileged."
fi

# Negation: path exists but is not a directory
if [[ -e "$file" && ! -d "$file" ]]; then
  echo "Path is not a directory."
fi

Steg 6:Användaeliftill kortslutningskontroller. När ett villkor är sant, hoppas senare grenar över, vilket påskyndar utvärderingen och minskar onödiga kommandon.

status="warning"

if [[ "$status" == "error" ]]; then
  echo "Exit immediately."
  exit 1
elif [[ "$status" == "warning" ]]; then
  echo "Log and continue."
else
  echo "All good."
fi

Metod 2: Jämför heltal med(( ))aritmetisk utvärdering

Steg 1:Använd aritmetiska sammanhang för numerisk logik. Inuti(( )), du kan skriva matematikliknande jämförelser (<,>,==) utan att citera variabler. Detta är kortfattat och snabbt för kontroller av enbart heltal.

a=12 b=8

if (( a > b )); then
  echo "a is larger."
elif (( a == b )); then
  echo "Equal."
else
  echo "b is larger."
fi

Steg 2:Kombinera booleska operatorer direkt i aritmetiska sammanhang. Detta minskar plattan vid utvärdering av flera numeriska förhållanden.

x=7 y=3 z=10

if (( (x > y) && (z >= 10) )); then
  echo "Threshold met."
fi

Steg 3:Validera indata. Aritmetiska sammanhang behandlar icke-numeriska värden som noll. Om inmatningen kan vara icke-numerisk, skydda den med ett regextest in[[ ]]innan man utvärderar.

read -r n
if [[ "$n" =~ ^-?[0-9]+$ ]] && (( n >= 0 )); then
  echo "Non-negative integer."
else
  echo "Invalid number."
fi

Metod 3: Använd POSIX-portable[ ]för bredare skalkompatibilitet

Steg 1:Föredrar enkla parenteser när du riktar in skal bortom Bash (t.ex./bin/sh). Kom ihåg det[är ett kommando: mellanslag och citat krävs.

#!/bin/sh

a="hello"
b="hello"

if [ "$a" = "$b" ]; then
  echo "Match."
else
  echo "No match."
fi

Steg 2:Använd numeriska operatorer för heltal och citattecken för att förhindra orddelning. Detta undviker buggar när variabler är tomma eller innehåller mellanslag.

a=5
b=30

if [ "$a" -lt "$b" ]; then
  echo "a is less than b."
fi

Steg 3:När man gör lexikografiska strängjämförelser med<eller>, undkomma operatörerna för att förhindra omdirigering. Många fel beror på att man glömmer detta.

x="apple" y="banana"

if [ "$x" < "$y" ]; then
  echo "apple comes before banana."
fi

Steg 4:Använd filtester på samma sätt som i[[ ]], men håll allt citerat för att undvika kantfall.

file="./cfg.ini"
if [ -r "$file" ] && [ -w "$file" ]; then
  echo "Config is readable and writable."
fi

Metod 4: Byt ut långa kedjor motcaseför värdebaserad förgrening

Steg 1:Användacaseför att förenkla flera likhetskontroller av en enda variabel. Detta minskar kapsladeifblockerar och förbättrar läsbarheten och hastigheten vid matchning av mönster.

read -r -p "Enter mode (start|stop|status): " mode

case "$mode" in
  start)  echo "Starting...";;
  stop)   echo "Stopping...";;
  status) echo "Service is running.";;
  *)      echo "Unknown mode."; exit 1;;
esac

Steg 2:Matcha flera mönster enkelt. Detta håller din logik kompakt och undviker upprepade variabeljämförelser.

level="warn"

case "$level" in
  error|err)  echo "Exit with failure."; exit 1;;
  warn|warning) echo "Log warning.";;

  info|debug) echo "Proceed normally.";;
  *)          echo "Unrecognized level.";;
esac

Metod 5: Testa flera villkor korrekt och felsöka fel

Steg 1:Gruppera boolesk logik för att återspegla din sanningstabell. Till exempel, "kräver Z eller både X och Y" blirif [[ "$Z" == "TRUE" || ( "$X" == "TRUE" && "$Y" == "TRUE" ) ]]. Parenteser förtydligar prioritet och förhindrar subtila buggar.

X="TRUE" Y="FALSE" Z="TRUE"

if [[ "$Z" == "TRUE" || ( "$X" == "TRUE" && "$Y" == "TRUE" ) ]]; then
  echo "Conditions met."
else
  echo "Conditions not met."
fi

Steg 2:Välj rätt operatörer. Använda==för strängar och-eqför heltal. Att blanda dem orsakar felaktiga grenar (t.ex. sträng jämfört med-eqmisslyckas alltid).

Steg 3:Citera variabla expansioner i tester, speciellt med enkla parenteser. Citering undviker krascher när variabler är tomma och förhindrar expansion av jokertecken mot filsystemposter.

Steg 4:Spåra logik när resultaten ser fel ut. Aktivera xtrace för att se varje utökat kommando och tillstånd när Bash utvärderar det.

#!/usr/bin/env bash
set -x  # turn on trace
# ... your conditionals here ...
set +x  # turn off trace

Steg 5:Håll skript konsekventa och läsbara. Dra in kroppen underthen/else, lämna mellanrum runt parenteser och gynna tidiga utgångar på felgrenar för att minska häckningen.

Referens: Vanliga testoperatörer i korthet

Den här snabblistan hjälper dig att välja rätt operatör för jobbet.

• Strängar:==,!=,-n var(längd > 0),-z var(tömma).
• Heltal:-eq,-ne,-gt,-ge,-lt,-le; eller använda(( ))med<,>,==.
• Filer:-f(regelbunden),-d(katalog),-e(finns),-x(körbar),-r(läsbar),-w(skrivbar).
• Logik:&&(OCH),||(ELLER),!(INTE); grupp med( ... )inuti[[ ]].

Med rätt testformulär, korrekta operatorer och konsekvent citering, exekverar dina Bash-villkor den avsedda grenen varje gång. Hålla[[ ]]för Bash-skript, använd(( ))för matematik, och falla tillbaka till[ ]endast när portabilitet är ett måste.

Se även:Felkod 0-2031 (17002) Microsoft Office-installationsproblem