Custom ViewModifiers in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What is the visual result of this Custom ViewModifier?

Consider this SwiftUI code defining a custom modifier and applying it to a Text view. What will the text look like?

iOS Swift

struct Highlight: ViewModifier {
  func body(content: Content) -> some View {
    content
      .padding(10)
      .background(Color.yellow)
      .cornerRadius(8)
  }
}

Text("Hello SwiftUI")
  .modifier(Highlight())

A Text with red background and no padding

B Text with padding but transparent background

C Text with yellow background but no corner radius

D Text with yellow background, padding around text, and rounded corners

💡 Hint

Look at the order of modifiers inside the body function.

The Highlight modifier adds padding, then a yellow background, then rounds corners. So the text is padded inside a yellow rounded rectangle.

❓ lifecycle

intermediate

When is the body of a Custom ViewModifier called?

In SwiftUI, when does the body(content:) method of a ViewModifier get executed?

A Only when the modifier is explicitly reapplied in code

B Only once when the view is first created

C Every time the view's state changes and the view needs to update

D Never, it is only a placeholder method

💡 Hint

Think about how SwiftUI updates views reactively.

The body(content:) method is called whenever SwiftUI recomputes the view's body, which happens on state changes or environment updates.

📝 Syntax

advanced

Which option correctly defines a Custom ViewModifier with a parameter?

Choose the correct Swift code for a ViewModifier that takes a Color parameter to set the background color.

A

struct ColoredBackground: ViewModifier {
  var color: Color
  func body(content: Content) -> some View {
    content.background(color)
  }
}

B

struct ColoredBackground: ViewModifier {
  func body(content: Content, color: Color) -> some View {
    content.background(color)
  }
}

C

struct ColoredBackground: ViewModifier {
  var color: Color
  func body(content: Content) -> View {
    content.background(color)
  }
}

D

struct ColoredBackground: ViewModifier {
  var color: Color
  func body(content: Content) -> some View {
    content.background(Color)
  }
}

💡 Hint

Remember the body method signature and how to use parameters in structs.

Option A correctly declares a stored property color and uses it inside body. The method returns some View. Option A wrongly adds a parameter to body. Option A returns View instead of some View. Option A uses Color type instead of the variable color.

🔧 Debug

advanced

Why does this Custom ViewModifier cause a runtime crash?

Given this code, why does the app crash when applying the modifier?

iOS Swift

struct CrashModifier: ViewModifier {
  func body(content: Content) -> some View {
    content
      .background(nil)
  }
}

Text("Crash")
  .modifier(CrashModifier())

A The modifier is missing a required initializer

B Passing nil to background causes a runtime crash because background expects a View, not nil

C Text cannot have a background modifier

D The modifier must return a Text view explicitly

💡 Hint

Check the parameter type for the background modifier.

The background modifier expects a View as parameter. Passing nil is invalid and causes a crash.

🧠 Conceptual

expert

What is the benefit of using a Custom ViewModifier in SwiftUI?

Which of these best explains why you would create a custom ViewModifier?

A To reuse a set of view styling and behavior across multiple views easily

B To replace the need for creating new Views entirely

C To improve app performance by compiling views faster

D To allow views to modify their own state directly

💡 Hint

Think about code reuse and consistency in UI design.

Custom ViewModifiers let you package styling and behavior to apply consistently to many views, improving code reuse and clarity.