MVVM pattern in iOS Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does MVVM stand for in mobile app development?

MVVM stands for Model-View-ViewModel. It is a design pattern that helps separate the user interface (View) from the business logic and data (Model) using a ViewModel as a bridge.

beginner

What is the role of the ViewModel in the MVVM pattern?

The ViewModel holds the app's data and business logic. It prepares data from the Model to be displayed by the View and handles user actions from the View, keeping UI and data separate.

intermediate

How does the View communicate with the ViewModel in MVVM?

The View observes the ViewModel for changes, often using data binding or reactive programming. When the ViewModel updates data, the View automatically refreshes to show the latest information.

intermediate

Why is MVVM beneficial for iOS app development?

MVVM helps keep code organized and easier to test by separating UI from logic. It makes apps more maintainable and allows developers and designers to work independently.

beginner

In MVVM, what is the Model responsible for?

The Model represents the app's data and business rules. It manages data storage, retrieval, and any data-related logic, without knowing about the UI or how data is shown.

In MVVM, which component directly updates the user interface?

A View

B Model

C ViewModel

D Controller

The View is responsible for displaying the user interface and updates when the ViewModel changes.

Which MVVM part holds the app's data and business logic?

A Router

B Model

C View

D ViewModel

The ViewModel holds data and business logic, acting as a bridge between Model and View.

What is a key advantage of using MVVM in iOS apps?

A Separates UI from business logic for better maintainability

B Makes code less testable

C Combines UI and logic in one place

D Removes the need for Models

MVVM separates UI and logic, making code easier to maintain and test.

How does the View get notified about data changes in MVVM?

A Directly from the Model

B It does not get notified

C Through the ViewModel using data binding or observation

D By polling the database

The View observes the ViewModel, which notifies it about data changes.

Which component in MVVM should NOT know about the user interface?

A View

B Model

C ViewModel

D ViewController

The Model handles data and business rules without any knowledge of the UI.

Explain the responsibilities of each MVVM component: Model, View, and ViewModel.

Think about who handles data, who shows it, and who acts as the middleman.

Describe how MVVM improves app maintainability and testing in iOS development.

Consider how separating concerns helps developers and testers.

Practice

1. What is the main role of the ViewModel in the MVVM pattern?

easy

A. To display the user interface elements

B. To hold data and business logic separate from the UI

C. To store raw data from the database only

D. To handle user input directly without any data processing

Solution

1. Step 1: Understand MVVM roles

   The ViewModel acts as a middleman between the Model and the View, holding data and logic.

2. Step 2: Identify ViewModel responsibility

   It keeps data and business logic separate from UI, so the View only handles display.

3. Final Answer:

   To hold data and business logic separate from the UI -> Option B

4. Quick Check:

   ViewModel = data + logic [OK]

Hint: ViewModel holds data and logic, not UI [OK]

Common Mistakes:

• Confusing ViewModel with View
• Thinking ViewModel handles UI rendering
• Assuming ViewModel stores raw database data only

2. Which of the following is the correct way to declare a ViewModel property in Swift for binding to a SwiftUI View?

easy

A. @State var viewModel = MyViewModel()

B. @EnvironmentObject var viewModel = MyViewModel()

C. var viewModel = MyViewModel()

D. @ObservedObject var viewModel = MyViewModel()

Solution

1. Step 1: Identify property wrapper for ViewModel

   In SwiftUI, @ObservedObject is used to observe ViewModel changes.

2. Step 2: Check other options

   @State is for local state, @EnvironmentObject requires external injection, plain var lacks observation.

3. Final Answer:

   @ObservedObject var viewModel = MyViewModel() -> Option D

4. Quick Check:

   ViewModel binding uses @ObservedObject [OK]

Hint: Use @ObservedObject for ViewModel in SwiftUI [OK]

Common Mistakes:

• Using @State for ViewModel instead of @ObservedObject
• Forgetting to mark ViewModel as ObservableObject
• Trying to instantiate ViewModel inside @EnvironmentObject

3. Given the following SwiftUI code snippet, what will be displayed when the button is tapped once?

class CounterViewModel: ObservableObject {
  @Published var count = 0
  func increment() { count += 1 }
}

struct ContentView: View {
  @ObservedObject var viewModel = CounterViewModel()
  var body: some View {
    VStack {
      Text("Count: \(viewModel.count)")
      Button("Tap me") {
        viewModel.increment()
      }
    }
  }
}

medium

A. Count: 0

B. Count: Tap me

C. Count: 1

D. Count: nil

Solution

1. Step 1: Understand initial state

   The count starts at 0 as declared in ViewModel.

2. Step 2: Analyze button tap effect

   When tapped, increment() adds 1 to count, updating the published property.

3. Final Answer:

   Count: 1 -> Option C

4. Quick Check:

   Button tap increments count to 1 [OK]

Hint: Button tap calls increment, count updates [OK]

Common Mistakes:

• Assuming count stays 0 after tap
• Confusing button label with count value
• Expecting nil instead of initial 0

4. Identify the error in this ViewModel code snippet and how to fix it:

class UserViewModel {
  @Published var username: String = ""
  func updateName(newName: String) {
    username = newName
  }
}

medium

A. Missing ObservableObject conformance; add ': ObservableObject' to class

B. Cannot use @Published on String; change to Int

C. updateName should return String; add return type

D. username should be private; add 'private' keyword

Solution

1. Step 1: Check @Published usage

   @Published requires the class to conform to ObservableObject to work properly.

2. Step 2: Fix class declaration

   Add ': ObservableObject' after class name to enable property observation.

3. Final Answer:

   Missing ObservableObject conformance; add ': ObservableObject' to class -> Option A

4. Quick Check:

   @Published needs ObservableObject [OK]

Hint: Add ObservableObject to use @Published [OK]

Common Mistakes:

• Forgetting ObservableObject conformance
• Thinking @Published works without ObservableObject
• Changing data type unnecessarily

5. You want to create a SwiftUI app using MVVM where the ViewModel fetches a list of users asynchronously and updates the View. Which approach correctly handles this scenario?

hard

A. Make ViewModel conform to ObservableObject, use @Published for users array, fetch data asynchronously and update @Published property

B. Fetch data directly in the View and update a local @State variable

C. Store users array in the Model only and let View read it directly

D. Use a global variable for users and update it from anywhere

Solution

1. Step 1: Understand MVVM async data flow

   ViewModel should handle data fetching and update @Published properties to notify View.

2. Step 2: Evaluate options

   Make ViewModel conform to ObservableObject, use @Published for users array, fetch data asynchronously and update @Published property correctly uses ObservableObject and @Published with async fetch; others break MVVM or cause bad design.

3. Final Answer:

   Make ViewModel conform to ObservableObject, use @Published for users array, fetch data asynchronously and update @Published property -> Option A

4. Quick Check:

   Async fetch in ViewModel updates @Published [OK]

Hint: Async fetch in ViewModel updates @Published property [OK]

Common Mistakes:

• Fetching data in View instead of ViewModel
• Using global variables for state
• Letting View read Model data directly