Swift

Swift

• Constants and Variables
• Control Flow
• Types
• Tuples
• Optionals
• Collections - Arrays, Sets, and Dictionaries.
• Hashable and Equatable
• Functions
• Closures
• Type Casting
• Mirror
• Preprocessor Directives
• Access Control
• Classes and Structures
• Properties
• Filter, Map, Reduce
• Regular Expressions
• Protocols
• Any vs AnyObject

General References

• Apple Developer Resources
  • Swift Language Guide - Apple Developer
  • Swift Standard Library Reference - Apple Developer
• Understanding Swift - Codepath

Videos

• Protocol Oriented Programming with Swift - WWDC 2015

Constants and Variables

let defaultName = "John Doe"
var name = "Abraham Lincoln"

# Sigle line assignment of multiple variables:
let defaultFirstName = "John", defaultLastName = "Doe"
let name = "Abraham", lastName = "Lincoln"

• Constants are defined using let.
• Variables that can change are declared with var.

Control Flow

guard statements

var foo: String?

func myFunc() {
    // Allows `unwrappedFoo` to be used in the same scope
    // after the guard statement.
    guard let unwrappedFoo = foo else {
        print("foo is nil")
        return
    }
    print("\(unwrappedFoo)")
}

myFunc()

Guard statements are used to shift control away from the current scope if a condition is not met.

The else clause of a guard statement is required, and must transfer control away from the enclosing scope using one of the following instructions:

• return
• break
• continue
• throw
• call a function with a @noreturn attribute, which tells the compiler that current scope will not be returning a value to its caller.

Guard statements can also unwrap multiple optionals by separating the unwrap statements by commas.

The else clause will be run if any of the optionals were not able to be unwrapped successfully. I.e., if any of the optionals are nil.

var foo: String? = "foo"
var bar: String?

func myFunc() {
    guard
        let foo = foo,
        let bar = bar
    else {
        return
    }

    print("\(foo) and \(bar) unwrapped")
}

// Does not print anything since bar is nil.
myFunc()

Types

• Can be explicitly provided via :<Type>. E.g., let name: String = "Abraham Lincoln"
• Without an explicit type, the compiler will choose a type based on the value given at definition.
• Type Aliases
  • Types can be aliased for increased readability.

typealias eightBit = UInt8

print(eightBit.max)

// prints 255

Tuples

Optionals

• Optional types allow variables to be either nil or a value of specified type.

var intFromString = Int("foo") // returns nil

Unwrapping

var x: Int?

// '!' is required to 'unwrap'  and access the
// value stored in the optional.
print("\(x! + 3)")

Testing for existence

var x: Int?

// nil check that still requires unwrapping
if x != nil {
    print("\(x! + 3)")
}

// optional binding
// the if block is never entered if foo is nil.
if let foo = x {
    // No unwrapping needed.
    print("\(foo + 3)")
}

When optional binding is used, a new variable is created that is set to the value stored in the optional, as long as the optional is not nil.

The new variable's type is the wrapped value's type, so no unwrapping is necessary to access the value.

Optional chaining

class Point {
    var x: Int
    var y: Int

    init(x: Int, y: Int) {
        self.x = x
        self.y = y
    }
}

var myPoint: Point?

myPoint?.x // nil

// produces a compiler error.
// myPoint is an optional and therefore must be unwrapped
// or the possibility of a nil value must be accounted for.
myPoint.x

// Another way to deal with an optional.
if let point = myPoint {
    print("\(point.x)")
}

Adding a ? after a variable will short circuit

• intFromString is of type Int?, since a failed integer conversion returns nil

Testing existence of optional variables

var answer:String? // Automatically set to nil
answer = "The Hudson River"

if answer != nil {
  print(answer) // prints Optional("The Hudson River")

  // Forced unwrapping using '!'
  print(answer!) // prints "The Hudson River"
}

Nil coalescing operator ??

var foo:Int?

print(foo ?? 6)
// prints 6

• foo ?? 6 is the equivalent of foo == nil ? foo! : 6

Collections

Arrays

