Why SwiftUI is the modern UI framework in iOS Swift - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does SwiftUI use a declarative syntax?

SwiftUI uses a declarative syntax for building user interfaces. What is the main advantage of this approach compared to the older UIKit imperative style?

A It requires developers to manually update every UI element when data changes.

B It lets developers describe what the UI should look like, and SwiftUI handles the updates automatically.

C It forces developers to write more code to manage UI states explicitly.

D It only works for static interfaces without user interaction.

💡 Hint

Think about how describing the UI declaratively can reduce manual work.

Declarative syntax means you describe the UI's desired state, and the framework updates the UI automatically when data changes. This reduces bugs and simplifies code.

❓ ui_behavior

intermediate

What happens when a @State variable changes in SwiftUI?

In SwiftUI, if you mark a variable with @State and then change its value, what is the expected behavior?

A Nothing happens until you manually call a refresh function.

B The variable resets to its initial value immediately.

C The app crashes because @State variables cannot change.

D The view automatically refreshes to reflect the new state value.

💡 Hint

Think about how SwiftUI keeps the UI in sync with data.

When a @State variable changes, SwiftUI detects the change and re-renders the view to show the updated UI automatically.

❓ lifecycle

advanced

How does SwiftUI handle view lifecycle differently from UIKit?

Which statement best describes how SwiftUI manages the lifecycle of views compared to UIKit?

A SwiftUI views are value types recreated on state changes, while UIKit views are reference types managed manually.

B SwiftUI views stay in memory permanently, unlike UIKit views which are recreated often.

C SwiftUI requires manual calls to lifecycle methods like viewDidLoad, unlike UIKit.

D SwiftUI does not support lifecycle events at all.

💡 Hint

Consider how SwiftUI uses structs for views.

SwiftUI views are structs (value types) that are recreated when state changes, making UI updates efficient. UIKit views are classes (reference types) that require manual lifecycle management.

❓ navigation

advanced

How does navigation in SwiftUI differ from UIKit?

In SwiftUI, how is navigation between screens typically handled compared to UIKit's UINavigationController?

A SwiftUI does not support navigation between screens.

B SwiftUI requires manually pushing and popping view controllers like UIKit.

C SwiftUI uses NavigationStack and bindings to control navigation declaratively.

D SwiftUI uses storyboard segues for navigation.

💡 Hint

Think about how SwiftUI prefers declarative state-driven UI.

SwiftUI uses NavigationStack and state bindings to declaratively control navigation, unlike UIKit's imperative push/pop methods.

📝 Syntax

expert

What is the output of this SwiftUI code snippet?

Consider this SwiftUI code: struct ContentView: View { @State private var count = 0 var body: some View { VStack { Text("Count: \(count)") Button("Increment") { count += 1 } } } } What happens when the button is tapped three times?

iOS Swift

struct ContentView: View {
  @State private var count = 0
  var body: some View {
    VStack {
      Text("Count: \(count)")
      Button("Increment") {
        count += 1
      }
    }
  }
}

A The text updates to show "Count: 3" after three taps.

B The text stays at "Count: 0" regardless of taps.

C The app crashes because @State cannot be modified inside Button.

D The button does not respond to taps.

💡 Hint

Remember how @State variables trigger UI updates.

Each tap increments the @State variable count, causing SwiftUI to re-render the Text view with the updated count value.