Ab hier wird es spannend. Sollte dir der Kopf noch nicht rauchen - Hier passierts bestimmt.

Funktionen sind ein wichtiger Bestandteil, um den Code zu organisieren, lesbarer und verständlicher zu machen. Sie verhindern Codedopplungen und machen das Testen wesentlich einfacher.

Je nach Programmiersprache spricht man von Funktion, Methode, Prozedur oder Routine. Der Einfachheit halber wird hier beim Term Funktion geblieben.

Funktionen sollte man so kurz wie möglich halten, dafür mehr davon. Das steigert die Lesbarkeit eines Codes enorm.

Funktionen können iterativ oder rekursiv sein. Rekursionen sind recht elegant, für Anfänger aber oft schwer zu verstehen. Eine rekursive Funktion ruft sich selbst mit veränderten Parametern auf.

In den folgenden Beispielen wird die Fakultät einer Zahl berechnet. Einmal iterativ und einmal rekursiv. Die Fakultät einer Zahl ist äusserst einfach erklärt. Die Fakultät von 1 ist 1, die Fakultät von 2 ist 2*1, die Fakultät von 3 ist 3*2*1 und so weiter. Die Fakultät wird in der Mathematik auch mit einem ! gekennzeichnet. 4! = 4*3*2*1. Einfach, oder?

#!/bin/bash
 
# Definieren der iterativen Funktion
function factorial_iterativ {
  # Parameter auslesen
  local n=$1
  # Ergebnis Variable anlegen
  local result=1
 
  # die iterative Berechnung
  while [ $n -gt 1 ]; do
    result=$(($result * $n))
    let n=n-1
  done
 
  # das Ergebnis ausliefern
  echo $result
}
 
# und das ist die rekursive Variante
function factorial_recursive {
  # Parameter auslesen
  local n=$1
  # nächsten Parameter berechnen
  local m=$(($n - 1))
 
  # Abbruchbedingung => parameter ist kleiner als 2. Wir geben einfach 1 zurück.
  if [ $n -lt 2 ]; then 
    echo 1
  # Abbruchbedingung => parameter ist 2. Die Multiplikation mit 1 lassen wir aus
  elif [ $n -eq 2 ]; then 
    echo $n
  else
    # Der rekursive Aufruf
    echo $(($n * `factorial_recursive $m`))
  fi
}
 
# Wir wollen die Fakultät von 5 berechnen
num=5
# Zuerst iterativ...
ret1=$(factorial_iterativ $num)
# ...dann rekursiv
ret2=$(factorial_recursive $num)
 
# Und dann geben wir das Ergebnis aus
echo "Die Fakultät von $num ist $ret1"
echo "Die Fakultät von $num ist $ret2"

chmod +x factorial.sh # als ausführbar markieren
./factorial.sh        # ausführen

#include <iostream>
 
// definieren der iterativen variante
int factorial_iterative(int n) { 
  // Ergebnisvariable anlegen
  int result = 1;
 
  // solange n > 1 (man könnte auch n >= 2 schreiben)
  while(n > 1) {
    // multipliziere das Ergebnis mit n
    result *= n;
    // zähle Eins von n weg
    n--;
  }
 
  // Das Ergebnis zurück geben
  return result;
}
 
// und der rekursiven Variante
int factorial_recursive(int n) {
  // erste Abbruchbedingung => n ist kleiner als 2.
  if (n < 2) {
    return 1;
  }
  // zweite Abbruchbedingung => n ist gleich zwei
  else if (n == 2) {
    return n;
  }
  // der rekursive aufruf
  else {
    return n * factorial_recursive(n-1);
  }
}
 
int main() {
  // Die Fakultät von 5 ist gefragt
  int num = 5;
 
  // Die beiden Berechnungen anstellen...
  int ret1 = factorial_iterative(num);
  int ret2 = factorial_recursive(num);
 
  // ...und deren Ergebnis ausgeben
  printf("%s%d%s%d%s", "Die Fakultät von ", num, " ist ", ret1, "\n");
  printf("%s%d%s%d%s", "Die Fakultät von ", num, " ist ", ret2, "\n");
}

Die Datei factorial.cpp mit dem obigen Code erstellen

g++ -Wall -g -std=c++14 factorial.cpp -o factorial # kompilieren
./factorial                                        # ausführen

using System;
 
namespace Functions { 
  class Factorial {
    public int Factorial_Iterative(int n) {
      int result = 1;
 
      while (n > 1) {
        result *= n;
        n--;
      }
 
      return result;
    }
    public int Factorial_Recursive(int n) {
      if (n < 2) {
        return 1;
      } else if (n == 2) {
        return n;
      } else {
        return n * Factorial_Recursive(n-1);
      }
    }
    static void Main() {
      int num = 5;
      Factorial fr = new Factorial();
 
      int res1 = fr.Factorial_Iterative(num);
      int res2 = fr.Factorial_Recursive(num);
 
      Console.WriteLine("Die Fakultät von "+num+" ist "+res1);
      Console.WriteLine("Die Fakultät von "+num+" ist "+res2);
    }
  }
}

package main
 
import "fmt"
 
