Funktionen

Eine Funktion ist wie ein kleines Programm, das einen eigenen Namen hat und durch das Aufrufen dieses Namens aus einer anderen Funktion ausgeführt (aufgerufen) werden kann.

Eine Funktion fasst eine Gruppe von Aktivitäten zusammen und ist die grundlegendste Methode, um Ihre Programme zu organisieren und Code wiederzuverwenden.

Sie übergeben Informationen an eine Funktion, und die Funktion verwendet diese Informationen, um ein Ergebnis zu berechnen und zu erzeugen. Die Grundform einer Funktion ist:

fun functionName(p1: Type1, p2: Type2, ...): ReturnType {
  lines of code
  return result
}

p1 und p2 sind die Parameter: die Informationen, die Sie in die Funktion übergeben. Jeder Parameter hat einen Bezeichnernamen (p1, p2) gefolgt von einem Doppelpunkt und dem Typ dieses Parameters. Die schließende Klammer der Parameterliste wird von einem Doppelpunkt und dem Typ des von der Funktion erzeugten Ergebnisses gefolgt. Die Codezeilen im Funktionskörper sind in geschweifte Klammern eingeschlossen. Der Ausdruck nach dem Schlüsselwort return ist das Ergebnis, das die Funktion erzeugt, wenn sie abgeschlossen ist.

Ein Parameter definiert, was in eine Funktion übergeben wird — er ist der Platzhalter. Ein Argument ist der tatsächliche Wert, den Sie in die Funktion übergeben.

Die Kombination aus Name, Parametern und Rückgabetyp wird als Funktionssignatur bezeichnet.

Hier ist eine einfache Funktion namens multiplyByTwo():

// Functions/MultiplyByTwo.kt

fun multiplyByTwo(x: Int): Int {  // [1]
  println("Inside multiplyByTwo") // [2]
  return x * 2
}

fun main() {
  val r = multiplyByTwo(5)        // [3]
  println(r)
}
/* Output:
Inside multiplyByTwo
10
*/

• [1] Beachten Sie das fun Schlüsselwort, den Funktionsnamen und die Parameterliste, die aus einem einzigen Parameter besteht. Diese Funktion nimmt einen Int Parameter und gibt einen Int zurück.
• [2] Diese zwei Zeilen sind der Körper der Funktion. Die letzte Zeile gibt den Wert ihrer Berechnung x * 2 als Ergebnis der Funktion zurück.
• [3] Diese Zeile ruft die Funktion mit einem geeigneten Argument auf und erfasst das Ergebnis in val r. Ein Funktionsaufruf imitiert die Form seiner Deklaration: den Funktionsnamen, gefolgt von Argumenten in Klammern.

Der Funktionscode wird durch Aufrufen der Funktion ausgeführt, wobei der Funktionsname multiplyByTwo() als Abkürzung für diesen Code dient. Aus diesem Grund sind Funktionen die grundlegendste Form der Vereinfachung und Wiederverwendung von Code in der Programmierung. Sie können auch an eine Funktion als Ausdruck mit austauschbaren Werten (den Parametern) denken.

println() ist ebenfalls ein Funktionsaufruf – er wird einfach von Kotlin bereitgestellt. Wir beziehen uns auf von Kotlin definierte Funktionen als Bibliotheksfunktionen.

Wenn die Funktion kein sinnvolles Ergebnis liefert, ist ihr Rückgabetyp Unit. Sie können Unit explizit angeben, wenn Sie möchten, aber Kotlin erlaubt es Ihnen, es wegzulassen:

// Functions/SayHello.kt

fun sayHello() {
  println("Hallo!")
}

fun sayGoodbye(): Unit {
  println("Auf Wiedersehen!")
}

fun main() {
  sayHello()
  sayGoodbye()
}
/* Output:
Hallo!
Auf Wiedersehen!
*/

Sowohl sayHello() als auch sayGoodbye() geben Unit zurück, aber sayHello() lässt die explizite Deklaration weg. Die main()-Funktion gibt ebenfalls Unit zurück.

Wenn eine Funktion nur einen einzigen Ausdruck enthält, können Sie die abgekürzte Syntax mit einem Gleichheitszeichen gefolgt von dem Ausdruck verwenden:

fun functionName(arg1: Type1, arg2: Type2, ...): ReturnType = expression

Ein Funktionskörper, der von geschweiften Klammern umgeben ist, wird als Blockkörper bezeichnet. Ein Funktionskörper, der die Gleichungssyntax verwendet, wird als Ausdruckskörper bezeichnet.

Hier verwendet multiplyByThree() einen Ausdruckskörper:

// Functions/MultiplyByThree.kt

fun multiplyByThree(x: Int): Int = x * 3

fun main() {
  println(multiplyByThree(5))
}
/* Output:
15
*/

Dies ist eine kurze Version, um return x * 3 innerhalb eines Blockkörpers zu sagen.

Kotlin leitet den Rückgabetyp einer Funktion ab, die einen Ausdruckskörper hat:

// Functions/MultiplyByFour.kt

fun multiplyByFour(x: Int) = x * 4

fun main() {
  val result: Int = multiplyByFour(5)
  println(result)
}
/* Output:
20
*/

Kotlin leitet ab, dass multiplyByFour() ein Int zurückgibt.

Kotlin kann Rückgabetypen nur für Ausdruckskörper ableiten. Wenn eine Funktion einen Blockkörper hat und Sie ihren Typ weglassen, gibt diese Funktion Unit zurück.

• -

Beim Schreiben von Funktionen sollten Sie beschreibende Namen wählen. Dies macht den Code leichter lesbar und kann oft die Notwendigkeit für Codekommentare reduzieren. Wir können nicht immer so beschreibend sein, wie wir es uns wünschen würden, mit den Funktionsnamen in diesem Buch, weil wir durch die Zeilenbreiten eingeschränkt sind.

Übungen und Lösungen finden Sie unter www.AtomicKotlin.com.