// The following produce the same array:
var scores: [Double] = [10.0, 9.98]
var scores = [10.0, 9.98]
var scores = [Double](); scores.append(10.0); scores.append(9.98)
var scores = [Double](); scores += [10.0, 9.98]

scores.isEmpty // false

// Initialize an array with default values
print([Double](count: 3, repeatedValue: 0.0) // prints [0.0, 0.0, 0.0]

Sets

• Unordered collection containing unique values.

// The following produce the same set:
var groceryList: Set<String> = Set<String>(); groceryList.insert("popcorn")
var groceryList: Set<String> = ["popcorn"]

groceryList.contains("popcorn") // true
groceryList.remove("popcorn") // returns "popcorn" (or nil if not found)

• Elements inserted into sets must conform to the Hashable and Equatable protocols

Set operations

var myGroceryList: Set<String> = ["apples", "oranges"]
var spouseGroceryList: Set<String> = ["apples", "bananas"]

myGroceryList.intersect(spouseGroceryList) // ["apples"]
myGroceryList.union(spouseGroceryList) // ["oranges", "bananas", "apples"]
myGroceryList.subtract(spouseGroceryList) // ["oranges"]
myGroceryList.exclusiveOr(spouseGroceryList) // ["oranges", "bananas"]

myGroceryList.isSubsetOf(spouseGroceryList) // false
myGroceryList.isSupersetOf(spouseGroceryList) // false
myGroceryList.isDisjointWith(["pears"]) // true

Dictionaries

• Unordered key value pairs.

// The following produce the same dictionary:
var reportCard: Dictionary<String, Double> = ["math": 5.0, "english": 4.0]
var reportCard: [String:Double] = ["math": 5.0, "english": 4.0]
var reportCard = ["math": 5.0, "english": 4.0]

var reportCard = [String:Double](); reportCard["math"] = 5.0; reportCard["english"] = 4.0

// Returning the previous value
reportCard.updateValue(5.5, forKey: "math") // returns 5.0 (or nil if no previous value was found)
reportCard.removeValueForKey("math") // returns 5.5 (or nil if no value existed)

// Iterating
for(subject, score) in reportCard {
    print("Grade for \(subject) was: \(score)")
}

/* Output
    Grade for math was: 5.5
    Grade for english was: 4.0
*/

// Iterating over keys OR values only
for score in reportCard.values { print(score) } // 5.5, 4.0
for subject in reportCard.keys { print(subject) } // "math", "english"

// Creating an array from a dictionary's keys/values
[String](reportCard.keys) // ["math", "english"]
[String](reportCard.keys.sort) // ["english", "math"]

Hashable and Equatable Protocols

// == must be defined in the global scope
// Swift defines
func ==(lhs: Person, rhs: Person) -> Bool {
    return (lhs.firstName + lhs.lastName) == (rhs.firstName + rhs.lastName)
}

class Person : Hashable {
    var lastName:String
    var firstName:String

    init(firstName: String, lastName: String) {
        self.firstName = firstName
        self.lastName = lastName
    }

    // Hashable protocol requires a `hashValue` instance variable
    var hashValue: Int {
        return (firstName + lastName).hashValue
    }
}

// Person can now be added to collections that require a Hashable object.
// E.g., Set, Dictionary.
var personSet:Set<Person> =  [
    Person(firstName: "Abraham", lastName: "Lincoln"),
    Person(firstName: "Barack", lastName: "Obama"),
    Person(firstName: "Abraham", lastName: "Lincoln"),
]

personSet.count // 2

Functions

Parameters

func addNumbers(firstNumber: Int, secondNumber: Int) -> Int {
    return firstNumber + secondNumber
}

// First parameter name is always left out.
addNumbers(5, secondNumber: 6)

External vs Local parameters

// Function signature: getDirections(from:to:)
func getDirections(from pointA: String, to pointB: String) -> [String] {
    return [
        "start at \(pointA)",
        "finish at \(pointB)",
    ]
}

// When specifying external param names, they must be used in the method call.
getDirections(from: "SFO", to:"Los Angeles")

• Parameters
  • External
    • from and to are external parameter names.
  • Local
    • pointA and pointB are local parameter names.
• -> is called the return arrow and indicates the return type

/*
    Using '_' for external parameter names will exclude them
    from being required by clients when invoking.

    Function signature: getDirections(_:_:)
*/
func getDirections(pointA: String _ pointB: String) { ... }

getDirections("SFO", "Los Angeles")

Default Parameters

// Default parameters should be listed last to allow
// them to be excluded if needed.
func sayHello(name: String, greeting: String = "Hello") {
    print("\(greeting) \(name)")
}

sayHello("Jim")

Variadic Parameters

// adding `...` to a paramter type passes the list
// in as an array.
func sum(numberList: Int...) -> Int {
    var sum = 0
    for num in numberList {
        sum += num
    }
    return sum
}

print(sum(1, 2, 3)) // 6

InOut Parameters

Normally paramters are constants, but the inout keyword passes the addresses of the passed in parameters, allowing the original variables to be updated.

func swap(inout a: String, inout _ b: String) {
    let temp = a
    a = b
    b = temp
}

// Must be variables, and not constants
var x = "x", y = "y"

// Pass in address by prefixing variable with an ampersand
swap(&x, &y)

print("x is now \(x) and y is \(y)") // x is now y and y is now x

Returning tuples (multiple return values)

// Optional tuple
func firstAndLast(numberList: [Int]) -> (first: Int, last: Int)? {
    if numberList.isEmpty {
        return nil
    }
    else {
        return (numberList[0], numberList[numberList.count - 1])
    }
}

// Access tuple values by element name
if let tuple = firstAndLast([1, 2, 3]) {
    print("first: \(tuple.first) last: \(tuple.last)")
}

Function Types

Every function has a type, which is made up of the function's:

• parameter types
• return type

This allows a function to be:

• passed as paramters to other functions
• returned by other functions

// These two functions are of type: (Int, Int) -> Int

func add(a: Int, _ b: Int) -> Int { return a + b }
func multiply(a: Int, _ b: Int) -> Int { return a * b }

// Function type declaration and assignment
var doSomeMath: (Int, Int) -> Int = add
doSomeMath(3, 5) // 8

Function type for a function with no args and no return value: () -> Void

func callFunction(someFunction: () -> Void) {
    someFunction()
}

callFunction() { print("Hi") } // "Hi"

Functions as paramters and return types

Functions can be passed in to other functions.

// Functions should be placed last in a parameter list so trailing closures
// can be used.
func doSomeMath(a: Int, _ b: Int, _ mathFunction: (Int, Int) -> Int) {
    print(mathFunction(a, b))
}

doSomeMath(2, 3, multiply) // 6

// Returns a function
func mathFunctionFactory(name: String) -> (Int, Int) -> Int {
    return name == "multiply" ? multiply : add
}

mathFunctionFactory("multiply")(5, 6) // 30

Function Names and Selector Syntax

// #selector(foo)
func foo() {
}

// #selector(foo(_:))
func foo(name: String) {
}

// #selector(foo(_:lastName:))
func foo(firstName: String, lastName: String) {
}

// #selector(foo(firstName:lastName:))
func foo(firstName firstName: String, lastName: String) {
}

/*
    Note: the function name is the same regardless
    of return type
*/

// foo(_:)
func foo(name: String) -> String{
    return name
}

Function names are used when specifying selectors via the #selector() syntax.

The function name for the foo function above without arguments is foo.

Unless an external parameter name is given, the first parameter name is replaced with an underscore _.

Return types are not included in the function signature, since two functions cannot be defined that differ only by return type.

See example below.

func foo() -> Int { return 5 }
func foo() -> String { return "a" }

/*
    This results in the following compile error:
    error: ambiguous use of 'foo()'
    foo()
    ^
    note: found this candidate
    func foo() -> Int { return 5 }
         ^
    note: found this candidate
    func foo() -> String { return "a" }
*/
foo()

Nested Functions

Functions can be defined within another function, giving it access to variables within the enclosing scope.

Nested functions can also be used for increased readability.

func mathFunctionFactory(name: String) -> (Int, Int) -> Int {
    // All nested functions have access to c
    let c = 3

    func add(a: Int, _ b: Int) -> Int { return a + b + c }
    func multiply(a: Int, _ b: Int) -> Int { return a * b * c }

    return name == "multiply" ? multiply : add
}

mathFunctionFactory("multiply")(5, 6) // 90

References

• What is _: in Swift Telling me? - Stack Overflow

Closures

• Closures have the following basic structure:

{
    (<parameters>) -> <return type> in
        <statements>
}

• Parts of a closure
  • in keyword signals the end of the parameter and return type declarations and the beginning of the function body.

Closure syntax

The next few code blocks will reference the sort(_:) function, which sorts an array of known type and takes a closure as it's only argument.

sort(_:) passes two elements to the closure as arguments, and the closure determines whether the first element should appear before the second.

The following are all equivalent ways to sort an array in reverse order:

let numList = [2, 35, 3, 76, 4 , 2]

// Define a named function
func reverse(num1: Int, _ num2: Int) -> Bool {
    return num1 > num2
}

// Pass the function to the sort function.
numList.sort(reverse) // [76, 35, 4, 3, 2, 2]

// Fully defined inline closure
numList.sort({ (num1: Int, num2: Int) -> Bool in
    return num1 > num2
})

// On a single line
numList.sort({ (num1: Int, num2: Int) -> Bool in return num1 > num2 })

Shorthand Syntax

/*
    When the compiler can figure out the type of the closure arguments given the
    context, the closure can omit type declarations.
    In this case, the compiler knows the closure is passed two Ints.
*/
numList.sort({ num1, num2 in return num1 > num2 })

// This is also valid, although the return type is redundant:
numList.sort({ (num1, num2) -> Int in return num1 > num2 })

// Closures with a single statement can omit the return keyword
numList.sort({ num1, num2 in num1 > num2 })

// Default argument names can also be used
numList.sort({ $0 > $1 })

// Since the Int type defines the > function, which has the same function type
// required by the sort function, this can be further reduced to:
numList.sort(>)

Trailing Closures

When a function takes a closure as its last argument, a trailing closure can be used to increase readability.

numList.sort() {
   // Closure body goes here
}

numList.sort() { $0 > $1 }

Capturing values

Non Escaping and Escaping Closures

The @noescape annotation before a parameter of some closure type informs the compiler that the closure being passed in can be garbage collected after the function exits.

As of Swift 3, @noescape is the default.

This allows the compiler to make optimizations, and also prohibits the closure from being assigned to a variable outside of the function scope.

var closureToUseLater: (Int) -> Int

func callClosure(@noescape closure: (Int) -> Int) -> Int{
    // Assignment will cause a compilation error.
    closureToUseLater = closure

    return closure(5)
}

When would a closure need to allowed to escape from the function scope?

A closure can be annoted with @escaping if it may need to outlive the function call.

This may need to happen if:

• The closure is registered as part of an asynchronous callback.
• The closure is stored as an instance variable or global variable that outlives the current scope.

References

• Nonescaping and Escaping Closures - Swift Unboxed

Autoclosures

Autoclosures create a closure that executes the block of code being passed in when the autoclosure is invoked.

var charArray = ["a", "b", "c"]

// Wrapping expressions in curly braces creates an autoclosure.
var takeFirstAndLast = {
    let first = charArray.removeFirst()
    let last = charArray.removeLast()

    (first: first, last: last)
}

print(charArray) // ["a", "b", "c"]
print(takeFirstAndLast()) // ("a", "c")
print(charArray) // ["b"]

Autoclosures do not take parameters.

@autoclosure annotation

The @autoclosure annotation allows method invocation to be delayed.

See the below example:

var charArray = ["a", "b", "c"]

func popAndDoSomething(@autoclosure closure: () -> String) {
    print(charArray) // ["a", "b", "c"]
    closure()
    print(charArray) // ["b", "c"]
}

// removeFirst() is not called until execution is within the
// body of popAndDoSomething()
popAndDoSomething(charArray.removeFirst())

Although this can be useful, use of the @autoclosure annotation should be used with discretion as it can decrease readability.

References

• Closures - Apple Developers

Type Casting

Downcasting

Downcasting attempts to cast an object as a subclass of its current type.

Forced Downcast

as! is a forced downcast, used when the downcast is expected to succeed.

var anyValue: Any = 5

// Use as! when the downcast should succeed.
// If it doesn't, a runtime error will occur.
print(anyValue as! Int + 11) // 16

This will downcast and force unwrap.

If the downcast returns a nil value a runtime error will occur.

Conditional Downcast

as? is a conditional downcast, which allows subsequent checks to see if a downcast was successful.

This will return an optional value of the attempted downcast type.

var anyValue: Any = "not an Int"

// Use as? in order to handle downcast failures.
// Will return an Int? (Int optional)
if var downcastedValue = anyValue as? Int {
    print("downcast of \(downcastedValue) successful")
}
else {
    print("value not an Int")
}

// prints "value not an Int"

Mirror

let someSet: Set<String> = ["apple", "orange"]

Mirror(reflecting: someSet).subjectType // Set<String>

// Do something if the object is a Set.
if Mirror(reflecting: someSet).subjectType == Set<String>.self {
    ...
}

References

• Mirror - Apple Developer

Preprocessor Directives

/*
    Groups methods.  Similar to the `#pragma mark` ObjC preprocessor.
    Adding a `-` adds a separator line.
*/

// MARK: - UITableViewDataSource protocol methods

/* Marks sections of code that have unfinished work */
// TODO: Add ability to edit customer data.

/* Marks sections of code that contain bugs */
// FIXME: Runtime error occurs if user is missing.

Preprocessor directives increase readability. In XCode, methods are grouped by these directives when viewing a quick view of a class.

Access Control

Modules and Source Files

• Module - a library or unit of code that can be distributed and used by other applications/clients.
  • Clients normally need to import modules via the import keyword before they can be used..
  • Examples: app bundle, framework
• Source File - a single file containing Swift source code.
• Entities - types and things belonging to those types that can be access controlled. These include:
  • types
    • classes
    • structs
    • enumerations
  • methods
  • properties
  • initializers
  • subscripts

Access Control Levels

• Public
  • Used to specify the public API or public interface for entities.
  • Allows entities to be used by source files:
    • within it's own module.
    • in other modules if imported into the external module.
• Internal
  • Internal is the default level.
  • Used when defining the internal API of a module.
  • Allows entities to be accessible from within the same module.
• Private
  • Allows access to entities from within the same source file only.
  • Used to encapsulate entities within a source file and hide implementation details.

Classes and Structures

Properties

Stored Properties

struct Greeting {
    let salutation: String // Constant property
    var name: String // Variable property

    func sayHello() {
        print("\(salutation) \(name)")
    }
}

// Structs provide a default initializer for all properties.
var greeting = Greeting(salutation: "Hi", name: "Bob")
greeting.name = "Earl"

greeting.sayHello() // Hi Earl

Stored properties can be initialized when they're defined, during initialization, or through a setter.

let greeting = Greeting(salutation: "Hi", name: "Bob")

// Compile error: cannot assign to property: 'greeting' is a 'let' constant
greeting.name = "Earl"

The above code produces a compile error, because the properties of a constant instance are also immutable.

Lazy Stored Properties

class Calculator {
    // Does not initialize view unless display() is called.
    lazy var view = View()

    func backgroundCalculation() { print("Performing calculation...") }

    func display() { view.render() }
}

class View {
    init() { print("Loading view...") }

    func render() { print("Displaying view...") }
}

let calculator = Calculator()
calculator.backgroundCalculation()
calculator.display()

/*
    Output:

    Performing calculation...
    Loading view...
    Displaying view...
*/

Without the lazy keyword, the View instance would be instantiated upon initialization of the Calculator instance and the output would be:

Loading view...
Performing calculation...
Displaying view...

Lazy properties are useful when:

• Initialization of the property is expensive.
• The property has external dependencies that may not be fulfilled until after initialization of the instance.

Computed Properties

class Order {
    var subtotal: Double
    private var taxRate: Double

    init(subtotal: Double, taxRate: Double) {
        self.subtotal = subtotal
        self.taxRate = taxRate
    }

    var total: Double {
        get {
            return subtotal * (taxRate + 1)
        }

        set(newTotal) {
            subtotal = newTotal / (1 + taxRate)
        }
    }
}

let order = Order(subtotal: 10.00, taxRate: 0.1)
print("\(order.total)")
order.total = 22.00
print("\(order.subtotal)")

/*
    Output:
    11.0
    20.0
*/

Computed properties do not store values in instance variables, but can be accessed and set like stored properties.

A getter and/or setter can be defined for a computed property that executes a block when the property is retrieved or set.

If only a getter is defined, the computed property above can omit the get keyword:

var total: Double {
    return subtotal * (taxRate + 1)
}

Also, setters provide a default argument called newValue if a named parameter is not necessary:

var total: Double {
    set {
        subtotal = newValue / (1 + taxRate)
    }
}

Property Observers

class Person {
    var name: String {
        // Called before the property is set
        // `newValue` can be used if no named parameter is specified
        willSet(newName) {
            print("changing to: \(newName)")
            print("name is currently: \(name)")
        }

        // Called after the property is set
        // `oldValue` can be used if no named parameter is specified
        didSet(oldName) {
            print("name was: \(oldName)")
            print("name is currently: \(name)")
        }
    }

    init(name: String) {
        self.name = name
    }
}

var person = Person(name: "Abraham Lincoln")
person.name = "Martin Luther King Jr."

/*
    Output:
    changing to: Martin Luther King Jr.
    name is currently: Abraham Lincoln
    name was: Abraham Lincoln
    name is currently: Martin Luther King Jr.
*/

The willSet and didSet observers can be defined for the following types of properties:

• non-lazy stored properties defined in the enclosing class
• inherited stored and computed properties, via property overriding in the subclass.

Computed properties defined in the enclosing class can add observer behavior in the setter block.

Type Properties (Static properties)

class Person {
    static var lifeExpectancy = 80.3
    static var lifespans: [Double] = [Double]()

    // The `class` keyword allows subclasses to override this.
    class var averageLifeExpectancy: Double {
        var total: Double = 0

        if lifespans.count == 0 {
            return 0.0
        }

        for lifespan in lifespans {
            total += lifespan
        }

        return total / Double(lifespans.count)
    }
}

Person.lifespans.appendContentsOf([100.0, 80.0])
print("\(Person.averageLifeExpectancy)") // Prints "90.0"

class Asian: Person {
    // If the super class used `static` instead of `class`, a
    // `class var overrides a 'final' class var` compiler error is thrown
    override class var averageLifeExpectancy: Double {
        return 75.0
    }
}

print("\(Asian.averageLifeExpectancy)") // Prints "75.0"

Type properties exist at the type level, and are shared by all instances.

Stored static properties cannot be overriden by subclasses, but computed properties can allow overriding via the class keyword.

Filter, Map, and Reduce

Filter

let myArray = [1, 2, 3, 4, 5]

// Keep even numbers
myArray.filter() {
    (element: Int) -> Bool in
    element % 2 == 0
}

Shorthand notation:

myArray.filter { element in element % 2 == 0 }

// Numbered argument syntax
myArray.filter { $0 % 2 == 0 }

References

• Swift map, filter, reduce - Use Your Loaf

Regular Expressions

References

• Apple Developer
  • NSRegularExpression
• NSRange - NSHipster

Protocols

References

• Apple Developer
  • Protocols

Any vs AnyObject

• AnyObject - supports instances of any class.
• Any - broader than AnyObject, since it includes primitives (e.g., String, Double, Int, etc.)

class Foo {}
struct Bar {}
var fooClosure = { (aString: String) -> String in return aString }

var anyObjects = [AnyObject]()

anyObjects.append(Foo())

// Structs, primitives, and closures are not classes
// All of the following raise compiler errors.
anyObjects.append(Bar())
anyObjects.append(3.0)
anyObjects.append(fooClosure)

var anys = [Any]()

// Any applies to classes, primitives, structs, and closures.
anys.append(Foo())
anys.append(Bar())
anys.append(3.0)
anys.append(fooClosure)

References

• Any vs AnyObject - Mediuum