func factorial_iterative(n int) int {
    result := 1
 
    for (n > 1) {
        result *= n
        n--
    }
 
    return result
}
 
func factorial_recursive(n int) int {
    if(n < 2) {
        return 1;
    } else if (n == 2) {
        return n;
    } else {
        return n * factorial_recursive(n-1)
    }
}
 
func main() {
    num := 5
    res1 := factorial_iterative(num)
    res2 := factorial_recursive(num)
    fmt.Println("Die Fakultät von ", num, " ist ", res1)
    fmt.Println("Die Fakultät von ", num, " ist ", res2)
}

Die Datei factorial.go erstellen und so kompilieren und ausführen:

go build factorial.go # kompilieren
./factorial           # ausführen

oder den Online go compiler verwenden

public class Factorial {
    private int factorial_iterative(int n) {
        int result = 1;
 
        while(n > 1) {
            result *= n;
            n--;
        }
 
        return result;
    }
 
    private int factorial_recursive(int n) {
        if(n < 2) {
            return 1;
        } else if (n == 2) {
            return n;
        } else {
            return n * factorial_recursive(n-1);
        }
    }
 
    public static void main(String[] args) {
        int num = 5;
        Factorial f = new Factorial();
 
        int res1 = f.factorial_iterative(num);
        int res2 = f.factorial_recursive(num);
 
        System.out.println("Die Fakultät von "+num+" ist "+res1);
        System.out.println("Die Fakultät von "+num+" ist "+res2);
    }
}

Die Datei Factorial.java mit obigen Inhalt erstellen und so zum Laufen bringen:

javac Factorial.java
java Factorial

<!DOCTYPE HTML>
<!-- HTML Grundstruktur -->
<html>
  <body>
    <script>
      // Variable anlegen
      var factorial_iterative = function(n) {
          result = 1;
 
          while (n > 1) {
              result *= n;
              n--;
          }
 
          return result;
      }
      var factorial_recursive = function(n) {
          if(n < 2) {
              return 1;
          } else if (n == 2) {
              return n;
          } else {
              return n * factorial_recursive(n-1);
          }
      }
 
      num = 5;
 
      res1 = factorial_iterative(num);
      res2 = factorial_iterative(num);
 
      alert("Die Fakultät von "+num+" ist "+res1);
      alert("Die Fakultät von "+num+" ist "+res2);
    </script>
  </body>
</html>

Den obigen Code in die Datei factorial.html kopieren und im Browser öffnen

#!/usr/bin/perl
 
sub Factorial_Iterative {
  my $n = shift;
 
  $result = 1;
 
  while ($n > 1) {
    $result *= $n;
    $n = $n - 1;
  }
 
  return $result;
}
 
sub Factorial_Recursive {
  my $n = shift;
 
  if ($n < 2) {
    return 1;
  } elsif ($n == 2) {
    return $n;
  } else {
    return $n * Factorial_Recursive($n - 1);
  }
}
 
my $num = 5;
 
my $res1 = Factorial_Iterative($num);
my $res2 = Factorial_Recursive($num);
 
print "Die Fakultät von $num ist $res1\n";
print "Die Fakultät von $num ist $res2\n";

Die Datei factorial.pl mit dem gezeigten Quelltext erstellen und wie folgt ausführen:

perl factorial.pl

<?php
function factorial_iterative($n) {
    $result = 1;
 
    while($n > 1) {
        $result *= $n;
        $n--;
    }
 
    return $result;
}
function factorial_recursive($n) {
    if($n < 2) {
        return 1;
    } else if ($n == 2) {
        return $n;
    } else {
        return $n * factorial_recursive($n - 1);
    }
}
 
$num = 5;
 
$res1 = factorial_iterative($num);
$res2 = factorial_recursive($num);
 
echo "Die Fakultät von $num ist $res1\n";
echo "Die Fakultät von $num ist $res2\n";

Die Datei factorial.php mit dem gezeigten Code füllen und auf folgende Weise ausführen

php factorial.php

#!/usr/bin/python3
 
def factorial_iterative(n):
    result = 1
 
    while(n > 1):
        result *= n
        n = n - 1
 
    return result
 
def factorial_recursive(n):
    if(n < 2):
        return 1
    elif (n == 2):
        return n
    else:
        return n * factorial_recursive(n-1)
 
num = 5
 
res1 = factorial_iterative(num)
res2 = factorial_recursive(num)
 
print("Die Fakultät von "+str(num)+" ist "+str(res1))
print("Die Fakultät von "+str(num)+" ist "+str(res2))

Die Datei factorial.py mit dem gezeigten Inhalt erstellen und wie folgt ausführen:

python3 factorial.py

• Schreibe eine Funktion, die zwei Zahlen multipliziert und das Ergebnis zurück gibt
• Schreibe eine Funktion, die prüft, ob eine Zahl gerade oder ungerade ist. Das Ergebnis soll true oder false sein
• Schreibe eine Funktion, die prüft, ob eine Zahl ohne Rest durch drei dividierbar ist
• Schreibe eine Funktion, die prüft, ob ein Datum korrekt ist
• Schreibe eine Funktion, die eine Datei (Parameter ist der Pfad der Datei) ausliest und ausgibt