Apple App-Development-with-Swift-Certified-User Exam Dumps - Actual Questions Answers

This question belongs to View Building with SwiftUI , specifically the domain on creating a multi-view app with navigation stacks, links, and sheets .

To present a modal view in SwiftUI when a Boolean state changes, the correct modifier is .sheet . The matching sheet API for a Boolean binding is:

sheet(isPresented: $showInfo) {

// modal content

}

So the first blank must be .sheet , and the second blank must be (isPresented: .

The logic works like this:

@State stores the local Boolean that controls presentation.

Pressing the button calls showInfo.toggle(), changing the value from false to true.

When that Boolean becomes true, the .sheet(isPresented:) modifier presents the modal view.

When the modal is dismissed, SwiftUI updates the Boolean back as needed.

There is also a typing issue in the screenshot: the state variable appears as ShowInfo, while the button and binding use showInfo. Swift is case-sensitive, so those names must match. The corrected code should use the same identifier consistently, such as:

@State var showInfo = false

Therefore, the correct dropdown selections are:

sheet

(isPresented:

This question belongs to Swift Programming Language , specifically the objective on variable scope and shadowing .

The code first declares:

let even = 2

This creates a constant named even in the outer scope with the value 2.

Inside the for loop, the code declares another constant with the same name:

let even = num * 2

This inner even exists only inside the loop body. It shadows the outer even, which means that within the loop, the name even refers to the loop’s local constant, not the original one. However, that inner constant goes out of scope at the end of each loop iteration.

After the loop finishes, the inner even no longer exists. So when the final line runs:

print(even)

Swift uses the original outer constant, which is still 2.

So the output is:

2

This question tests two important Swift concepts:

Scope : where a variable or constant can be accessed

Shadowing : when a local declaration temporarily hides another declaration with the same name

Therefore, the correct answer is 2 .

This question belongs to View Building with SwiftUI , particularly the domain involving positioning and/or laying out a single SwiftUI view with standard views and modifiers . To place text on top of a shape such as a Capsule, SwiftUI uses the overlay modifier. Apple documents overlay as a view modifier that layers one view in front of another, which is exactly what is needed here: the text should appear on top of the blue capsule rather than beside or below it. The second blank must therefore be Text , because SwiftUI uses a Text view to display string content like " Great! " .

The completed code is:

struct ContentView: View {

var body: some View {

Capsule()

.fill(.blue)

.frame(width: 200.0, height: 100.0)

.overlay(

Text( " Great! " )

.font(.largeTitle)

)

}

}

This works because Capsule() creates the shape, .fill(.blue) gives it the blue color, .frame(width:height:) sets its size, and .overlay(...) places the Text( " Great! " ) directly above that shape. This is a standard SwiftUI composition pattern: build a base view, then apply modifiers to style it and layer additional content. In App Development with Swift objectives, this aligns with understanding standard views, modifiers, and layout techniques in SwiftUI.