Swift Cheat Sheet

enum ShirtSize: String {
  case small = "S"
  case medium = "M"
  case large = "L"
  case extraLarge = "XL"
  var description: String {
    return "The size of this shirt is \(self.rawValue)"
  }
}

enum Hello: String {
  case english = "Hello"
  case japanese = "Hello!"
  case emoji = "👋"
}
let hello1 = Hello(rawValue: "Hello!")
let hello2 = Hello(rawValue: "Привет")
print(hello1) // Optional(Hello.japanese)
print(hello2) // nil

enum Traffic {
  case light
  case heavy
  mutating func reportAccident() {
    self = .heavy
  }
}
var currentTraffic: Traffic = .light
currentTraffic. reportAccident()
// currentTraffic is now .heavy

Just like classes and structs, enumerations can have instance methods. If an instance method mutates the value of the enum, it needs to be marked mutating

enum Dessert {
  case cake(flavor: String)
  case vanillaIceCream(scoops: Int)
  case brownie
}
let order: Dessert = .cake(flavor: "Red Velvet")

enum Beatle: String {
  case john paul george ringo
}
print("The Beatles are \(Beatle.john.rawValue).")
// print: The Beatles are john.

enum Season: CaseIterable {
  case winter
  case spring
  case summer
  case falls
}
for season in Season.allCases {
  print(season)
}

Add conformance to the CaseIterable protocol to access the allCases property, which returns an array of all cases of the enumeration

enum Day {
  case monday
  case tuesday
  case wednesday
  case thursday
  case friday
  case saturday
  case sunday
}
let casualWorkday: Day = .friday

struct Resolution {
  var width = 0
  var height = 0
}
class VideoMode {
  var resolution = Resolution()
  var interlaced = false
  var frameRate = 0.0
  var name: String?
}

The Resolution structure definition and the VideoMode class definition only describe the appearance of Resolution or VideoMode, create an instance of the structure or class:

let resolution = Resolution(width: 1920)
let someVideoMode = VideoMode()

use data type

class Student {
  var name: String
  var year: Int
  var gpa: Double
  var honors: Bool
}

Use default property values

class Student {
  var name = ""
  var gpa = 0.0
  var honors = false
}

Suppose we have a BankAccount class:

class BankAccount {
  var balance = 0.0
  func deposit(amount: Double) {
    balance += amount
  }
  func withdraw(amount: Double) {
    balance -= amount
  }
}

SavingsAccount extends BankAccount class

class SavingsAccount: BankAccount {
  varinterest = 0.0
  func addInterest() {
    let interest = balance \*0.005
    self. deposit(amount: interest)
  }
}

The new SavingsAccount class (subclass) automatically gets all the characteristics of the BankAccount class (superclass). Additionally, the SavingsAccount class defines an .interest property and an .addInterest() method.

var ferris = Student()
ferris.name = "Ferris Bueller"
ferris.year = 12
ferris.gpa = 3.81
ferris.honors = false

class Person {
  var name = ""
  var age = 0
}
var sonny = Person()
// sonny is now an instance of Person

class Player {
  var name: String
  init(name: String) {
    self.name = name
  }
}
var player1 = Player(name: "Tomoko")
var player2 = player1
player2.name = "Isabella"
print(player1.name) // Isabella
print(player2.name) // Isabella

struct Dog {
  func bark() {
    print("Woof")
  }
}
let fido = Dog()
fido.bark() // prints: Woof

struct Menu {
  var menuItems = ["Fries", "Burgers"]
  mutating func addToMenu(dish: String) {
    self.menuItems.append(dish)
  }
}

Using the Menu class

var dinerMenu = Menu()
dinerMenu.addToMenu(dish: "Toast")
print(dinerMenu.menuItems)
// prints: ["Fries", "Burgers", "Toast"]

print(type(of: "abc")) // print: String
print(type(of: 123))   // print: 123

struct TV {
  var size: Int
  var type: String

  init(size: Int, type: String) {
    self.size = size
    self.type = type
  }
}

Using the TV class

var newTV = TV(size: 65, type: "LED")

struct Person {
  var name: String
  var age: Int
  init(name: String, age: Int) {
    self.name = name
    self. age = age
  }
}
// Person instance:
var morty = Person(name: "Peter", age: 14)

