Examples and Projects - Swift for Masterminds

HOME BOOKS VIDEO COURSES

NEWSLETTER CONTACT

Swift for Masterminds

How to take advantage of Swift to program powerful and scalable applications for iPhones, iPads, and Macs

1st Edition
January 2026
ISBN: 978-1-7779782-9-7

Examples and Projects

Although typing the examples can help reinforce what you are learning, it can also be time consuming. To make the process faster, you can download the source code in TXT format, access the complete Xcode projects, or open the specific examples you want to review using the links below.

Download TXT Files
117.0 KBytes

Download Projects
4.8 MBytes

Chapter 1 - Introduction to Swift

Listing 1-1: Playground template

Listing 1-2: Declaring variables

Listing 1-3: Initializing variables

Listing 1-4: Declaring and initializing variables in the same statement

Listing 1-5: Assigning a new value to a variable

Listing 1-6: Declaring variables of different data types

Listing 1-7: Declaring variables without specifying the data type

Listing 1-8: Assigning variables to variables

Listing 1-9: Assigning the result of an operation to a variable

Listing 1-10: Performing operations in variables of different type

Listing 1-11: Inferring the data type from an operation

Listing 1-12: Calculating the remainder

Listing 1-13: Adding numbers to variables

Listing 1-14: Performing operations on the variable’s current value

Listing 1-15: Modifying the value of a variable using incremental operators

Listing 1-16: Declaring and initializing a constant

Listing 1-17: Declaring and initializing a Character variable

Listing 1-18: Declaring and initializing a String variable

Listing 1-19: Concatenating strings

Listing 1-20: Concatenating strings with the + and += operators

Listing 1-21: Including variables in strings

Listing 1-22: Performing operations within strings

Listing 1-23: Including special characters in a string

Listing 1-24: Generating multiple lines of text

Listing 1-25: Declaring a Boolean variable

Listing 1-26: Declaring an optional variable of type Int

Listing 1-27: Assigning new values to optional variables

Listing 1-28: Using nil to empty an optional variable

Listing 1-29: Unwrapping an optional variable

Listing 1-30: Assigning an optional to another optional

Listing 1-31: Declaring Implicitly Unwrapped Optionals

Listing 1-32: Declaring a tuple with two values

Listing 1-33: Declaring a tuple with values of different type

Listing 1-34: Reading the values of a tuple

Listing 1-35: Modifying the value of a tuple

Listing 1-36: Declaring names for the values of a tuple

Listing 1-37: Creating multiple variables from the values of a tuple

Listing 1-38: Ignoring some of the values of a tuple

Listing 1-39: Comparing two values with if

Listing 1-40: Comparing two values with the <= operator

Listing 1-41: Conditions with Boolean values

Listing 1-42: Using logical operators

Listing 1-43: Using logical operators to check multiple conditions

Listing 1-44: Checking whether an optional contains a value or not

Listing 1-45: Using Optional Binding to unwrap an optional variable

Listing 1-46: Using the same name to unwrap a value

Listing 1-47: Unwrapping an optional value of the same name

Listing 1-48: Checking multiple conditions with Optional Binding

Listing 1-49: Using if else to respond to both states of the condition

Listing 1-50: Concatenating if else instructions

Listing 1-51: Implementing if else as an expression

Listing 1-52: Implementing a ternary operator

Listing 1-53: Unwrapping an optional with a ternary operator

Listing 1-54: Unwrapping an optional with the nil-coalescing operator

Listing 1-55: Checking conditions with switch

Listing 1-56: Checking multiple conditions per case

Listing 1-57: Matching a tuple in a switch statement

Listing 1-58: Matching only the second value of a tuple

Listing 1-59: Capturing values with constants

Listing 1-60: Comparing values with where

Listing 1-61: Implementing the switch statement as an expression

Listing 1-62: Using while to create a loop

Listing 1-63: Using repeat while to create a loop

Listing 1-64: Using for in to iterate over the characters of a string

Listing 1-65: Iterating over a string without reading the characters

Listing 1-66: Adding a condition to a loop

Listing 1-67: Jumping to the next cycle of the loop

Listing 1-68: Interrupting the loop

Listing 1-69: Ignoring values in a switch statement

Listing 1-70: Interrupting a loop with guard

Chapter 2 - Functions

Listing 2-1: Declaring and calling functions

Listing 2-2: Calling functions from a loop

Listing 2-3: Sending values to a function

Listing 2-4: Sending multiple values to a function

Listing 2-5: Sending different values to a function

Listing 2-6: Returning a value from a function

Listing 2-7: Returning a tuple

Listing 2-8: Interrupting the execution of a function with guard

Listing 2-9: Removing the return keyword

Listing 2-10: Modifying external variables from a function

