Swift is new programming language for developing iOS and Mac OS applications. Apple at WWDC 2014 introduced Swift. Swift is not based on C and is different from the Objective C language. It takes the scripting approach making it easier for developer to understand. Apple main aim is to make Application developer life easier so that more and more solutions are uploaded on the App’s Store. In order to achieve this goal Swift is introduced.
For any language most important to understand is how variables, constants and functions are declared and are used. We will go into these one by one before we start writing the code in the Xcode.
1. SWIFT Variable
We declare variables in Swift by using “var” keyword. Throughout this book we will be using various real world examples to make things easier to understand. We will start with simple example of making ID making App. This App will help user to design the ID card.
For making the ID card for the student we need student unique code (roll number), first name, last name, course name, age and nationality.
We will declare all these parameters as variables in the program as follows
Suppose we need to initialize the variables than we will use following statement.
var rollNumber = 1
var firstName =“Priyank”
var courseName=“Programming Language”
Following some points we can observe from above initialization.
a. Unlike other languages, Swift does not require you to write semicolon (;) after each statement in your code.
b. You can avoid writing datatype for each variable you declare. Swift will convert the variable into respective datatype when variable gets the value for the first time.
c. You can change the value of the variable after initialization
d. One can declare and initialize multiple variables in single line as follows var x = 0.0, y = 0.0, z = 0.0
e. One has to write semicolon if you have to write multiple statements in single line.
For example var age = 28; println(age)
f. We can use any character for declaring variables even Unicode characters like smiles and other Unicode characters.
2. Type Annotation
You can declare the variables with the specific type using type annotation.
The syntax is as follows
var firstName : String
The colon in the declaration means “of type”, so we can read as “firstName is of type String”.
firstName = “Priyank” // It is valid
firstName = 10//complier will give an error as we have declared firstName as String and thus can not assign integer value
Note: It is rare we use type annotation.
3. Swift Constants
We declare constants in Swift by using “let” keyword. Value of a constant will never change.
let photoWidth = 200.0
let photoHeight = 300.00
4. Type Aliases
Type Aliases is similar to type def. We can use different name for the datatype by using keyword “typealias”.
typealias NimapINT = int
One can use NimapINT to represent int in the code by writing the above line of code.
5. Tuple Data Type
The Swift introduces this data type, which is not there in Objective C. With tuples you can group multiple values. Thus tuples allows you to group different type of values into one compound value. Thus one can return tuple type of data in order to return multiple values from the method.
let idError = (100,”First Name Of Student Missing”)
We have declared tuple idError which group Int and String to give ID card error with code and human readable string. This can be described as “tuple of type (Int, String)”. You can create tuples with any permutation of type like (Int,Int,Int) or (String,Boolean) or (Int,Float,Student).
Now question comes, how can we read values from tuples? There are various ways we can decompose tuples to extract the values.
let (errorCode,errorMessage) = idError
After the above line whenever you refer “errorCode” it will referred as “100”. And whenever you refer “errorMessage” it will be referred as “First Name Of Student Missing”.
Another way to decompose the tuple is to name the individual element in a tuple when initializing the tuple.
let idError = (errorCode : 100, errorMessage : “First Name Of Student Missing”)
If you name the element in the tuple, you can use the elements name to access those elements.
Thus you can access tuple elements as idError.errorCode or idError.errorMessage
The most important use of the tuple is to return more information from the function rather than returning the single value.
Note: Tuple should be used when group of related data is needed for temporary scope.
6. Optional Variable or Constant
Optional are used in situation where there can be value or value does not exist. Optional concept is not available in the C or Objective C. In Objective C we had to come extends concept of optional called as nil object, with nil meaning “absence of the valid object”. But objective C does not provide optional concept for primitive types or structure types of variables and constant.
In order to declare the optional type, you need to use “?” after data type name. Thus Int will denote integer value but Int? will denote an optional integer value. An inbuilt example is toInt method of String class. toInt method returns Int? an optional Int value. This is because it is not always toInt will return an integer value. “123” will be converted into integer 123 but “Priyank Ranka” will not be converted into integer value. Thus toInt method might fail to return valid Int value, so better to use optional Int value.
In order to access the optional value it is always better to use “if” statement to check whether optional value exist in the variable or not, “if” statement will return true if value exists else false.
We need to use exclamation mark “!” to access the optional value. Run time system will throw an error if we try to access the optional value, which does not have value. Thus you need to use “if” statement and “!” mark to access the optional value.
Accessing the optional value using “!” is known as “Forced UnWrapping”.
var ageString = “25”
let age = ageString.toInt(“123”)
let retirementAgeLeft = 60 – age!
Optional Binding is used in the situation when optional contains value and you need to make that value available temporary. Optional Binding is used in “if” and “while” statement when condition returns an optional and the value inside the optional need to be made available inside the condition scope.
if let optionalAge = ageString.toInt(“123”)
let retirementAgeLeft = 60 – optionalAge
So above statement you can interpret as if optional return by ageString.toInt() contains a value make it available to constant “optionalAge”. This constant will
be available within the “if “ statement scope. Note: If you see we did not use “!” to access the optional Age because optional Age already got the value using option binding We can use “nil” with any optional. Only optional can be assign to nil value, nil in objective C is pointer to non-exisiting object. In Swift, nil is not a pointer but absence of value for any type.
Var age: Int? = 30
Age = nil
var firstName: String? // default it will assign to nil
Sometimes it is clear from a program’s structure that an optional will always have a value, after that value is first set. In these cases, it is useful to remove the need to check and unwrap the optional’s value every time it is accessed, because it can be safely assumed to have a value all of the time. These kinds of optionals are defined as implicitly unwrapped optionals. You write an
implicitly unwrapped optional by placing an exclamation mark (String!) rather than a question mark (String?) after the type that you want to make optional.
let photoWidth: Float? = 200.0
let photoHeight: Float! = 300.00
ipadPhotoWidth = 2.4 * photoWidth!
ipadPhotoHeight = 2.3 * photoHeight
You can think of an implicitly unwrapped optional as giving permission for the optional to be unwrapped automatically whenever it is used. Rather than placing an exclamation mark after the optional’s name each time you use it, you place an exclamation mark after the optional’s type when you declare it.
Implicitly unwrapped optionals should not be used when there is a possibility of a variable becoming nil at a later point. Always use a normal optional type if you need to check for a nil value during the lifetime of a variable.
7. Functions or Methods
In object oriented we work around the object. An object is a capsule having the state and behaviour. State is represented as variable and behaviour is represented as method. We have already seen various ways to declare variables in Swift. Lets discuss how to declare and call the methods.
We will compare method declaration in other language and Objective C and compare it with the Swift.
In C++ or JAVA we declare and call method as follow int getRollNumber();
int a = s1.getRollNumber;
Where s1 is the object of Student and we use dot operator to call the method of the Student Object.
In Objective C it will as follows
int a = [s1 getRollNumber];
In Swift it will be as follows
func getRollNumber() —> Int
var a = s1.getRollNumber()
In Swift we use word “func” to declare the method, followed by the function/method name, followed by () and finally return type is written at extreme right with right arrow followed by the returned type. In all the languages we write return type first but in Swift return type is written on right side. This make function or method declaration more readable. Lets see how to declare method with arguments or parameters.
In Other languages void createStudent(int rollNum, String fname, String lname, float age); s1.createStudent(1,”Priyank”,”Ranka”,28);
In Objective C it is -(void) createStudentWithRollNumber:(int) rollNum firstName:(NSString*)
fname lastName:(NSString*) lname age:(float) age;
[s1 createStudentWithRollNumber:1 firstName:@“Priyank” lastName:@“Ranka” age:28];
In Swift it is func createStudent(rollNumber rollNum:Int, firstName fname:String, lastName:String, age age:Float) s1.createStudent(rollNumber:1, firstName:”Priyank”,lastName:”Ranka”, age:28)
If you notice both objective C and Swift gives developer provision to label each argument. So while calling the method we can use same label with the value making calling of function/method more readable. Objective C made syntax too complex and removed conventional round brackets but Swift maintained the same convention and also added label to the method/function.
The label is termed as “External Parameter” where as argument is termed as “Internal Parameter”.
Also if you notice method was retuning void type, in Swift if method is returning void, we do not have to mention it. You can ignore it, complier will automatically will come to know that function is not returning any thing.
If you noticed that age is repeated as external and also as internal parameter. One can avoid this by using “#” in place of external parameter. This is called “short handed external Parameter”.
func createStudent(rollNumber rollNum:Int, firstName fname:String, lastName:String, # age:Float)
s1.createStudent(rollNumber:1, firstName:”Priyank”,lastName:”Ranka”, age:28)
If you notice we used “#” for the age label. We use double pointer to pass the reference of the object or pointer for passing the reference of the value. This is needed when function and your code should use same copy of the value
so that any modification made to the argument is reflected in the scope where function was called. In swift to achieve this we use “inout” as the label before the external Parameter.
func swap(inout one number1:Int, inout two number2:Int)
var a = 4
var b = 5
With this we can move forward to make iOS Applications. In coming chapters we will start setting up the iOS App Project and will play with various concepts in respective chapters.