struct Car {
  var numOfWheels = 4
  var topSpeed = 80
}
var reliantRobin = Car(numOfWheels: 3)
print(reliantRobin.numOfWheels) // prints: 3
print(reliantRobin.topSpeed)    // print: 80

struct Building {
  var address: String
  var floors: Int
  init(address: String, floors: Int) {
    self.address = address
    self. floors = floors
  }
}

Structs or structs are used to programmatically represent real-life objects in code. A structure is created using the struct keyword, followed by its name, followed by a body containing its properties and methods

func getFirstInitial(from name: String?) -> String? {
  return name?.first
}

Functions can accept optional types and return optional types. When a function cannot return a reasonable instance of the requested type, it should return nil

func totalStudent(data: String...) -> Int {
  let numStudents = data.count
  return numStudents
}
print(totalStudent(data: "Denial", "Peter"))
// print: 2

var currentSeason = "Winter"
func season(month: Int, name: inout String) {
  switch month {
    case 1...2:
      name = "Winter ⛄️"
    case 3...6:
      name = "Spring 🌱"
    case 7...9:
      name = "Summer ⛱"
    case 10...11:
      name = "Autumn 🍂"
    default:
      name = "Unknown"
  }
}
season(month: 4, name: &currentSeason)
print(currentSeason) // Spring 🌱

func greet(person: String = "guest") {
  print("Hello \(person)")
}
greet() // Hello guest
greet(person: "Aliya") // Hello Aliya

func nextTotalSolarEclipse() -> String {
  "April 8th, 2024 🌎"
}
print(nextTotalSolarEclipse())
// print: April 8th, 2024 🌎

func findSquarePerimet(side: Int) -> Int {
  return side \*4
}
let perimeter = findSquarePerimet(side: 5)
print(perimeter) // print: 20
// Parameter: side
// Argument: 5

func smartphoneModel() -> (name: String, version: String, yearReleased: Int) {
  return ("iPhone", "8 Plus", 2017)
}
let phone = smartphoneModel()
print(phone.name)         // print: iPhone
print(phone.version)      // print: 8 Plus
print(phone.yearReleased) // print: 2017

func findDiff(\_ a: Int, b: Int) -> Int {
  return a -b
}
print(findDiff(6, b: 4)) // prints: 2

func convertFracToDec(numerator: Double, denominator: Double) -> Double {
  return numerator / denominator
}
let decimal = convertFracToDec(numerator: 1.0, denominator: 2.0)
print(decimal) // prints: 0.5

let birthYear = 1994
var currentYear = 2020
func findAge() -> Int {
  return currentYear-birthYear
}
print(findAge()) // prints: 26

func greetLearner() {
 print("Welcome to QuickRef.ME!")
}
// function call:
greetLearner()
// print: Welcome to QuickRef.ME!

func washCar() -> Void {
  print("Soap")
  print("Scrub")
  print("Rinse")
  print("Dry")
}

var emojiMeaning = [
  "🤔": "Thinking Face",
  "😪": "Sleepy Face",
  "😵": "Dizzy Face"
]
// loop through keys and values
for (emoji, meaning) in emojiMeaning {
  print("\(emoji) is called '\(meaning)Emoji'")
}
// iterate through keys only
for emoji in emojiMeaning. keys {
  print(emoji)
}
// iterate through values only
for meaning in emojiMeaning. values {
  print(meaning)
}

var hex = [
  "red": "#ff0000",
  "yellow": "#ffff00",
  "blue": "#0000ff",
]
print("Blue hexadecimal code \(hex["blue"])")
// print: blue hex code Optional("#0000ff")
if let redHex = hex["red"] {
  print("red hexadecimal code \(redHex)")
}
// print: red hex code #ff0000

Assigning the value of a key-value pair to a variable will return an optional value. To extract values, use the optional expansion

var change = [
  "Quarter": 0.29,
  "Dime": 0.15,
  "Nickel": 0.05
]
// Change the value using subscript syntax
change["Quarter"] = .25
// Change the value using .updateValue()
change. updateValue(.10, forKey: "Dime")

