8/2/2017 - 4:16 PM


Swift notes from iOS dev learning - assumes Java knowledge. Test apps are here:

- Strongly typed, object oriented
- Semi-colons are optional to end statements
- // or /* */ for comments
- Used across Apple platforms
- Execution starts in main.swift
- Libraries imported using import statements
- Can use any unicode character in names
- Short circuits evaluations of conditional statements
- Functions and tuples are unnamed compound types (all others are named types)
- Any names type can have methods (classes, structs, enums)

Variables + Simple Types / Operators
All variables are value types, except objects which are reference types

Standard Types
    String (Double quoted)
    Int (Also Int8, Int16... and UInt8, UInt16...)
    Double (inferred by default over Float)
Integer literals
    Decimal, e.g. 234
    Binary, e.g. 0b101
    Octal, e.g. 0o76
    Hexadecimal, e.g. 0xA3
Floating-point literals
    Decimal, e.g. 32.4
    Exponent, e.g. 1.5e2
    Hexadecimal, e.g. 0x1Fp2

Use var for variables or let for constants
    var <identifier> = <value>
    let <identifier> = <value>

//define explicit type using ':' - This is generally not required for simple types
var string: String = "I am a string"
//Can mix on same line
var varOne = 1, varTwo = 2, varThree: Int
Can define without initialising (but must be initialised before use)
Variables can generally be cast by using initialisers for the various types:
    Int(<value>) //Will truncate floating point numbers
Standard Maths Operators / logic
    = //Does not return any value on assignment / fail
    ===, !==
    ( condition ? A : B )
    x...y //Range, Ints only
    x..<y //Range (not including value of y), Ints only

Can use _ to represent a temp variable which is not used (e.g iterator in for loop)

