When coding in Swift, there is a function that all developers undeniably call generously and without much thinking, and that is print. We all use it every day, everywhere; and most of the times, it’s our path towards fast and dirty debugging.
Even though print seems to be winning the battle among the most used commands in Swift, have you ever wondered how it makes it possible to accept an arbitrary number of arguments? And even more, have you ever wanted to implement our own functions that would be acting just like print?
If so, then the answer to all that is simple and has a name; variadic parameters.
Functions with variadic parameters
A function with a variadic parameter is a function with a parameter that can accept zero, one, or more arguments of the same type. To indicate that a parameter is variadic, all we have to do is to append three dots after the parameter’s data type.
Using the value of a variadic parameter is also pretty straightforward inside a function’s body; we treat it as an array. Take a look at the following example that showcases all that:
|
1 2 3 4 5 |
func createSentence(_ words: String…) -> String { words.joined(separator: ” “) } |
createSentence(_:) is a simple function that creates a sentence using the words given as arguments. That sentence can be as short or as long as we want, and its length depends on the number of provided words. For instance:
|
1 2 3 4 5 6 7 |
let sentence = createSentence(“Variadic”, “parameters”, “in”, “Swift!”) print(sentence) // It prints: // Variadic parameters in Swift! |
The following function is similar to the previous one; the only thing that changes is the parameter, which this time is an array of String values:
|
1 2 3 4 5 |
func createSentence(_ words: [String]) -> String { words.joined(separator: ” “) } |
There are two differences when it comes to using the above, comparing always to the first function with the variadic parameter. The first one regards the way we pass values to the function; it has to be an array, in contrast to the previous example where values were separated simply with the comma symbol:
|
1 2 3 4 5 6 7 |
let anotherSentence = createSentence([“Hello”, “Swift”, “world!”]) print(anotherSentence) // It prints: // Hello Swift world! |
The second difference has already been mentioned; it’s that the function with the variadic parameter can accept zero arguments. The following is perfectly correct as variadic parameters allow to do so:
|
1 2 3 |
let empty = createSentence() |
empty is going to be an empty String in this case. In the second function, we can still avoid providing any values; yet, it remains mandatory to pass an empty array:
|
1 2 3 |
let anotherEmpty = createSentence([]) |
Here is a different example of a function with a variadic parameter:
|
1 2 3 4 5 6 7 |
func averageTemperature(_ temperatures: Double…) -> Double { !temperatures.isEmpty ? temperatures.reduce(0, { $0 + $1 }) / Double(temperatures.count) : 0 } |
What the above does, is to calculate the average temperature of all those given as arguments. Since temperatures is a variadic parameter, we can supply as many temperature values as we desire, even none. In the latter case, the returned value is just zero:
|
1 2 3 4 5 6 7 8 9 10 11 |
var avg = averageTemperature(22.3, 25.4, 24, 26.2, 22.1) print(avg) // It prints: // 24.0 avg = averageTemperature() print(avg) // It prints: // 0.0 |
Note that having a variadic parameter can exist with other normal parameters as well. As an example, see the following function that stores an athlete’s scores in various sport competitions; the athlete’s name is expected to be given as well:
|
1 2 3 4 5 6 7 8 9 10 |
struct Performance { var name: String var scores: [Double] } func keepPerformance(_ scores: Double…, name: String) -> Performance { Performance(name: name, scores: [scores]) } |
Having multiple variadic parameters
Up until Swift 5.4, a function could contain just one variadic parameter. However, this has changed since version 5.4, and functions may have multiple such parameters.
There is just a requirement necessary to keep in mind, and it became obvious in the previous example; the next parameter after a variadic one should have an argument label, so it’s clear to the compiler which arguments are given to the variadic and which to the next parameter.
The following code demonstrates a function that contains three variadic parameters; note that normal parameters can always get into the mix too:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
func showGameInfo(_ players: String…, points: Int…, fouls: Int…) { for i in 0..<players.count { print(“”“ Player \(players[i]) scored \(i < points.count ? points[i] : 0) points and commited \(i < fouls.count ? fouls[i] : 0) fouls. ““”) } } showGameInfo(“John”, “Tom”, “Max”, “Ben”, “Matt”, points: 8, 4, 0, 4, fouls: 3, 2) // It prints: // Player John scored 8 points and commited 3 fouls. // Player Tom scored 4 points and commited 2 fouls. // Player Max scored 0 points and commited 0 fouls. // Player Ben scored 4 points and commited 0 fouls. // Player Matt scored 0 points and commited 0 fouls. |
Summary
Variadic parameters is an easy topic in Swift, and a tool that worths considering when it comes to function parameters. If you are implementing a function or method with parameters that can accept zero or more values, then think about using variadic parameters; you’ll end up with a bit more readable and clearer code, and you keep the advantages of array handling. In any case, I hope you found this post interesting; thank you for reading!
This post has also been published on Medium.