Listing 2-11: Declaring argument labels

Listing 2-12: Removing argument labels

Listing 2-13: Declaring default values for parameters

Listing 2-14: Printing values on the console with print()

Listing 2-15: Creating collections of values

Listing 2-16: Using variables and constants of different scopes

Listing 2-17: Declaring different functions with the same name

Listing 2-18: Defining generic functions

Listing 2-19: Assigning closures to variables

Listing 2-20: Initializing a variable with the value returned by a closure

Listing 2-21: Simplifying a closure

Listing 2-22: Sending a closure to a function

Listing 2-23: Assigning the closure to the function's argument

Listing 2-24: Using Trailing Closures

Listing 2-25: Inferring the closure's data types

Chapter 3 - Structures

Listing 3-1: Defining a structure

Listing 3-2: Declaring a variable of type Item

Listing 3-3: Assigning new values to the properties of a structure

Listing 3-4: Structures inside structures

Listing 3-5: Accessing optional properties

Listing 3-6: Creating key paths

Listing 3-7: Using read and write key paths

Listing 3-8: Defining methods

Listing 3-9: Assigning new values to properties from the methods in the structure

Listing 3-10: Initializing properties

Listing 3-11: Using memberwise initializers to provide the initial values of a structure

Listing 3-12: Initializing properties from the init() method

Listing 3-13: Declaring the parameters to initialize the structure

Listing 3-14: Declaring multiple init() methods

Listing 3-15: Declaring computed properties

Listing 3-16: Defining read-only properties

Listing 3-17: Adding the set() method to set a new value

Listing 3-18: Using a different name for the parameter of the set() method

Listing 3-19: Adding observers to a store property

Listing 3-20: Defining type properties

Listing 3-21: Defining type methods

Listing 3-22: Defining generic structures

Listing 3-23: Using generic structures

Listing 3-24: Initializing variables with standard initializers

Listing 3-25: Casting a variable

Listing 3-26: Extracting numbers from strings

Listing 3-27: Checking the maximum possible value for the Int8 type

Listing 3-28: Rounding floating-point values

Listing 3-29: Modifying the value of a Bool variable

Listing 3-30: Using for in to iterate over a range

Listing 3-31: Inverting a range

Listing 3-32: Using range operators in a switch statement

Listing 3-33: Calculating random numbers

Listing 3-34: Converting a number into a string

Listing 3-35: Processing the characters of a string

Listing 3-36: Calculating a specific index

Listing 3-37: Getting the next index

Listing 3-38: Inserting a character in a string

Listing 3-39: Removing a character

Listing 3-40: Getting a range of characters

Listing 3-41: Working with ranges of characters

Listing 3-42: Implementing String methods

Listing 3-43: Declaring arrays

Listing 3-44: Declaring arrays with type inference

Listing 3-45: Reading the array’s elements

Listing 3-46: Assigning a new value to an element

Listing 3-47: Adding new elements to an array

Listing 3-48: Concatenating two arrays

Listing 3-49: Creating multidimensional arrays

Listing 3-50: Reading values from a multidimensional array

Listing 3-51: Removing the elements of an array

Listing 3-52: Reading an array with a for in loop

Listing 3-53: Reading indexes and values of an array

Listing 3-54: Checking whether an array contains a value in a specific index

Listing 3-55: Adding and removing elements

Listing 3-56: Removing all the elements that meet a condition

Listing 3-57: Finding if an element meets a condition

Listing 3-58: Selecting a random value from an array

Listing 3-59: Changing the order of the elements of an array

Listing 3-60: Reading a range of elements

Listing 3-61: Casting arrays of type ArraySlice

Listing 3-62: Removing and replacing elements

Listing 3-63: Initializing an array with elements of the same value

Listing 3-64: Filtering the values of an array

Listing 3-65: Mapping an array

Listing 3-66: Converting the elements of an array into strings

Listing 3-67: Using a structure initializer with the map() method

Listing 3-68: Reducing an array

Listing 3-69: Reversing the elements of an array

Listing 3-70: Sorting the elements of an array

Listing 3-71: Sorting the elements of an array in a custom order

Listing 3-72: Sorting an array of integers

Listing 3-73: Sorting strings according to the number of characters

Listing 3-74: Getting the largest element

Listing 3-75: Getting the first value of an array

Listing 3-76: Getting the index of a specific value

Listing 3-77: Getting the index of a value that meets a condition

Listing 3-78: Working with a range of indexes

Listing 3-79: Declaring a dictionary with initial values

Listing 3-80: Declaring a dictionary with type inference

Listing 3-81: Assigning a new value to an element of a dictionary

Listing 3-82: Adding a new element to a dictionary

Listing 3-83: Reading an element that does not exist

