Beheersing van de Linux-opdrachtregel · Les

Taken automatiseren met shellfuncties

Schrijf herbruikbare shellfuncties om complexe scripts en workflows te modulariseren en vereenvoudigen.

Les 3 van 411 stappen

Taken automatiseren met shellfuncties is een gratis Beheersing van de Linux-opdrachtregel-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Beheersing van de Linux-opdrachtregel. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Beheersing van de Linux-opdrachtregel bevat in totaal 4 lessen.

Wat zijn shellfuncties?

Shellfuncties zijn net mini-scripts binnen je hoofdscript of shellsessie. Hiermee kun je opdrachten groeperen om een specifieke taak uit te voeren.

Herbruikbaarheid: voer dezelfde reeks opdrachten meerdere keren uit zonder ze opnieuw te schrijven.
Organisatie: deel complexe scripts op in kleinere, beheersbare onderdelen.
Modulariteit: verbeter de leesbaarheid en maak je scripts eenvoudiger te onderhouden.

Zie ze als aangepaste opdrachten die je zelf definieert!

Een eenvoudige functie definiëren

Een functie definiëren is eenvoudig. Je geeft de functie een naam, gevolgd door haakjes (optioneel in sommige shells, maar wel een goede gewoonte), en daarna accolades met de opdrachten.

Probeer dit eenvoudige voorbeeld uit te voeren:

#!/bin/bash

# Define a function named 'say_hello'
say_hello() {
  echo "Hello, CoddyKit user!"
}

# Call the function
say_hello

Functies aanroepen

Nadat je een functie hebt gedefinieerd, kun je deze aanroepen door simpelweg de naam te typen, net als bij elke andere opdracht. Je kunt functies meerdere keren in je script aanroepen.

Zo kun je een functie aanroepen om een herhalende taak uit te voeren:

#!/bin/bash

log_action() {
  echo "[INFO] Action performed: $1"
}

echo "Starting daily tasks..."
log_action "Backup database"
log_action "Clean temporary files"
log_action "Send notification"
echo "Daily tasks completed."

Argumenten aan functies doorgeven

Functies worden veel krachtiger wanneer je er informatie aan kunt doorgeven. Deze gegevens worden argumenten genoemd.

Binnen de functie krijg je toegang tot argumenten via speciale variabelen: $1 voor het eerste argument, $2 voor het tweede, enzovoort. $@ verwijst naar alle argumenten.

#!/bin/bash

greet_person() {
  echo "Hello, $1! Welcome to CoddyKit."
  echo "We heard you like $2."
}

# Call with arguments
greet_person Alice Bash
greet_person Bob Python

Retourwaarden begrijpen

In tegenstelling tot sommige programmeertalen geven shellfuncties niet op de traditionele manier een waarde terug, zoals een getal of tekenreeks. In plaats daarvan geven ze een afsluitstatus terug.

Een afsluitstatus van 0 betekent meestal dat de bewerking is geslaagd, terwijl elk ander getal (1-255) op een fout duidt. Je kunt deze expliciet instellen met de opdracht return. Gebruik echo om uitvoer te krijgen.

#!/bin/bash

check_number() {
  if (( $1 % 2 == 0 )); then
    echo "Number $1 is even."
    return 0 # Success
  else
    echo "Number $1 is odd."
    return 1 # Failure
  fi
}

check_number 4
echo "Exit status: $?"

check_number 7
echo "Exit status: $?"

Lokale variabelen gebruiken

Variabelen die binnen een functie worden gedefinieerd, zijn standaard globaal. Dat betekent dat ze variabelen buiten de functie kunnen beïnvloeden. Dit kan tot onverwacht gedrag leiden.

Gebruik het sleutelwoord local om dit te voorkomen en variabelen te declareren die alleen binnen die functie toegankelijk zijn. Zo blijft het bereik van je functie overzichtelijk.

#!/bin/bash

global_message="I am a global message."

my_function() {
  local function_message="I am local to the function."
  echo "Inside function: $global_message"
  echo "Inside function: $function_message"
}

echo "Outside function (before call): $global_message"
my_function
echo "Outside function (after call): $global_message"
# Trying to access function_message here would fail.

Functies in grotere scripts

Bij langere scripts is het een goede gewoonte om je functies aan het begin te definiëren. Zo zijn ze beschikbaar voordat een deel van het script ze probeert aan te roepen.

