Basis van shellscripts

Een shellscript bewaart een reeks commando's in een bestand met platte tekst. Bash leest de commando's op volgorde, net zoals het commando's leest die je bij een prompt invoert. Een script kan een taak herhalen zonder dat iemand elke stap typt en geeft je één plek om die taak te corrigeren of te verbeteren.

Zet de interpreter op de eerste regel

De shebang vertelt Linux welk programma een uitvoerbaar script moet lezen. Begin een Bash-script met #!/bin/bash. De #! moet uit de eerste twee tekens van het bestand bestaan: er mogen geen spaties of lege regel voor staan. Bash is de Bourne Again Shell. Die wordt op Linux veel gebruikt als interactieve shell en leest ook scriptbestanden.

Een interpreter is een programma dat een andere taal leest en uitvoert. Via hetzelfde mechanisme kiest #!/usr/bin/python3 voor Python en #!/usr/bin/awk -f voor awk. De rest van een Bash-script moet shellcommando's bevatten die Bash begrijpt.

Maak backup-notes.sh in een editor voor platte tekst zoals nano of vi:

#!/bin/bash
# Keep a copy of the notes and show the backup folder.
mkdir -p ~/backup
cp ~/notes.txt ~/backup/
ls -l ~/backup

Bash maakt eerst de bestemmingsdirectory, kopieert daarna de notities en toont vervolgens de inhoud van de bestemming. mkdir -p slaagt ook als de directory al bestaat, zodat een latere uitvoering die kan hergebruiken. Het bronbestand ~/notes.txt moet bestaan om het kopiëren te laten werken. Door de commando's op te slaan maak je dat bronbestand niet aan.

Maak het bestand leesbaar voor mensen

De tweede regel is commentaar. Buiten afgeschermde tekst begint # aan het begin van een woord een commentaarregel; Bash negeert de rest van die regel. Schrijf commentaar over het doel van een stap, bijvoorbeeld waarom een back-up moet worden bewaard. Lege regels en inspringing maken groepen commando's beter zichtbaar. Laat de inspringing consistent blijven als je voorwaarden en lussen toevoegt.

De extensie .sh helpt een lezer een shellscript te herkennen. Linux vereist die extensie niet en door die toe te voegen kies je geen Bash en verleen je geen uitvoerrecht. Een bestand met de naam backup-notes kan dezelfde commando's uitvoeren.

Stem de shell af op de taal

Op Debian en Ubuntu kiest /bin/sh normaal gesproken dash. Bash-functies zoals [[ ... ]] werken daarin niet. Een Bash-script heeft een Bash-interpreter nodig, ook als eenvoudige commando's toevallig onder beide shells werken. Een bestand something.sh noemen lost een niet-passende shebang niet op.

Herken een probleem met regeleinden

Windows-editors kunnen vóór elk nieuweregelteken een carriage-returnteken opslaan. Op Linux kan dat onzichtbare teken deel worden van het shebangpad. Een fout zoals /bin/bash^M: bad interpreter: No such file or directory wijst op dit probleem, ook al bestaat /bin/bash.

Zet het bestand om naar Unix-regeleinden met dos2unix backup-notes.sh en sla toekomstige scripts daarna in de editor op met Unix-regeleinden. De commando's in het bestand kunnen correct zijn terwijl het extra teken voorkomt dat Linux hun interpreter start.

Bash kan een script rechtstreeks lezen of het script kan als programma worden gestart. Deze manieren verschillen in de rechten die ze nodig hebben en in de keuze van de interpreter. Het pad dat je typt, bepaalt ook of de shell een commando zoekt of één specifiek bestand gebruikt.

Twee manieren om hetzelfde bestand te starten

bash backup-notes.sh
chmod u+x backup-notes.sh
./backup-notes.sh

Het eerste commando start Bash en vraagt die het bestand te lezen. Het script heeft leesrecht nodig; de eigen uitvoerbit is niet vereist. Bash behandelt de shebang als commentaar omdat de interpreter al is gekozen.

Het tweede commando voegt uitvoerrecht toe voor de eigenaar van het bestand. In een rechtenreeks zoals -rwxr--r-- betekent de x van de eigenaar dat het bestand uitvoerbaar is. Het derde commando voert het bestand uit als programma en gebruikt de shebang. Ook chmod +x wordt veel gebruikt; zonder genoemde rechtenklasse beperkt de umask welke klassen uitvoerrecht krijgen. chmod u+x richt zich expliciet op de eigenaar.

Als ./backup-notes.sh “Permission denied” meldt, controleer dan het uitvoerrecht en de toegang tot het pad. Als bash backup-notes.sh werkt, betekent dat niet dat de rechten voor directe uitvoering in orde zijn.

Begrijp hoe commando's worden gezocht

./ betekent de huidige directory. Als een commando een schuine streep bevat, volgt Bash dat pad. Als je een naam zonder schuine streep typt, doorzoekt Bash de directory's in PATH. De huidige directory ontbreekt normaal gesproken in die lijst, dus in de directory van een script staan is niet genoeg om het met alleen de naam uit te voeren.

echo "$PATH"
command -v backup-notes.sh
type backup-notes.sh

PATH is een lijst gescheiden door dubbele punten, zoals /home/sam/.local/bin:/usr/local/bin:/usr/bin:/bin. Het eerste overeenkomende uitvoerbare bestand wordt gebruikt. De laatste twee commando's helpen bepalen wat bij een naam wordt uitgevoerd, ook als er ergens anders op PATH een oudere kopie staat.

Om een persoonlijk script met zijn naam beschikbaar te maken, plaats je het in een directory op je PATH. Veel distributies voegen ~/bin of ~/.local/bin bij het aanmelden toe als die directory bestaat; controleer je eigen PATH. /usr/local/bin is een gebruikelijke locatie voor scripts die gebruikers delen en je hebt beheerdersrechten nodig om erin te schrijven.

Kies een kindshell of de huidige shell

Als je ./settings.sh of bash settings.sh uitvoert, start een Bash-kindproces. De variabelen en directorywijzigingen ervan horen bij dat kindproces. Een script met cd /var/log verplaatst de terminal die het startte niet. Als het eindigt, sta je nog steeds in de oorspronkelijke directory van de terminal.

Inlezen in de huidige shell (sourcing) leest commando's in de huidige shell:

source ./settings.sh
# Equivalent short form:
. ./settings.sh

Gebruik dit voor een instellingenbestand dat bedoeld is om je sessie te wijzigen. Inlezen vereist leesrecht, geen uitvoerrecht, en een shebang start geen afzonderlijke interpreter. Als je een Bash-instellingenbestand inleest, ga je er dus van uit dat de huidige shell Bash-syntaxis begrijpt.

