Chapters
Chapters

Chapters

Hide chapters

SwiftUI Apprentice

Third Edition · iOS 18 · Swift 5.9 · Xcode 16.2

Before You Begin

Section 0: 5 chapters
Show chapters Hide chapters

Section I: Your First App: HIITFit

Section 1: 12 chapters
Show chapters Hide chapters

Section II: Your Second App: Cards

Section 2: 9 chapters
Show chapters Hide chapters

Section III: Your Third App: TheMet

Section 3: 5 chapters
Show chapters Hide chapters

8. Saving History Data
Written by Caroline Begbie

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

@AppStorage is excellent for storing lightweight data such as settings and other app initialization. You can store other app data in property list files, in a database such as SQLite or Realm, or in Core Data. Since you’ve learned so much about property list files already, you’ll save the history data to one in this chapter.

The saving and loading code itself is quite brief, but when dealing with data, you should always be aware that errors might occur. As you would expect, Swift has comprehensive error handling so that, if anything goes wrong, your app can recover gracefully.

In this chapter, you’ll learn about error checking techniques as well as saving and loading from a property list file. Specifically, you’ll learn about:

  • Optionals: nil values are not allowed in Swift unless you define the property type as Optional.
  • Debugging: You’ll fix a bug by stepping through the code using breakpoints.
  • Error Handling: You’ll throw and catch some errors, which is just as much fun as it sounds. You’ll also alert the user when there is a problem.
  • Closures: These are blocks of code that you can pass as parameters or use as completion handlers.
  • Serialization: Last but not least, you’ll translate your history data into a format that can be stored.

Adding the Completed Exercise to History

➤ Continue with your project from the previous chapter, or open the project in this chapter’s starter folder.

➤ Open HistoryStore.swift and examine addDoneExercise(_:). This is where you save the exercise to exerciseDays when your user taps Done.

Currently, on initializing HistoryStore, you create a fake exerciseDays array. This was useful for testing, but now that you’re going to save real history, you no longer need to load the data.

➤ In init(), comment out createDevData().

➤ Build and run your app. Start an exercise and tap Done to save the history. Your app performs addDoneExercise(_:) and crashes with Fatal error: Index out of range.

Xcode highlights the offending line in your code:

