HOME BOOKS QUICK GUIDES VIDEO COURSES APPLICATIONS
NEWSLETTER CONTACT
SwiftUI for Masterminds
How to take advantage of SwiftUI to create insanely great apps for iPhones, iPads, and Macs
4th Edition
October 2023
ISBN: 978-1-7779782-3-5
Buy Now
Examples and Projects
Although writing down the examples can help you remember what you are learning, sometimes it can be time consuming. To speed up the process, you can download the codes in TXT files, all Xcode projects, or open the codes you want to see from the links below.
Download TXT Files
402.0 KBytes
Download Projects
1.15 GBytes
CHAPTER 1 - APP DEVELOPMENT
There are no Examples in this Chapter
CHAPTER 2 - INTRODUCTION TO SWIFT
Listing 2-1: Playground template
Listing 2-2: Declaring variables
Listing 2-3: Initializing variables
Listing 2-4: Declaring and initializing variables in the same statement
Listing 2-5: Assigning a new value to a variable
Listing 2-6: Declaring variables of different data types
Listing 2-7: Declaring variables without specifying the data type
Listing 2-8: Assigning variables to variables
Listing 2-9: Assigning the result of an operation to a variable
Listing 2-10: Performing operations in variables of different type
Listing 2-11: Inferring the data type from an operation
Listing 2-12: Calculating the remainder
Listing 2-13: Adding numbers to variables
Listing 2-14: Performing operations on the variable’s current value
Listing 2-15: Modifying the value of a variable using incremental operators
Listing 2-16: Declaring and initializing a constant
Listing 2-17: Declaring and initializing a Character variable
Listing 2-18: Declaring and initializing a String variable
Listing 2-19: Concatenating strings
Listing 2-20: Concatenating strings with the + and += operators
Listing 2-21: Including variables in strings
Listing 2-22: Performing operations within strings
Listing 2-23: Including special characters in a string
Listing 2-24: Generating multiple lines of text
Listing 2-25: Declaring a Boolean variable
Listing 2-26: Declaring an optional variable of type Int
Listing 2-27: Assigning new values to optional variables
Listing 2-28: Using nil to empty an optional variable
Listing 2-29: Unwrapping an optional variable
Listing 2-30: Assigning an optional to another optional
Listing 2-31: Declaring Implicitly Unwrapped Optionals
Listing 2-32: Declaring a tuple with two values
Listing 2-33: Declaring a tuple with values of different type
Listing 2-34: Reading the values of a tuple
Listing 2-35: Modifying the value of a tuple
Listing 2-36: Declaring names for the values of a tuple
Listing 2-37: Creating multiple variables from the values of a tuple
Listing 2-38: Ignoring some of the values of a tuple
Listing 2-39: Comparing two values with if
Listing 2-40: Comparing two values with the <= operator
Listing 2-41: Conditions with Boolean values
Listing 2-42: Using logical operators
Listing 2-43: Using logical operators to check multiple conditions
Listing 2-44: Checking whether an optional contains a value or not
Listing 2-45: Using Optional Binding to unwrap an optional variable
Listing 2-46: Using the same name to unwrap a value
Listing 2-47: Unwrapping an optional value of the same name
Listing 2-48: Checking multiple conditions with Optional Binding
Listing 2-49: Using if else to respond to both states of the condition
Listing 2-50: Concatenating if else instructions
Listing 2-51: Implementing if else as an expression
Listing 2-52: Implementing a ternary operator
Listing 2-53: Unwrapping an optional with a ternary operator
Listing 2-54: Unwrapping an optional with the nil-coalescing operator
Listing 2-55: Checking conditions with switch
Listing 2-56: Checking multiple conditions per case
Listing 2-57: Matching a tuple in a switch statement
Listing 2-58: Matching only the second value of a tuple
Listing 2-59: Capturing values with constants
Listing 2-60: Comparing values with where
Listing 2-61: Implementing the switch statement as an expression
Listing 2-62: Using while to create a loop
Listing 2-63: Using repeat while to create a loop
Listing 2-64: Using for in to iterate over the characters of a string
Listing 2-65: Iterating over a string without reading the characters
Listing 2-66: Adding a condition to a loop
Listing 2-67: Jumping to the next cycle of the loop
Listing 2-68: Interrupting the loop
Listing 2-69: Ignoring values in a switch statement
Listing 2-70: Interrupting a loop with guard
CHAPTER 3 - SWIFT PARADIGM
Listing 3-1: Declaring and calling functions
Listing 3-2: Calling functions from a loop
Listing 3-3: Sending values to a function
Listing 3-4: Sending multiple values to a function
Listing 3-5: Sending different values to a function
Listing 3-6: Returning a value from a function
Listing 3-7: Returning a tuple
Listing 3-8: Interrupting the execution of a function with guard
Listing 3-9: Removing the return keyword
Listing 3-10: Modifying external variables from a function
Listing 3-11: Declaring argument labels
Listing 3-12: Removing argument labels
Listing 3-13: Declaring default values for parameters
Listing 3-14: Declaring different functions with the same name
Listing 3-15: Defining generic functions
Listing 3-16: Printing values on the console with print()
Listing 3-17: Creating collections of values
Listing 3-18: Using variables and constants of different scopes
Listing 3-19: Assigning closures to variables
Listing 3-20: Initializing a variable with the value returned by a closure
Listing 3-21: Simplifying a closure
Listing 3-22: Sending a closure to a function
Listing 3-23: Assigning the closure to the function's argument
Listing 3-24: Using Trailing Closures
Listing 3-25: Inferring the closure's data types
Listing 3-26: Declaring escaping closures
Listing 3-27: Defining a structure
Listing 3-28: Declaring a variable of type Item
Listing 3-29: Assigning new values to the properties of a structure
Listing 3-30: Structures inside structures
Listing 3-31: Accessing optional properties
Listing 3-32: Creating key paths
Listing 3-33: Using read and write key paths
Listing 3-34: Defining methods
Listing 3-35: Assigning new values to properties from the methods in the structure
Listing 3-36: Initializing properties
Listing 3-37: Using memberwise initializers to provide the initial values of a structure
Listing 3-38: Initializing properties from the init() method
Listing 3-39: Declaring the parameters to initialize the structure
Listing 3-40: Declaring multiple init() methods
Listing 3-41: Declaring computed properties
Listing 3-42: Defining read-only properties
Listing 3-43: Adding the set() method to set a new value
Listing 3-44: Using a different name for the parameter of the set() method
Listing 3-45: Adding observers to a store property
Listing 3-46: Defining type properties
Listing 3-47: Defining type methods
Listing 3-48: Defining generic structures
Listing 3-49: Using generic structures
Listing 3-50: Initializing variables with standard initializers
Listing 3-51: Casting a variable
Listing 3-52: Extracting numbers from strings
Listing 3-53: Checking the maximum possible value for the Int8 type
Listing 3-54: Rounding floating-point values
Listing 3-55: Modifying the value of a Bool variable
Listing 3-56: Using for in to iterate over a range
Listing 3-57: Inverting a range
Listing 3-58: Using range operators in a switch statement
Listing 3-59: Calculating random numbers
Listing 3-60: Converting a number into a string
Listing 3-61: Processing the characters of a string
Listing 3-62: Calculating a specific index
Listing 3-63: Getting the next index
Listing 3-64: Inserting a character in a string
Listing 3-65: Removing a character
Listing 3-66: Getting a range of characters
Listing 3-67: Working with ranges of characters
Listing 3-68: Implementing String methods
Listing 3-69: Declaring arrays
Listing 3-70: Declaring arrays with type inference
Listing 3-71: Reading the array’s elements
Listing 3-72: Assigning a new value to an element
Listing 3-73: Adding new elements to an array
Listing 3-74: Concatenating two arrays
Listing 3-75: Creating multidimensional arrays
Listing 3-76: Reading values from a multidimensional array
Listing 3-77: Removing the elements of an array
Listing 3-78: Reading an array with a for in loop
Listing 3-79: Reading indexes and values of an array
Listing 3-80: Checking whether an array contains a value in a specific index
Listing 3-81: Adding and removing elements
Listing 3-82: Removing all the elements that meet a condition
Listing 3-83: Finding if an element meets a condition
Listing 3-84: Selecting a random value from an array
Listing 3-85: Changing the order of the elements of an array
Listing 3-86: Reading a range of elements
Listing 3-87: Casting arrays of type ArraySlice
Listing 3-88: Removing and replacing elements
Listing 3-89: Initializing an array with elements of the same value
Listing 3-90: Filtering the values of an array
Listing 3-91: Mapping an array
Listing 3-92: Converting the elements of an array into strings
Listing 3-93: Using a structure initializer with the map() method
Listing 3-94: Reducing an array
Listing 3-95: Reversing the elements of an array
Listing 3-96: Sorting the elements of an array
Listing 3-97: Sorting the elements of an array in a custom order
Listing 3-98: Sorting an array of integers
Listing 3-99: Sorting strings according to the number of characters
Listing 3-100: Getting the largest element
Listing 3-101: Getting the first value of an array
Listing 3-102: Getting the index of a specific value
Listing 3-103: Getting the index of a value that meets a condition
Listing 3-104: Creating an empty set of integers
Listing 3-105: Creating a set of integers
Listing 3-106: Using contains() to find an element in a set
Listing 3-107: Inserting a new element in a set
Listing 3-108: Removing an element from a set
Listing 3-109: Sorting the elements of a set
Listing 3-110: Combining sets
Listing 3-111: Comparing sets
Listing 3-112: Declaring a dictionary with initial values
Listing 3-113: Declaring a dictionary with type inference
Listing 3-114: Assigning a new value to an element of a dictionary
Listing 3-115: Adding a new element to a dictionary
Listing 3-116: Reading an element that does not exist
Listing 3-117: Reading the value of an element in a dictionary
Listing 3-118: Removing an element from a dictionary
Listing 3-119: Using for in to iterate over a dictionary
Listing 3-120: Combining dictionaries with arrays
Listing 3-121: Reading arrays inside dictionaries
Listing 3-122: Grouping values by a key
Listing 3-123: Adding and removing elements from a dictionary
Listing 3-124: Sorting the values of a dictionary
Listing 3-125: Iterating over the dictionary’s keys
Listing 3-126: Reading the keys of a dictionary
Listing 3-127: Defining an enumeration type
Listing 3-128: Declaring the enumeration values in one statement
Listing 3-129: Initializing an instance of an enumeration
Listing 3-130: Assigning a new value to a variable of type Number
Listing 3-131: Using switch with an enumeration type
Listing 3-132: Assigning raw values to enumeration values
Listing 3-133: Reading raw values
Listing 3-134: Creating an enumeration from a raw value
Listing 3-135: Adding methods to an enumeration
Listing 3-136: Associating values
Listing 3-137: Reading associated values from an if statement
Listing 3-138: Defining a class
Listing 3-139: Creating an object from a class
Listing 3-140: Modifying properties from the object’s methods
Listing 3-141: Declaring a type method for a class
Listing 3-142: Referring to the object with self
Listing 3-143: Referring to the data type with self
Listing 3-144: Referencing one object from another
Listing 3-145: Assigning weak references
Listing 3-146: Defining a basic class
Listing 3-147: Inheriting properties and methods from another class
Listing 3-148: Creating objects from a subclass
Listing 3-149: Overriding an inherited method
Listing 3-150: Calling a method on the superclass
Listing 3-151: Creating an array of objects from different subclasses
Listing 3-152: Identifying the object’s data type
Listing 3-153: Casting an object
Listing 3-154: Casting an object with the as? operator
Listing 3-155: Casting an object on the fly
Listing 3-156: Working with objects of AnyObject type
Listing 3-157: Declaring a Designated Initializer
Listing 3-158: Declaring a Convenience Initializer
Listing 3-159: Inheriting the Designated Initializer
Listing 3-160: Declaring a Designated Initializer for the subclass
Listing 3-161: Declaring a deinitializer
Listing 3-162: Defining lazy properties
Listing 3-163: Declaring private properties
Listing 3-164: Declaring a public getter and private setter
Listing 3-165: Defining a singleton
Listing 3-166: Defining protocols
Listing 3-167: Defining multiple structures that conform to the same protocol
Listing 3-168: Using protocols as data types
Listing 3-169: Accessing the instance's own properties
Listing 3-170: Returning values of a protocol type
Listing 3-171: Defining generic protocols
Listing 3-172: Conforming to the Equatable protocol
Listing 3-173: Letting the compiler create the protocol methods for us
Listing 3-174: Adding a type constraint to a generic function
Listing 3-175: Using the Numeric protocol to set a type constraint
Listing 3-176: Conforming to the Comparable protocol
Listing 3-177: Conforming to the Hashable protocol
Listing 3-178: Defining our own hash value
Listing 3-179: Conforming to the CaseIterable protocol
Listing 3-180: Extending a protocol
Listing 3-181: Extending data types
Listing 3-182: Extending custom data types
Listing 3-183: Defining a conditional extension
Listing 3-184: Customizing string interpolation
Listing 3-185: Delegating tasks
Listing 3-186: Delegating with protocols
Listing 3-187: Using different delegates
Listing 3-188: Getting an error inside a method
Listing 3-189: Throwing errors
Listing 3-190: Handling errors
Listing 3-191: Getting information about the error
Listing 3-192: Catching errors with try?
Listing 3-193: Ignoring the errors
Listing 3-194: Returning an error with a Result enumeration
Listing 3-195: Processing an error with the get() method
Listing 3-196: Defining a property wrapper
Listing 3-197: Using a property wrapper
Listing 3-198: Implementing Freestanding macros
CHAPTER 4 - INTRODUCTION TO FRAMEWORKS
Listing 4-1: Applying math functions
Listing 4-2: Creating an NSString object
Listing 4-3: Casting a String value into an NSString object
Listing 4-4: Creating a formatted string
Listing 4-5: Formatting numbers
Listing 4-6: Comparing String values
Listing 4-7: Comparing String values with options
Listing 4-8: Comparing only a range of characters
Listing 4-9: Searching and replacing characters in a string
Listing 4-10: Getting the components of a string
Listing 4-11: Creating and reading an NSRange value
Listing 4-12: Converting a range of string indexes
Listing 4-13: Working with NSNumber objects
Listing 4-14: Formatting a number
Listing 4-15: Rounding a number
Listing 4-16: Disabling grouping
Listing 4-17: Adding the sign
Listing 4-18: Formatting the number as a percentage value
Listing 4-19: Formatting currency values
Listing 4-20: Storing dates with Date structures
Listing 4-21: Comparing two dates
Listing 4-22: Extracting components from a date
Listing 4-23: Extracting multiple components from a date
Listing 4-24: Creating a new date from single components
Listing 4-25: Using a Gregorian calendar
Listing 4-26: Adding components to a date
Listing 4-27: Comparing dates
Listing 4-28: Finding a date in an interval
Listing 4-29: Formatting dates
Listing 4-30: Specifying a custom format
Listing 4-31: Including multiple date components
Listing 4-32: Specifying a different locale
Listing 4-33: Working with different time zones
Listing 4-34: Initializing Measurement structures
Listing 4-35: Adding the values of two Measurement structures
Listing 4-36: Adding two values of different units
Listing 4-37: Converting units
Listing 4-38: Formatting a measurement
Listing 4-39: Formatting a measurement for a specific purpose
Listing 4-40: Formatting the measurement value
Listing 4-41: Formatting a measurement for a specific locale
Listing 4-42: Creating a non-repeating timer
Listing 4-43: Creating a repeating timer
Listing 4-44: Using regular expressions
Listing 4-45: Capturing values with subexpressions
Listing 4-46: Capturing multiple values
Listing 4-47: Processing multiple lines of text with a regular expression
Listing 4-48: Replacing the characters that match a regular expression
Listing 4-49: Defining a regular expression with a Regex Builder
Listing 4-50: Capturing a value with a Regex Builder
Listing 4-51: Transforming values to the right data type
Listing 4-52: Matching dates and currency
Listing 4-53: Initializing Core Graphics' structures
Listing 4-54: Using the CGRect convenience initializer
Listing 4-55: Accessing the structures inside a CGRect structure
Listing 4-56: Assigning empty structures to a CGRect variable
Listing 4-57: Calculating the coordinate at the center of the rectangle
CHAPTER 5 - SWIFTUI FRAMEWORK
Listing 5-1: Initializing the app
Listing 5-2: Defining a structure that conforms to the View protocol
Listing 5-3: Defining the preview for the canvas
Listing 5-4: Generating multiple previews
Listing 5-5: Returning values of complex data types
Listing 5-6: Returning opaque types
Listing 5-7: Displaying values with a Text view
Listing 5-8: Formatting a value for a Text view
Listing 5-9: Displaying a date with a Text view
Listing 5-10: Displaying a timer with a Text view
Listing 5-11: Applying modifiers to a view
Listing 5-12: Assigning a fixed size to a view
Listing 5-13: Creating flexible containers
Listing 5-14: Adding padding to a view
Listing 5-15: Assigning a specific padding for each side
Listing 5-16: Assigning padding with Edge values
Listing 5-17: Assigning dynamic font types
Listing 5-18: Using the system font
Listing 5-19: Using standard fonts
Listing 5-20: Using custom fonts
Listing 5-21: Applying multiple styles to a text
Listing 5-22: Nesting Text views
Listing 5-23: Styling the font
Listing 5-24: Formatting text
Listing 5-25: Truncating text
Listing 5-26: Implementing Color views
Listing 5-27: Defining the color with RGB values
Listing 5-28: Assigning a dynamic color
Listing 5-29: Assigning a custom color
Listing 5-30: Assigning a color to the text of a Text view
Listing 5-31: Assigning a background color to a Text view
Listing 5-32: Assigning a background color to a view with a padding
Listing 5-33: Assigning a border to the view
Listing 5-34: Rounding corners
Listing 5-35: Displaying a view in front of another view
Listing 5-36: Applying a predefined gradient to a view
Listing 5-37: Applying a material
Listing 5-38: Applying a material to the view's content
Listing 5-39: Displaying an image
Listing 5-40: Loading an image from the ImageResource structure
Listing 5-41: Clipping the image
Listing 5-42: Resizing the image
Listing 5-43: Resizing an image to fit the view
Listing 5-44: Resizing the image to fit within the view with the scaledToFit() modifier
Listing 5-45: Resizing and clipping the image to fill the view
Listing 5-46: Resizing image to fill the container
Listing 5-47: Applying style modifiers to an Image view
Listing 5-48: Applying visual effects to an Image view
Listing 5-49: Scaling an image to the selected font size
Listing 5-50: Displaying SF symbols
Listing 5-51: Styling a symbol
Listing 5-52: Storing the font in a constant
Listing 5-53: Assigning a variant to a symbol
Listing 5-54: Displaying multicolor symbols
Listing 5-55: Displaying a multicolor symbol with custom colors
Listing 5-56: Displaying a variable SF Symbol
Listing 5-57: Displaying a text with an SF Symbol
Listing 5-58: Performing a task when the view appears
Listing 5-59: Applying custom modifiers
Listing 5-60: Customizing a custom modifier
Listing 5-61: Creating a vertical stack of views
Listing 5-62: Aligning views in a vertical stack
Listing 5-63: Adding a space between the views
Listing 5-64: Creating a horizontal stack of views
Listing 5-65: Creating a ZStack
Listing 5-66: Setting the Z index of a view
Listing 5-67: Assigning modifiers to the stack and its content
Listing 5-68: Nesting stacks
Listing 5-69: Aligning the views with a flexible space
Listing 5-70: Aligning the views to the left and the top
Listing 5-71: Ignoring the safe area
Listing 5-72: Ignoring only the container safe area at the bottom
Listing 5-73: Expanding the safe area
Listing 5-74: Arranging the views with priorities by default
Listing 5-75: Assigning a higher priority to a view
Listing 5-76: Defining a view with a fixed size
Listing 5-77: Aligning images to the center with standard values
Listing 5-78: Aligning an image to the center with custom values
Listing 5-79: Aligning all images to the center with custom values
Listing 5-80: Defining custom alignment guides
Listing 5-81: Aligning views with custom alignment guides
Listing 5-82: Arranging the views in groups
Listing 5-83: Assigning different views to the body property
Listing 5-84: Defining a grid layout
Listing 5-85: Defining a multicolumn cell
Listing 5-86: Embedding a grid within another grid
Listing 5-87: Extracting views
Listing 5-88: Defining a custom layout
Listing 5-89: Selecting a layout
Listing 5-90: Wrapping views in an AnyView view
Listing 5-91: Constructing views with the @ViewBuilder property wrapper
Listing 5-92: Returning an empty view
Listing 5-93: Activating dark mode
Listing 5-94: Responding to updates in the states of the environment
CHAPTER 6 - DECLARATIVE USER INTERFACE
Listing 6-1: Defining a state
Listing 6-2: Defining multiple states
Listing 6-3: Defining bidirectional binding
Listing 6-4: Using @Binding properties
Listing 6-5: Accessing the properties of a State structure
Listing 6-6: Initializing @State properties
Listing 6-7: Accessing the values of a @Binding property
Listing 6-8: Creating a Binding structure
Listing 6-9: Creating a Binding structure with an immutable value
Listing 6-10: Implementing Button views
Listing 6-11: Using functions to organize the code
Listing 6-12: Referencing a method
Listing 6-13: Adding and removing views from the interface
Listing 6-14: Disabling a button
Listing 6-15: Defining the label of a button with an Image view
Listing 6-16: Styling buttons
Listing 6-17: Assigning a role
Listing 6-18: Scaling buttons
Listing 6-19: Defining custom styles for the button
Listing 6-20: Configuring a text field
Listing 6-21: Responding to the Done button
Listing 6-22: Responding to changes in focus
Listing 6-23: Closing the keyboard
Listing 6-24: Checking the values before storing
Listing 6-25: Disabling the button
Listing 6-26: Controlling user's input
Listing 6-27: Accepting only integer numbers
Listing 6-28: Defining a multiline text field
Listing 6-29: Using a secure text field
Listing 6-30: Implementing a text editor
Listing 6-31: Implementing a Toggle
Listing 6-32: Including a subtitle
Listing 6-33: Defining a custom label for the Toggle view
Listing 6-34: Implementing a toggle button
Listing 6-35: Defining a custom Toggle view
Listing 6-36: Creating a slider
Listing 6-37: Responding to the slider state
Listing 6-38: Showing progress
Listing 6-39: Simulating progress
Listing 6-40: Showing an activity indicator
Listing 6-41: Creating a stepper
Listing 6-42: Defining the steps of a stepper
Listing 6-43: Modifying the interface when the value is incremented or decremented
Listing 6-44: Defining a group of views
Listing 6-45: Storing our data in an observable object
Listing 6-46: Initializing the observable object
Listing 6-47: Creating a bidirectional binding with the observable object
Listing 6-48: Defining an observable object for a view
Listing 6-49: Initializing the view's observable object
Listing 6-50: Initializing the view's observable object when the view appears
Listing 6-51: Disabling observation for a property in an observable object
Listing 6-52: Assigning the observable object to the view's environment
Listing 6-53: Getting a reference to the observable object from the environment
Listing 6-54: Turning the environment property into a bindable property
Listing 6-55: Creating a bindable property with the Bindable structure
CHAPTER 7 - LISTS
Listing 7-1: Creating a list of views dynamically
Listing 7-2: Creating a list with a standard design
Listing 7-3: Defining a model to work with lists of views
Listing 7-4: Injecting the model into the environment
Listing 7-5: Creating a list of views with data from the model
Listing 7-6: Creating a scrollable list of views
Listing 7-7: Configuring the scroll view
Listing 7-8: Scrolling the list of views horizontally
Listing 7-9: Adapting the size of the views to the container
Listing 7-10: Scrolling the content page by page
Listing 7-11: Scrolling two views at a time
Listing 7-12: Defining each view as a scroll target
Listing 7-13: Scrolling the content programmatically
Listing 7-14: Displaying information about the active view on the screen
Listing 7-15: Applying a visual effect to the transition
Listing 7-16: Applying multiple visual effects to the transition
Listing 7-17: Scrolling the list programmatically
Listing 7-18: Creating a grid with a fixed number of items
Listing 7-19: Defining flexible items
Listing 7-20: Defining adaptive items
Listing 7-21: Creating a list of views with the List view
Listing 7-22: Creating a plain list
Listing 7-23: Customizing the rows
Listing 7-24: Assigning alternate backgrounds
Listing 7-25: Mixing static and dynamic content in a list
Listing 7-26: Dividing the content into sections
Listing 7-27: Configuring the section separators
Listing 7-28: Configuring the list from the environment
Listing 7-29: Providing an ordered list of values
Listing 7-30: Deleting rows
Listing 7-31: Activating the edit mode
Listing 7-32: Moving rows
Listing 7-33: Selecting a row
Listing 7-34: Selecting multiple rows
Listing 7-35: Customizing the edit mode
Listing 7-36: Customizing the selection
Listing 7-37: Storing the selection in the model
Listing 7-38: Defining custom swipe actions
Listing 7-39: Implementing a custom button to delete the rows
Listing 7-40: Refreshing the list
Listing 7-41: Defining the model to create a hierarchical list
Listing 7-42: Displaying a hierarchical list
Listing 7-43: Implementing an OutlineGroup view
Listing 7-44: Defining a model to test tables
Listing 7-45: Creating a table with multiple columns
Listing 7-46: Defining the rows manually
Listing 7-47: Sorting the values by column
Listing 7-48: Allowing the user to select items in a table
Listing 7-49: Using a context menu to process a row
Listing 7-50: Defining the content of a column with a Toggle view
Listing 7-51: Defining a custom sort comparator
Listing 7-52: Sorting Boolean values on a table
Listing 7-53: Defining a model with hierarchical data
Listing 7-54: Disclosing hierarchical data
Listing 7-55: Defining a picker
Listing 7-56: Selecting an initial value
Listing 7-57: Listing values by index
Listing 7-58: Implementing a segmented picker
Listing 7-59: Defining a DatePicker to select a date
Listing 7-60: Limiting the DatePicker to a range of values
Listing 7-61: Presenting a picker with a spinning wheel
Listing 7-62: Picking multiple dates
Listing 7-63: Defining a form
Listing 7-64: Defining a custom label for a form
Listing 7-65: Styling a form
Listing 7-66: Disclosing controls
CHAPTER 8 - NAVIGATION
Listing 8-1: Initiating a navigation stack
Listing 8-2: Setting the title mode
Listing 8-3: Adding a button to the navigation bar
Listing 8-4: Adding multiple buttons
Listing 8-5: Adding buttons to the bottom toolbar
Listing 8-6: Defining the buttons intent
Listing 8-7: Customizing the bar
Listing 8-8: Creating a popup menu
Listing 8-9: Filtering the data in the model
Listing 8-10: Displaying a search bar
Listing 8-11: Keeping the search bar on the screen
Listing 8-12: Performing the search when the Return/Done key is pressed
Listing 8-13: Suggesting terms to the user
Listing 8-14: Cancelling the search programmatically
Listing 8-15: Adding scope buttons
Listing 8-16: Searching by title and author
Listing 8-17: Adding tokens
Listing 8-18: Filtering books by author
Listing 8-19: Including a navigation link
Listing 8-20: Defining a second view
Listing 8-21: Dismissing the view from the environment
Listing 8-22: Selecting rows with a navigation link
Listing 8-23: Defining a Detail view
Listing 8-24: Defining custom navigation
Listing 8-25: Adding and removing views from the path
Listing 8-26: Removing a view from the path
Listing 8-27: Controlling the navigation path from the model
Listing 8-28: Controlling the navigation path from the initial view
Listing 8-29: Adding views to the navigation path programmatically
Listing 8-30: Returning to different views in the navigation path
Listing 8-31: Displaying a sheet
Listing 8-32: Defining the view for the sheet
Listing 8-33: Disabling the interactive feature to dismiss the sheet
Listing 8-34: Assigning a predefined height
Listing 8-35: Assigning a custom height
Listing 8-36: Presenting a sheet for every value on the list
Listing 8-37: Editing a book
Listing 8-38: Presenting the inspector
Listing 8-39: Defining the size of the inspector
Listing 8-40: Showing a popover
Listing 8-41: Defining the content of the popover
Listing 8-42: Displaying an alert view
Listing 8-43: Defining an Alert view with multiple buttons
Listing 8-44: Defining an action sheet
Listing 8-45: Defining a TabView
Listing 8-46: Defining the BooksView
Listing 8-47: Defining the SettingsView
Listing 8-48: Displaying a badge in a tab
Listing 8-49: Selecting the initial view
Listing 8-50: Updating the model
Listing 8-51: Designing the rows according to the app's configuration
Listing 8-52: Configuring the app
Listing 8-53: Configuring the TabView to show content in pages
Listing 8-54: Defining a two-column split view
Listing 8-55: Defining the view for the left column
Listing 8-56: Defining a placeholder view for the right column
Listing 8-57: Defining a Multiplatform Detail view
Listing 8-58: Showing an item by default
Listing 8-59: Enabling navigation in the right column
Listing 8-60: Creating a navigation path for the right column
Listing 8-61: Expanding the cover in a Multiplatform application
Listing 8-62: Adding navigation to the left column
Listing 8-63: Opening a view on the left column
Listing 8-64: Providing the list of authors
Listing 8-65: Defining a three-column layout
Listing 8-66: Showing the authors
Listing 8-67: Showing the books
Listing 8-68: Hiding columns programmatically
Listing 8-69: Configuring the columns
Listing 8-70: Detecting changes in the horizontal size class
Listing 8-71: Using a GeometryReader to detect orientation
Listing 8-72: Adapting an Image view to the size of its container
Listing 8-73: Reading the position of the GeometryReader view
Listing 8-74: Reading the position and size of a view
Listing 8-75: Setting and reading preferences
CHAPTER 9 - CONCURRENCY
Listing 9-1: Initiating an asynchronous task
Listing 9-2: Running multiple asynchronous processes
Listing 9-3: Defining a task explicitly
Listing 9-4: Cancelling a task
Listing 9-5: Reading a value returned by a task
Listing 9-6: Defining asynchronous properties
Listing 9-7: Responding to errors
Listing 9-8: Defining a concurrent task
Listing 9-9: Defining an actor
Listing 9-10: Defining a non-isolated method
Listing 9-11: Defining a non-isolated method
Listing 9-12: Asking the compiler not to check conformity to the Sendable protocol
Listing 9-13: Executing a method in the Main Actor
Listing 9-14: Executing code in the Main Actor
Listing 9-15: Returning a value from the Main Actor
Listing 9-16: Defining an asynchronous sequence
Listing 9-17: Defining a task group
Listing 9-18: Loading an image asynchronously
Listing 9-19: Configuring the image after it is downloaded
CHAPTER 10 - STORAGE
Listing 10-1: Storing and reading values from User Defaults
Listing 10-2: Storing app settings in User Defaults
Listing 10-3: Adapting the interface to the app's settings
Listing 10-4: Modifying the app's settings
Listing 10-5: Defining a SwiftData model
Listing 10-6: Creating the container
Listing 10-7: Controlling the navigation path from an observable object
Listing 10-8: Fetching books from the database
Listing 10-9: Storing a book in the database
Listing 10-10: Storing unique values
Listing 10-11: Creating a second model to store the authors
Listing 10-12: Creating a relationship with the Author instance
Listing 10-13: Defining the relationship in the Book class
Listing 10-14: Defining the relationship in the Author class
Listing 10-15: Controlling navigation from the observable object
Listing 10-16: Opening additional views for navigation
Listing 10-17: Assigning an author to a book
Listing 10-18: Listing the authors
Listing 10-19: Inserting new authors
Listing 10-20: Displaying the author's name
Listing 10-21: Including all the models in the container
Listing 10-22: Deleting objects
Listing 10-23: Sorting objects
Listing 10-24: Sorting objects with a SortDescriptor structure
Listing 10-25: Sorting books by author and year
Listing 10-26: Sorting with a lexical comparator
Listing 10-27: Filtering books by year
Listing 10-28: Filtering books by author
Listing 10-29: Defining a dynamic query
Listing 10-30: Searching books by title
Listing 10-31: Fetching objects manually
Listing 10-32: Counting objects
Listing 10-33: Checking for duplicates
Listing 10-34: Defining a custom container with values for testing
Listing 10-35: Implementing a custom container in the preview
Listing 10-36: Preparing the selectedBook property to add new books
Listing 10-37: Opening the view to edit a book
Listing 10-38: Editing a book
Listing 10-39: Providing a single object for the preview
Listing 10-40: Storing images externally
Listing 10-41: Displaying an image from a UIImage object
Listing 10-42: Displaying the image in the DetailView view
Listing 10-43: Converting a UIImage object into data
Listing 10-44: Creating Book objects with images from the Asset Catalog
Listing 10-45: Sorting the books
Listing 10-46: Displaying the books in sections
Listing 10-47: Storing the letters for the sections
Listing 10-48: Adding the relationship to sort the books by letter
Listing 10-49: Getting the SortLetters object that correspond to the book
Listing 10-50: Listing books in alphabetical sections
Listing 10-51: Listing books in alphabetical sections
Listing 10-52: Defining a Codable structure
Listing 10-53: Storing and decoding data
Listing 10-54: Encoding data
Listing 10-55: Displaying encoded data
Listing 10-56: JSON file
Listing 10-57: Decoding with JSON
Listing 10-58: Encoding with JSON
Listing 10-59: Preparing the Book model for CloudKit
Listing 10-60: Preparing the Author model for CloudKit
Listing 10-61: Saving files
Listing 10-62: Opening a sheet to add files to the model
Listing 10-63: Creating new files
Listing 10-64: Getting the list of files
Listing 10-65: Listing the files created by the user
Listing 10-66: Reading the content of a file
Listing 10-67: Allowing the user to open a file
Listing 10-68: Displaying the contents of a file
Listing 10-69: Deleting a file
Listing 10-70: Allowing the user to delete files
Listing 10-71: Storing text in a file
Listing 10-72: Editing the content of a file
Listing 10-73: Loading a file from the bundle
Listing 10-74: Displaying the content of a file stored in the bundle
Listing 10-75: Defining a document model
Listing 10-76: Creating a Document app
Listing 10-77: Editing the document
Listing 10-78: Exporting a document
Listing 10-79: Importing a document
CHAPTER 11 - GRAPHICS AND ANIMATIONS
Listing 11-1: Drawing standard shapes
Listing 11-2: Filling a shape with a color
Listing 11-3: Defining a border
Listing 11-4: Defining a custom border
Listing 11-5: Combining shapes with other views
Listing 11-6: Assigning a shape as the background of a button
Listing 11-7: Defining a linear gradient
Listing 11-8: Defining a linear gradient with custom stops
Listing 11-9: Defining a circular gradient
Listing 11-10: Defining a conic gradient
Listing 11-11: Adding a shadow to a view
Listing 11-12: Filling a shape with an image
Listing 11-13: Defining a custom path
Listing 11-14: Combining lines and arcs
Listing 11-15: Combining lines and ellipses
Listing 11-16: Creating complex curves
Listing 11-17: Adapting the size of the path to the size of the container
Listing 11-18: Creating a custom shape view
Listing 11-19: Implementing custom shape views
Listing 11-20: Displacing an image
Listing 11-21: Rotating the image
Listing 11-22: Clipping the image
Listing 11-23: Rotating a shape
Listing 11-24: Inverting a shape with the scale() modifier
Listing 11-25: Trimming a path
Listing 11-26: Drawing an image on the canvas
Listing 11-27: Drawing an image on the canvas
Listing 11-28: Drawing shapes and text
Listing 11-29: Rotating the canvas
Listing 11-30: Rotating an image
Listing 11-31: Performing multiple transformations
Listing 11-32: Preparing images
Listing 11-33: Clipping the canvas
Listing 11-34: Working with different configurations
Listing 11-35: Applying filters to the graphics
Listing 11-36: Providing the data for a chart
Listing 11-37: Visualizing data with a bar chart
Listing 11-38: Visualizing data with a line chart
Listing 11-39: Displaying an overlay
Listing 11-40: Defining a custom scale for the y axis
Listing 11-41: Assigning different styles based on a value
Listing 11-42: Representing the values with different types of marks
Listing 11-43: Drawing a line in the plot area
Listing 11-44: Selecting a value
Listing 11-45: Representing the values with different types of marks
Listing 11-46: Visualizing two series of values
Listing 11-47: Visualizing two series of values with a bar chart
Listing 11-48: Defining the positions of the bars
Listing 11-49: Scrolling the chart
Listing 11-50: Creating an image from a view
Listing 11-51: Animating a view
Listing 11-52: Applying a linear animation
Listing 11-53: Declaring a specific duration
Listing 11-54: Configuring the animation
Listing 11-55: Defining a custom animation
Listing 11-56: Animating multiple states at a time
Listing 11-57: Applying a different animation to each state
Listing 11-58: Instantiating a view with a value that can be animated
Listing 11-59: Defining an animatable path
Listing 11-60: Updating the interface
Listing 11-61: Animating the canvas
Listing 11-62: Creating a real animation
Listing 11-63: Adding and removing a view with a transition
Listing 11-64: Extending the AnyTransition structure
Listing 11-65: Defining an asymmetric transition
Listing 11-66: Combining transitions
Listing 11-67: Customizing the transition
Listing 11-68: Coordinating transitions
Listing 11-69: Coordinating views
Listing 11-70: Animating an SF Symbol
Listing 11-71: Animating an SF Symbol when a value changes
Listing 11-72: Animating an SF Symbol multiple times
Listing 11-73: Scaling a symbol
Listing 11-74: Removing a symbol from the screen
Listing 11-75: Adapting the layout to the effect
CHAPTER 12 - GESTURES
Listing 12-1: Detecting a tap gesture on an image
Listing 12-2: Expanding the image
Listing 12-3: Detecting a long press gesture
Listing 12-4: Disabling the tap gesture
Listing 12-5: Defining the shape of the content
Listing 12-6: Defining a TapGesture recognizer
Listing 12-7: Defining a LongPressGesture recognizer
Listing 12-8: Controlling the states of a gesture with an enumeration
Listing 12-9: Defining a MagnificationGesture recognizer
Listing 12-10: Determining a minimum and a maximum scale
Listing 12-11: Defining a RotationGesture recognizer
Listing 12-12: Allowing the user to drag an image
Listing 12-13: Providing a custom preview for the gesture
Listing 12-14: Dropping images into an Image view
Listing 12-15: Providing feedback to the user
Listing 12-16: Dragging custom values
Listing 12-17: Using a custom content type
Listing 12-18: Dragging and dropping custom values
CHAPTER 13 - MAP KIT
Listing 13-1: Displaying a map
Listing 13-2: Displaying a hybrid map
Listing 13-3: Selecting points of interest
Listing 13-4: Configuring the map from the model
Listing 13-5: Zooming on a region on the map
Listing 13-6: Showing the current latitude and longitude
Listing 13-7: Disabling panning
Listing 13-8: Defining the boundaries for the camera
Listing 13-9: Applying the boundaries to the map
Listing 13-10: Adding markers to the map
Listing 13-11: Displaying annotations
Listing 13-12: Drawing a circle over the labels
Listing 13-13: Drawing a line
Listing 13-14: Storing places found by Local Search
Listing 13-15: Searching for places
Listing 13-16: Selecting markers
Listing 13-17: Displaying map controls
Listing 13-18: Creating custom controls
Listing 13-19: Presenting a Look Around preview
Listing 13-20: Presenting the Look Around sheet
Listing 13-21: Displaying a route
Listing 13-22: Conforming to the CLLocationManagerDelegate protocol
Listing 13-23: Requesting authorization and showing the user's location
Listing 13-24: Implementing the user location button
CHAPTER 14 - NOTIFICATIONS
Listing 14-1: Listening to notifications from the model
Listing 14-2: Listening to notifications
Listing 14-3: Adding new values to the model
Listing 14-4: Adding information to the notification
Listing 14-5: Reading the value in the notification
Listing 14-6: Cancelling the task
Listing 14-7: Interface to test the keyboard
Listing 14-8: Scrolling the interface to make room for the keyboard
Listing 14-9: Listening to keyboard notifications
Listing 14-10: Modifying the interface when the keyboard state changes
Listing 14-11: Detecting changes in the orientation
Listing 14-12: Adapting the interface to changes in the orientation
Listing 14-13: Asking permission to send notifications
Listing 14-14: Scheduling a notification
Listing 14-15: Playing a sound
Listing 14-16: Attaching an image to a notification
Listing 14-17: Showing notifications while the app is running
Listing 14-18: Organizing notifications into groups
Listing 14-19: Configuring a summary of notifications
Listing 14-20: Adding an action to a notification
Listing 14-21: Processing actions for notifications
Listing 14-22: Adding an input action to a notification
Listing 14-23: Processing the user's feedback
Listing 14-24: Defining an observable property for KVO
Listing 14-25: Observing a property
Listing 14-26: Working with a KVO property
Listing 14-27: Detecting changes in the app's state
Listing 14-28: Defining a custom app delegate
Listing 14-29: Assigning the app delegate from a SwiftUI application
Listing 14-30: Defining a custom Scene delegate
Listing 14-31: Configuring a Scene
Listing 14-32: Defining the model as a singleton
Listing 14-33: Injecting the singleton into the environment
Listing 14-34: Modifying the model from the app delegate
Listing 14-35: Implementing a model created from a singleton
CHAPTER 15 - ICLOUD
Listing 15-1: Storing a value in iCloud
Listing 15-2: Defining the interface to store and read values from iCloud
Listing 15-3: Storing multiple values in iCloud
Listing 15-4: Reading multiple values from iCloud
Listing 15-5: Saving multiple values in iCloud
Listing 15-6: Creating the document
Listing 15-7: Initializing the model required to store a document in iCloud
Listing 15-8: Processing query results
Listing 15-9: Updating the document
Listing 15-10: Defining the main interface
Listing 15-11: Editing the document
Listing 15-12: Working with multiple documents
Listing 15-13: Processing the list of files in the container
Listing 15-14: Updating the container
Listing 15-15: Adding and removing documents from the container
Listing 15-16: Opening, saving, and closing a document
Listing 15-17: Listing the documents available in the container
Listing 15-18: Creating new documents
Listing 15-19: Displaying the document's content
CHAPTER 16 - FRAMEWORK INTEGRATION
Listing 16-1: Preparing a UIKit view to work with SwiftUI
Listing 16-2: Showing a UIKit view within a SwiftUI view
Listing 16-3: Sending and receiving values from the SwiftUI view
Listing 16-4: Receiving and sending values to a UIKit view
Listing 16-5: Creating a UIKit view controller
Listing 16-6: Creating the representable view for a UIKit view controller
Listing 16-7: Loading a UIKit view controller from a SwiftUI view
CHAPTER 17 - WEB
Listing 17-1: Opening a website
Listing 17-2: Encoding URLs
Listing 17-3: Encoding custom URLs
Listing 17-4: Creating a Safari Browser
Listing 17-5: Opening a Safari Browser
Listing 17-6: Configuring the view controller
Listing 17-7: Preserving the bars at their original size
Listing 17-8: Assigning a delegate to the Safari View Controller
Listing 17-9: Disabling the button from the Safari View Controller delegate
Listing 17-10: Loading a website with a WebKit View
Listing 17-11: Showing the WebKit view
Listing 17-12: Allowing the user the insert a URL
Listing 17-13: Updating the WKWebView with the URLs inserted by the user
Listing 17-14: Providing buttons for navigation
Listing 17-15: Navigating back and forth in the navigation history
Listing 17-16: Loading a remote document
Listing 17-17: Displaying the document's content
Listing 17-18: Initializing a custom session
Listing 17-19: Redirecting the user
Listing 17-20: Loading a JSON document
Listing 17-21: Listing the values from the document
CHAPTER 18 - MEDIA
Listing 18-1: Creating a Photo picker
Listing 18-2: Embedding the Photos Picker in our interface
Listing 18-3: Hiding controls
Listing 18-4: Defining the model for multiple selection
Listing 18-5: Allowing the user to perform multiple selections
Listing 18-6: Creating the Image Picker Controller to take pictures
Listing 18-7: Defining the interface to take pictures
Listing 18-8: Showing an Alert view when a picture is saved
Listing 18-9: Sharing the image with other applications
Listing 18-10: Defining a UIView subclass to show the camera's preview video
Listing 18-11: Defining the properties we need to manage the camera
Listing 18-12: Asking for permission to use the camera
Listing 18-13: Initializing the camera
Listing 18-14: Showing the video from the camera on the screen
Listing 18-15: Taking a picture
Listing 18-16: Processing the image
Listing 18-17: Showing the image
Listing 18-18: Taking a picture
Listing 18-19: Preparing the video to be played
Listing 18-20: Playing a video
Listing 18-21: Automatically playing a video
Listing 18-22: Presenting views over the video
Listing 18-23: Building a custom video player
Listing 18-24: Building a custom video player
Listing 18-25: Showing a video
Listing 18-26: Preparing the video player
Listing 18-27: Playing and pausing the video
Listing 18-28: Executing an asynchronous method to detect the end of the video
Listing 18-29: Rewinding the video
Listing 18-30: Playing a list of videos
Listing 18-31: Showing a color picker
CHAPTER 19 - MULTIPLATFORM APPLICATIONS
Listing 19-1: Detecting the platform before compiling
Listing 19-2: Applying different modifiers to each platform
Listing 19-3: Defining a multiplatform interface
Listing 19-4: Adding a menu to the menu bar
Listing 19-5: Assigning a keyboard shortcut to a menu option
Listing 19-6: Adding options to a standard menu
Listing 19-7: Removing options
Listing 19-8: Defining a property in the model to store the index of the selected option
Listing 19-9: Adding a submenu
Listing 19-10: Adding predefined options to import resources
Listing 19-11: Importing an image form an external device
Listing 19-12: Defining a state to enable and disable a menu option
Listing 19-13: Enabling and disabling a menu option
Listing 19-14: Defining a TextField view to enable and disable the option
Listing 19-15: Storing a focus state in the FocusedValues structure
Listing 19-16: Passing the focus state to the FocusedValues structure
Listing 19-17: Disabling a menu option according to the focus state of a view
Listing 19-18: Defining a two-column interface
Listing 19-19: Adding items to the toolbar for a Mac application
Listing 19-20: Showing a tooltip for a button
Listing 19-21: Defining a model to test alternate backgrounds
Listing 19-22: Creating a list with alternate background
Listing 19-23: Opening an auxiliary window
Listing 19-24: Opening a window programmatically
Listing 19-25: Configuring the auxiliary window
Listing 19-26: Defining a Settings Scene
Listing 19-27: Inserting a control in the system's menu bar
Listing 19-28: Defining a control to open a view
Listing 19-29: Storing the state of the Scene
CHAPTER 20 - INTERNATIONALIZATION
Listing 20-1: Testing String Catalogs
Listing 20-2: Selecting the language for the previews
Listing 20-3: Including comments for the translator
Listing 20-4: Localizing strings
Listing 20-5: Localizing values
Listing 20-6: Specifying singular and plural versions of the text
CHAPTER 21 - APP STORE
There are no Examples in this Chapter
Tools and Resources
Select Country
Paperback
$ 39.95 BUY NOW
Kindle
$ 9.99 BUY NOW
Apple Books
$ 9.99 BUY NOW
Google Books
$ 9.75 BUY NOW
Information
4th Edition
October 2023
ISBN: 978-1-7779782-3-5
More than 800 Codes Explained!
More than 300 Projects!