Lees het resultaat van een uitvoering

Direct nadat een script eindigt, toont echo $? de afsluitstatus. Tenzij het script exit met een gekozen code gebruikt, komt de status van het laatste commando. Een geslaagde laatste bestandslijst kan daardoor een eerder mislukte kopieeractie verbergen; met foutcontroles verderop kan het script het werkelijke resultaat van de taak melden.

Een variabele geeft een waarde een naam zodat hetzelfde script die kan hergebruiken. Bash-variabelen bevatten normaal gesproken tekst, ook als die tekst op een getal lijkt. Je kent de waarde één keer toe en expandeert de naam overal waar een commando die waarde nodig heeft.

Ken waarden toe zonder spaties

city=Lisbon
greeting="Good morning"
echo "$greeting from $city"

De uitvoer is “Good morning from Lisbon”. Er staan geen spaties rond de = van de toekenning. In city = Lisbon behandelt Bash city als een commando en de andere woorden als argumenten. Aanhalingstekens rond "Good morning" houden beide woorden in één waarde.

Gebruik letters, cijfers en underscores in variabelenamen, met een letter of underscore vooraan. Namen zijn hoofdlettergevoelig: file, File en FILE zijn verschillend. Kies namen met kleine letters zoals backup_dir voor waarden die bij je script horen. Zo voorkom je dat je omgevingsvariabelen zoals PATH of HOME vervangt. Als je PATH=/data instelt, verandert het zoeken naar commando's en worden gewone commando's mogelijk niet meer gevonden.

Geef aan waar een naam eindigt

Een dollarteken leidt een expansie in. Accolades geven de grens aan als er direct meer tekst volgt:

file=report
echo "${file}_old"

Dit toont “report_old”. Bij "$file_old" zoekt Bash een variabele met de naam file_old, niet file gevolgd door _old. Zonder set -u expandeert een niet-ingestelde naam naar lege tekst. Een spelfout kan daardoor zonder directe foutmelding een leeg pad of een lege melding opleveren.

Een waarde zoals in count=5 slaat de tekst “5” op. Tekst naast een expansie toevoegen voert geen berekening uit: echo "$count+1" toont “5+1”. Bij rekenkundige expansie krijgen getallen een andere rol als berekeningen nodig zijn.

Lees een invoerregel

read -r -p "Your name: " name
echo "Hello, $name"

read slaat de ingevoerde regel op in name. -p geeft de prompt op en -r behoudt backslashes. Bij de invoer “Lee Kim” is de begroeting “Hello, Lee Kim”. Een script dat zonder aanwezige persoon draait, heeft invoer uit argumenten, bestanden of standaardwaarden nodig; een prompt kan een ontbrekende waarde niet betrouwbaar leveren.

Exporteer waarden voor kindprogramma's

Een gewone shellvariabele hoort bij de shell waarin die is ingesteld. Met exporteren markeer je de variabele voor opname in de omgeving die wordt gekopieerd naar programma's die die shell start:

export BACKUP_DIR=/mnt/usb
bash backup-notes.sh

Het Bash-kindproces kan nu BACKUP_DIR lezen. Als dat kindproces een andere waarde toekent, behoudt het ouderproces zijn eigen waarde. Overerving van de omgeving gaat van ouder naar kind; latere wijzigingen worden niet teruggestuurd.

env of printenv toont omgevingsvariabelen. unset name verwijdert de variabele met de naam name; het kent geen lege tekenreeks toe. Bij normale expansie kunnen beide leeg lijken, maar een controle op niet-ingestelde variabelen kan een ontbrekende variabele van een ingestelde onderscheiden.

Bash leest een commando voordat het programma zijn argumenten ontvangt. Spaties scheiden woorden en tekens zoals *, ?, $, ;, &, |, < en > hebben speciale functies. Afscherming bepaalt welke van die functies actief blijven.

Kies wat mag expanderen

Vergelijk met HOME=/home/sam:

echo 'Home: $HOME *'
echo "Home: \$HOME *"

De eerste toont “Home: $HOME *”. De tweede toont “Home: /home/sam *”. Het sterretje blijft in beide gevallen letterlijk, maar alleen dubbele aanhalingstekens laten de variabele expanderen. Een enkel aanhalingsteken kan niet rechtstreeks binnen een tekenreeks tussen enkele aanhalingstekens worden geplaatst.

Binnen dubbele aanhalingstekens kunnen backslashes een dollarteken, backtick, dubbel aanhalingsteken of backslash afschermen. Zo toont echo "Price: \$5" de tekst “Price: $5”. Buiten aanhalingstekens toont echo 5 \* 3 de tekst “5 * 3” en maakt touch my\ file.txt één bestand met een spatie in de naam.

Volg een niet-afgeschermde waarde door Bash

file="my report.txt"
cp $file backup/

Eerst expandeert Bash de variabele. Daarna verdeelt woordsplitsing de waarde bij spaties, tabs en nieuweregeltekens. Het commando ontvangt my, report.txt en backup/ als afzonderlijke argumenten. Het probeert twee bronbestanden te kopiëren in plaats van het ene bedoelde bestand.

Als een resulterend woord jokertekens bevat, vervangt bestandsnaamexpansie het daarna door overeenkomende bestandsnamen. Een opgeslagen waarde van *.txt kan meerdere bestandsargumenten worden als die zonder aanhalingstekens wordt geëxpandeerd. Deze extra stappen vinden plaats voordat cp start; het programma kan je bedoelde groepering niet herstellen.

cp "$file" backup/

Nu blijft de geëxpandeerde waarde één argument, “my report.txt”. Bash verwijdert de aanhalingstekens zelf; het zijn instructies voor de verwerking, geen onderdeel van het pad dat aan cp wordt doorgegeven. Zet variabele-expansies en commandosubstituties tussen dubbele aanhalingstekens wanneer hun volledige waarde bij elkaar moet blijven.

Behoud een lege waarde

Afscherming is ook belangrijk als een waarde leeg is. In [ $answer = yes ] verdwijnt een lege answer, waardoor een ongeldige test overblijft. [ "$answer" = yes ] geeft een lege tekenreeks door als één argument, zodat de test geldig en onwaar is.

Dezelfde groeperingsregel geldt voor letterlijke woorden. mkdir new folder maakt twee directory's, terwijl mkdir "new folder" er één maakt. Een volledig pad afschermen is nuttig, of de spatie nu rechtstreeks is getypt of uit een variabele komt.

Combineer letterlijke en geëxpandeerde tekst

