Shell-scripting in Linux

Shell scripting is als het hebben van een persoonlijke assistent die nooit slaapt, nooit klaagt en jouw opdrachten met robotachtige precisie uitvoert. Het is de kunst van het samenvoegen van commandoregelinstructies om krachtige, geautomatiseerde workflows te creëren.

Hoe kan shell scripting jou helpen?

• Automatiseer repetitieve taken (want het leven is te kort voor ctrl+C, ctrl+V)
• Beheer systeemprocessen als een baas
• Creëer reproduceerbare operaties (zodat je toekomstige zelf je verleden niet vervloekt)
• Flex je Linux-spieren en maak indruk op je collega's

Voordat we aan de slag gaan, laten we één ding duidelijk maken: we hebben het hier over Bash. Natuurlijk zijn er andere shells zoals Zsh, Fish, of de goede oude Sh, maar Bash is de coole gast waar iedereen mee omgaat op de Linux-speelplaats.

Je Eerste Date met Shell Scripting

Laten we beginnen met de klassieke "Hello, World!" want, nou ja, traditie:

#!/bin/bash
echo "Hello, World! Ik ben een shell script, leuk je te ontmoeten!"

Sla dit op als hello_world.sh, en laten we het ontleden:

• #!/bin/bash: Dit wordt een shebang genoemd. Het is alsof je de computer vertelt: "Hé, voer dit uit met Bash, alsjeblieft!"
• echo: Dit commando is als schreeuwen in de leegte, behalve dat de leegte je terminal is.

Nu maken we het uitvoerbaar en voeren we het uit:

chmod +x hello_world.sh
./hello_world.sh

Bam! Je bent nu officieel een shell scripter. Zet dat op je cv! 😄

Variabelen: De Specerij van Shell Leven

Variabelen in shell scripts zijn als containers voor je digitale spullen. Laten we ermee spelen:

#!/bin/bash

# Ken een waarde toe aan een variabele
greeting="Hallo, aardbewoner!"

# Gebruik de variabele
echo $greeting

# Vraag input van de gebruiker
read -p "Wat is je naam? " name
echo "Leuk je te ontmoeten, $name!"

Pro tip: Wanneer je variabelen gebruikt, zet ze tussen accolades zoals ${variable} om dubbelzinnigheid te voorkomen. Je toekomstige zelf zal je dankbaar zijn.

Controle Structuren: Shell naar Je Hand Zetten

Laten we nu wat logica aan onze scripts toevoegen. We beginnen met de if-then-else structuur, het brood en boter van besluitvorming:

#!/bin/bash

read -p "Voer een nummer in: " num

if [ $num -gt 10 ]; then
    echo "Dat is een groot nummer!"
elif [ $num -eq 10 ]; then
    echo "Je hebt de juiste plek geraakt!"
else
    echo "Denk groter!"
fi

En hier is een lus om je het gevoel te geven dat je in The Matrix bent:

#!/bin/bash

for i in {1..5}
do
    echo "Iteratie $i"
    sleep 1  # Pauze voor dramatisch effect
done

echo "Lus voltooid. Geest = Geblazen."

Bestandsbewerkingen: Omdat Data Zichzelf Niet Verplaatst

Laten we een script maken dat een bestand back-upt en een tijdstempel toevoegt:

#!/bin/bash

