© Liashko/Shutterstock.com
Kolumne: Die Golumne

Kolumne: Die Golumne


Was soll an Funktionen so besonders sein? Sie begleiten uns doch fast seit Anbeginn der Softwareentwicklung, und mit der funktionalen Programmierung existiert auch ein entsprechendes Paradigma. Was also macht Go an dieser Stelle dann so besonders? Ganz einfach: nichts. Doch ganz dem Motto der Sprache entsprechend, lässt sich die Arbeit mit Funktionen und ihren Verwandten, den Methoden, ganz pragmatisch an. Und ebenso können sie Bestandteil schöner Lösungen werden.

Fangen wir mit den ganz einfachen Funktionen an. Sie können entweder kein, ein, mehrere oder eine variable Anzahl von Argumenten annehmen. Auf der Rückgabeseite gilt Ähnliches, also kein, ein oder mehrere Rückgabewerte.

func SayHello() { ... }
 
func Div(v ...float64) (float64, error) { ... }

Während die erste Funktion einfach in sich geschlossen ist, ohne Argumente und Rückgabe, nimmt die zweite von gar keinem Argument bis zu einer unbegrenzten Anzahl float64 entgegen. Diese sollen in der Funktion dividiert werden. Und da 0 nicht so gut wäre, wird das geprüft und im entsprechenden Fall ein Fehler ausgegeben. Hier ist zu sehen, wie dieser als letzter zurückgegeben wird. Das ist eine der Konventionen in Go: Fehler werden allein zurückgegeben oder sind die letzten der Werte.

Diese Funktionen überraschen noch nicht. Schön ist jedoch, dass sie auch nur Typen sind. So lässt sich ein eigener Funktionstyp leicht deklarieren:

type FilterFunc func(string) bool

Dort, wo dieser Typ dann zum Einsatz kommt, kann die Implementierung recht einfach ausgetauscht werden (Listing 1).

Listing 1

func Filter(in []string, isOK FilterFunc) []string {
  var out []string
  for _, s := range in {
    if isOK(s) {
      out = append(out, s)
    }
  }
  return out
}

Beim Aufruf kann die jeweilige Filterfunktion übergeben werden. Wenn zum Beispiel alle Strings mit mehr als zwanzig Zeichen aus einer Menge von Strings herausgefiltert werden sollen, geht dies auf folgende simple Weise:

out := Filter(in, func(s string) bool {
  return len(s) <= 20
})

In diesem Fall wird eine anonyme, an Ort und Stelle definierte Funktion übergeben. Doch das sieht Go glücklicherweise nicht so genau. Wichtig ist nur die Signatur der Funktion; damit können auch zuvor oder in anderen Packages definierte Funktionen übergeben werden.

func MaxTwenty(s string) bool {
  return len(s) <= 20
}
 
. . .
 
out := Filter(in, MaxTwenty)

Wichtig ist, an dieser Stelle nur den Bezeichner der Funktion zu übergeben. Das gilt für Funktionen, die Variablen zugewiesen sind, für statische Funktion und auch für Methoden, denn auch die lassen sich als Argument übergeben. Auf diese Weise weiß der Compiler, dass nur die Referenz auf die Funktion übergeben wird. Ein versehentlicher Aufruf der Funktion, zum Beispiel via Filter(in, MaxTwenty(„foo“)), würde bedeuten, dass der Rückgabewert von MaxTwenty() an Filter() übergeben wird. Das ist jedoch ein bool und nicht der definierte Funktionstyp.

Doch Funktionen können nicht nur Argumente sein, sie können auch als Rückgabewerte von Funktionen zurückgegeben werden. Das Schöne dieser Funktionen ist, dass sie Zugriff auf die ihr übergeordneten Variablen haben. Das schließt auch die Argumente des Erzeugers ein. Auf diesem Weg lässt sich die zurückgegebene Funktion leicht parametrisieren.

Listing 2

func MakeFilter(max int) FilterFunc {
  return func(s string) bool {
    return len(s) <= max
  }
}
 
. . .
 
out := Filter(in, MakeFilter(80))

So haben wir in Listing 2 nun alles: Eine Funktion, die eine anonyme Funktion zurückgibt und eine Funktion, die diese wiederum als Argument entgegennimmt. Diese schon seit langer Zeit bekannten Funktionen höherer Ordnung ...

headline from sands settings