To change the value of a key-value pair, use the .updateValue() method or the subscript syntax by appending brackets [ ] with the existing keys within to the name of the dictionary, then adding the assignment operator (= ) followed by the modified value

var bookShelf = [
  "Goodnight": "Margaret Wise Brown",
  "The BFG": "Roald Dahl",
  "Falling Up": "Shel Silverstein",
  "No, David!": "David Shannon"
]
// remove value by setting key to nil
bookShelf["The BFG"] = nil
// remove value using .removeValue()
bookShelf. removeValue(forKey: "Goodnight")
// remove all values
bookShelf. removeAll()

var pronunciation = [
  "library": "lai·breh·ree",
  "apple": "a·pl"
]
// new key: "programming", new value: "prow gra"
pronunciation["programming"] = "prow·gra"

// initializer syntax:
var yearlyFishPopulation = [Int: Int]()
// Empty dictionary literal syntax:
var yearlyBirdPopulation: [Int: Int] = [:]

var employeeID = [
  "Hamlet": 1367,
  "Horatio": 8261,
  "Ophelia": 9318
]

var numberOfSides = [
  "triangle": 3,
  "square": 4,
  "rectangle": 4
]

Contains only String keys and Int values

var fruitStand = [
  "Coconuts": 12,
  "Pineapples": 12,
  "Papaya": 12
]

Each key is unique even if they all contain the same value

var dictionaryName = [
  "Key1": "Value1",
  "Key2": "Value2",
  "Key3": "Value3"
]

An unordered collection of pairs of data or key-value pairs

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D"]
var setC = setA.subtracting(setB)
print(setC) 
// print: ["B", "A"]

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]
var setC = setA.symmetricDifference(setB)
print(setC)
// print: ["B", "E", "F", "A"]

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]
var setC = setA.union(setB)
print(setC) 
// print: ["B", "A", "D", "F", "C", "E"]

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]
var setC = setA.intersection(setB)
print(setC) // print: ["D", "C"]

var emptySet = Set<String>()
print(emptySet.isEmpty)     // print: true
var populatedSet: Set = [1, 2, 3]
print(populatedSet.isEmpty) // print: false

var recipe: Set = ["Egg", "Flour", "Sugar"]
for ingredient in recipe {
  print ("Include \(ingredient) in the recipe")
}

var names: Set = ["Rosa", "Doug", "Waldo"]
print(names.contains("Lola")) // print: false
if names.contains("Waldo"){
  print("There's Waldo!")
} else {
  print("Where's Waldo?")
}
// print: There's Waldo!

var oddNumbers: Set = [1, 2, 3, 5]
// remove existing element
oddNumbers.remove(2)
// remove all elements
oddNumbers.removeAll()

var cookieJar: Set = [
  "Chocolate Chip",
  "Oatmeal Raisin"
]
// add a new element
cookieJar.insert("Peanut Butter Chip")

var vowels: Set = ["a", "e", "i", "o","u"]

To create a set filled with values, use the Set keyword before the assignment operator.

var team = Set<String>()
print(team)
// print: [] 

var paintingsInMOMA: Set = [
  "The Dream",
  "The Starry Night",
  "The False Mirror"
]

We can use a collection (Set) to store unique elements of the same data type

var employees = ["Peter", "Denial", "Jame"]
for person in employees {
  print(person)
}
// print: Peter
// print: Denial
// print: Jam

var moon = ["🌖", "🌗", "🌘", "🌑"]
moon.insert("🌕", at: 0)
// ["🌕", "🌖", "🌗", "🌘", "🌑"]
moon. remove(at: 4)
// ["🌕", "🌖", "🌗", "🌘"]

var gymBadges = ["Boulder", "Cascade"]
gymBadges.append("Thunder")
gymBadges += ["Rainbow", "Soul"]
// ["Boulder", "Cascade", "Thunder",
// "Rainbow", "Soul"]

// use type inference:
var snowfall = [2.4, 3.6, 3.4, 1.8, 0.0]
// explicit type:
var temp: [Int] = [33, 31, 30, 38, 44]

The index refers to the item's position in the ordered list, and a single element is retrieved from the array using the subscript syntax array[index].