Aangrenzende afgeschermde delen zonder spatie ertussen vormen één woord. Met price=8 toont echo 'Price: $'"$price" de tekst “Price: $8”. Het vaste deel staat tussen enkele aanhalingstekens en het veranderlijke deel tussen dubbele. Ook een zoekpatroon kun je vast houden: grep 'cost: \$[0-9]' prices.txt geeft het patroon zonder shellexpansie door, zodat grep het patroon kan interpreteren.

Commando's leveren vaak een waarde op die een andere stap nodig heeft. Bash kan die uitvoer opvangen, in tekst plaatsen of in een berekening gebruiken. Commandosubstitutie en rekenkundige expansie gebruiken vergelijkbare leestekens, maar doen iets anders.

Vang standaarduitvoer op

today=$(date +%F)
cp notes.txt "notes-${today}.txt"

$(...) voert een commando uit en vervangt de substitutie door de standaarduitvoer ervan. Op 2026-10-22 bevat today “2026-10-22” en heet de kopie notes-2026-10-22.txt. Een datum in de volgorde jaar-maand-dag houdt bestandsnamen bij sortering op naam in datumvolgorde. Je kunt de substitutie ook rechtstreeks in de naam zetten: "notes-$(date +%F).txt".

Nieuweregeltekens aan het einde worden uit opgevangen uitvoer verwijderd. De oudere vorm met backticks vangt ook uitvoer op, maar $(...) is gemakkelijker te lezen en te nesten. Scherm een substitutie die als commandoargument wordt gebruikt af, zoals "$(date +%F)", om het resultaat bij elkaar te houden.

Commandosubstitutie vangt alleen standaarduitvoer op. Fouten die naar standaardfoutuitvoer worden gestuurd, gaan nog steeds naar hun gebruikelijke bestemming. result=$(some_command 2>&1) combineert beide stromen binnen de opgevangen uitvoer als het script dat nodig heeft. Als je fouten mengt met een waarde die een getal moet bevatten, mislukken latere berekeningen.

Vang een telling op zonder bestandsnaam

lines=$(wc -l < access.log)
echo "Lines: $lines"

Als het bestand 342 nieuweregeltekens bevat, levert wc de telling 342. Door het bestand naar wc om te leiden bevat de uitvoer alleen de telling; wc -l access.log toont ook de bestandsnaam. Een resultaat dat op een getal lijkt, kun je dan hergebruiken, mits het commando is geslaagd.

Reken met gehele getallen

$(( ... )) voert rekenkundige expansie uit:

echo "$(( 17 / 5 ))"
echo "$(( 17 % 5 ))"

De resultaten zijn 3 en 2. Bij geheeltallige deling vervalt de rest; % geeft die terug. Voor optellen, aftrekken en vermenigvuldigen gebruik je +, - en *. Variabelenamen kunnen binnen de expressie zonder dollarteken voorkomen: total=$(( price * qty )).

Met a=5 toont echo "$a+3" de tekst “5+3”. echo "$(( a + 3 ))" rekent en toont 8. De extra haakjes kiezen voor rekenkunde; $(a + 3) zou in plaats daarvan een commando met de naam a proberen uit te voeren.

Een teller begint met een waarde zoals count=0 en wordt bijgewerkt met count=$(( count + 1 )). Bash biedt ook (( count++ )); dit is een rekenkundig commando met een eigen afsluitstatus, wat belangrijk is in scripts die foutopties gebruiken.

Behoud de benodigde nauwkeurigheid

Bash rekent met gehele getallen. 7 / 2 geeft 3 en een decimale waarde zoals 2.5 veroorzaakt een rekenkundige syntaxisfout. Een afzonderlijke tool kan met decimalen rekenen:

echo "scale=2; 7 / 2" | bc

Dit levert 3.50 op. Vermenigvuldig bij het rekenen met gehele getallen vóór het delen als het product een breukdeel behoudt dat je nog nodig hebt. Voor 45 van de 60 geeft $(( 45 * 100 / 60 )) de waarde 75. Als je eerst deelt, geeft 45 / 60 nul, zodat $(( 45 / 60 * 100 )) nul blijft; het verloren breukdeel kun je niet herstellen door later te vermenigvuldigen.

Een commando meldt zijn resultaat op twee manieren: het kan tekst tonen en het geeft een afsluitstatus terug. Programma's gebruiken die status om te bepalen wat er daarna gebeurt. Een script kan een geruststellende melding tonen en toch zijn mislukt, of niets tonen en slagen.

Lees een status voordat die verandert

Een afsluitstatus is een geheel getal van 0 tot en met 255. Nul betekent succes. Een waarde anders dan nul meldt een mislukking of een ander gedocumenteerd resultaat. grep gebruikt bijvoorbeeld 0 voor een overeenkomst, 1 voor geen overeenkomst en 2 voor een fout. Een zoekopdracht zonder overeenkomst kan voor je taak een normale uitkomst zijn, ook al is de status anders dan nul.

$? bevat de status van het meest recente commando:

grep -q root /etc/passwd
status=$?
echo "Search status: $status"

De toekenning slaat het resultaat op voordat een ander commando het vervangt. In ls /missing; echo $?; echo $? geeft GNU ls de waarde 2 terug voor het ontoegankelijke pad op de commandoregel. De eerste echo toont 2 en slaagt daarna. De tweede toont 0, de status van die echo, niet van de oorspronkelijke bestandslijst.

Eindig met een bruikbaar resultaat

exit 1 beëindigt een script onmiddellijk en meldt 1 aan de aanroeper. exit 0 meldt succes. Een exit zonder getal gebruikt de status van het vorige commando; als het script normaal het einde bereikt, gebruikt het de status van het laatste commando. Kies codes binnen 0–255: exit 256 loopt terug naar 0 en zou ten onrechte succes melden.

Sommige statussen komen van Bash zelf:

Ctrl+C verzendt signaal 2, dus een commando dat op die manier wordt beëindigd, meldt gewoonlijk 130. Gewone programma's documenteren ook hun eigen codes; 1 en 2 hebben niet één universele betekenis voor alle tools.

Koppel afhankelijke commando's

mkdir -p ~/backup && cp notes.txt ~/backup/
cd /data/reports || exit 1

&& voert het volgende commando alleen uit na succes. Hier hangt het kopiëren af van het maken of vinden van de back-updirectory. || voert het volgende commando alleen uit na mislukking. Hier stopt een mislukte directorywijziging het script voordat latere commando's de verkeerde werkdirectory gebruiken.

true geeft 0 terug; false geeft 1 terug. Een ! vooraan keert succes of mislukking van een commando om. ! grep -q ERROR app.log slaagt als de zoekopdracht geen overeenkomende regel vindt, maar ook als grep met een fout mislukt; gebruik expliciete statuscontroles als je die uitkomsten moet onderscheiden.

Controleer een hele pijplijn

grep ERROR missing.log | wc -l

