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

9. Strings
Written by Matt Galloway

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

So far, you have briefly seen what the type String has to offer for representing text. Text is a ubiquitous data type: people’s names, addresses and the words of a book. These are examples of text that an app might need to handle. It’s worth having a deeper understanding of how String works and what it can do.

This chapter deepens your knowledge of strings in general and how strings work in Swift. Swift is one of the few languages that handle Unicode characters correctly while maintaining maximum predictable performance.

Strings as Collections

In Chapter 2, “Types & Operations”, you learned what a string is, and what character sets and code points are. To recap, they define the mapping numbers to the character it represents. And now, it’s time to look deeper into the String type.

It’s pretty easy to conceptualize a string as a collection of characters. Because strings are collections, you can do things like this:

let string = "Matt"
for char in string {
  print(char)
}

This code will print out every character of Matt individually. Simple, eh?

You can also use other collection operations, such as:

let stringLength = string.count

This assignment will give you the length of the string.

Now imagine you want to get the fourth character in the string. You may think of doing something like this:

let fourthChar = string[3]

However, if you did this, you would receive the following error message:

'subscript' is unavailable: cannot subscript String with an Int, use a String.Index instead.

Why is that? The short answer is that characters do not have a fixed size, so you can’t access them like an array. Why not? It’s time to take a detour further into how strings work by introducing what a grapheme cluster is.

Grapheme Clusters

As you know, a string is made up of a collection of Unicode characters. Until now, you have considered one code point to precisely equal one character and vice versa. However, the term “character” is relatively loose.

é a ́ 502 797 751

👍 🏽 196776 034011 👍🏽

Indexing Strings

Swift doesn’t allow you to get a specific character (err, I mean grapheme cluster) using an integer subscript. While it’s certainly possible to write a function to do this, there are good reasons for the standard library not providing it. The first reason is correctness – Characters are variable in size and cannot be accessed using constant offsets. Swift also wants to prevent you from inadvertently writing inefficient, battery-draining string-processing code. You might not see problems with small strings, but performance would be unacceptable with larger strings. Indexing into a string would take linear time to find the Character at a certain integer index.

Mini-Exercises

  1. Create a string called name and set it to be equal to your name. Then extract the sixth character into a constant called sixthChar.
  2. Write a for-loop to iterate through the individual characters of name and print out the unicode code points of each character. Hint: Use the unicodeScalars property of Character to get an array of all the code points in the character.
  3. Add some combining characters to your name to check your printing of all code points for each character is working correctly. Hint: \u{0302} and \u{0308} are examples of combining characters.

Equality With Combining Characters

Combining characters make the equality of strings a little trickier. For example, consider the word café written once using the single é character, and once using the combining character, like so:

p a t é 29 73 361 457 c a b e 26 91 891 736 ́ 660

Strings as Bi-directional Collections

Sometimes you want to reverse a string. Often this is so you can iterate through it backward. Fortunately, Swift has a rather simple way to do this, through a method called reversed() like so:

Raw Strings

A raw string is useful when you want to avoid special characters or string interpolation. Instead, the complete string as you type it is what becomes the string. To illustrate this, consider the following raw string:

Substrings

Another thing you often need to do when manipulating strings is to generate substrings. That is, pull out a part of the string into its own value. Swift can do this using a subscript that takes a range of indices.

Mini-exercises

  1. Write a function called nameLength which takes a string and returns a tuple containing the length of the first name and the length of the last name. Hint: Use String’s distance(from:to:) function to calculate a distance between two String.Index values.

Character Properties

You encountered the Character type earlier in this chapter. Some rather interesting properties of this type allow you to introspect the character in question and learn about its semantics.

Mini-exercises

  1. Write a for-loop to iterate over a string and print out for each character what type of character it is.

Encoding

So far, you’ve learned what strings are and explored how to work with them but haven’t touched on how strings are stored or encoded.

UTF-8

A much more common scheme is called UTF-8. This encoding uses 8-bit code units instead. One reason for UTF-8’s popularity is that it is fully compatible with the venerable, English-only, 7-bit ASCII encoding. But how do you store code points that need more than eight bits?! Herein lies the magic of the encoding.

3 4 5 8 5 3 6 8 7 7 9 2 8 4 2 2

0 Q B R N J T N 5 5 0 H W B F M 2 2 9 6 S V W M 1 9 7 5 4 B V Y 1 3 N S P W N J 9 8 V D Y D N T 1 6 K D C N Q H 5 7 H X W K D B 8 0 T B Z L Y M 0 5 C L R D P B

UTF-16

There is another encoding that is useful to introduce, namely UTF-16. Yes, you guessed it. It uses 16-bit code units!

Converting Indexes Between Encoding Views

As you saw earlier, you use indexes to access grapheme clusters in a string. For example, using the same string from above, you can do the following:

Challenges

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

Challenge 1: Character Count

Write a function that takes a string and prints out the count of each character in the string. For bonus points, print them ordered by the count of each character. For bonus-bonus points, print it as a nice histogram.

Challenge 2: Word Count

Write a function that tells you how many words there are in a string. Do it without splitting the string.

Challenge 3: Name Formatter

Write a function that takes a string that looks like “Galloway, Matt” and returns one which looks like “Matt Galloway”, i.e., the string goes from "<LAST_NAME>, <FIRST_NAME>" to "<FIRST_NAME> <LAST_NAME>".

Challenge 4: Components

A method exists on a string named components(separatedBy:) that will split the string into chunks, which are delimited by the given string, and return an array containing the results.

Challenge 5: Word Reverser

Write a function that takes a string and returns a version of it with each individual word reversed.

Key Points

  • Strings are collections of Character types.
  • A Character is grapheme cluster and is made up of one or more code points.
  • A combining character is a character that alters the previous character in some way.
  • You use special (non-integer) indexes to subscript into the string to a certain grapheme cluster.
  • Swift’s use of canonicalization ensures that the comparison of strings accounts for combining characters.
  • Slicing a string yields a substring with the type Substring, which shares storage with its parent String.
  • You can convert from a Substring to a String by initializing a new String and passing the Substring.
  • Swift String has a view called unicodeScalars, a collection of the individual Unicode code points that make up the string.
  • There are multiple ways to encode a string. UTF-8 and UTF-16 are the most popular.
  • The individual parts of an encoding are called code units. UTF-8 uses 8-bit code units, and UTF-16 uses 16-bit code units.
  • Swift’s String has views called utf8 and utf16that are collections that allow you to obtain the individual code units in the given encoding.
8. Collection Iteration With Closures
10. Regex
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