var vowels = ["a", "e", "i", "o", "u"]
print(vowels[0]) // prints: a
print(vowels[1]) // prints: e
print(vowels[2]) // print: i
print(vowels[3]) // prints: o
print(vowels[4]) // prints: u

Note: Swift arrays are zero-indexed, meaning the first element has index 0.

var grocery = ["🥓", "🥞", "🍪", "🥛", "🍊"]
print(grocery.count)
// print: 5

var scores = [Int]()
// array is empty: []

var counter = 1
var stopNum = Int. random(in: 1...10)
while counter < stopNum {
  print(counter)
  counter += 1
}
// loop to print until the stop condition is met

A while loop accepts a condition and keeps executing its body code while the provided condition is true. If the condition is never false, the loop will keep running and the program will get stuck in an infinite loop

for \_ in 1...3 {
  print("Ole")
}
// print: Ole
// print: Ole
// print: Ole

for char in "supercalifragilistic" {
if char == "c" {
    break
  }
  print(char)
}
// print: s
// print: u
// print: p
// print: e
// print: r

for num in 0...5 {
  if num % 2 == 0 {
    continue
  }
  print(num)
}
// print: 1
// print: 3
// print: 5

The continue keyword will force the loop to continue for the next iteration

for char in "hehe" {
  print(char)
}
// print: h
// print: e
// print: h
// print: e

for oddNum in stride(from: 1, to: 5, by: 2) {
  print(oddNum)
}
// print: 1
// print: 3

let zeroToThree = 0...3
//zeroToThree: 0, 1, 2, 3

func greet(name: String?) {
  guard let unwrapped = name else {
    print("Hello guest!")
    return
  }
  print("Hello \(unwrapped)!")
}
greet(name: "Asma") // output: Hello Asma!
greet(name: nil)    // output: Hello guest!

// without parentheses:
true || true && false || false
//----> true
// with brackets:
(true || true) && (false || false)
//----> false

!false && true || false // true

!false && true first evaluates and returns true Then, the expression, true || false evaluates and returns the final result true

false || true && false // false

true && false first evaluates to return false Then, the expression, false || false evaluates and returns the final result false

!true  // false
!false //true

let num = 7
switch num {
  case let x where x % 2 == 0:
    print("\(num) is even")
  case let x where x % 2 == 1:
    print("\(num) odd number")
  default:
    print("\(num) is invalid")
}
// print: 7 odd

let service = "Seamless"
switch service {
case "Uber", "Lyft":
    print("travel")
  case "DoorDash", "Seamless", "GrubHub":
    print("Restaurant delivery")
  case "Instacart", "FreshDirect":
    print("Grocery Delivery")
  default:
    print("Unknown service")
}
// print: restaurant takeaway

let year = 1905
var artPeriod: String
switch year {
  case 1860...1885:
    artPeriod = "Impressionism"
  case 1886...1910:
    artPeriod = "Post-Impressionism"
  default:
    artPeriod = "Unknown"
}
// print: post-impressionism

var secondaryColor = "green"
switch secondaryColor {
  case "orange":
    print("A mixture of red and yellow")
  case "purple":
    print("A mix of red and blue")
  default:
    print("This may not be a secondary color")
}
// print: mix of blue and yellow

var driverLicense = true
driverLicense
    ? print("driver seat") : print("passenger seat")
// print: driver's seat

5 > 1      // true
6 < 10     // true
2 >= 3     // false
3 <= 5     // true
"A" == "a" // false
"B" != "b" // true

-< less than -> greater than -<= less than or equal to ->= greater than or equal to -== is equal to -!= is not equal to

var weather = "rainy"
if weather == "sunny" {
  print("Get some sunscreen")
} else if weather == "rainy" {
  print("Take an umbrella")
} else if weather == "snowing" {
  print("Put on your snow boots")
} else {
  print("Invalid weather")
}
// print: take an umbrella

var turbulence = false
if turbulence {
  print("Please sit down.")
} else {
  print("You are free to move around.")
}
// print: You are free to move around.

var halloween = true
if halloween {
  print("Trick or treat!")
}
// print: Trick or treat!
if 5 > 3 {
  print("5 is greater than 3")
} else {
  print("5 is not more than 3")
}
// output: "5 is greater than 3"