Swift Programming - Part 2

1
Swift in depth
Presenter: Waseem Ahmad, Mindfire Solutions
Date: 18/02/2015

What we discussed
What is Swift?
Variable/Constants
String/Character Interpolation
Array and Dictionary
Loops
Optionals, Unwrapping an Optional
Functions
Tuples
Classes
Properties

What we will Learn Today
- Closures
- Structures
- Enum
- Memory Management
- Extensions

Closures
To an Objective-C developer, a closure is Swift’s equivalent of blocks.
A formal definition should be that Swift closures are self-contained blocks of
functionality that can be passed around and used in your code.
Intuitively, a closure is a kind of anonymous, nested functions. It’s a chunk
of functionality that can be passed around and used in your code.

Swift closures syntax
To define one, you’d write something like this:
{ (parameters) -> return_type in
// block body
// write code here
}
{(op1: Double, op2: Double) -> Double in
return op1 + op2
}

Type Inference
{(op1, op2) in
return op1 + op2
}
Implicit Return
{(op1, op2) in op1 + op2}

Implicit Arguments
performOperation({$0 + $1})
Trailing Closures
performOperation() {$0 - $1}

Some Closures Definition
As a variable:
var closureName: (parameterTypes) -> (returnType)
As a type alias:
typealias closureType = (parameterTypes) -> (returnType)
As a function parameter:
array.sort({ (item1: Int, item2: Int) -> Bool in return item1 < item2 })

Structure
Classes and structures have a similar definition syntax. We introduce classes with the
class keyword and structures with the struct keyword. Both place their entire
definition within a pair of braces:
class SomeClass {
// class definition goes here
}
struct SomeStructure {
// structure definition goes here
}

Structure Declaration
struct Point {
var x, y: Double
}
struct Size {
var width, height: Double
}
struct Rect {
var origin: Point
var size: Size
}
var point = Point(x: 0.0, y: 0.0)
var size = Size(width: 640.0, height: 480.0)
var rect = Rect(origin: point, size: size)

Swift Structure
Swift classes and structures are much closer in functionality than in other languages.
- We can define method inside the structure.
- We can define property inside the structure.

Define properties
struct Rect {
var origin: Point
var size: Size
var area: Double {
return size.width * size.height
}
}

Define methods
struct Rect {
var origin: Point
var size: Size
var area: Double {
return size.width * size.height
}
func isBiggerThanRect(other: Rect) -> Bool {
return self.area > other.area
}

Difference between class and struct
- Structures cannot Inherit from other types.
- Class Instances are Passed by Reference (Reference Type). “Unlike value types,
reference types are not copied when they are assigned to a variable or constant, or
when they are passed to a function.”
- Structures are Passed by Value (Value Type) “A value type is a type whose value is
copied when it is assigned to a variable or constant, or when it is passed to a
function.”
- Structures cannot have multiple references to the same instance
- Structures do not have deinitializers.

Mutating a Structure
struct Point {
var x, y: Double
mutating func moveToTheRightBy(dx: Double) {
x += dx
}
}

Enum
An enumeration defines a common type for a group of related values.
As you are familiar with C, Objective C, you know that C, Objective C
enumerations assign related names to a set of integer values.
Enumerations in Swift are much more flexible, and do not have to provide a
value for each member of the enumeration. the value can be a string, a
character, or a value of any integer or floating-point type.

Enum Declaration
enum CompassPoint {
case North
case South
case East
case West
}
var directionToHead = CompassPoint.West
Unlike C and Objective-C, Swift enumeration members are not assigned a
default integer value when they are created.
In the CompassPoint example above, North, South, East and West do not
implicitly equal 0, 1, 2 and 3. Instead, the different enumeration members are
fully-fledged values in their own right, with an explicitly-defined type of
CompassPoint

Enum and row value
enum Planet : Int {
case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn
}
let earthsOrder = Planet.Earth.rawValue
// earthsOrder is 3
let possiblePlanet = Planet(rawValue: 7)
// possiblePlanet is of type Planet? and equals Planet.Uranus
enum ASCIIControlCharacter: Character {
case Tab = "t"
case LineFeed = "n"
case CarriageReturn = "r"
}

Enumerations: Associated Values
enum TrainStatus {
case OnTime
case Delayed(Int)
}
var status = TrainStatus.OnTime
// status is inferred to be a TrainStatus
status = .Delayed(42)

Enumerations: Properties
enum TrainStatus {
case OnTime, Delayed(Int)
init() {
self = OnTime
}
var description: String {
switch self {
case OnTime:
return "on time"
case Delayed(let minutes):
return "delayed by (minutes) minute(s)”
}
}
}

Enumerations: Properties
var status = TrainStatus()
println("The train is (status.description)")
// The train is on time
status = .Delayed(42)
println("The train is now (status.description)")
// The train is now delayed by 42 minute(s)

Memory Management
-Swift uses Automatic Reference Counting (ARC) to track and manage your
app’s memory usage.
-ARC requires information about the relationships between parts of your code
in order to manage memory.
-Reference counting only applies to instances of classes. Structures and
enumerations are value types, not reference types, and are not stored and
passed by reference.

How ARC Works
-Every time you create a new instance of a class, ARC allocates a chunk of
memory to store information about that instance. Something like book
keeping.
-Additionally, when an instance is no longer needed, ARC frees up the memory
used by that instance.
-Reference counting only applies to instances of classes. Structures and
enumerations are value types, not reference types, and are not stored and
passed by reference.

How ARC Works
class Person {
let name: String
init(name: String) {
self.name = name
}
deinit {
// prints "John Appleseed is being deinitialized"
}
}
var reference1: Person(name: "John Appleseed")

How ARC Works
var reference2: Person?
var reference3: Person?
If you assign the same Person instance to two more variables, two more
strong references to that instance are established:
reference2 = reference1
reference3 = reference1
There are now three strong references to this single Person instance.

How ARC Works
reference1 = nil
reference2 = nil
ARC does not deallocate the Person instance until the third and final strong
reference is broken, at which point it is clear that you are no longer using the
Person instance:
reference3 = nil
// prints "John Appleseed is being deinitialized"

Strong Reference Cycles
In the examples, ARC is able to track the number of references to the new
Person instance you create and to deallocate that Person instance when it is
no longer needed.
However, it is possible to write code in which an instance of a class never gets
to a point where it has zero strong references.
This can happen if two class instances hold a strong reference to each other,
such that each instance keeps the other alive. This is known as a strong
reference cycle.

class Person {
let name: String
init(name: String) { self.name = name }
var apartment: Apartment?
deinit { println("(name) is being deinitialized") }
}
class Apartment {
let number: Int
init(number: Int) { self.number = number }
var tenant: Person?
deinit { println("Apartment #(number) is being deinitialized") }
}

Every Person instance has a name property of type String and an optional
apartment property that is initially nil. The apartment property is optional.
var john: Person?
var number73: Apartment?
john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)
john!.apartment = number73
number73!.tenant = john
Unfortunately, linking these two instances creates a strong reference cycle
between them.

