In the tutorials so far in this course, you've used functions many times. In this tutorial, you'll see how to create new ones! After that, you'll learn about loops in Swift, one of the most important concepts in programming. In plain English, loop-statements correspond to “Do this action X times.” or “Keep doing that action as long as this condition is true.”
Your own functions!
Remember functions like uppercased() that you can execute in Swift? Well, good news – you will learn how to write your own functions now!
A function is a sequence of instructions that Swift should execute. Each function in Swift starts with the keyword func, is given a name, and can have some parameters. Let's give it a go.
func hi() {print("Hi there!")print("How are you?")}hi()// Hi there!// How are you?
Over here you will see those statements being printed on the result bar as well as on the bottom of the screen. If the bottom tab isn't open, you can do so by clicking here:
If you execute the function twice, it'll print twice in the bottom pane and on the result bar you will see (2 times) written for each print statement.
Okay, our first function is ready!
You may wonder why we've written the name of the function at the bottom. The first time (lines 3-6 in the screenshot), we're defining what the function does. The second time (line 8), we're calling the function, i.e. asking Swift to actually execute the function.
Note that because Swift reads the file and executes it from top to bottom. When Swift is executing the function, if it hasn't yet found the definition, it will throw an error of unresolved identifier. Hence, we define the function before calling it.
Functions with parameters
Let's build our first function with parameters. We will use the previous example – a function that says "hi" to the person running it – with a name:
func hi(name: String) {}
As you can see, we now gave our function a parameter that we called name. We also have to specify its data type, which in this case is String.
func hi(name: String) {if name == "Commonlounge" {print("Hi Commonlounge!")} else if name == "Dave" {print("Hi Dave!")} else {print("Hi anonymous!")}}hi()
Within the function, a parameter works exactly the same as a variable.
Let's run the code and see how it works now:
Oops, An error. Luckily, Swift gives us a pretty useful error message. It tells us that the function hi() (the one we defined) has Missing argument for parameter 'name' in call. It's saying that the function requires an argument 'name', and we forgot to pass it in our function call.
We're using the words parameters and arguments interchangeably. We think parameters is much more clear to a beginner, but arguments is the word used conventionally.
Let's fix it. Replace hi() at the bottom with:
hi(name: "Commonlounge")
And run it again:
// Hi Commonlounge
And if we change the name?
hi(name: "Dave")// Hi Dave
Now, what do you think will happen if you write another name in there? (Not Commonlounge or Dave.) Give it a try and see if you're right. It should print out this:
Hi anonymous!
Xcode has a fine auto-type feature, when you just type your function name hi and hit enter, it completes the function with hi(name: String) waiting for you to enter something in the String placeholder. This feature should be used most of the times to avoid getting errors.
This is awesome, right? This way you don't have to repeat yourself every time you want to change the name of the person the function is supposed to greet. And that's exactly why we need functions – you never want to repeat your code!
Let's do something smarter – there are more names than two, and writing a condition for each would be hard, right?
func hi(name: String) {print("Hi " + name + "!")}hi(name: "Rachel")// Hi Rachel!
Multiple parameters and return values
So far, you have seen functions which take one parameter, and print something based on that. In fact, a function can take multiple inputs, and also return a value. Here's a simple example,
func subtract(x: Int, y: Int) -> Int {return x - y}var z = subtract(x: 5, y: 2)print(z)// 3
The above subtract function takes two inputs, which it calls x and y. It then returns the result of subtracting y from x. Hence, when we call subtract(x: 5, y: 2), the returned value is 3. You can assign this value to a variable, or use it any other way you want. -> Int is used to tell Swift that the function is going to return a value of the type Int.
Then evaluating an expression, functions evaluate to the value they return. For example:
subtract(x: 5, y: 2) + 8=> 3 + 8=> 11
Note that you can also return a String, Array, Dictionary, etc. Here's an example of a function which returns a dictionary.
func math(x: Int, y: Int) -> [String: Int] {return ["sum": x+y, "difference": x-y, "product": x*y, "quotient": x/y]}print(math(x: 5, y: 2))// Outputs: ["difference": 3, "quotient": 2, "sum": 7, "product": 10]
→ [String: Int] tells Swift what kind of dictionary is going to be returned.
Default argument values
Swift functions also support default values for arguments. Take a look at the function below:
func hi(name: String = "Commonlounge") {print("Hi " + name + "!")}hi() // "Hi Commonlounge!"hi(name: "Alice") // "Hi Alice!"
In the above, func hi(name: String = "Commonlounge") means that if the arguments name is not given when calling the function, a default value of name will be "Commonlounge".
Finally, you can also write functions where only some arguments have default values. For example:
func greet(name: String, greeting: String = "Hi") {print(greeting + " " + name + "!")}
In the above function, name is a mandatory argument, and greeting is optional. So you can call it in the following ways:
greet(name: "Alice") // "Hi Alice!"greet(name: "Alice", greeting: "Hello") // "Hello Alice!"
In all cases, the first argument must be passed. Only the second argument is optional.
External and Internal Parameter Names
There's one last thing about functions you should know. In Swift, functions have specify external and internal parameter names.
The external name is used when calling the function. The internal name is used in the implementation of the function.
By default, the internal and external names are the same — which is what you have seen in all the examples so far:
func hi(name: String) {print("Hi " + name + "!")}hi(name: "Rachel")// Hi Rachel!
To specify the external and internal parameter names, you write the external name before the internal name, separated by a space. Here’s a variation of the greet() function that takes a person’s name and hometown:
func greet(person name: String, from hometown: String) {print("Hi " + name + "! Glad you could visit from " + hometown + ".")}greet(person: "Bill", from: "San Francisco")// Hi Bill! Glad you could visit from San Francisco.
The use of external and internal parameter names can allow a function to be called in an expressive, sentence-like manner, while still providing a function body that is readable and clear in intent.
Omitting External Parameter Name
If you don’t want an external name for a parameter, write an underscore (_) instead of the external name for that parameter.
func greet(_ name: String, from hometown: String) {print("Hi " + name + "! Glad you could visit from " + hometown + ".")}greet("Bill", from: "San Francisco")// Hi Bill! Glad you could visit from San Francisco.
If a parameter has an external name, the external name must be used when you call the function.
Congratulations! You just learned how to write functions! :)
Loops
Programmers don't like to repeat themselves. Programming is all about automating things, so we don't want to greet every person by their name manually, right? That's where loops come in handy.
Still remember Arrays? Let's do a Array of people:
var people = ["Rachel", "Monica", "Phoebe", "Ola", "You"]
We want to greet all of them by their name. We have the hi function to do that, so let's use it in a loop:
for name in people {}
The for statement behaves similarly to the if statement;
Here is the full code:
func hi(name: String) {print("Hi " + name + "!")}var people = ["Rachel", "Monica", "Phoebe", "Ola", "You"]for person in people {hi(name: person)print("Next person")}
And when we run it:
Hi Rachel!Next personHi Monica!Next personHi Phoebe!Next personHi Ola!Next personHi You!Next person
As you can see, everything you put inside a for statement will be repeated for every element of the Array people.
You can also use for on numbers. Let's see how to print the numbers 1 - 6 using ... to specify a range.
for i in 1...6 {print(i)}
Which would print:
123456
Another variation for the specifying a range is ..< which is used when we want to exclude the final number. For example:
for i in 1..<6 {print(i)}
Which would print:
12345
Conclusion
That's it. You totally rock! This was a tricky chapter, so you should feel proud of yourself. We're definitely proud of you for making it this far!
