Hur Linux-utgångskoder hjälper dig att skriva robusta skript

Lär dig hur exitkoder i Linux, med 0 för framgång och icke-noll för misslyckande, kan förbättra styrning av skript och programflöden.

Sammanfattning

• Varje Linux-kommando returnerar en exitkod, där 0 indikerar framgång och icke-nollvärden indikerar misslyckande.
• Du kan använda variabeln $? för att få tillgång till exitkoden och styra programflödet i skript.
• Var försiktig med okonventionella exitkoder som varierar mellan kommandon, som diff och curl.

Varje Linux-kommando kommer att skriva ut felmeddelanden om det misslyckas, men denna information är svår att förlita sig på. Dina skript bör använda exitkoder för att bli så robusta som möjligt.

Vad är exitkoder?

När du kör ett Linux-kommando kan det misslyckas. Saker kan gå fel av olika skäl, men du kommer vanligtvis att se ett meddelande som förklarar varför:

Felmeddelandet du ser visas på STDERR, en annan ström än STDOUT, vilket gör att du kan isolera fel från förväntad utdata. Som användare bör en beskrivning av felet vara informativ, men skript och andra automatiserade processer behöver känna till fel mer pålitligt.

Utöver läsbara felmeddelanden returnerar varje kommando också en exitkod. Detta är ett nummer mellan 0 och 255 som indikerar om kommandot misslyckades eller lyckades. Som standard döljs exitkoden, men din shell ger tillgång till detta värde i den speciella variabeln $?

Notera att ett värde på 0 indikerar framgång och ett icke-nollvärde betyder misslyckande. Du kan kontrollera detta värde på kommandoraden, fråga om det i ett skript och använda det för att styra flödet av dina program.

Hur använder jag exitkoder?

I exemplet ovan returnerade ls en 0 exitkod när det lyckades och en 1 när dess argument inte var en giltig fil. Detta kan verka kontraintuitivt, och det motsäger typiska programmeringsspråk som behandlar 0 som ett falskt värde och 1 som sant. Men denna uppsättning möjliggör ett enda, universellt framgångsvärde och ett brett spektrum av värden för att representera olika feltyper.

Utöver att echoa variabeln $? för att manuellt kontrollera exitstatus, kan du använda den med ett villkorsuttryck i if-satsen. Om kommandot returnerar en 0 exitstatus kommer uttalandet att köra den associerade then-blocket. Annars, om det finns ett, kommer det att köra else-blocket. Till exempel:

if command; then echo "kommandot lyckades"; else echo "kommandot misslyckades"; fi

Du kan använda denna konstruktion i ett shell-skript, där det är lite lättare att format för läsbarhet:

if command
 then echo "kommandot lyckades"
 else echo "kommandot misslyckades"
fi

Detta är ekvivalent med:

command

if [ $? -eq 0 ]
 then echo "kommandot lyckades"
 else echo "kommandot misslyckades"
fi

Den längre versionen använder hakparentessyntax för att testa värdet av $?, men det är vanligtvis lättare att testa värdet direkt, som i det första fallet. Kom ihåg att $? alltid representerar exitkoden från det senaste kommandot, så var försiktig. Du kan frestas att skriva ut värdet av $? för felsökning, t.ex.

command

echo "kommandot returnerade exitkod:" $?

if [ $? -eq 0 ]
 then echo "kommandot lyckades"
 else echo "kommandot misslyckades"
fi

Men, vid tidpunkten för villkorskontrollen, kommer $? att ha värdet av echos exitstatus, vilket nästan garanteras att vara 0. För att undvika detta, testa antingen kommandot direkt i villkoret eller lagra värdet av $? i en variabel.

Vad mer ska jag veta om exitstatus?

Exitkoder är ganska enkla och följer Unix-principen, och detta är en del av deras styrka. Men det finns några fallgropar och exceptionella fall du bör vara medveten om.

Exitkoder från din shell

Din shell kommer att använda exitkoder även när kommandot du skriver inte körs korrekt. Till exempel använder zsh och bash 127 om kommandot inte hittas och 126 om kommandot inte är körbart:

