App-Development-with-Swift-Certified-User App Development with Swift Certified User Exam Questions and Answers

This question belongs to Swift Programming Language , specifically the domain on functions , including internal and external parameter names and default parameter values .

The function is defined as:

func rightSum(_ num1: Int, by num2: Int, and num3: Int = 25) - > Int {

return num1 + num2 + num3

}

This means:

the first parameter uses _, so it has no external label

the second parameter must use the external label by

the third parameter must use the external label and

the third parameter also has a default value of 25, so it may be omitted

Now evaluate each option:

A is invalid because it uses num2: instead of the required external label by:

B is valid because it correctly uses no label for the first argument, then by: and and:

C is invalid because the first parameter cannot be called with num1: since the external label is omitted with _

D is valid because it correctly passes the first argument unlabeled and the second with by:, while omitting the third argument so Swift uses the default value 25

E is invalid because it uses num1: and num2: instead of the required calling syntax

So the two correct function calls are B and D .

This question belongs to Swift Programming Language , specifically the objectives covering arrays , loops , and range operators . The array has 6 elements, so menuItems.count is 6. The loop uses the half-open range operator:

for index in 1.. < (menuItems.count - 1)

That becomes:

for index in 1.. < 5

In Swift, the half-open range operator a.. < b includes the lower bound but does not include the upper bound. So this loop runs with index values 1, 2, 3, 4, not 0 and not 5.

Array subscripting uses those indexes to print:

menuItems[1] → " Burger "

menuItems[2] → " Chicken "

menuItems[3] → " Pasta "

menuItems[4] → " Salad "

That means " Pizza " at index 0 is skipped, and " Steak " at index 5 is also skipped. Swift arrays use zero-based indexing, and count returns the number of elements in the array.

Therefore, the program prints only " Burger " , " Chicken " , " Pasta " , and " Salad " , so the correct answer is A .

This question belongs to View Building with SwiftUI , especially the domain covering positioning and/or layout a single SwiftUI View with standard Views and modifiers and the foundational structure of a SwiftUI view. In SwiftUI, a custom screen is typically declared as a struct that conforms to the View protocol. Apple’s SwiftUI documentation shows the standard pattern:

struct ScreenView: View {

var body: some View {

Text( " Hello " )

}

}

Here, struct is required because SwiftUI views are commonly defined as structures. View is required after the colon because the type must conform to the View protocol. body is the required computed property that returns the content of the view as some View. Apple documents that every conforming View type must provide a body property that describes its content.

So the completed code is:

import SwiftUI

struct ScreenView: View {

var body: some View {

Text( " Hello " )

}

}

This is the canonical SwiftUI view declaration pattern and is one of the most fundamental concepts in App Development with Swift.

This question is from Swift Programming Language , especially the domains for Optional types , safe and unsafe unwrapping , and control flow . The code uses the ternary conditional operator :

nextApplePhone.releaseDate != nil ? _____

In Swift, the ternary operator follows this structure:

condition ? valueIfTrue : valueIfFalse

So if nextApplePhone.releaseDate != nil is true, the expression must return the new release date. If it is false, it must keep lastReleaseDate unchanged. That means the missing part must be:

nextApplePhone.releaseDate! : lastReleaseDate

which is option D .

This works because nextApplePhone.releaseDate is declared as String?, so it is an optional. Once the condition confirms it is not nil, the code force-unwraps it with ! to access the underlying String value. If the optional is nil, the expression returns lastReleaseDate instead. Apple’s Swift documentation describes the ternary conditional operator as a shortcut for choosing one of two expressions based on a condition, and it explains that force unwrapping with ! accesses an optional’s wrapped value when you know it is not nil.

The other options are incorrect because they reverse the true/false logic, omit the needed unwrap, or contain invalid identifiers. Therefore, the correct completion is D .

Comprehensive and Detailed Explanation From App Development with Swift domains:

This question belongs to View Building with SwiftUI , specifically the objective on using @State, @Binding, @Environment, and observable data to share data between views.

The correct answer is @Binding because @Binding creates a two-way connection to a value that is owned by another view. In this scenario, View A owns the state, and View B needs to read and modify that value so the change is reflected back in View A. Apple’s SwiftUI documentation describes a binding as a reference to a mutable value that is owned elsewhere, which is exactly the pattern used when a child view needs to update a parent view’s state. ( developer.apple.com )