# Controleer of er een bestandsnaam is opgegeven
if [ $# -eq 0 ]; then
    echo "Gebruik: $0 "
    exit 1
fi

filename=$1
timestamp=$(date +"%Y%m%d_%H%M%S")
backup_file="${filename}_${timestamp}.bak"

# Controleer of het bestand bestaat
if [ ! -f "$filename" ]; then
    echo "Fout: Bestand '$filename' niet gevonden."
    exit 1
fi

# Maak de backup
cp "$filename" "$backup_file"

if [ $? -eq 0 ]; then
    echo "Backup succesvol aangemaakt: $backup_file"
else
    echo "Fout: Backup mislukt."
fi

Dit script introduceert enkele nieuwe concepten:

• $#: Het aantal argumenten dat aan het script is doorgegeven
• $1: Het eerste argument dat aan het script is doorgegeven
• $(command): Commando substitutie - voert een commando uit en retourneert de uitvoer
• $?: De exitstatus van het laatste commando (0 betekent succes)

Foutafhandeling: Omdat Fouten Gebeuren

Laten we ons script upgraden met wat foutafhandeling:

#!/bin/bash

set -e  # Stop onmiddellijk als een commando een niet-nul status heeft
set -u  # Behandel niet-ingestelde variabelen als een fout

log_error() {
    echo "FOUT: $1" >&2
}

backup_file() {
    local filename=$1
    local backup_dir="/tmp/backups"

    # Maak backup directory als deze niet bestaat
    mkdir -p "$backup_dir" || { log_error "Maken van backup directory mislukt"; return 1; }

    # Kopieer bestand naar backup directory
    cp "$filename" "$backup_dir" || { log_error "Kopiëren van bestand mislukt"; return 1; }

    echo "Backup van $filename gemaakt in $backup_dir"
}

# Hoofdscript uitvoering
main() {
    if [ $# -eq 0 ]; then
        log_error "Gebruik: $0 "
        exit 1
    fi

    backup_file "$1"
}

main "$@"

Dit script introduceert:

• set -e en set -u voor strengere foutcontrole
• Een functie voor foutlogboek
• Een hoofdfunctie om de logica van het script te organiseren

Geavanceerde Technieken: Je Shell Spel Verbeteren

Nu we de basis hebben behandeld, laten we eens kijken naar enkele meer geavanceerde technieken:

1. Gebruik van Arrays

#!/bin/bash

# Declareer een array
fruits=("appel" "banaan" "kers")

# Loop door de array
for fruit in "${fruits[@]}"
do
    echo "Ik hou van $fruit"
done

# Voeg een element toe aan de array
fruits+=("dadel")

# Print de hele array
echo "Alle vruchten: ${fruits[*]}"

2. Functie met Return Waarden

#!/bin/bash

is_even() {
    if [ $(($1 % 2)) -eq 0 ]; then
        return 0  # Waar (in bash, 0 is waar)
    else
        return 1  # Onwaar
    fi
}

number=42
if is_even $number; then
    echo "$number is even"
else
    echo "$number is oneven"
fi

3. Lezen uit een Bestand

#!/bin/bash

filename="sample.txt"

while IFS= read -r line
do
    echo "Regel: $line"
done < "$filename"

Best Practices: Schiet Jezelf Niet in de Voet

• Gebruik altijd set -e en set -u aan het begin van je scripts
• Citeer je variabelen: "$variable" in plaats van $variable
• Gebruik local variabelen in functies om vervuiling van de globale namespace te voorkomen
• Commentaar op je code (je toekomstige zelf zal je dankbaar zijn)
• Gebruik betekenisvolle variabele- en functienamen
• Test je scripts grondig, vooral randgevallen

Veelvoorkomende Valkuilen: Leer van de Fouten van Anderen

• Vergeten je script uitvoerbaar te maken (chmod +x script.sh)
• Gebruik van == in plaats van = voor stringvergelijking in test haakjes
• Geen rekening houden met spaties in bestandsnamen (gebruik aanhalingstekens!)
• Aannemen dat een commando is geslaagd zonder de exitstatus te controleren

Afronding: De Shell en Verder

Gefeliciteerd! Je hebt je eerste stappen gezet in de krachtige wereld van shell scripting. Met deze vaardigheden ben je goed op weg om taken te automatiseren, systemen te beheren en in het algemeen een commandoregel-ninja te zijn.

Onthoud, shell scripting is nog maar het begin. Naarmate je meer vertrouwd raakt, wil je misschien verkennen:

• Meer geavanceerde tekstverwerking met awk en sed
• Je scripts plannen met cron
• Je scripts versiebeheer met Git
• Je scripts integreren met andere tools en diensten

Blijf experimenteren, blijf leren, en vooral, blijf scripten! De commandoregel is jouw oester, en je hebt de tools om hem open te breken.

"Het verschil tussen een goede beheerder en een geweldige beheerder is ongeveer 40 shell scripts." - Onbekend

Ga nu en automatiseer alle dingen! 🚀