var str = "Hello";
//Iterate over characters and print
for character in newString.characters {
  print(character, "Can", "add", "more (spaces are added automatically)");

//Optionally add separator / terminator
print("hello", "this is", "a", "test", separator: "||", terminator: "***")
//Create a string with manipulation methods
var newTypeString = NSString(string: newString);
NSString(string: newTypeString.substring(from: 6)).substring(to: 4);

newTypeString.substring(with: NSRange(location: 6, length: 4));

if newTypeString.contains("Dave") {
  print("String contains Dave");

//Split into array
newTypeString.components(separatedBy: " ");


//Interpolate in Strings, concatenate strings
var string = "My age is \(age)" + ", more"

    //Arrays - stupid number of ways to create
    //Value type (but only copied when needed as an optimisation)
    var a1:[Int] = [Int]()
    var a2:[Int] = [Int](repeating: 10, count: 4)
    var myArray:Array<Int> = Array<Int>()
    vara3:Array<Int> = Array<Int>(repeating: 0, count: 5)
    var myArray = [1, 2, 3, 4]
    let myArray: [Int] = Array(1...50);
    myArray[1] === 2
    myArray[1...3] = [3,4,5,6,7] //Can do daft range expansion
    array.remove(at: <index>)
    varenglishFrench: Dictionary<String,String>
    var myDic = ["key" : "value", "key2" : "value"]
    myDic["newKey"] = <value>
    myDic.removeValue(forkey: "key")
    myDic.updateValue(forkey: "key") //Will add and return null if didn't exist
    //A set can only store types that conform to the Hashableprotocol and an implementation of ==(the “is equal to” operator) (Most types are hashableby default)
    var myCustomers= Set<String>()
    var myFriends: Set<String> = Set<String>()
    myFriends.insert("John"); myFriends.insert("Duncan"); myFriends.insert("Pam")
    var yourFriends: Set = ["Pam", "Paul", "Keith"]
    var numbers: Set<Int> = [10,20,30]
    numbers = [] // numbers is now an empty set  
    let setA: Set = [1,2,3,4]
    let setB: Set = [3,4,5,6]
    var res = setA.union(setB) // [1,2,3,4,5,6]
    res = setA.subtracting(setB) // [1,2]
    res = setA.intersection(setB) // [3,4]
    res = setA.symmetricDifference(setB) // [1,2,5,6]
    //All collections must have types, var / let determine if mutable
    var myArray : [<type>]
    var myDic : [<keyType> : <valueType>]

Control Structures
Use break to exit a loop
Use continue to skip to next loop

if <condition> {
  //If true

//If / else
if <condition> {
  //If true
} else {
  //if False

//If / else-if
if <condition> {
  //If true
} else if <condition> {
  //if true
} else {
  //if False

//While loop
while <condition> {

//Do-While loop
do {
} while <condition>

//Iterate over array or a range
for <identifier> in <arrayIdentifier|range> {
  //Stuff with <identifier>

//Iterate over dictionary tuples
for (<indexIdentifier>, <valueIdentifier>) in <arrayIdentifier>.enumerate() {
  //Stuff with <indexIdentifier> / <valueIdentifier>

//Switch statement - must be exhaustive (e.g. Int switch will have to have a default)
//Skips rest of case statements on match
switch variable {
    case value1:
    case value2:
    case x...y: //Can use ranges
    case x, y, z:
    case var m where m < 0 || m > 100: //Can use a where clause with temp variable

//Loops can be labelled to allow for use of break at parent levels
outerLoop: for i in 1...5 {
    for j in 1...5 {
        if i == 3 && j == 2 {
            break outerLoop
        } else {
            print("i is \(i) and j is \(j)")

Return definition required if the function has a return statement

//Func with return and two params (one with a defined external naming which overrides the internal name when invoking function)
//Can use _ as external name which means that no parameter naming is required when invoking function
func funcName (varInternalName: Int, varExternalName varInternalNameTwo: String) -> resultType {
    return value:resultType

//With a default value
func funcName (varInternalName: Int = 8) -> resultType {
    return value:resultType

//Variadic parameters
func myFunc(something: Int...) {

//Pass by reference
func swapNums(num1:inout Int, num2:inout Int) {
    let temp = num1
    num1 = num2
    num2 = temp
swap(&x, &y)

//Type description
(Type, Type, Etc) ()
(Type, Type, Etc) -> Type
(Type, Type, Etc) -> (Type, Etc)

//Can set to var
var sillyFunc = { (a: Int, b: Int) -> Bool in a > b) }

//SHhrtest closure form example - params are zero index, types and return have been inferred
sortedNumList= numList.sorted(by: { $1 < $0 })
sortedNumList= numList.sorted(){ $1 < $0 }

- Values which can be nil / not set
- To force unwrap use exclamation mark after variable - reverts to type from optional

var variable: Type?
let variable: Type?

//Can test with standard nil checks or:
if let variable = optional {
} else {

Simple unnamed strongly typed data structure
  Can be nested
  e.g. var myTuple = ("I Am A Tuple", (10, 5))
  Access using zero index
    myTuple.0 //I Am A Tuple

Can use in switch statement
  switch myTuple {
    case ("Meh", (10, 5):
      //No match
    case (_, let(first, second)):
      //Hit and disregards first value in tuple and inits first and second vars
    case (_, let(first, second)) where <logic>
    default <etc>

Access Modifiers
Access (to variables and types) can be controlled with the keywords open, public, private, fileprivate, and internal
Default is internal
Open access and public access enable entities to be used within any source file from their defining module, and also in a source file from another module that imports the defining module. You typically use open or public access when specifying the public interface to a framework.
Internal access enables entities to be used within any source file from their defining module, but not in any source file outside of that module. You typically use internal access when defining an app’s or a framework’s internal structure.
File-private access restricts the use of an entity to its own defining source file. Use file-private access to hide the implementation details of a specific piece of functionality when those details are used within an entire file.
Private access restricts the use of an entity to the enclosing declaration, and to extensions of that declaration that are in the same file. Use private access to hide the implementation details of a specific piece of functionality when those details are used only within a single declaration.

All classes must have a designated initialiser (a constructor)
Any other (optional) initialisers must be marked as "convenience" and call the designated initialiser
One is provided if no parameters or all parameters have default
All parameters must either have a default or be set by the designated initialiser
Can declare properties or method as static

class ClassName {
    var property
    //"Designated" initialiser
    init(property: Int){
    //Optional "Convenience" initiliser
    convenience init()
        self.init(property: 5)

    func method(vars) {

var class = ClassName(5)

Methods can have same name, different parameter types / names /  defaults
Classes can have a deinit destructor method with no args too
Properties can be marked as lazy (only calculated when needed)
    lazy var value = Expensive()
Properties can be normal "stored" properties or "computed" properties

//Computed property (get / set)
var value: Int {
    get {
    set (valueName) {
        //will get newValue if no valueName given

//Get only, do not need to include block:
var value: Int {

Can "adopt" protocols or inherit from parent classes
Methods which override an existing parent method must start with 'override' keyword

class myClass: parentClassOrProtocol {
    init() {

Interfaces, basically. Classes can adopt as many as they like

protocol {
    func funcName() -> Type
    var variable: Int

Add to source without altering original code
Cannot use stored properties
Can adopt a protocol to make a class adopt it

extension classBeingExtended {

Extremely similar to classes in definition (includes all of the above syntax)
Value type, not reference like object
Cannot use inheritance
A default initializer and a memberwiseinitializer are automatically generated (if none defined)
Memberwise is simply ordered constructor with all params of the struct
Methods which change state must be marked as mutating (as value types should be immutable)
    mutating method(vars) {
        //can replace entire instance
        self = ckass(changesVars)
Can aggregate further structs (can access using chained dot operators)

Extremely similar to classes in definition (includes all of the above syntax) - but defines a set

//Example with days of week and 1 -> 7 as rawValues (access Key)
enum WeekDay:Int {
    case Monday=1, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday

var day = enum.Monday
let todayNum= day.rawValue
varday4 = WeekDay(rawValue: 4) //Returns an optional

//Can shortcut when used in switch statements:
switch day {
    case .Monday:
    case .Tuesday:

//Can also have different states as tuples
enum State {
    case Start(String)
    case DoWork(Int, Int, Int)
    case End(String, Int)
vartheState: State = State.Start("about to start the work")
theState = State.DoWork(3,4,5)
theState = State.End("Finished", result)

Error Handling
Enums which implement "Error" can be thrown and caught
Code must state (using try) when calling a method which may throw

enum myError: Error {
    case IllegalArgs(args: [String])
    case ...

func funcWhichCanThrow() {
    throw myError.IllegalArgs(["Meh"])

do {
    try funcWhichCanThrow
} catch myError.IllegalArgs {

//Will always be executed even if error in surrounding block
defer {

//Converts result to null on exception throw
let var = try? func()

//Error suppression! :(
try! func()

//Guard statements (inverse if for error catching generally)
guard <condition> else {
    //code, throw maybe

Generally use T symbol but can use anything

class sillyClass<T> {
    init() {
        //Do stuff with type T

//Forcing adherence to type
class sillyClass<T: Type> {
    init() {
        //Do stuff with type T

func genericSwap<T>(_ item1 : inoutT, _ item2 : inoutT) {
    let temp = item1
    item1 = item2
    item2 = temp

//Adding further constraints
func myFunc<T1: Sequence where T1.Generator.Element : Person>(theList: T1) -> T1.Generator.Element? {

Other Stuff
arc4random_uniform(<limit>) //Random nums

iOS APIs / XCode

View Controllers
Common methods:
  viewDidLoad - Initial load delegate method
  viewDidAppear - User navigated to view delegate method
  didReceiveMemoryWarning - 

A method which is invoked by an event (managed / brough in through the storyboard
  @IBAction <definition>

A property representing a view item which can be manipulated
  @IBOutlet <definition>
Table Views
Need to extend UITableViewDelegate, UITableViewDataSource and implement:

  public func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int
  -> Return number of rows in table view
  public func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell
  -> Return content of a cell

Use <tableView>.reloadData(); to update the table with any changes

An example delete swipe:

    func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCellEditingStyle, forRowAt indexPath: IndexPath) {
        if editingStyle == UITableViewCellEditingStyle.delete {
            items.remove(at: indexPath.row);
            UserDefaults.standard.set(items, forKey: "list")
Web View
Example load URL in webview:
  let url = URL(string: "")!;
  <webviewOutlet>.loadRequest(URLRequest(url: url));
Example load HTML:
  <webviewOutlet>.loadHTMLString("<h1>Hello World!</h1>", baseURL: nil);

Note (if insecure content error, can add exception):
Example scrape (asynchonous):

  if let url = URL(string: "") {
      let request = URLRequest(url: url);
      let task = URLSession.shared.dataTask(with: request) {
          data, response, error in
          if error != nil {
          } else {
              if let unwrappedData = data {
                  let dataString = NSString(data: unwrappedData, encoding: String.Encoding.utf8.rawValue);

Persistant Storage
  UserDefaults.standard.set(<value>, forKey: <key>);
  - Save a value
  let <object> = UserDefaults.standard.object(forKey: <key>);
  - Fetch a value object
Use a let check to ensure a value is set before use when fetching from store

Keyboard Control
To close keyboard when user taps off the keyboard:
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
To close keyboard on return tap, need to extend UITextFieldDelegate and 
    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        return true;
Set a timer using normally
  Timer.scheduledTimer(timeInterval: <#T##TimeInterval#>, target: <#T##Any#>, selector: <#T##Selector#>, userInfo: <#T##Any?#>, repeats: <#T##Bool#>)
Stop a timer using:
  if (self.started == false) {
      self.timer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(ViewController.tickerFunction), userInfo: nil, repeats: true)
      self.buttonText.setTitle("Stop!", for: .normal);
  } else {
      self.buttonText.setTitle("Start!", for: .normal);
(Use above timer methods)
Set a new image for an UIImageView:
  self.image.image = UIImage(named: <string>);
Simple fade in example:
    @IBAction func fadeIn(_ sender: Any) {
        <image>.alpha = 0;
        UIView.animate(withDuration: <time>, animations: {
            <image>.alpha = 1;
Simple slide in example (from left):
    @IBAction func slideIn(_ sender: Any) {
        <image>.center = CGPoint(x: - <offscreenValue>, y:;
        UIView.animate(withDuration: <time>, animations: {
            <image>.center = CGPoint(x: + <offscreenValue>, y:

Simple grow example (from top left)
    @IBAction func grow(_ sender: Any) {
        <image>.frame = CGRect(x: 0, y: 0, width: 0, height: 0);
        UIView.animate(withDuration: 5, animations: {
            <image>.frame = CGRect(x: 0, y: 0, width: 200, height: 200);