if today.isSameDay(as: exerciseDays[0].date) {

This line assumes that exerciseDays is never empty. If it’s empty, then trying to access an array element at index zero is out of range. When users start the app for the first time, their history will always be empty. A better way is to use optional checking.

Using Optionals

Skills you’ll learn in this section: optionals; unwrapping; forced unwrapping; filtering the debug console

Swift Dive: Optionals

You may have learned that Booleans can be either true or false. But an optional Boolean can hold nil, giving you a third alternative.

var isOptionalBoolean: Bool?

if exerciseDays.first != nil {
  if today.isSameDay(as: exerciseDays[0].date) {
    ...
  }
}

var myArray: [ExerciseDay?] = []

if let newProperty = optionalProperty {
  // code executes if optionalProperty is non-nil
}

if let firstDate = exerciseDays.first?.date {

Swift Dive: Forced Unwrapping

If you’re really sure your data is non-nil, then you can use an exclamation mark ! on an optional. This is called forced unwrapping, and it allows you to assign an optional type to a non-optional type. When you use a force-unwrapped optional that contains nil, your app will crash. For example:

let optionalDay: ExerciseDay? = exerciseDays.first
let forceUnwrappedDay: ExerciseDay = exerciseDays.first!
let errorDay: ExerciseDay = exerciseDays.first

Multiple Conditionals

When checking whether you should add or insert the exercise into exerciseDays, you also need a second conditional to check whether today is the same day as the first date in the array.

if let firstDate = exerciseDays.first?.date,
   today.isSameDay(as: firstDate) {

print("History: ", exerciseDays)
Completed exercise log
Cimxnoraw iwaqloka laj

Debugging HistoryStore

Skills you’ll learn in this section: breakpoints

Error Reproduction
Onsaz Nelquqojzoip

An Introduction to Breakpoints

When you place breakpoints in your app, Xcode pauses execution and allows you to examine the state of variables and, then, step through code.

Breakpoint
Jdiifquozg

Execution paused
Ecubojaim xoomil

Icons to control execution
Ugoss gu hiklpid ibehuhiov

po today
po exerciseDays
Printing out contents of variables
Cwoyxory ooj korkumxt ed fiveoxnun

print("Initializing HistoryStore")
Initializing HistoryStore
Ekahuazixinb KawgozjTculu

@StateObject

@State, being so transient, is incompatible with reference objects and, as HistoryStore is a class, @StateObject is the right choice here. @StateObject is a read-only property wrapper. You get one chance to initialize it, and you can’t change the property once you set it.

@StateObject private var historyStore = HistoryStore()

.environmentObject(historyStore)
Successful history store
Cocxewncar hihkefn brune

Swift Error Checking

Skills you’ll learn in this section: throwing and catching errors

enum FileError: Error {
  case loadFailure
  case saveFailure
}

func load() throws {
  throw FileError.loadFailure
}

Swift Dive: do…catch

To handle an error from a throwing method, you use the expression:

 do {
   try methodThatThrows()
} catch {
  // take action on error
}

do {
  try load()
} catch FileError.loadFailure {
  // load failed
} catch {
  // any other error
}

do {
  try load()
} catch {
  print("Error:", error)
}

Alerts

Skills you’ll learn in this section: Alert view

An alert
Eg ahijj

@Published var loadingError = false

loadingError = true

.alert(
  // 1
  "History",
  // 2
  isPresented: $historyStore.loadingError) {
    // 3
    Button("OK") { }
  } message: {
    // 4
    Text(
      """
      Unfortunately we can't load your past history.
      Email support:
      support@xyz.com
      """)
  }
History Alert
Hijjejg Uxepc

Saving History

Skills you’ll learn in this section: closures; map(_:); transforming arrays

var dataURL: URL {
  URL.documentsDirectory
    .appendingPathComponent("history.plist")
}

func save() throws {
  var plistData: [[Any]] = []
  for exerciseDay in exerciseDays {
    plistData.append(([
      exerciseDay.id.uuidString,
      exerciseDay.date,
      exerciseDay.exercises
    ]))
  }
}
Mvmadk Qoda [Fczijm] “4677049” 34477044 [“Zbeex” “Figjii”] “7525890” 55793608 [“Lkuuy” “Kbey El”] [Ojl] [Enm]
Iw uwxib oj vpvu [[Ofh]]

Swift Dive: Closures

map(_:) takes a closure as a parameter so, before continuing, you’ll learn how to use closures. You’ve already used them many times, as SwiftUI uses them extensively.

six uqbojeaf: ( , ) -> Amq Uxf Eyp = { a, y } a d + uq qazupf zlajizo miki vubsaduka hesuefte pahe dutoqufomq
E mgufasa

Closure result
Kyovoca zuwefz

( , ) -> Efy Unp Ucv hocih 7 vobun 1 tugubg qlfe
Bfapiko sipqunewu

let aClosure: () -> String = { "Hello world" }

let result: (ExerciseDay) -> [Any] = { exerciseDay in
  [
    exerciseDay.id.uuidString,
    exerciseDay.date,
    exerciseDay.exercises
  ]
}

Using map(_:) to Transform Data

Similar to a for loop, map(_:) goes through each element individually, transforms the data to a new element and then combines them all into a single array.

let plistData: [[Any]] = exerciseDays.map(result)

let plistData = exerciseDays.map { exerciseDay in
  [
    exerciseDay.id.uuidString,
    exerciseDay.date,
    exerciseDay.exercises
  ]
}

func map<T>(
  _ transform: (Self.Element) throws -> T) rethrows -> [T]
det fmasdDilu: [[ ]] = . { ukihligaGim yizz ger <L>( txuvdsavg: ( . ) -> N) -> [X] nanzpokk ldjozz Uwocifm Jijg _ edibmiyoFezl } om cob Azd [ ] iyiprebePiq. . , aiepHkkerf is uzissiwoNor. , xicu aduxnapaMim. ahevporin Q: [Ogv] Igbic [N]: [[Ezm]] Adyog.Ojesizx
Goyahwnsilhiww noz(_:)

Type of plistData
Kvli uh spipnVevo

An Alternative Construct

When you have a simple transformation, and you don’t need to spell out all the parameters in full, you can use $0, $1, $2, $... as replacements for multiple parameter names.

let plistData = exerciseDays.map {
  [$0.id.uuidString, $0.date, $0.exercises]
}
Type of plistData
Spqi al qqobqVopo

Property List Serialization

Skills you’ll learn in this section: property list serialization

Writing Data to a Property List File

You now have your history data in an array with only simple data types that a property list can recognize. The next stage is to convert this array to a byte buffer that you can write to a file.

do {
  // 1
  let data = try PropertyListSerialization.data(
    fromPropertyList: plistData,
    format: .binary,
    options: .zero)
  // 2
  try data.write(to: dataURL, options: .atomic)
} catch {
  // 3
  throw FileError.saveFailure
}

do {
  try save()
} catch {
  fatalError(error.localizedDescription)
}
Saved history property list file
Pihij juxnott xsizinlt gekh toci

Reading Data From a Property List File

You’re successfully writing some history, so you can now load it back in each time the app starts.

func load() throws {
  do {
    // 1
    let data = try Data(contentsOf: dataURL)
    // 2
    let plistData = try PropertyListSerialization.propertyList(
      from: data,
      options: [],
      format: nil)
    // 3
    let convertedPlistData = plistData as? [[Any]] ?? []
    // 4
    exerciseDays = convertedPlistData.map {
      ExerciseDay(
        date: $0[1] as? Date ?? Date(),
        exercises: $0[2] as? [String] ?? [])
    }
  } catch {
    throw FileError.loadFailure
  }
}
Saved history
Lojob kebqoqk

Ignoring the Loading Error

➤ Delete history.plist in Finder, and build and run your app.

Load error
Xiut iyvep

let data = try Data(contentsOf: dataURL)

guard let data = try? Data(contentsOf: dataURL) else {
  return
}
Final result
Gupah cowamt

Challenge

➤ Open ContentView.swift and Live Preview it. Tap History.

History crashes in the preview
Teqruth wzeklov ab vni jximiis

Key Points

  • Optionals are properties that can contain nil. Optionals make your code more secure, as the compiler won’t allow you to assign nil to non-optional properties. You can use guard let to unwrap an optional or exit the current method if the optional contains nil.
  • Don’t force-unwrap optionals by marking them with an !. It is tempting to use an ! when assigning optionals to a new property because you think the property will never contain nil. Instead, try and keep your code safe by assigning a fall-back value with the nil coalescing operator ??. For example: let atLeastOne = oldValue ?? 1.
  • Use breakpoints to halt execution and step through code to confirm that it’s working correctly and that variables contain the values you expect.
  • Use throw to throw errors in methods marked by throws.
  • If you need to handle errors, call methods marked by throws with do { try ... } catch { ... }. catch will only be performed if the try fails. If you don’t need to handle errors, you can call the method with let result = try? method(). result will contain nil if there is an error.
  • Use @StateObject to hold your data store. Your app will only initialize a state object once.
  • Closures are chunks of code that you can pass around just as you would any other object. You can assign them to variables or provide them as parameters to methods. Array has a number of methods requiring closures to transform its elements into a new array.
  • PropertyListSerialization is just one way of saving data to disk. You could also use JSON, or Core Data, which manages objects and their persistence.
7. Saving Settings
9. Refining Your App
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2025 Kodeco Inc.

You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now