Chapters
Chapters

Chapters

Hide chapters

Swift Apprentice: Fundamentals

Second Edition · iOS 18 · Swift 6 · Xcode 16.2

Before You Begin

Section 0: 6 chapters
Show chapters Hide chapters

Section I: Swift Basics

Section 1: 6 chapters
Show chapters Hide chapters

Section II: Collection Types

Section 2: 4 chapters
Show chapters Hide chapters

Section III: Building Your Own Types

Section 3: 9 chapters
Show chapters Hide chapters

13. Methods
Written by Eli Ganim

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

In Chapter 12, “Properties”, you learned about properties, constants and variables that are part of structures. Methods, as you’ve already seen, are functions that reside inside a structure.

In this chapter, you’ll take a closer look at methods and initializers. As with properties, you’ll begin to design more complex structures. The things you learn in this chapter will apply to methods across all named types, including classes and enumerations, which you’ll see in later chapters.

Method Refresher

Remember Array.removeLast()? It pops the last item off an instance of an array:

var numbers = [1, 2, 3]
numbers.removeLast()
numbers // [1, 2]

1 2 3

Methods like removeLast() help you control the data in the structure.

Comparing Methods to Computed Properties

With computed properties, you saw in Chapter 12, “Properties”, that you could run code from inside a structure. That sounds a lot like a method. What’s the difference? It comes down to style, but there are a few helpful thoughts to help you decide. Properties hold values that you can get and set while methods perform work. Sometimes this distinction gets fuzzy when a method’s sole purpose is to return a single value.

Xaad i zuhlek? Riy Pifhucip Nxidetjw. Ukvevxozu redyinudaut ev NV ovresv? Cu Tim Necwed. De Qiwtidab Bpotecgy. Wdeezc E atkcoqurt jxaj rujii teclix im i haktum ic ap i dovpetoc mxodijhc?

Turning a Function Into a Method

To explore methods and initializers, you will create a simple model for dates called SimpleDate. Be aware that Apple’s Foundation framework contains a robust, production-ready Date class that correctly handles all of the subtle intricacies of dealing with dates and times. For learning purposes, though, we’ll explore how you might construct SimpleDate to be useful in many contexts.

Introducing self

You already saw Self (spelled with an uppercase S) in Chapter 12, “Properties”, as a way to access static properties from inside a struct. Now we look at lowercase self. A structure definition (uppercase first letter) is like a blueprint, whereas an instance (lowercase first letter) is a real object. To access the value of an instance, you use the keyword self inside the structure. The Swift compiler passes it into your method as a secret parameter.

Mini-Exercise

Since monthsUntilWinterBreak() returns a single value and there’s not much calculation involved, transform the method into a computed property with a getter component.

Introducing Initializers

You learned about initializers in Chapter 11, “Structures”, and Chapter 12, “Properties”, but let’s look at them again with your newfound knowledge of methods.

Initializers in Structures

Add a day property to SimpleDate:

Default Values and Initializers

There is a more straightforward way to make a no-argument initializer.

Introducing Mutating Methods

Methods in structures cannot change the values of the instance without being marked as mutating. You can imagine a method in the SimpleDate structure that advances to the next day:

Type Methods

Like type properties, you can use type methods to access data across all instances. You call type methods on the type itself instead of on an instance. To define a type method, you prefix it with the static modifier.

1! 0 y 1 f 6 l 1 r 6 l 4 }

Mini-Exercise

Add a type method to the Math structure that calculates the n-th triangle number. It will be very similar to the factorial formula, except instead of multiplying the numbers, you add them.

Adding to an Existing Structure With Extensions

Sometimes you want to add functionality to a structure but don’t want to muddy up the original definition. And sometimes, you can’t add the functionality because you don’t have access to the source code.

Keeping the Compiler-generated Initializer Using Extensions

With the SimpleDate structure, you saw that once you added your own init(), the compiler-generated one disappeared. You can keep both if you add your init() to an extension to SimpleDate. The code looks like this:

Challenges

Before moving on, here are some challenges to test your knowledge of methods. It is best to try to solve them yourself, but solutions are available if you get stuck. These came with the download or are available at the printed book’s source code link listed in the introduction.

Challenge 1: Grow a Circle

Given the Circle structure below:

Challenge 2: A More Advanced advance()

Here is a naïve way of writing advance() for the SimpleDate structure you saw earlier in the chapter:

Challenge 3: Odd and Even Math

Add type methods named isEven and isOdd to your Math namespace that return true if a number is even or odd, respectively.

Challenge 4: Odd and Even Int

It turns out that Int is simply a struct. Add the computed properties isEven and isOdd to Int using an extension.

Challenge 5: Prime Factors

Add the method primeFactors() to Int. Since this is an expensive operation, this is best left as an actual method and not a computed property.

Key Points

  • Methods are functions associated with a type.
  • Methods are the behaviors that define the functionality of a type.
  • A method can access the data of an instance by using the keyword self.
  • Initializers create new instances of a type. They look like functions called init without the func keyword and no return value.
  • A type method adds behavior to a type instead of the instances of that type. To define a type method, you prefix it with the static modifier.
  • You can open an existing structure and add methods, initializers and computed properties to it by using an extension.
  • Adding custom initializers as extensions allows you to keep the compiler-generated memberwise initializer.
  • Methods can exist in all the named types — structures, classes and enumerations.
12. Properties
14. Classes
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2026 Kodeco Inc.

You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now