Listing 3-84: Reading the value of an element in a dictionary

Listing 3-85: Removing an element from a dictionary

Listing 3-86: Using for in to iterate over a dictionary

Listing 3-87: Combining dictionaries with arrays

Listing 3-88: Reading arrays inside dictionaries

Listing 3-89: Grouping values by a key

Listing 3-90: Adding and removing elements from a dictionary

Listing 3-91: Sorting the values of a dictionary

Listing 3-92: Iterating over the dictionary’s keys

Listing 3-93: Reading the keys of a dictionary

Listing 3-94: Creating an empty set of integers

Listing 3-95: Creating a set of integers

Listing 3-96: Using contains() to find an element in a set

Listing 3-97: Inserting a new element in a set

Listing 3-98: Removing an element from a set

Listing 3-99: Sorting the elements of a set

Listing 3-100: Combining sets

Listing 3-101: Comparing sets

Chapter 4 - Enumerations

Listing 4-1: Defining an enumeration type

Listing 4-2: Declaring the enumeration values in one statement

Listing 4-3: Initializing an instance of an enumeration

Listing 4-4: Assigning a new value to a variable of type Number

Listing 4-5: Using switch with an enumeration type

Listing 4-6: Assigning raw values to enumeration values

Listing 4-7: Reading raw values

Listing 4-8: Creating an enumeration from a raw value

Listing 4-9: Adding methods to an enumeration

Listing 4-10: Associating values

Listing 4-11: Checking the value of an enumeration with an if statement

Chapter 5 - Objects

Listing 5-1: Defining a class

Listing 5-2: Creating an object from a class

Listing 5-3: Modifying properties from the object’s methods

Listing 5-4: Declaring a type method for a class

Listing 5-5: Referencing the object with self

Listing 5-6: Referring to the data type with self

Listing 5-7: Referencing one object from another

Listing 5-8: Assigning weak references

Listing 5-9: Defining a basic class

Listing 5-10: Inheriting properties and methods from another class

Listing 5-11: Creating objects from a subclass

Listing 5-12: Overriding an inherited method

Listing 5-13: Calling a method on the superclass

Listing 5-14: Creating an array of objects from different subclasses

Listing 5-15: Identifying the object’s data type

Listing 5-16: Casting an object

Listing 5-17: Casting an object with the as? operator

Listing 5-18: Casting an object on the fly

Listing 5-19: Working with objects of AnyObject type

Listing 5-20: Extending data types

Listing 5-21: Extending custom data types

Listing 5-22: Defining a conditional extension

Listing 5-23: Customizing string interpolation

Listing 5-24: Declaring a Designated Initializer

Listing 5-25: Declaring a Convenience Initializer

Listing 5-26: Inheriting the Designated Initializer

Listing 5-27: Declaring a Designated Initializer for the subclass

Listing 5-28: Declaring a deinitializer

Listing 5-29: Defining lazy properties

Listing 5-30: Declaring private properties

Listing 5-31: Declaring a public getter and private setter

Listing 5-32: Defining a singleton

Chapter 6 - Protocols

Listing 6-1: Defining protocols

Listing 6-2: Defining multiple structures that conform to the same protocol

Listing 6-3: Using protocols as data types

Listing 6-4: Accessing the instance's own properties

Listing 6-5: Returning values of a protocol type

Listing 6-6: Conforming to multiple protocols

Listing 6-7: Returning a data type that conforms to multiple protocols

Listing 6-8: Conforming to the Equatable protocol

Listing 6-9: Letting the compiler create the protocol methods for us

Listing 6-10: Conforming to the Comparable protocol

Listing 6-11: Adding a type constraint to a generic function

Listing 6-12: Using the Numeric protocol to set a type constraint

Listing 6-13: Conforming to the Hashable protocol

Listing 6-14: Defining our own hash value

Listing 6-15: Conforming to the CaseIterable protocol

Listing 6-16: Extending a protocol

Listing 6-17: Implementing a delegate

Listing 6-18: Delegating with protocols

Listing 6-19: Using different delegates

Listing 6-20: Defining generic protocols

Listing 6-21: Returning values of complex data types

Listing 6-22: Returning opaque types

Chapter 7 - Error Handling

Listing 7-1: Getting an error inside a method

Listing 7-2: Throwing errors

Listing 7-3: Handling errors

Listing 7-4: Getting information about the error

Listing 7-5: Catching errors with try?

Listing 7-6: Ignoring the errors

Listing 7-7: Returning an error with a Result enumeration

Listing 7-8: Processing an error with the get() method

Chapter 8 - Frameworks

Listing 8-1: Applying math functions

Listing 8-2: Creating an NSString object

Listing 8-3: Casting a String value into an NSString object

