Lets Code Them Up!

Tag: tutorial

Learning Swift – Enumerations

May 25th, 2017
In this post, we will implement enumerations in swift.

What’s an enumeration?

According to the official documentation of Swift:

“An enumeration defines a common type for a group of related values.”

In simple words, an enumeration is a user defined data type which stores a set of values. Examples of such sets can be days of the week, days of the month, etc.

How to define enums in swift?

In swift, the enumeration is defined using the following syntax:
```
enum EnumerationName {
    // cases
}
```
Here enum is the keyword, and enumerationName is the name for the enumeration. The following example code creates an enum which stores days of the week.
```
enum DaysOfWeek{
    case monday 
    case tuesday 
    case wednesday
    case thursday
    case friday 
    case saturday 
    case sunday 
}
```
Once the enums are created, we define a variable of this enum type as the following code shows:
```
var today = DaysOfWeek.tuesday
```
When we assign DaysOfWeek.tuesday to variable today, type of today becomes an enumeration. Switch statements which we studied in this post, can be used to match individual enumeration values.
```
today = .thursday
switch today{
case .monday, .tuesday, .wednesday, .thursday, .friday:
    print("Working Days")
case .saturday, .sunday:
    print("Holidays")
}
```
After first initialization, we can assign values to the enum variables only using “.casename”, as done in the above example through “.thursday“.

The output of above program is “Working Days” as “.thursday” falls into the first switch case.

Raw Values

In swift, enumerations can be initialized with raw values. In this example, we assign “Int” to the enumeration, making sure all the cases in this enumeration will have an integer raw value by default on initialization.
```
enum DaysOfWeek: Int{
    case monday
    case tuesday
    case wednesday
    case thursday
    case friday
    case saturday
    case sunday
}

var today = DaysOfWeek.thursday

print("\(today.rawValue)")
```
When we fetch the raw value using “today.rawValue“, we get an output of three. Because by default, if we don’t assign values to all the cases, swift assigns “0” to the first case and the remaining cases are incremented by “1“, i.e. monday is 0, tuesday is 1, wednesday is 2, thursday is 3 and so on.

Similarly, if we assign monday with 61, the output of thursday will be 64. Here, Swift assigns 61 to monday and all other values are incremented by 1.

Last, we assign separate and different values to all the enumeration cases.

The type of raw values in the enumerations could be float or double or string also.

Associated Values

The raw values are of the same type, so all cases store values of the same type. But in swift, enumeration cases can also store values of different data types. These values associated with each enumeration case are called associated values. For example the below enumeration:
```
enum EmployeeRecord{
    case name(String, String)
    case age(Int)
    case weight(Float)
}
```
Here we have an enumeration EmployeeRecord with three cases(values): name which can store two string values, age which can store one integer value and weight which can store a float value.

The next question that arises is how to initialize a variable of this enumeration type?
```
var employee = EmployeeRecord.name("John", "Doe")
```
Consider the name case which stores two strings. While initializing the variable employee with the enumeration EmployeeRecord, we fill in the values of the associated strings with “John” and “Doe“.
```
switch employee {
case .name(let first, let last):
    print("First Name: \(first)")
    print("Last Name: \(last)")
case .age(var age):
    print("Age: \(age)")
case .weight(let weight):
    print("Weight: \(weight)")
default:
    print("Invalid value")
}
```
Similarly, when we check these cases in the switch, we have to add the associated values as constants or variables to be able to use them. For the name, there are “let first” and “let second“.

With this, we complete enumeration in swift. If any questions, leave them in comments below. You can find the code for this post here.
Learning Swift: Functions [Argument labels]

March 31st, 2017
From last three posts, we have been working on functions in swift. So far we learned
In this post, we will learn about function argument labels.

Recall this syntax we discussed in the first post on functions.
```
func functionName (paramName: paramType  ) -> returnType{
 
 //block of code
 return object
 
 }
```
Here we have not used argument labels. First, let’s add the argument labels to this syntax.
```
func functionName (argumentLabel paramName: paramType  ) -> returnType{
 
 //block of code
 return object
 
 }
```
What is this argument label? Why do we use it? How’s it different from the parameter names.

Let’s find out.

