Introduction
Functions are self-contained chunks of code that perform specific tasks.
Defining and Calling a Function
Right below is a simple function, that actually does nothing at the moment.
func emptyFunction() { //your code should go inside here}
The func
keyword is use to define a function while the emptyFunction
is the name given to the function. You must use the func
anytime you create a function, and the function name can vary base on what the function will do.
The above function can be called within my code like below
emptyFunction()
Function Parameters
There are times when we need to pass parameters
to a function, we can pass parameters to a function like below
func functionWithParameter(parameterOne: Int) {
print("This is my parameter: \(parameter)")
}
The paramterOne
is the parameter passed into the function while the Int
denote the data type of the parameter. The data type (Int)
serves as a kind of contract that must be adhere to when we call the function meaning, the parameter must be a type of Int.
We need to include the parameter we passed when calling the function like below
functionWithParameter(parameterOne: 32)
We can use more than one parameter in a function by separating the parameters with a comma
//declaring the function
functionWithParameters(parameterOne: Int, parameterTwo: String) {
}
//calling the function
functionWithParameters(parameterOne: 32, parameterTwo: "Hello")
Function Return Types
The return type
is use to denote the data type of the value our function should return. Just like the parameter type, Xcode will enforce us to make sure that the function returns the type it specified.
func functionWithReturnType() -> String {
return "I must return a string"
}
There are many data types in swift which include Integer, Boolean, String, Float, Double. The -> String
denotes that the function must return a type of String. Any function that does not return a value has a special return type named Void
. When we do not specify a function return type, we have simply told swift that the return type is a void hence our function must not return anything.
//Different ways to declare Void
func noReturnType() {
//swift will automatically take this function as void
//hence we must not return anything
}
function returnWithReturnType() -> Void {
//same as above, but we declare the void ourselves
}
function returnWithReturnType() -> () {
//this is another way to declare void
}
Function With More Than One Return Value & Type
There are times when we need our function to return more than one value, We can do this in swift with the help of a tuple like below
//declaring the function
myFunction () -> (value1: Int, value2: String) {
return (value1, value2)
}
//calling the function
let result = myFunction(value1: 12, value2: "Hello from me")
//we can access the return value like below
result.value1
result.value2
Function Parameter With Default Value
We can define a default value for any function parameter should in case we do not want to pass the value at all time
func someFunction(parameterWithDefault: Int = 32) {}
If we call the someFunction(parameterWithDefault: 50)
and pass in a parameter of 50, it will override 32 which is the default value assigned to the function, we can also call the function without a parameter.
Function Parameter External And Local Name
There are times when we need to give our function an external and local name, mostly basically for readability. The external name is use to pass the parameter into the function while the internal name is use to access the parameter inside of the function.
func myFunction(havingValue value: Int) {
//we can access the havingValue parameter with value
print(value)
}
//calling the function
myFunction(havingValue: 50)
Notice that we use the havingValue
to pass the parameter when we call the function but to access the parameter inside of the function, we use value
.
Omitting Argument Labels
Each time we have called a function that has a parameter, we have been defining the parameter name like below
myFunction(label: Int) {}
//calling the function
myFunction(label: 32)
We can omit the label
when calling the function by adding a _
as the function external name like below
myFunction(_ label: Int) {}
//calling the function without the label definition
myFunction(32)
There is more to function in swift than what I have covered here which is just an introduction to it. You can read more about swift function here on apple documentation
I am happy to share this article with you. If you’ve enjoyed this article, do show support by giving a few claps 👏 . Thanks for your time and make sure to follow me or drop your comment below 👇
Top comments (0)