Swift demystifying Variadic Parameters, write flexible and concise code

Swift is a powerful and expressive programming language that allows developers to write clean, efficient, and reusable code. One of the language’s features is variadic parameters, which allow a function to accept an arbitrary number of arguments.

Variadic parameters are useful when you don’t know how many arguments a function will need to accept. By using this feature, you can write functions that are more flexible and can handle a variety of input sizes.

To declare a variadic parameter, you need to add three dots (…) after the parameter’s type. For example:

func sum(_ numbers: Double...) -> Double {
    var total = 0.0
    for number in numbers {
        total += number
    }
    return total
}

In this example, the sum function accepts an arbitrary number of Double values. You can pass in one value, two values, or even no values. The function will add up all of the values and return the total.

let total1 = sum()
let total2 = sum(1.0)
let total3 = sum(1.0, 2.0)
let total4 = sum(1.0, 2.0, 3.0)

In the first call, the function is called with no arguments. The function returns 0.0 since there are no numbers to add up. In the second call, the function is called with one argument, so it returns the same value. In the third call, the function is called with two arguments, so it adds them up and returns the total. In the fourth call, the function is called with three arguments, so it adds them up and returns the total.

Variadic parameters can also be used with other types, such as strings or arrays. Here’s an example that concatenates an arbitrary number of strings:

func concatenateStrings(_ strings: String...) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

In this example, the concatenateStrings function accepts an arbitrary number of String values. You can pass in one string, two strings, or even no strings. The function will concatenate all of the strings and return the result.

let result1 = concatenateStrings()
let result2 = concatenateStrings("Hello")
let result3 = concatenateStrings("Hello", " ", "World")

In the first call, the function is called with no arguments. The function returns an empty string since there are no strings to concatenate. In the second call, the function is called with one argument, so it returns the same string. In the third call, the function is called with three arguments, so it concatenates them and returns the result.

Variadic parameters can be very useful when you need to write functions that can accept a variable number of arguments. They allow you to write more flexible and reusable code, and can simplify your code by eliminating the need for multiple function overloads.