Resolving Strong Reference
Cycles Between Class Instances
Swift provides two ways to resolve strong reference cycles when you work
with properties of class type: weak references and unowned references.
- Week references
- Unowned references
The instances can then refer to each other without creating a strong reference
cycle.

Weak References
Weak references must be declared as variables, to indicate that their value
can change at runtime. A weak reference cannot be declared as a constant.
class Person {
let name: String
init(name: String) { self.name = name }
var apartment: Apartment?
}
class Apartment {
let number: Int
init(number: Int) { self.number = number }
weak var tenant: Person?
}

Weak References

Unowned References
- Does not keep a strong hold on the instance it refers to.
- An unowned reference is assumed to always have a value.
- Because of this, an unowned reference is always defined as a non-optional
type.

Unowned References
class Customer {
let name: String
var card: CreditCard?
init(name: String) {
self.name = name
}
}
class CreditCard {
let number: UInt64
unowned let customer: Customer
init(number: UInt64, customer: Customer) {
self.number = number
self.customer = customer
}
deinit { println("Card #(number) is being deinitialized") }
}

Unowned References

Unowned/Weak References
Use a weak reference whenever it is valid for that reference to become nil at
some point during its lifetime.
Conversely, use an unowned reference when you know that the reference will
never be nil once it has been set during initialisation.
If you try to access an unowned reference after the instance that it references
is deallocated, you will trigger a runtime error. Use unowned references only
when you are sure that the reference will always refer to an instance.
Note also that Swift guarantees your app will crash if you try to access an
unowned reference after the instance it references is deallocated. You will
never encounter unexpected behaviour in this situation. Your app will always
crash reliably, although you should, of course, prevent it from doing so.

Extensions
Extensions add new functionality to an existing class, structure, or
enumeration type.
Extensions can add new functionality to a type, but they cannot override
existing functionality.
Extensions in Swift can:
-Add computed properties and computed static properties
-Define instance methods and type methods
-Make an existing type conform to a protocol

Extension Syntax
extension SomeType {
// new functionality to add to SomeType goes here
}
extension SomeType: SomeProtocol, AnotherProtocol {
// implementation of protocol requirements goes here
}
extension Int {
func repetitions(task: () -> ()) {
for i in 0..<self {
task()
}
}
}

Our USA client wanted us to develop an iPhone app which would be a
replica of their existing flash-based web-application related to fashion
encompassing all the features of the web-app. User can create account,
register/login, and then play around with the dummy models by creating
makeovers with the available accessories. User even has the facility to
save/upload their makeover as well as vote for other makeovers by
participating in daily/weekly contests. Mindfire responded well to create an
app for this mobile platform that contained 20,000 individual dress-up
elements without loosing quality or speed.
Click to know more >>
CASE STUDY
iPhone Fashion App
www.mindfiresolutions.com

Recap
- Closures
- Structures
- Enum
- Memory Management
- Extensions

References
- Apple WWDC 2014
- Apple Inc. “The Swift Programming Language.” iBooks.

Question and Answer

Thank you

Swift Programming - Part 2

More Related Content

What's hot

Similar to Swift Programming - Part 2

More from Mindfire Solutions

Recently uploaded

Swift Programming - Part 2