Skip to content

Strings in Swift

This tutorial belongs to the Swift series

Strings are one of the most popular tools in programming.

In Swift, a string can be defined using the string literal syntax:

let name = "Roger"

We use double quotes. Single quotes are not valid string delimiters.

A string can span over multiple lines, using 3 double quotes:

let description = """
	a long
      	long description

You can use string interpolation to embed an expression in a string:

let age = 8

let name = """
	Roger, age \(age)
	Next year he will be \(age + 1)

Concatenate two strings with the + operator:

var name = "Roger"
name = name + " The Dog"

Append text to a string with the += operator:

var name = "Roger"
name += " The Dog"

Or using the append(_:) method:

var name = "Roger"
name.append(" The Dog")

You can count the characters in a string using the count string property:

let name = "Roger"
name.count //5

Any string comes with a set of useful methods, for example:

  • removeFirst() to remove the first character
  • removeLast() to remove the last character
  • lowercased() to get a new string, lowercased
  • uppercased() to get a new string, uppercased
  • starts(with:) which returns true if the string starts with a specific substring
  • contains() which returns true if the string contains a specific character

and many, many more.

When you need to reference an item into the string, since strings in Swift are unicode, we can't simply reference the letter o in let name = "Roger" using name[1]. You need to work with indexes.

Any string provides the starting index with the startIndex property:

let name = "Roger"
name.startIndex //0

To calculate a specific index in the string, you calculate it using the index(i:offsetBy:) method:

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
name[i] //"g"

The index can be used also to get a substring:

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
name.suffix(from: i) //"ger"

//Or using the subscript:

name[i...] //"ger"

When you get a substring from a string, the type of the result is Substring, not String.

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
print(type(of: name.suffix(from: i))) 

Substrings are more memory efficient, because you do not get a new string, but the same memory structure is used behind the scenes, although you need to be careful when you deal with strings a lot, as there are optimizations you can implement.

Strings are collections, and they can be iterated over in loops.

→ Download my free Swift Handbook!



You might be interested in those things I do:

  • Learn to code in THE VALLEY OF CODE, your your web development manual
  • Find a ton of Web Development projects to learn modern tech stacks in practice in THE VALLEY OF CODE PRO
  • I wrote 16 books for beginner software developers, DOWNLOAD THEM NOW
  • Every year I organize a hands-on cohort course coding BOOTCAMP to teach you how to build a complex, modern Web Application in practice (next edition February-March-April-May 2024)
  • Learn how to start a solopreneur business on the Internet with SOLO LAB (next edition in 2024)
  • Find me on X

Related posts that talk about swift: