Almanach der Programmiergrundlagen

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Funktionen ======

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. \\

===== Beispiele =====

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?

==== Bash ====
=== Code ===
<code bash>
#!/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"
</code>

=== Ausführen ===
<code bash>
chmod +x factorial.sh # als ausführbar markieren
./factorial.sh        # ausführen
</code>

==== C++ ====
=== Code ===
<code cpp>
#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");
}
</code>

=== Kompilieren und Ausführen ===
Die Datei factorial.cpp mit dem obigen Code erstellen
<code bash>
g++ -Wall -g -std=c++14 factorial.cpp -o factorial # kompilieren
./factorial                                        # ausführen
</code>

==== C# ====
=== Code ===
<code csharp>
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);
    }
  }
}
</code>

==== golang ====
=== Code ===
<code go>
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)
}
</code>

=== Kompilieren und Ausführen ===
Die Datei factorial.go erstellen und so kompilieren und ausführen:
<code bash>
go build factorial.go # kompilieren
./factorial           # ausführen
</code>

oder den [[https://tour.golang.org|Online go compiler]] verwenden

==== Java ====
=== Code ===
<code java>
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);
    }
}
</code>

=== Kompilieren und ausführen ===
Die Datei Factorial.java mit obigen Inhalt erstellen und so zum Laufen bringen:
<code bash>
javac Factorial.java
java Factorial
</code>

==== JavaScript ====
=== Code ===
<code javascript>
<!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>
</code>

=== Ausführen ===
Den obigen Code in die Datei factorial.html kopieren und im Browser öffnen

==== Perl ====
=== Code ===
<code perl>
#!/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";
</code>

=== Ausführen ===
Die Datei factorial.pl mit dem gezeigten Quelltext erstellen und wie folgt ausführen:
<code bash>
perl factorial.pl
</code>

==== PHP ====
=== Code ===
<code php>
<?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";
</code>

=== Ausführen ===
Die Datei factorial.php mit dem gezeigten Code füllen und auf folgende Weise ausführen
<code bash>
php factorial.php
</code>

==== Python ====
=== Code ===
<code python>
#!/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))
</code>

=== Ausführen ===
Die Datei factorial.py mit dem gezeigten Inhalt erstellen und wie folgt ausführen:
<code bash>
python3 factorial.py
</code>

===== Übungen =====
  * 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