Variable Anzahl an Argumenten in einer Kotlin-Funktion

In Kotlin gibt es die Möglichkeit, eine Funktion so zu definieren, dass sie eine variable Anzahl an Argumenten mit demselben Datentyp entgegennehmen kann. Dies nennt man ein Vararg-Parameter. Dies ist nützlich, wenn man nicht genau weiß, wie viele Argumente an die Funktion übergeben werden. Ein Vararg-Parameter wird in der Funktionsdeklaration mit dem Schlüsselwort vararg gekennzeichnet.

Beispiel: Nehmen wir an, dass wir eine Reihe von Zahlen vom Datentyp Int an eine Funktion übergeben möchten, ohne genau zu wissen, wie viele Zahlen es sein werden. Um diesen Fall abzubilden, kann uns die folgende Funktion mit variabler Anzahl an Argumenten helfen:

fun main() {
    printAllNumbers(1, 2, 3, 4, 5)
    println()
    printAllNumbers(10, 15, 20, 25, 30, 35, 40, 45, 50)
}

fun printAllNumbers(vararg numbers: Int) {    // Deklaration der Funktion mit variabler Anzahl an Argumenten
    for (number in numbers) {                 // Innerhalb der Funktion können wir dann auf die übergebenen Zahlen mithilfe einer for-Schleife wie auf ein Array zugreifen
        print("$number ")
    }
}

Ein weiteres Beispiel ist, wenn wir eine Funktion haben möchten, die die Summe aller Zahlen berechnet, die ihr übergeben werden:

fun main() {
    val result1 = sumOfAllNumbers(1, 2, 3, 4, 5)
    println(result1)
    val result2 = sumOfAllNumbers(10, 15, 20, 25, 30)
    println(result2)
}

fun sumOfAllNumbers(vararg numbers: Int): Int {
    var sum: Int = 0
    for (number in numbers) {
        sum = sum + number
    }
    return sum
}

Vararg-Parameter können auch mit benannten Argumenten kombiniert werden. Zum Beispiel kann eine Funktion mehrere benannte Argumente und einen Vararg-Parameter haben. In solchen Fällen wird der vararg-Parameter normalerweise an letzter Stelle in der Parameterliste eingesetzt.

fun main() {
    printWithText("Number", 1, 2, 3, 4, 5)
}

fun printWithText(text: String, vararg numbers: Int) {
    for (number in numbers) {
        println("$text: $number")
    }
}

Es ist aber kein Muss,  wenn es nach einem vararg-Parameter noch andere Parameter gibt, werden bei dem Funktionsaufruf die Werte dieser Parameter über benannte Argumente übergeben:

fun main() {
    printWithText("Begin of sequence", "Number", 1, 2, 3, 4, 5, text3="End of sequence")  // Nach vararg-Parameter wird der Wert 'End of sequence' über das benannte Argument 'text3' übergeben
}

fun printWithText(text1: String, text2: String, vararg numbers: Int, text3: String) {
    println(text1)
    for (number in numbers) {
        println("$text2: $number")
    }
    println(text3)
}

Spread-Operator (*)

Normalerweise wird ein Array als ein Einzelargument an eine Funktion übergeben. In oben dargestellten Beispielen würde das einen Kompilierungsfehler auslösen. Der Spread-Operator (*) hilft uns, jedes Element eines Arrays als ein separates Argument an eine Funktion zu übergeben.

fun main() {
    val nums = intArrayOf(1, 2, 3, 4)
    numberPlusNumber(*nums, plusNumber = 1)  // Mithilfe des Operators '*' werden Elemente aus dem Array 'nums' einzeln an die Funktion 'numberPlusNumber' übergeben
}

fun numberPlusNumber(vararg sequenceOfNumbers: Int, plusNumber: Int) {
    for(number in sequenceOfNumbers)
    println(number + plusNumber)
}