We mentioned the Playground feature earlier—it is a new innovative feature supported in Xcode 6 and higher. It gives you the ability to try any piece of code in Swift, and see the results immediately without the need to compile or run the code. So, imagine that you are learning Swift, or working in a project with Swift, and you need to try some code, and check its result. If you are in Objective-C, you need to create a new project, write the code, build, run, and open the simulator to see the results! Very time consuming, isn't it? I mean, it's time consuming here, in the learning track, but after you master the language, you don't need to use Playgrounds. You may just need to use it in test or to check something. To play with the Playground feature use the following steps:

As you see, each line of code is examined, and its result is shown in the results sidebar, in the right-hand side. Even the for loop statement shows you how many times the entire code was executed. To see the value of any variable, just write it in a separate line, and check its value in the right-hand side sidebar. (Check line 11 in the preceding screenshot).

Another feature of Playground is the value history. In the previous for loop, we have a piece of code that is executed repeatedly, right? But I want to know what is going on in each iteration. Xcode helps you with this by providing the history button in the results sidebar, on the line containing the number of times. Once you click on it, it displays a complete graph (timeline) for the values over the time. In the graph, x axis represents time, and y axis represents the value at this time (this iteration).

Once you click on the circle in the results view, you can see the value of this iteration:

Also, keep in mind that Playground includes the standard editing features of Xcode, such as code completion, error checking, syntax correction, and suggestions.

Before starting to write Swift, you have to be aware of its structure, as it is a very important thing to know in any programming language.

As we said earlier, Swift is not a superset of C. For sure it's influenced by C and Objective-C but easier and fun to use than both.

I will share with you a piece of code in Swift to show its structure:

import UIKit

let pi = 3.14
//Display all even numbers from 0 to 10
for i in 0...10
{
    if i % 2 == 0
    {
        println("\(i) is even")
    }
}

func sayHello(name: String = "there")
{
    
    println("Hello \(name)")
}

sayHello(name: "John") // will print "Hello John" 
sayHello() //Will print "Hello there", based on default value

If you check this code, you will find that we don't use semicolons. This is because in Swift they are optional. However, compiler will not complain if you do use them. The only area where semicolons are required is when you write multiple statements in the same line.

In Swift, you use var for variables, and let for constants; but this doesn't mean that Swift is not a typed language. The compiler, based on the initial value, identifies the type implicitly. But in some cases, you have to write the type if you don't set an initial value; or the initial value is not sufficient to identify the type.

Consider the following code for example:

var count = 5
var msg : String
var total : Double = 0

In this code, the count variable is of the Int type, because its initial value is in integer. In the msg variable, we didn't set an initial value, so we will have to explicitly write the type of the msg variable. The same is applicable for total; we need it to be of the Double type but as its initial value is not sufficient, the compiler will consider it as Int.

In Swift, you will see that there is no main function to start with, as the code written in the global scope is considered as the start of your program. So, you can imagine that a single line of code in Swift can be considered as a program!

The last thing I want to mention is that curly braces are very important in Swift, as they are mandatory in any control flow statements, such as if, while, and so on.

An array is every developer's best friend and saves the collection of data in an ordered list. In Swift, an array is very easy to use and contains many helpful methods for use. Before exploring it, we have to clarify some important points.

Array by default is mutable so that it accepts adding, changing, or removing items from it, except if we define it as a constant, using let. In this case, it will be immutable, as it becomes constant.

In Objective-C, you can save any type of object, and you won't have to specify any information about their type. In Swift, arrays are typed; this means that the type of item should be clear, and all the items should be of the same type. The type can be defined explicitly, or it can be inferred.

An array doesn't have to be of a class type. So, you can create an array of Int, and in such a case, you can't insert any other value than the Int type.

The following are examples to make these points clear:

let languages = ["Arabic", "English", "French"]
//Here type is inferred as String, So this Array is of type String
//Also this array is immutable as it defined as let

var primes :[Int] = [2, 3, 5, 7, 11]
//Type is written explicitly

primes.append(13) //mutable array as it defined as var

Initializing an array

To initialize and create an array, you can use the previous ways with initial values, or you can either create it empty, or by using repeating values:

As you see in the example, it's very easy to initialize empty arrays, or arrays with repeating values. Swift also provides a great feature to append two arrays that result in a new array.

var seasons = ["Winter", "Spring", "Summer", "Autumn"]

for season in seasons{
    println(season)
}
/*
Winter
Spring
Summer
Autumn
*/

for (index, season) in enumerate(seasons){
    
    println("Season #\(index + 1) is \(season)")
}
/*
Season #1 is Winter
Season #2 is Spring
Season #3 is Summer
Season #4 is Autumn
*/

var nums = [1, 3]            // [1, 3]
nums.append(4)              //  [1, 3, 4]
nums.insert(5, atIndex: 1) //   [1, 5, 3, 4]
nums += [10, 11]          //    [1, 5, 3, 4, 10, 11]

nums.removeAtIndex(1) // return 5
nums.removeLast()    //  return 11
nums                //   [1, 3, 4, 10]
nums[0...2] = []   //    array now is [10]

Dictionaries in Swift are like arrays in special characteristics, such as mutable and strongly typed. Dictionary is mutable by default, except if used with let. Also keys and values should be of the same type.

The dictionary type is inferred by the initial values, or you can explicitly write it using the square brackets [keyType, valueType].

var dic1 = [String:Int]() // 0 key/value pairs

var dic2 = ["EN" : "English", "FR" : "French"]
//["EN": "English", "FR": "French"]

