Funktionen

Funktionen lassen einen wieder-verwendbare Stücke an Code definieren, die eine bestimmte Funktionalität erfüllen. In vielen Fällen können Funktionen Werte entgegen nehmen, um deren Verhalten zu steuern, aber das ist kein Muss.

Lass uns mit einer simplen Funktion anfangen:

func favoriteAlbum() {
    print("Mein Lieblings-Album ist Fearless")
}

Wenn Du diesen Code in Deinen Playground schreibst, wird nichts ausgegeben. Und ja, das ist korrekt. Der Grund, warum nichts ausgegeben wurde, ist, dass wir die Nachricht "Mein Lieblings-Album ist Fearless" in eine Funktion namens favoriteAlbum() geschrieben haben. Dieser Code wird nicht aufgerufen, bis wir Swift gebeten haben, die favoriteAlbum()-Funktion auszuführen. Um das zu tun, füge folgende Zeile hinzu:

favoriteAlbum()

Dies führt die Funktion aus (bzw. "ruft sie auf"), also siehst Du auch die Ausgabe "Mein Lieblings-Album ist Fearless".

Wie Du sehen kannst, wird eine Funktion definiert, indem man func schreibt, dann den Funktions-Namen, dann Klammern, dann einen Code-Block, der durch geschweifte Klammern begrenzt ist. Du rufst diese Funktion auf, indem Du ihren Namen und dann Klammern schreibst.

Natürlich ist das ein blödes Beispiel - diese Funktion macht immer wieder dasselbe, also hat sie keine Daseinsberechtigung. Aber was, wenn wir jedes Mal ein anderes Album ausgeben wollen? In dem Fall könnten wir Swift sagen, dass unsere Funktion einen Wert entgegen nehmen, wenn sie aufgerufen wird, und diesen Wert dann darin verwenden soll.

Lass uns das tun:

func favoriteAlbum(name: String) {
    print("Mein Lieblings-Album ist \(name)")
}

Das sagt Swift, dass unsere Funktion einen Wert entgegen nehmen soll (wir nennen das "Parameter"), welcher "name" heißt und einen String darstellt. Wir benutzen anschließend String-Interpolation um den Namen des Lieblings-Albums in unsere Ausgabe zu schreiben. Um die Funktion nun aufzurufen, schreiben wir folgendes:

favoriteAlbum(name: "Fearless")

Du wirst Dich möglicherweise immer noch wundern, was das Ziel des Ganzen ist, weil das immer noch eine Zeile Code ist. Nun, stell' Dir vor, wir benutzen diese Funktion an 20 anderen Stellen in einer großen App. Dann kommt Dein Design-Chef und sagt Dir, dass Du die Nachricht auf "Ich liebe Fearless so sehr - es ist mein Lieblings-Album!" ändern sollst. Willst Du wirklich alle 20 Instanzen dieser Nachricht in Deinem Code suchen und ändern? Wahrscheinlich nicht. Eine Funktion änderst Du ein Mal und alles andere bleibt ebenso aktuell.

Deine Funktionen können so viele Parameter entgegen nehmen, wie Du willst, also lass sie uns den Namen und das Jahr entgegen nehmen.

func printAlbumRelease(name: String, year: Int) {
    print("\(name) kam raus im Jahre \(year)")
}

printAlbumRelease(name: "Fearless", year: 2008)
printAlbumRelease(name: "Speak Now", year: 2010)
printAlbumRelease(name: "Red", year: 2012)

Die Namen der Funktions-Parameter sind wichtig und machen im Prinzip einen Teil der Funktion selbst aus. Manchmal wirst Du mehrere Funktionen mit dem gleichen Namen sehen, z.B. handle(), aber sie haben andere Parameter-Namen, um die verschiedenen Funktionalitäten zu unterscheiden.

Externe und Interne Parameter-Namen

Manchmal will man Parameter auf eine bestimmte Weise benennen, wenn die Funktion aufgerufen wird, aber auf eine andere Weise in der Funktion selbst. Soll heißen, dass ein Funktionsaufruf sich fast wie natürliches Englisch lesen, aber die Parameter innerhalb einer Funktion zweckmäßige Namen haben sollen. Diese Technik wird in Swift sehr oft verwendet, also ist es lohnenswert, diese jetzt schon zu verstehen.