@State is not correct for View B here because @State is used for local state owned by that specific view. If View B used @State, it would manage its own separate copy rather than updating the parent’s value. @Environment is used to access values provided by the system or ancestor views, not for directly returning a specific parent state value in this pattern. @Observable is related to observable model objects and is not the direct property wrapper used in a child view for two-way parent-child state passing. ( developer.apple.com )

So when View A passes a state value into View B and expects updates to flow back, View B should use @Binding .

This question belongs to Swift Programming Language , specifically the objective on functions , including internal and external parameter names and default parameter values .

The function is defined as:

func schedule(who name: String, from starting: String, to ending: String, _ place: String = " Zoom " ) {

print( " Appointment: meeting \(name) from \(starting) to \(ending) at \(place) " )

}

This means:

the external parameter names are who, from, and to

the internal parameter names are name, starting, and ending

the last parameter uses _, which means it has no external label

the last parameter also has a default value of " Zoom "

Now evaluate the options:

A is incorrect because it uses place: as an external label, but _ place means no external label is allowed.

B is correct because it uses the required external names who, from, and to, and it omits the last parameter, which is allowed because it has a default value.

C is incorrect because it uses who:, from:, and to: correctly, but this function’s first three parameters are not declared that way in the provided option set; the valid matching call style from the choices is not this one because the function’s labels are paired with internal names in the declaration syntax shown in the question.

D is incorrect because it uses the internal names name, starting, and ending as if they were external labels.

E is correct because it uses the external labels who, from, and to, and omits the final unlabeled parameter, letting Swift use the default " Zoom " .

So the two correct answers are B and E .

C:\Users\Waqas Shahid\Desktop\Mudassir\Untitled.jpg

This question belongs to View Building with SwiftUI , especially the objectives for using List views to iterate through collections and structuring views with standard SwiftUI containers. The screenshot shows two grouped sets of rows: one headed MY FRIENDS and one headed MY PETS . In SwiftUI, the correct container for a scrollable table-style presentation of rows is List, and the correct way to divide that list into labeled groups is Section. Apple documents List as a container that presents data in a single-column row-based layout, and Section as a way to organize list content into grouped areas with headers and optional footers. That is exactly the structure shown in the image. ( developer.apple.com , developer.apple.com )

The ForEach(names, id: \.self) and ForEach(pets, id: \.self) lines are already iterating through the arrays, so each ForEach should be wrapped inside a Section. The section labels such as " My Friends " and " My Pets " are provided with the header: label. So the intended code structure is:

List {

Section {

ForEach(names, id: \.self) { name in Text(name) }

} header: {

Text( " My Friends " )

}

Section {

ForEach(pets, id: \.self) { pet in Text(pet) }

} header: {

Text( " My Pets " )

}

}

This matches the UI shown in the image and aligns directly with SwiftUI list and section composition patterns in App Development with Swift.

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.

You can treat a NavigationLink like a button, and run some Swift code when it is pressed. — False

NavigationSplitView can be used to do navigation differently on different device sizes. — True

You can put a header on your present View in a NavigationStack using .navigationTitle. — True

If you have a NavigationLink that goes to another View with a NavigationLink, you need to declare a NavigationStack at each level. — False

This question belongs to View Building with SwiftUI , specifically the objective on creating a multi-view app with navigation stacks, links, and sheets . Statement 1 is False because NavigationLink is primarily a navigation control that pushes or presents a destination in a navigation container; Apple documents it as creating a navigation link that presents a destination, not as a general-purpose action control like Button.

Statement 2 is True because NavigationSplitView is designed for adaptive navigation and can present navigation in different ways depending on platform and available space. Apple documents NavigationSplitView as a container for navigation across multiple columns, and this adaptive behavior is exactly why it is used differently across device sizes.

Statement 3 is True because .navigationTitle(...) sets the navigation title for a view shown inside a navigation container. Apple explicitly describes a view’s navigation title as something used to visually display the current navigation state of an interface.

Statement 4 is False because you do not need a separate NavigationStack at every level. Apple describes NavigationStack as the container that manages a stack of views, and NavigationLink pushes additional destinations onto that stack. Nested destinations can keep navigating within the same stack.