dic2["AR"] = "Arabic" //Add
dic2["EN"] = "ENGLISH" //update
//["EN": "ENGLISH", "FR": "French", "AR": "Arabic"]

dic2.updateValue("ARABIC", forKey: "AR") //returns "Arabic"
//dic2 now is ["EN": "ENGLISH", "FR": "French", "AR": "ARABIC"]

dic2["AR"] = nil
dic2.removeValueForKey("FR") //returns French
//["EN": "ENGLISH"]
dic2["FR"]  // Returns nil

Enumeration is a very useful concept that is used to group related values together and define a new type for them. You must be familiar with enumeration in Objective-C or in C. Swift added new flavors to enum, and made it more flexible and easy to use.

To create enum in Swift, use the enum keyword, and then you can list all the possible cases after the case keyword:

enum LevelDifficulty{
    case Easy
    case Medium
    case Hard
    case Advanced
}

In the preceding code, we defined the new type as LevelDifficulty to group the related values of difficulties together (Easy, Medium, Hard, and Advanced). To use this enum, you can easily create variables with the LevelDifficulty type:

var easyMode = LevelDifficulty.Easy
//Type is inferred as LevelDifficulty

var mode : LevelDifficulty
mode = .Hard

As we see in this example, there are various ways to create enum. In the second one, for the variable mode, we set the type first, and then gave it a value. To set the value of a variable, we use a . (dot) operator.

var power :Int
switch mode
{
case .Easy:
    power = 20
case .Medium:
    power = 30
case .Hard:
    power = 50
case .Advanced:
    power = 90
}

enum MissionState{
    case Accomplished(Int)
    case Attempted(String, Int)
    case UnAttempted
}

var state = MissionState.Accomplished(3)
var attemptState = MissionState.Attempted("80%", 3)

switch attemptState
{
case .Accomplished(let stars):
    println("Mission accomplished with \(stars) stars")
case .Attempted(let progress, let count):
    println("Mission attempted \(count) times with most progress \(progress)")
case .UnAttempted:
    println("UnAttempted")
}

enum MissionState{
    case Accomplished(stars:Int)
    case Attempted(missionProgress:String, attemptsCount:Int)
    case UnAttempted
}

var state = MissionState.Accomplished(stars:3)
var attemptState = MissionState.Attempted(missionProgress: "80%", attemptsCount: 3)

In Swift, it's very easy to create the functions using the func keyword, followed by the function name and parameters between the parentheses. Parentheses are required even if the function doesn't take parameters. So we will use parentheses without writing anything in between. For some other languages we need to use the void keyword for the function that doesn't take parameters. Parameters are comma separated and each one is combined with two items: the name and the type of parameters, separated by : (colon). Check this example of a simple function:

func sayHi(name:String)
{
    println("Hi \(name)")
}

sayHi("John") //Hi John

One of the great features that I love in Objective-C is that you can write a full description for each parameter in methods, which helps everyone, working in the project, to understand the code. The same is here in Swift; you can label parameters more easily. To do so, just type the name (description) before the parameter, or add # before the name of parameter, if the name is sufficient as a description and meaningful. Check these two examples:

func joinStrings(string1 str1:String, toString str2:String, joinWith j:String)
{
    println(str1 + j + str2)
}

joinStrings(string1: "John", toString: "Smith", joinWith: ",") //"John,Smith"

func joinStrings2(#string1:String, #toString:String, #glue:String)
{
    println(string1 + glue + toString)
}

joinStrings2(string1: "John", toString: "Deo",glue: "/") //"John/Deo"

As we saw in the first method, we wrote the description for each parameter, so that the code would be readable and understandable. In the second one, the parameter names were self-explained, and they needed no explanation. In such a case, we just added # before them, and then the compiler treated them as labels for parameters.

Like any function in any language, Swift may return results after the execution. Functions can return multiple values and not just a value like Objective-C, thanks to tuples! To do this, just write -> after the parentheses, and then add a tuple that describes the results:

func getMaxAndSum(arr:[Int]) -> (max:Int, sum:Int)
{
    var max = Int.min
    var sum = 0
    for num in arr{
        if num > max
        {
            max = num
        }
        sum += num
    }
    return(max, sum)
}

let result = getMaxAndSum([10, 20, 5])
result.max //20
result.sum //35

Think of closures as a piece of code or functionality to pass around in your code. Closures in Swift are very similar to blocks in C and Objective-C. Closures in Swift are the first class type and it is allowed to be returned or passed as a parameter. And as we will see, functions are just special instances of closures. The general formula for closures is like this:

{ (params) -> returnType in
    
    //statements
}

As you can see, we opened curly braces, and then we added the necessary parameters followed by the return type and the in keyword. Knowing this formula will help you a lot in using closures, and you will not feel any frustration using it.

This is an example of using closures in sorting the collection of data:

var nums = [10, 3, 20, 40, 1, 5, 11]
sorted(nums, { (number1, number2) -> Bool in
    return number1 > number2
})
//[40, 20, 11, 10, 5, 3, 1]

Here, the closure is used to identify the comparison result of any two numbers. As we saw, the closure takes two parameters and returns a Boolean, that is the result of the comparison.

In this chapter, we saw what Swift is, and how the code structure works. We saw its new features by using arrays, dictionaries, functions, and closures. We also learned how to use Playground to try any piece of code in Swift anytime, without creating a new project, or even compiling and building your project. At the end of this chapter, you have the basic skills to write Swift code. In the next chapter, we will talk about some advanced features in Swift, including casting and checking, protocols, delegation, generics, memory management, and much more. Stay tuned!