Standaard heeft een pijplijn de status van het laatste commando. grep mislukt op het ontbrekende bestand, maar wc leest een lege stroom, toont 0 en slaagt. De status van de pijplijn is daarom 0.

set -o pipefail laat een pijplijn mislukken als een van de onderdelen mislukt. Het geeft de meest rechtse status anders dan nul terug, of 0 als alle commando's slagen. Daardoor worden fouten eerder in de pijplijn zichtbaar voor if, &&, || en de aanroeper. Een planner kan dan een geslaagd rapport onderscheiden van een rapport dat zijn invoer nooit heeft gelezen.

Bash gaat normaal gesproken verder nadat een commando is mislukt. Als het volgende commando van dat werk afhangt, kan doorgaan een kleine fout tot een groter probleem maken. Controleer afhankelijke stappen expliciet en gebruik daarna syntaxiscontroles en tracering om te achterhalen waarom een uitvoering anders verloopt dan je had bedacht.

Stop voordat een mislukte stap verdere gevolgen heeft

cd /backups || exit 1

Commando's daarna kunnen nu alleen worden uitgevoerd als de directorywijziging is geslaagd. Dit is belangrijk vóór bestandsbewerkingen: als een directorywijziging mislukt en het script doorgaat, verwijzen relatieve paden nog steeds naar de oude directory. Controleer de bestemming voordat je commando's uitvoert die bestanden wijzigen of verwijderen.

Een foutmelding en een status die mislukking aangeeft, zijn voor verschillende lezers bedoeld:

echo "Error: $file not found" >&2
exit 1

De melding gaat naar standaardfoutuitvoer, zodat standaarduitvoer beschikbaar blijft voor gegevens. Met ./report.sh > report.txt blijft de melding zichtbaar in de terminal terwijl de normale uitvoer in het bestand terechtkomt. Dankzij de status anders dan nul kan een ander programma de fout herkennen zonder de zin te lezen.

Controleer de syntaxis en traceer daarna de uitvoering

Een ontbrekende fi, done of afsluitend aanhalingsteken is een syntaxisprobleem. bash -n kan het vinden, vaak via een melding “unexpected end of file”. Voor een syntactisch geldig bestandspad met een spelfout moet je de uitvoering controleren.

Bij tracering krijgen commando's een + als voorvoegsel. Een regel zoals cp "$src" "$dest" laat zien welke paden daadwerkelijk zijn doorgegeven. Met set -x en set +x schakel je tracering voor een gedeelte in en uit.

Begrijp de foutopties

set -euo pipefail combineert drie instellingen:

• -e stopt na een niet-afgehandelde mislukking van een commando.
• -u meldt een niet-ingestelde variabele als fout.
• pipefail zorgt ervoor dat mislukte onderdelen van een pijplijn de afsluitstatus van de pijplijn beïnvloeden.

-e laat ruimte voor verwachte mislukkingen in voorwaarden van if, while en until, ontkende commando's en commando's die niet de laatste zijn in lijsten met && of ||. Zonder pipefail leidt een mislukking vóór het laatste commando van een pijplijn niet tot stoppen. Expliciete controles blijven nuttig omdat ze aangeven wat het script moet doen als een bepaalde stap mislukt.

Een rekenkundig commando meldt ook waar of onwaar. (( count++ )) geeft status 1 terug als de oude waarde 0 is. Een niet-afgehandeld gebruik onder -e kan het script daardoor stoppen, ook al is de verhoging uitgevoerd. De toekenning count=$(( count + 1 )) vermijdt die status van het rekenkundige commando.

-u vangt een typefout zoals $filname op als alleen filename is ingesteld. Het wijst een variabele die bestaat maar leeg is niet af. ${dir:?not set} controleert bij die expansie of dir ontbreekt of leeg is. Een verwacht resultaat zonder overeenkomst kun je met een test afhandelen; command || true onderdrukt elke mislukking van dat commando, dus gebruik dit alleen als al die mislukkingen aanvaardbaar zijn.

Lees meldingen en ruim op

“Command not found” wijst op een probleem met een naam, een geïnstalleerd programma of PATH. “Permission denied” wijst op uitvoering of toegang tot een bestand. “Unary operator expected” komt vaak door een lege, niet-afgeschermde waarde in [ ]; “integer expression expected” betekent dat een numerieke test tekst heeft ontvangen.

Een EXIT-trap stelt een opruimactie in, zoals trap 'rm -f "$tmpfile"' EXIT, nadat aan tmpfile een waarde is toegekend. Het afgeschermde commando wordt uitgevoerd als Bash eindigt, ook bij een expliciete exit of een afsluiting na een fout onder -e. ShellCheck kan scripts vóór uitvoering ook controleren op veelvoorkomende fouten in afscherming en logica.

Een voorwaarde in Bash is een commando waarvan de status waar of onwaar betekent. Met tests stel je vragen over paden, tekst en getallen. Kies een operator die past bij het soort waarde; dezelfde zichtbare tekens kunnen als tekst en als getal verschillende betekenissen hebben.

Geef de test afzonderlijke woorden

test -f notes.txt en [ -f notes.txt ] vragen of een pad naar een bestaand gewoon bestand verwijst. [ is een commando en het laatste argument moet ] zijn. Spaties scheiden de argumenten:

[ -f "$file" ]