Um diese Technik zu demonstrieren, lass uns eine Funktion schreiben, welche die Anzahl an Buchstaben eines Strings ausgibt. Diese bekommt man mit dem count-Attribut von Strings, also könnten wir so etwas schreiben:

func countLettersInString(string: String) {
    print("Der String \(string) hat \(string.count) Buchstaben.")
}

Diese Funktion würde man folgendermaßen aufrufen:

countLettersInString(string: "Hello")

Obwohl das sicher funktioniert, ist das ein bisschen umständlich. Außerdem wäre das nichts, was man im Englischen laut aussprechen würde: “count letters in string string hello”.

Swifts Lösung des Ganzen ist, dass man einen Namen für den Parameter vergeben kann, wenn die Funktion aufgerufen wird, und einen anderen innerhalb der Funktion. Um dies zu gebrauchen, schreibt man den Parameter-Namen zwei Mal - ein Mal für externen Gebrauch, ein Mal für internen.

Beispielsweise könnten wir den Parameter myString nennen, wenn die Funktion aufgerufen wird und str innerhalb der Methode, so wie hier:

func countLettersInString(myString str: String) {
    print("Der String \(str) hat \(str.count) Buchstaben.")
}

countLettersInString(myString: "Hello")  

Du kannst auch einen Unterstrich, _, als externen Parameter-Namen festlegen, was Swift mitteilt, dass dieser Parameter gar keinen externen Namen haben soll. Als Beispiel:

func countLettersInString(_ str: String) {
    print("Der String \(str) hat \(str.count) Buchstaben.")
}

countLettersInString("Hello")

Wie Du sehen kannst, kann man diese Code-Zeile nun wie einen englischen Satz lesen: “count letters in string hello”.

Obwohl es viele Fälle gibt, in denen _ die richtige Wahl ist, ziehen es Swift-Programmierer im Allgemeinen vor, ihre Parameter zu benennen. Und man überlege sich: Warum sollten wir das Wort "String" überhaupt im Funktionsnamen haben wollen - wovon sonst sollen wir denn Buchstaben zählen können?

Was man daher oft sieht, sind externe Parameter-Namen wie "in", "for" und "with" und bedeutsamere interne Namen. Daher wäre die "Swifty" Art und Weise, diese Funktion zu schreiben, die Folgende:

func countLetters(in string: String) {
    print("Der String \(string) hat \(string.count) Buchstaben.")
}

Das bedeutet, dass man die Funktion mit dem Parameter-Namen "in" aufrufen würde, welcher in der Funktion selbst aber keinen Sinn ergibt. Deshalb wird der Parameter innerhalb der Funktion "string" genannt, was mehr Sinn ergibt. Also kann die Funktion folgendermaßen aufgerufen werden:

countLetters(in: "Hello")

Und das ist tatsächlich "Swifty" Code: “count letters in hello” liest sich wie natürliches Englisch, aber der Code selbst ist übersichtlich und verständlich.

Rückgabewerte

Swift-Funtkionen können einen Wert zurück geben, indem man -> und dann einen Datentypen hinter der Parameter-Liste schreibt. Sobald das getan ist, wird Swift dafür sorgen, dass die Funktion auf jeden Fall einen Wert zurück gibt, also machst Du hier wieder ein Versprechen darüber, was der Code tut.

Um ein Beispiel zu geben, lass uns eine Funktion schreiben, welche true zurück gibt, wenn ein Album von Taylor Swift stammt, und false, wenn nicht. Diese soll einen Parameter entgegen nehmen (den Namen des fraglichen Albums) und einen Boolean zurück geben. Hier der Code:

func albumIsTaylor(name: String) -> Bool {
    if name == "Taylor Swift" { return true }
    if name == "Fearless" { return true }
    if name == "Speak Now" { return true }
    if name == "Red" { return true }
    if name == "1989" { return true }

    return false
}

Falls Du Dein neues Wissen über switch/case ausprobieren möchtest, wäre diese Funktion ein Beispiel, wo das gut funktionieren würde.

Du kannst diese nun aufrufen, indem Du einen Album-Namen herein gibst und dann das Ergebnis verarbeitest:

if albumIsTaylor(name: "Red") {
    print("Das ist eins von ihr!")
} else {
    print("Wer hat das gemacht?!")
}

if albumIsTaylor(name: "Blue") {
    print("Das ist eins von ihr!")
} else {
    print("Wer hat das gemacht?!")
}

Sponsor Hacking with Swift and reach the world's largest Swift community!