Remember this factorial function from last few posts?
```
func factorial (number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
We will add an argument label “of” to the parameter name number.
```
func factorial (of number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
Immediately we have an error here, where we are calling this function factorial.

The error says “Incorrect argument label in call(have number:”, expected “of:”

When we replace the number with of, the error vanishes.

This “of’ here is an argument label. The argument labels are like external parameter name. These are used when calling a function. The other parameter name “number” is the internal parameter name and is used inside the function.

Earlier when there was no “of” ie argument label, the parameter name became the default argument label and we used “number:” instead of “of:”.

So when we explicitly write an argument label we have to use that in the function call. Else we use the parameter name as argument label.

The use of argument label makes a function more expressive, sort of like a sentence. Like this factorial function call above, now, can be read as the factorial of 7.

With this we complete functions. If you have any questions leave them in the comment section below.
Learning Swift: Functions [Return Values]

March 21st, 2017
From last two posts, we have been working on functions in swift. In the first post we learned how to define and call the functions and in the second we focused on the parameters.

In this post, we will look into the values a function can return.

If you recall the last two posts, we have used an example of a factorial function. For this post also, we will be using the same factorial function as an example.
```
func factorial (number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
Functions with One Return Value

When we take a closer look at the function, we see that this function returns factorial variable. What is this factorial variable?

This factorial variable stores the factorial of the number which we pass as the parameter. And this factorial is of the type integer.

Plus the main point to note here is that we have used Int as the return type in the function definition which you can see in the first line.

When we call this function for a factorial of 7, we get the output as 5040 which is an integer.

So this function has a return value. It returns just one value ie factorial.

But returning a value is not mandatory for a function. We will also have functions which are having no return values.

Functions with No Return Value

For the example of a function with no return value, we will be removing the return type of this factorial function.

Let’s delete this int from the first line. But as soon as we remove this int, we get an error which says, “Unexpected non-void return value in void function”

This actually means that we are returning a value in a function which has no return value. Void means that the function is not going to have a return value.

And when we delete this return statement the error vanishes.

Now factorial function is complete and we are calling this factorial function here in the print statement. The output is just the empty parenthesis and not 5040. why?

Well, coming back to the function, we see it does not return a value and also have no print statement to print the value of factorial.

What we can do is copy this print statement inside and replace the function call with the factorial variable. And call this function separately.

Now we can again see the output 5070.
```
//Example
//Factorial of a Number

func factorial (number : Int) {
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    print("Factorial is \(factorial)")

}

//functionName(paramName: paramValue)
factorial(number: 7)
```
Hmm, this was a function with no return value. And before this one, we saw the function with one return value.

Functions with Multiple Return Values

But what should we do if we want to return more than one value?

In swift, we can do that by using tuples as return values. And in these tuples, specify the multiple return types.

Not clear? I know. It will be through this example. We will first write a function to return the quotient and remainder of dividing number A by number B and then understand it.
```
//divide function with two return values quotient and remainder

func divide(numA: Int, numB: Int) -> (quotient: Int, remainder: Int){
    return (numA/numB, numA%numB)
}

let result = divide(numA: 9, numB: 2)

print("Quotient is \(result.quotient) and Remainder is \(result.remainder)")
```
We get the output as 4 and 1.

Any guess what’s going on here. We have a function divide with two input parameters: numA and numB. And the return values quotient and remainder which are enclosed in parenthesis to form a tuple.

Next, we return numA/numB to get the quotient and numA%numB to get the remainder.

We can directly print the result by calling the function in a print statement. But if want to access both the results separately, we store them in a constant and then call them by their names as we did in this print statement using the result.quotient and result.remainder.

Now we know how to make functions with no parameter, one parameter and also multiple parameters.

You can find the source code for this post here.

In the next post, we will move on to argument labels.
Learning Swift: Functions [Parameters]

March 14th, 2017
In the previous post on functions, we started with defining and calling functions.

Today we will go a bit deeper into function parameters or popularly called arguments.

Parameters are the inputs for the function.

If you recall from the previous video, this is the factorial function we studied. This factorial function has only one parameter i.e. number.
```
func factorial (number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
Here the number is the input for the factorial function.

There are functions with one parameter and function with more than one parameters also.

To see an example of the function with zero parameters we will remove the parameter number from the function factorial. And add a constant number 7 inside the function.
```
func factorial () -> Int{
    let number = 7
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}

//functionName(paramName: paramValue)

print("Factorial is \(factorial(number: 7))")
```
But we see an error in the print function where we call our function. The error says, “Argument passed to call that takes no arguments”

This is happening because the function we defined has no parameters but the function we are calling has one parameter. To remove the error we remove number: 7 from the function call. And now there is no error and we get our output 5040.
```
func factorial () -> Int{
    let number = 7
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}

//functionName(paramName: paramValue)

print("Factorial is \(factorial())")
```
Now to study an example of a function with two parameters, we will define a function product, having two parameters x and y, both integers, and the function will return the product of x and y as an integer.
```
//product of two numbers

func product(x: Int, y: Int) -> Int {
    return x*y
}

print("Product of 6 and 14 is \(product(x: 6, y: 14))")
```
We can see that this function has two parameters in the definition x and y. And we call the function product with values of x as 6 and y as 14 and get the product 84.

Similarly, there can be functions with three or even four or five parameters.

With this, we complete the function parameters. In next post, we will focus on the return types.

You can find the source code for this post here.

If you have any questions or comments do leave them in the comment section below.
Learning Swift: Functions [Define and Call]

March 8th, 2017
Hello Friends,

From the past few posts, we have been learning swift one step at a time. In our previous post, we completed control flow. The code for this post is available here.

Starting today next few posts will be on functions. Function definition and function call will be covered in this post. Subsequent posts will focus on parameters, return types and argument labels respectively.

So, what are functions?

Functions are self-contained blocks of code that solve a specific purpose. For example, the factorial function that you see here is used to find the factorial of a given number.
```
func factorial (number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
Or this print that we use so much. The print is also a function which is used to print the results on the console.

How do we define functions?

We do that using the following syntax
```
func functionName (paramName: paramType  ) -> returnType{
 
    //block of code
    return object
 
 }
```
It is clear that the function definition can be broken down into three main parts:
1. Function name through which we can call this function.
2. Parameters list which is actually list of inputs for this function
3. Return type which defines the type of result the function is going to return.
Let’s see this factorial function definition to better understand function definition

As we can see, the function name is defined as factorial. The parameter name is number. And the Parameter type is an integer. Return Type is also Integer. Then we have a code inside the curly brackets which calculates the factorial and stores it into a factorial variable and returns it. The data type of factorial variable is Integer, similar to the return type mentioned in the first line of the function.

How to call a function?

Now that we have defined factorial, how do we use it? How do we call it? How can we find the factorial of number 7 using this function?

The syntax for the function call is given below:
```
functionName(paramName: paramValue)
```
Like in this example we use print factorial of a number is factorial(number: 7). 7 is an integer and we have defined the parameter of the number as an integer.
```
print("Factorial is \(factorial(number: 7))")
```
In the next post, we will begin going deeper into functions.
Learning Swift: Control FLow [Switch]

February 27th, 2017
In our last post, we studied If-Else statements and implemented them in Swift.

In this post we will learn about Switch statements.

You can find the source code for this post here.

Consider the following example from previous post. I have updated the first condition, which now sets upper limit of marks to 100.

var marksOfStudents = 85 if(marksOfStudents >= 75){ print("First Division") } else if(marksOfStudents > 30 && marksOfStudents < 75){ print("Second Division") }else{ print("Student Fails") }

Right now if marksOfStudents is greater than 100. We will get an output of “Student Fails” which is wrong. As marks should never be greater than 100. Therefore to handle values more than 100 or less than zero, we will have to add one more condition.

var marksOfStudents = 185 if(marksOfStudents >= 75 && marksOfStudents<=100){ print("First Division") } else if(marksOfStudents > 30 && marksOfStudents < 75){ print("Second Division") }else if(marksOfStudents>=0 && marksOfStudents<=30){ print("Student Fails") }else{ print("Out of range") }

We can see addition of one else-if block now handles the condition in proper way. And we have an output Out of range for values -10 and 185.

As conditions increase, number of else-if blocks will increase. And the code will become more complex.

In this case, which involves multiple conditions, it is better to use switch statement.

Switch statements have been designed to handle multiple conditions only. You might have seen them in Java or Python.

The syntax of switch statements in Swift is generally like this:

switch conditionalValue { case value 1: //execute this block case value 2: //execute this block case value 3, value 4: //execute this block case value5...value6: //execute this block default: otherwise, do something else

Switch statement is followed by case statements which have a block of code associated with them.

Switch compares the conditionalValue with the values given in case statement(value 1, value2, etc). When a match is found, code associated with that case is executed.

default case is used to handle values not covered in the case statements.

Unlike other languages like java or python, swift allows compound cases and ranges and a lot of other options. Switch statements in Swift are very powerful and flexible.

For example we can have same case catering to two values like value3 and value4 here. Or we can have a range of values like value5 to value6.

Let’s see some examples to better understand these.

First we will convert the above if-else code. into switch code

var marksOfStudents = 85 switch marksOfStudents { case 75...100: print("First Division") case 31...75: print("Second Division") case 0...30: print("Student Fails") default: print("Out of range") }

Since we are checking the value of marksOfStudents in the if-else block, we can use marksOfStudents as our conditional variable of switch statement.

The first if-else condition covers marks between 75 and 100 (range of values between 75 and 100). This infers our first case statement will check for values between 75 and 100 using range operator.

Similarly the second case will cater to range of 31 and 75. And the third case will take range of 0 and 30. For any values less than 0 or greater than 100 we will add a default case.

With marksOfStudents = 85 we get the output of first division as expected.

Let’s check the outputs when marksOfStudents equals 25 or 60 or 105.

Now check with marksOfStudents equals 75.

Although 75 is included in the second case too, we get the output first division. Because swift checks the conditions one by one and executes the code associated with the first match. So in our case, as soon as first case 75…100 matches, first division is printed. And the second case 31..75 is ignored.

Let’s consider another example: To count the number of vowels in a sentence.

var sentence = "I am learning swift" var countVowels = 0 for letter in sentence.characters{ switch letter { case "a","A","e","E","i","I","o","O","u","U": countVowels += 1 default: countVowels += 0 } } print("Number of vowels = \(countVowels)")

Instead of writing separate cases for each vowel in upper or lowercase letter, we can compound all the values in one case itself as shown in example.

In above example itself, we will find the number of spaces in the sentence. For this we will add a case ” ” and a counter to store number of spaces. The code will look like.

var sentence = "I am learning swift" var countVowels = 0 var countSpaces = 0 for letter in sentence.characters{ switch letter { case "a","A","e","E","i","I","o","O","u","U": countVowels += 1 case " ": countSpaces += 1 default: countVowels += 0 } } print("Number of vowels = \(countVowels)") print("Number of spaces = \(countSpaces)")

This completes switch statement. Next we will start with functions.