Zonder de spatie na [ kan Bash zoeken naar een commando met de naam [-f. In [ "$a"="$b" ] vormen de ontbrekende spaties rond = één niet-leeg woord, waardoor de test waar is, ook als de waarden verschillen. Operators moeten afzonderlijke argumenten zijn.

Kies een bestandstest

Voor een directory met de naam logs slagen -e en -d, terwijl -f mislukt. Bestandstests volgen een symbolische koppeling normaal gesproken naar het doel; -L controleert de koppeling zelf. Een verbroken koppeling kan daardoor aan -L voldoen en niet aan -e.

Vergelijk tekst of gehele getallen

Tekenreekstests gebruiken = en != voor gelijkheid en ongelijkheid. -z controleert op lengte nul en -n op een lengte anders dan nul. [ "$answer" = yes ] komt precies overeen met “yes”; “Yes” en “yes ” zijn andere tekst. Dubbele aanhalingstekens behouden een lege waarde in de test.

Vergelijkingen van gehele getallen gebruiken -eq, -ne, -lt, -le, -gt en -ge: gelijk, ongelijk, kleiner dan, kleiner dan of gelijk aan, groter dan en groter dan of gelijk aan. [ "$count" -gt 100 ] vraagt of het getal groter is dan 100.

[ 07 -eq 7 ]
[ 07 = 7 ]

De numerieke vergelijking slaagt omdat de waarden gelijk zijn. De tekenreeksvergelijking mislukt omdat één tekst met een extra nul begint.

Gebruik geen losse > voor een numerieke test binnen [ ]. In [ 10 > 9 ] leidt Bash uitvoer om naar een bestand met de naam 9 en test het overblijvende niet-lege woord. In Bash vergelijkt de operator in [[ 10 < 9 ]] tekenreeksen, zodat het eerste teken 1 vóór 9 wordt gesorteerd. Gebruik -lt of -gt voor numerieke vergelijkingen, of Bash-rekenkunde zoals (( count > 100 )).

Combineer voorwaarden

[ ! -d "$dir" ] slaagt als het pad geen bestaande directory is; het kan een gewoon bestand zijn of ontbreken. [ -f "$f" ] && [ -r "$f" ] slaagt alleen als beide tests slagen. Afzonderlijke tests die met || zijn verbonden, slagen als er minstens één slaagt.

Bash heeft ook het sleutelwoord voor een testconstructie [[ ... ]]. Het voorkomt woordsplitsing van de variabele-expansies en staat && en || binnen de test toe. Een niet-afgeschermd patroon rechts van == wordt als patroon vergeleken: [[ $file == *.log ]] komt overeen met “app.log”. Als je dat patroon afschermt, wordt het letterlijk. Deze syntaxis vereist Bash; dash ondersteunt die niet.

Voorwaarden worden nuttig als ze acties kiezen. Een if-blok kiest een vertakking op basis van commandoresultaten. Een case-blok kiest een vertakking door één waarde met patronen te vergelijken. Beide maken de beschikbare acties zichtbaar in het script.

Laat een commando een vertakking kiezen

if grep -q ERROR app.log; then
  echo "Errors found"
else
  echo "No successful match"
fi

if voert het commando uit en gaat de eerste vertakking in als het 0 teruggeeft. Anders gaat het naar else. De zoekopdracht zelf is de voorwaarde; het is niet nodig die uit te voeren, iets te tonen en daarna $? te bekijken. Een fout van grep geeft ook een waarde anders dan nul, dus dit voorbeeld beschrijft de else-vertakking als een zoekopdracht zonder succesvolle overeenkomst, niet als bewijs dat het bestand geen fouten bevat.

then moet een nieuw commando beginnen: zet het op de volgende regel of na een puntkomma. fi sluit het blok af. Een ontbrekende fi veroorzaakt vaak een syntaxisfout bij het bestandseinde omdat Bash nog wacht op de afsluiting van het blok.

Orden overlappende voorwaarden

elif voegt een test toe die alleen wordt uitgevoerd als eerdere tests zijn mislukt. Voor een schijfgebruikspercentage als geheel getal:

if [ "$usage" -ge 90 ]; then
  echo "CRITICAL: disk ${usage}% full"
elif [ "$usage" -ge 75 ]; then
  echo "WARNING: disk ${usage}% full"
else
  echo "OK: disk ${usage}% full"
fi

Met usage=82 mislukt de eerste test en slaagt de tweede, wat “WARNING: disk 82% full” oplevert. Bij 95 wordt de eerste vertakking uitgevoerd en de waarschuwingsvertakking overgeslagen. Als de test op 75 eerst kwam, zou 95 daaraan voldoen en nooit de test voor kritiek bereiken. Orden overlappende bereiken zo dat de strengere voorwaarde aan bod komt.

Alleen de eerste vertakking waarvan de test slaagt, wordt uitgevoerd. else heeft geen voorwaarde nodig en verwerkt wat overblijft. Je kunt elif of else weglaten als de taak die niet nodig heeft.

Vergelijk één waarde met case

case "$1" in
  start) echo "Starting" ;;
  stop) echo "Stopping" ;;
  y|Y|yes) echo "Confirmed" ;;
  *) echo "Usage: $0 start|stop|y|Y|yes" >&2; exit 2 ;;
esac

Elk patroon eindigt met ), elke vertakking met ;; en esac sluit het blok af. De | binnen een patroon geeft alternatieven. De laatste * is het allesomvattende patroon en hoort als laatste omdat het met elke waarde overeenkomt.

case gebruikt bestandsnaampatronen, geen reguliere expressies. *.jpg komt overeen met een waarde die eindigt op .jpg. [0-9]* komt overeen met een waarde waarvan het eerste teken een cijfer is; de * kan daarna met elke volgende tekst overeenkomen, dus het patroon komt ook overeen met “7draft”. Het bewijst niet dat een hele waarde alleen cijfers bevat.

Kies de passende structuur

Gebruik case als één invoer, zoals een subcommando of antwoord, meerdere benoemde vormen heeft. Gebruik if als voorwaarden verschillende zaken onderzoeken, zoals of een bestand bestaat en of een aantal een grens overschrijdt. Een patroonvergelijking gaat over de tekens in een waarde; een bestandstest gaat over het pad op schijf. Een naam die eindigt op .log kan met een patroon overeenkomen, ook als zo'n bestand niet bestaat.

Een for-lus geeft dezelfde reeks commando's bij elke doorgang een nieuwe waarde. De lijst kan letterlijke woorden, overeenkomende bestandsnamen, een getallenbereik of de argumenten van het script bevatten. Bash kent één lijstitem toe aan de lusvariabele voordat het luslichaam wordt uitgevoerd.

Doorloop een vaste lijst

for host in web1 web2 db1; do
  echo "Checking $host"
done

De eerste doorgang heeft host=web1, de tweede host=web2 en de derde host=db1. De lus toont drie regels. do opent het luslichaam en done sluit het af. De variabele blijft na de lus beschikbaar en bevat de laatst toegekende waarde.

Een lus kan ook een resultaat opbouwen:

total=0
for n in 4 8 15; do
  total=$(( total + n ))
done
echo "$total"

Het opgeslagen totaal verandert van 0 naar 4, dan 12 en dan 27. Initialiseer het totaal vóór de lus zodat de eerste optelling een vastgelegde beginwaarde heeft.

Doorloop overeenkomende bestanden

for f in *.log; do
  [ -f "$f" ] || continue
  gzip -- "$f"
done

Bash expandeert het bestandsnaampatroon naar overeenkomende namen voordat het luslichaam wordt uitgevoerd. Elke overeenkomende bestandsnaam blijft één lijstitem, ook als die spaties bevat. Door "$f" binnen het luslichaam af te schermen, blijft dat item bij elkaar wanneer het aan gzip wordt doorgegeven. De test op een gewoon bestand slaat hier ook directory's over waarvan de naam eindigt op .log.

Met de standaardinstellingen voor bestandsnaamexpansie van Bash blijft een *.log zonder overeenkomsten letterlijk staan. Een lus zonder controle zou één keer worden uitgevoerd op de tekens *.log en het commando zou mislukken. [ -e "$f" ] || continue slaat niet-bestaande paden over; gebruik -f als je alleen gewone bestanden wilt.