Listing 8-4: Creating a formatted string

Listing 8-5: Formatting numbers

Listing 8-6: Comparing String values

Listing 8-7: Comparing String values with options

Listing 8-8: Comparing only a range of characters

Listing 8-9: Searching and replacing characters in a string

Listing 8-10: Getting the components of a string

Listing 8-11: Creating and reading an NSRange value

Listing 8-12: Converting a range of string indexes

Listing 8-13: Working with NSNumber objects

Listing 8-14: Formatting a number

Listing 8-15: Rounding a number

Listing 8-16: Disabling grouping

Listing 8-17: Adding the sign

Listing 8-18: Formatting the number as a percentage value

Listing 8-19: Formatting currency values

Listing 8-20: Creating Decimal values

Listing 8-21: Creating Decimal values for financial applications

Listing 8-22: Rounding Decimal values to two digits

Listing 8-23: Formatting a Decimal value

Listing 8-24: Performing calculations with Decimal values

Listing 8-25: Storing dates with Date structures

Listing 8-26: Comparing two dates

Listing 8-27: Extracting components from a date

Listing 8-28: Extracting multiple components from a date

Listing 8-29: Creating a new date from single components

Listing 8-30: Using a Gregorian calendar

Listing 8-31: Adding components to a date

Listing 8-32: Comparing dates

Listing 8-33: Finding a date in an interval

Listing 8-34: Formatting dates

Listing 8-35: Specifying a custom format

Listing 8-36: Including multiple date components

Listing 8-37: Specifying a different locale

Listing 8-38: Working with different time zones

Listing 8-39: Initializing Measurement structures

Listing 8-40: Adding the values of two Measurement structures

Listing 8-41: Adding two values of different units

Listing 8-42: Converting units

Listing 8-43: Formatting a measurement

Listing 8-44: Formatting a measurement for a specific purpose

Listing 8-45: Formatting the measurement value

Listing 8-46: Formatting a measurement for a specific locale

Listing 8-47: Creating a non-repeating timer

Listing 8-48: Creating a repeating timer

Listing 8-49: Initializing Core Graphics' structures

Listing 8-50: Using the CGRect convenience initializer

Listing 8-51: Accessing the structures inside a CGRect structure

Listing 8-52: Assigning empty structures to a CGRect variable

Listing 8-53: Calculating the coordinate at the center of the rectangle

Chapter 9 - Regular Expressions

Listing 9-1: Using regular expressions

Listing 9-2: Capturing values with subexpressions

Listing 9-3: Capturing multiple values

Listing 9-4: Processing multiple lines of text with a regular expression

Listing 9-5: Replacing the characters that match a regular expression

Listing 9-6: Defining a regular expression with a Regex Builder

Listing 9-7: Capturing a value with a Regex Builder

Listing 9-8: Transforming values to the right data type

Listing 9-9: Matching dates and currency

Chapter 10 - Swift Tools

Listing 10-1: Defining a property wrapper

Listing 10-2: Using a property wrapper

Listing 10-3: Specifying the availability of a function

Listing 10-4: Calling a function only if available

Listing 10-5: Declaring escaping closures

Listing 10-6: Declaring an Objective-C method

Listing 10-7: Implementing Freestanding macros

Chapter 11 - Swift Concurrency

Listing 11-1: Initial view

Listing 11-2: Running a synchronous task

Listing 11-3: Running an asynchronous task

Listing 11-4: Running multiple asynchronous tasks

Listing 11-5: Running asynchronous tasks sequentially

Listing 11-6: Running a task when the view is loaded

Listing 11-7: Cancelling a task

Listing 11-8: Processing a high demanding task

Listing 11-9: Processing a high demanding task in a background thread

Listing 11-10: Defining a concurrent task

Listing 11-11: Protecting data with an actor

Listing 11-12: Defining a non-isolated method

Listing 11-13: Modifying the user interface from a background thread

Listing 11-14: Modifying the user interface from a background thread

Listing 11-15: Running code in the Main Actor

Listing 11-16: Runing multiple concurrent tasks

Listing 11-17: Declaring a structure nonisolated

Listing 11-18: Defining a sendable class

Listing 11-19: Declaring a global variable unsafe

Listing 11-20: Defining an asynchronous sequence

Listing 11-21: Defining a task group

Listing 11-22: Loading an image asynchronously

Listing 11-23: Configuring the image after it is downloaded

TABLE OF CONTENTS

Select Country

Paperback

$ 18.99 BUY NOW

Kindle

$ 6.99 BUY NOW

Apple Books

$ 6.99 BUY NOW

Google Books

$ 6.99 BUY NOW

Information

1st Edition

January 2026

ISBN: 978-1-7779782-9-7