Okonventionella exitkoder

Vissa kommandon böjer reglerna för exitstatus något; de är egentligen bara konventioner. Till exempel använder diff ett värde på 0 för att betyda "inga skillnader," ett värde på 1 för att betyda "skillnader," och ett värde på 2 för att representera ett fel:

Detta kan förvirra betydelsen av villkor; till exempel:

if diff file1 file2; then
 echo dessa filer är desamma!
fi

Curl-kommandot är också lite ointuitivt. Du kanske förväntar dig att curl ska rapportera ett HTTP-fel, som en 404 för en icke-existerande.

URL, som en icke-noll statuskod, men det gör det inte:

Du kan använda -f (--fail) alternativet för att få curl att bete sig annorlunda och returnera en exitkod på 22 vid misslyckande:

Var dock medveten om att detta inte är 100% garanterat och vissa HTTP-fel, inklusive de som kräver autentisering, fortfarande kommer att returnera en 0 exitkod.

Använda Exit-status i en Kommandokedja

En av de bästa genvägarna för exitstatus inträffar utan att du ens behöver tänka på det. Här är ett enkelt exempel:

ls program && ./program && echo success || echo epic fail

&& och || logiska operatörer låter dig köra mer än ett kommando baserat på exitstatusen av andra. De liknar motsvarande operatörer i de flesta programmeringsspråk, men de respekterar exitkodkonventionen. Operatören && kommer att köra kommandot på sin höger sida endast om kommandot på sin vänster sida returnerar en 0 exitstatus. Operatören || kommer att köra kommandot på sin höger sida endast om kommandot på sin vänster sida misslyckas med en icke-noll status.

En mycket vanlig situation uppstår när du bygger programvara från grunden, med detta recept:

./configure && make && make install

De tre delarna av detta kommando gör följande:

• ./configure kör ett lokalt skript som inspekterar din miljö och genererar en Makefile.
• make kör make-programmet och bygger programvaran med hjälp av Makefile.
• make install kopierar den genererade körbara filen till en välkänd plats som /usr/local/bin.

Om någon del av denna process misslyckas, stoppas den omedelbart utan att försöka resten.

De sanna och falska Kommandona

Ditt Linux-system innehåller två nyfikna kommandon: true och false. Var och en av dessa gör ingenting, förutom att returnera en lämplig exitkod: 0 och 1 respektive:

De kanske inte verkar särskilt användbara, men dessa kommandon är praktiska för testning och för vissa shell-skriptuppgifter. Du kan använda true i en while-sats för att skapa en oändlig loop:

while true
do
 echo “running until you ^c”
 sleep 10
done

Du kan också använda dem tillsammans med logiska operatörer för att ändra kommandobeteendet. Till exempel kan du tillfälligt stoppa en lång kommandokedja från att köras:

false && (none || of-these && commands || will-run)

Eller så kan du tvinga en kommandokedja att fortsätta köra, även om ett kommando misslyckas:

cat file-that-may-not-exist | true && echo done

Återföra en Exitkod Från Dina Egna Skript

Du har förmodligen använt exit-kommandot tidigare, för att avsluta din terminal. Tekniskt sett avslutar det din shell och detta betyder att du kan använda det för att stoppa ett shell-skript också. Som standard kommer dina skript att avslutas med samma kod som det senaste kommandot:

Men du kan ändra exitkoden genom att skicka ett numeriskt parameter till exit-kommandot:

exit number

Ditt skript kommer nu att avslutas med den statuskod du angav, och du kan använda detta för att kommunicera olika felvillkor från ditt program till andra.

När du väl känner till dem är exitkommandon enkla att använda. Du kan till och med använda dem utan att riktigt tänka på det, men när det kommer till skriptning, se till att du använder exitkoder på rätt sätt.

Nu när du har läst klart Hur Linux-utgångskoder hjälper dig att skriva robusta skript, inbjuder vi dig att utforska kategorin Linux ytterligare. Där hittar du fler intressanta artiklar som kommer att utöka dina kunskaper och hålla dig informerad. Sluta inte läsa och upptäcka mer!