Maak geen bestandsnamenlus op basis van $(ls). De uitvoer is tekst, dus woordsplitsing kan “my report.txt” in twee lijstitems veranderen. Een bestandsnaampatroon levert de bestandsnamen al met hun grenzen intact.

Maak van elke oude naam een nieuwe

for f in *.jpeg; do
  [ -f "$f" ] || continue
  mv -- "$f" "${f%.jpeg}.jpg"
done

${f%.jpeg} verwijdert het achtervoegsel .jpeg uit de waarde. Voor “beach day.jpeg” wordt de bestemming “beach day.jpg”. De twee afgeschermde argumenten houden beide paden intact. -- geeft mv aan dat volgende argumenten namen zijn, ook als er één met - begint. Gebruik bij het uitproberen van het voorbeeld een bestemmingsmap zonder conflicterende namen, omdat mv een bestaande bestemming kan vervangen.

Tel door een bereik

for i in {1..5} levert 1 tot en met 5. Bash expandeert de accolades voordat het variabelen expandeert, dus {1..$n} levert geen bereik met variabele lengte op. Gebruik voor een opgeslagen grens de rekenkundige vorm:

for (( i = 1; i <= n; i++ )); do
  echo "$i"
done

De eerste expressie initialiseert de teller, de middelste test die vóór elke doorgang en de laatste werkt die bij. for i in $(seq 1 "$n") levert ook een getallenlijst voor een geschikte positieve gehele grenswaarde. De bewust niet-afgeschermde substitutie levert hier afzonderlijke getallen.

Voor argumenten levert for arg in "$@" één item per oorspronkelijk argument. De kortere vorm for arg; do betekent hetzelfde, inclusief het behoud van spaties binnen elk argument.

Sommige herhalingen eindigen wanneer een voorwaarde verandert, niet wanneer een lijst opraakt. while en until testen vóór elke doorgang. Het luslichaam van while wordt uitgevoerd zolang de voorwaarde slaagt; dat van until zolang de voorwaarde mislukt. Beide lussen kunnen nul keer worden uitgevoerd.

Werk bij waarvan de voorwaarde afhangt

i=1
while [ "$i" -le 3 ]; do
  echo "Attempt $i"
  i=$(( i + 1 ))
done

De voorwaarde ziet eerst 1, dan 2 en dan 3. Het luslichaam toont die drie pogingnummers en verhoogt telkens de teller. Na de wijziging naar 4 mislukt de volgende test en eindigt de lus. Als de wijziging ontbrak, zou i op 1 blijven en zou de lus doorgaan. Ctrl+C stopt een actieve voorgrondlus.

Om op een bestand te wachten:

until [ -f /tmp/export.done ]; do
  sleep 5
done

Als het bestand al bestaat, wordt het luslichaam nooit uitgevoerd. Anders pauzeert sleep 5 vijf seconden vóór de volgende controle. Een pauze voorkomt dat de lus voortdurend test en processortijd verspilt.

Lees records als regels

while IFS= read -r line; do
  echo "Host: $line"
done < hosts.txt

read levert bij elke doorgang één regel en geeft bij het bestandseinde een status terug die mislukking aangeeft. IFS= behoudt spaties aan het begin en einde van de regel; -r behoudt backslashes. De invoeromleiding na done voert invoer toe aan de hele lus, niet alleen aan het laatste commando.

Een regel zoals “web1 production” blijft één waarde. for line in $(cat hosts.txt) zou splitsen bij spaties, tabs en nieuweregeltekens en die twee woorden als afzonderlijke iteraties behandelen. Die vorm kan willekeurige records per regel niet behouden.

Behoud wijzigingen na de lus

Een pipe naar een lus, zoals cat hosts.txt | while read -r line; do ...; done, voert de lus in Bash normaal gesproken uit in een kindproces. Een teller die daar wordt gewijzigd, gaat voor het ouderproces verloren als het kindproces eindigt. Leid het bestand om naar de lus als latere commando's de opgebouwde waarden nodig hebben:

count=0
while IFS= read -r line; do
  count=$(( count + 1 ))
done < hosts.txt
echo "$count"

Dit verwerkt regels die eindigen op een nieuweregelteken en behoudt de bijgewerkte telling in de huidige shell. Er is geen pijplijn die een kindproces voor de lus maakt.

Verwerk het laatste record en voortijdige beëindiging

Een bestand kan eindigen met tekst maar zonder afsluitend nieuweregelteken. read slaat die laatste tekst op maar meldt mislukking, zodat een gewone while read het luslichaam voor dat record niet ingaat. Voeg een tweede test toe om de opgeslagen niet-lege tekst te accepteren:

while IFS= read -r line || [ -n "$line" ]; do
  echo "Host: $line"
done < hosts.txt

break verlaat de lus onmiddellijk. continue slaat de overige commando's in de huidige doorgang over en gaat daarna terug naar de volgende controle van de voorwaarde. Een while true-lus heeft daarom een break, een exit of een signaal nodig om te eindigen; die kan een menu ondersteunen dat stopt als de invoer “q” is. Plaats in een tellerlus een wijziging vóór elke continue die die wijziging anders zou overslaan, anders kan die doorgang zich eindeloos herhalen.

Argumenten maken van een script met vaste invoer een herbruikbaar commando. Bash plaatst de woorden na de scriptnaam in positionele parameters. Hun grenzen worden bepaald door de aanroepende shell, dus aanhalingstekens zijn belangrijk bij zowel de aanroep van het script als het gebruik van die waarden.

Herken de parameters

./backup.sh /home/sam/docs /mnt/usb

Binnen het script is $0 gelijk aan ./backup.sh, $1 aan /home/sam/docs en $2 aan /mnt/usb. $# is 2, het aantal argumenten. Het script kan cp -r "$1" "$2" gebruiken om de bronmap naar de bestemming te kopiëren zonder een van beide paden vast in de code te zetten.

$0 geeft de naam aan waarmee het script is gestart; die telt niet mee in $#. Bij ./greet.sh Ana "Lee Kim" is het eerste argument “Ana” en het tweede “Lee Kim”. Zonder de aanhalingstekens rond de tweede naam zou het script drie argumenten ontvangen.

Gebruik accolades na het negende argument

$1 tot en met $9 duiden de eerste negen positionele parameters aan. De tiende vereist ${10} en latere posities volgen dezelfde vorm. $10 betekent de expansie van $1 gevolgd door het letterlijke teken 0. Als het eerste argument “Ana” is, wordt $10 gelijk aan “Ana0”, ook als er een tiende argument bestaat.