Functies helpen om complexe automatiseringstaken op te delen in logische, herbruikbare blokken.

#!/bin/bash

# --- Function Definitions ---
log_info() {
  echo "[INFO] $(date +%H:%M:%S) - $1"
}

create_backup() {
  local target_dir="/tmp/backups"
  log_info "Creating backup in $target_dir..."
  mkdir -p "$target_dir"
  # Simulate backup process
  sleep 1
  log_info "Backup completed for $1."
}

# --- Main Script Logic ---
log_info "Script started."

create_backup "website_data"
create_backup "user_configs"

log_info "Script finished."

Externe functiebestanden inladen

Je kunt functies in een apart bestand opslaan en ze vervolgens met 'source' in je hoofdscript of shellsessie laden. Dit is handig om algemene functies in meerdere scripts te delen.

De opdracht source (of de verkorte vorm .) leest opdrachten uit het opgegeven bestand en voert ze uit in de huidige shellomgeving.

Inhoud van my_library.sh:

#!/bin/bash

hello_world() {
  echo "Hello from my_library!"
}

calculate_square() {
  echo $(( $1 * $1 ))
}

Inhoud van main_script.sh:

#!/bin/bash

source my_library.sh

hello_world
result=$(calculate_square 7)
echo "The square of 7 is: $result"

Wanneer je main_script.sh uitvoert, worden de functies uitgevoerd die in my_library.sh zijn gedefinieerd.

Praktijkvoorbeeld: opdrachten controleren

Dit is een handige functie die controleert of een specifieke opdracht beschikbaar is op het systeem. Je kunt dit gebruiken om te controleren of aan de vereisten is voldaan voordat je script verdergaat.

#!/bin/bash

command_exists() {
  # 'type -P' checks if command exists in PATH
  # '&> /dev/null' redirects all output to nowhere
  type -P "$1" &> /dev/null
}

echo "Checking for common commands..."

if command_exists "git"; then
  echo "Git is installed. Great!"
else
  echo "Git is not installed. Please install it."
fi

if command_exists "nonexistent_command"; then
  echo "This shouldn't print."
else
  echo "'nonexistent_command' is not found, as expected."
fi

Quiz: bereik van functies

Bekijk het volgende shellscript. Wat is de uitvoer?

#!/bin/bash

my_func() {
  local msg="World"
  echo "$1 $msg"
}

msg="CoddyKit"
my_func "Hello"
echo "$msg"

Beantwoord dit in de interactieve les

Samenvatting: shellfuncties

Je beheerst nu shellfuncties! Hier volgt een korte samenvatting:

Functies groeperen opdrachten voor herbruikbaarheid en organisatie.
Definieer ze met function_name() { commands; } en roep ze aan met hun naam.
Geef argumenten door met $1, $2, enzovoort.
Functies geven een afsluitstatus terug (0 bij succes); gebruik echo voor uitvoer.
Gebruik local om variabelen binnen het bereik van een functie te declareren.
Je kunt functies uit externe bestanden inladen om ze te delen.

Functies zijn een krachtig hulpmiddel om overzichtelijkere, efficiëntere en geautomatiseerde shellscripts te schrijven. Blijf oefenen!

Gratis beginnen

Leer Beheersing van de Linux-opdrachtregel met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Taken automatiseren met shellfuncties” gratis?

Ja — de volledige tekst van “Taken automatiseren met shellfuncties” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Beheersing van de Linux-opdrachtregel wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Beheersing van de Linux-opdrachtregel bevat in totaal 4 lessen.

Wat leer ik in “Taken automatiseren met shellfuncties”?

Schrijf herbruikbare shellfuncties om complexe scripts en workflows te modulariseren en vereenvoudigen. Je oefent met Beheersing van de Linux-opdrachtregel door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Beheersing van de Linux-opdrachtregel te beginnen?

Ervaring vooraf is niet nodig. Beheersing van de Linux-opdrachtregel op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Taken automatiseren met shellfuncties”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Beheersing van de Linux-opdrachtregel?

Ja. Elke les over Beheersing van de Linux-opdrachtregel bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Taken plannen: `cron` en `at`
Diensten beheren: `systemctl` (systemd)
Taken automatiseren met shellfuncties
Gecentraliseerde logging en rotatie met journald en logrotate

← Terug naar Beheersing van de Linux-opdrachtregel