Een weggelaten parameter expandeert onder normale instellingen naar lege tekst. Bij twee argumenten ontbreekt $3; onder set -u veroorzaakt expansie ervan een fout voor een niet-ingestelde variabele. Controleer het aantal voordat je verplichte posities leest, of gebruik een expansie die een standaardwaarde levert.

Behoud alle grenzen tussen argumenten

Stel dat een script "a b" en c ontvangt. Vergelijk:

"$@" is de gebruikelijke keuze om argumenten door te geven:

for arg in "$@"; do
  echo "Argument: $arg"
done

De lus wordt bij die aanroep twee keer uitgevoerd, één keer per oorspronkelijk argument. Zonder argumenten draait de lus nul keer. Dubbele aanhalingstekens rond "$@" hebben een speciale betekenis: elke positionele parameter blijft een afzonderlijk woord, dus de aanhalingstekens voegen niet de hele lijst samen tot één woord.

"$*" voegt waarden samen met het eerste teken van IFS, normaal gesproken een spatie. Dat kan nuttig zijn voor één tekenreeks om te tonen, maar het verliest de afzonderlijke grenzen die een later commando nodig kan hebben.

Verwerk parameters met shift

shift verwijdert de eerste positionele parameter, schuift de latere op en verlaagt $#. Bij de back-upaanroep zorgt één shift ervoor dat $1 gelijk wordt aan /mnt/usb en het aantal aan 1. shift 2 verwijdert de eerste twee parameters tegelijk.

Dit maakt een lus mogelijk die $1 bekijkt, verwerkt en daarna doorschuift vóór de volgende doorgang. Test met [ "$#" -gt 0 ] of er argumenten over zijn; anders kan het script een ontbrekende waarde lezen of proberen verder te schuiven dan de beschikbare argumenten. Doorschuiven verandert $0 niet en kan de argumentenlijst van de oudershell die het script startte niet wijzigen.

Een script moet vaststellen of zijn invoer bruikbaar is voordat het aan het werk gaat. Controleer het aantal argumenten en controleer daarna hun betekenis. Optionele invoer kan standaardwaarden hebben; ontbrekende verplichte invoer vereist een duidelijke foutmelding en een afsluitstatus anders dan nul.

Leg de verwachte aanroep uit

if [ "$#" -ne 2 ]; then
  echo "Usage: $0 SOURCE DEST" >&2
  exit 2
fi

Dit controleert het aantal voordat $1 of $2 wordt geëxpandeerd, dus het werkt ook onder set -u. De gebruiksinstructie gaat naar standaardfoutuitvoer. Hoofdletters duiden waarden aan die de gebruiker opgeeft, [DEST] zou een optionele bestemming betekenen en FILE... betekent één of meer bestandsargumenten. Een hulpoptie zoals -h toont normaal gesproken de gebruiksinstructie en sluit af met 0, omdat hulp vragen geslaagd gebruik is.

Alleen het aantal argumenten kan niet aangeven of een bron bruikbaar is. [ -d "$1" ] controleert op een bestaande directory. Een test op een gewoon bestand kan bestanden selecteren, maar het resultaat van de bewerking zelf moet nog steeds worden gecontroleerd: rechten of andere fouten kunnen lezen verhinderen.

Gebruik een standaardwaarde of vereis een waarde

logdir=${1:-/var/log}
src=${1:?Usage: backup.sh SOURCE [DEST]}

De eerste vorm gebruikt /var/log als de eerste parameter ontbreekt of leeg is. De tweede stopt een niet-interactief script in beide gevallen en toont de melding op standaardfoutuitvoer. De dubbele punt is onderdeel van beide vormen. Een standaardwaarde is een waarde die voor deze expansie wordt gebruikt; ${1:-...} voegt geen argument toe aan de lijst met positionele parameters.

Houd gedeeltelijke mislukking bij

Een script dat bestanden telt, kan na ongeldige invoer doorgaan en toch melden dat de hele taak niet is voltooid:

#!/bin/bash
if [ "$#" -eq 0 ]; then
  echo "Usage: $0 FILE..." >&2
  exit 2
fi
status=0
for f in "$@"; do
  if [ -f "$f" ]; then
    if lines=$(wc -l < "$f"); then
      echo "$f: $lines lines"
    else
      echo "$f: could not count lines" >&2
      status=1
    fi
  else
    echo "$f: not a regular file" >&2
    status=1
  fi
done
exit "$status"

Voor notes.txt missing.txt toont het script de telling van het leesbare bestand en meldt het het ontbrekende bestand, waarna het afsluit met 1. De toekenning wordt rechtstreeks getest, zodat een leesfout geen geslaagde lege telling wordt. Later succes zet de opgeslagen foutvlag nooit terug op 0.

Verwerk eenvoudige opties vóór bestandsnamen

verbose=0
while [ "$#" -gt 0 ]; do
  case "$1" in
    -v) verbose=1; shift ;;
    -h) echo "Usage: $0 [-v] FILE..."; exit 0 ;;
    --) shift; break ;;
    -*) echo "Unknown option: $1" >&2; exit 2 ;;
    *) break ;;
  esac
done

Elke herkende optie wordt met shift verwerkt en verwijderd. Het eerste gewone argument beëindigt de optieverwerking; -- beëindigt die ook en wordt zelf verwijderd. De resterende "$@" bevat de bestandsnamen, inclusief een naam die na -- met - begint. Bash getopts ondersteunt uitgebreidere verwerking van korte opties.

Een script zonder toezicht heeft alle verplichte invoer nodig uit argumenten, standaardwaarden of configuratie. read kan blijven wachten op een terminal of onmiddellijk mislukken bij het bestandseinde. Als je een ontbrekend argument door een prompt vervangt, heeft een geplande taak geen betrouwbare manier om verder te gaan.

Cron start commando's op overeenkomende kloktijden. De crontab van elke gebruiker bewaart diens planning en taken worden als die gebruiker uitgevoerd. Een gepland script heeft zowel een correcte tijdexpressie nodig als een omgeving die de paden, invoer en uitvoerbestemming biedt.

Lees de vijf velden

Gebruik crontab -e om je tabel te bewerken en crontab -l om die te bekijken. crontab -r verwijdert de hele tabel zonder te vragen; gebruik de editor om één taak te verwijderen.

30 2 * * * /home/sam/bin/backup.sh

Dit wordt elke dag om 02.30 uur uitgevoerd. Sterretjes accepteren elke waarde in een veld. 0 9 * * 1-5 kiest 09.00 uur op werkdagen en 0 0 1 * * kiest middernacht op de eerste dag van elke maand. Tijden gebruiken de tijdzone van het systeem, tenzij de cron-configuratie een andere ondersteunde tijdzone opgeeft.

Combineer bereiken, lijsten en stapgroottes

Een komma somt waarden op: 1,15 in het veld voor de dag van de maand kiest de eerste en de vijftiende. Een koppelteken geeft een bereik en / leidt een stapgrootte in. */15 in het minutenveld kiest 0, 15, 30 en 45.

*/20 8-10 * * * kiest drie minuten in elk van drie uren: negen dagelijkse uitvoeringen, beginnend om 08.00 uur en eindigend om 10.40 uur. Stapgroottes beginnen opnieuw binnen hun veld. */45 wordt uitgevoerd op minuut 0 en minuut 45 van elk uur; de tussenpoos tot minuut 0 van het volgende uur is slechts 15 minuten.

Als zowel de dag van de maand als de dag van de week is beperkt, is een overeenkomst met een van beide voldoende. 0 12 13 * 5 kiest het middaguur op de 13e en op vrijdagen, niet alleen op vrijdag de 13e. De andere velden moeten nog steeds overeenkomen.

Speciale tekenreeksen vervangen alle vijf velden: @hourly, @daily, @weekly, @monthly, @yearly en @reboot. @daily betekent middernacht, terwijl @reboot eenmaal bij het opstarten wordt uitgevoerd.

Geef paden op en bewaar de uitvoer

Cron gebruikt normaal gesproken /bin/sh voor de commandoregel, een korte PATH en geen opstartinstellingen van een interactieve shell. De eigen Bash-shebang van een uitvoerbaar script kiest nog steeds Bash. Gebruik absolute paden voor het script en de bestanden ervan, of stel PATH bovenaan de crontab in.

30 2 * * * /home/sam/bin/backup.sh >> /home/sam/backup.log 2>&1

De taak voegt beide uitvoerstromen achteraan toe aan het logbestand. Zonder omleiding verstuurt cron uitvoer per e-mail als e-mail is geconfigureerd, ook via MAILTO; anders kan uitvoer verloren gaan. Een procentteken heeft een speciale rol in een crontab-commando: het begint een nieuwe regel en de daaropvolgende invoer. Scherm een datumformaat daar af met een backslash, zoals in date +\%F. Een datumcommando binnen een afzonderlijk script gebruikt de gewone vorm %F.

Maak onderscheid tussen systeemplanningen en inhaaltaken

/etc/crontab en bestanden in /etc/cron.d/ voegen na de vijf tijdvelden een gebruikersveld toe. Zo wordt 30 2 * * * root /usr/local/bin/backup.sh als root uitgevoerd. Voeg dat gebruikersveld niet toe aan een persoonlijke crontab.

Veel distributies voeren ook geschikte uitvoerbare bestanden uit in /etc/cron.daily/, /etc/cron.weekly/ en /etc/cron.monthly/. De standaardnaamgevingsregels van Debian voor run-parts slaan namen met punten over, dus gebruik daar backup-notes, niet backup-notes.sh. Cron mist tijdstippen die verstrijken terwijl de computer uitstaat. Anacron kan periodieke dagelijkse, wekelijkse of maandelijkse taken na het opstarten inhalen.

Systemd scheidt het werk van de planning. Een service-unit beschrijft het uit te voeren commando. Een timerunit beschrijft wanneer het moet starten. Standaard activeert backup.timer de unit backup.service, waarbij de gedeelde basisnaam het paar verbindt.

Schrijf de service en de kalenderplanning

Plaats deze systeemunits in /etc/systemd/system/:

# backup.service
[Unit]
Description=Nightly backup

[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh

Type=oneshot is geschikt voor een script dat één keer wordt uitgevoerd en eindigt. Gebruik een absoluut commandopad en maak het script uitvoerbaar met een Bash-shebang. De timer levert de planning:

# backup.timer
[Unit]
Description=Run backup.service daily at 02:30

[Timer]
OnCalendar=*-*-* 02:30:00
Persistent=true

[Install]
WantedBy=timers.target

OnCalendar vergelijkt datums en kloktijden. Hier accepteert de datum met jokertekens elke dag. Persistent=true maakt inhalen mogelijk nadat de timer inactief was: als minstens één kalenderuitvoering is gemist, start de timer de service eenmaal bij heractivering. Niet elke gemiste uitvoering wordt opnieuw uitgevoerd.

Laad en activeer de timer

sudo systemctl daemon-reload
sudo systemctl enable --now backup.timer

Herlaad na het maken of wijzigen van unitbestanden. enable --now start de timer onmiddellijk en schakelt die in voor toekomstige systeemstarts. Alleen de service inschakelen maakt geen planning. Test het werk afzonderlijk met sudo systemctl start backup.service.

Kies kloktijd of verstreken tijd

Kalenderexpressies kunnen daily gebruiken voor elke dag om middernacht of weekly voor maandag om middernacht. Controleer een expressie met systemd-analyze calendar "Mon..Fri 09:00" om de interpretatie en het volgende tijdstip te zien.

De laatste twee instellingen zijn monotone timers: ze meten de verstreken tijd vanaf een gebeurtenis. Combineer ze voor een eerste uitvoering na het opstarten en latere activeringen per uur. Persistent=true geldt voor kalendertimers; het voegt geen inhaalfunctie voor kalendertaken toe aan monotone timers.

Bekijk planning en resultaten afzonderlijk

systemctl list-timers toont de volgende en laatste activeringen. systemctl status backup.service toont het resultaat van de service en journalctl -u backup.service toont de uitvoer en fouten. Een vermelde volgende uitvoering toont aan dat een planning actief is, niet dat de vorige taak van het script is geslaagd.

Timers hebben een tijdvenster waarbinnen ze afgaan. AccuracySec staat standaard op één minuut; AccuracySec=1s verkleint het venster waarin uitvoeringen worden samengevoegd. RandomizedDelaySec voegt bewust een willekeurige vertraging toe om werk over machines te spreiden. Deze instellingen garanderen bij belasting geen exacte startseconde.

Voer een eigen gebruikerstimer uit

Gebruikersunitbestanden staan in ~/.config/systemd/user/ en commando's gebruiken systemctl --user, waaronder daemon-reload, enable --now en list-timers. Een gebruikersbeheerder draait normaal gesproken tijdens de sessie van die gebruiker. Een beheerder kan met loginctl enable-linger username gebruikersbeheer zonder aanmeldsessie inschakelen om het beschikbaar te houden zonder aanmelding.

Cron heeft een compacte tijdregel nodig en werkt zonder systemd. Timers voegen een serviceresultaat en logboek, het inhalen van kalendertaken en meer controle toe. Geen van beide laadt normaal gesproken ~/.bashrc; beide hebben scripts nodig die werken met expliciete paden en zonder interactieve prompts.