# Strings in Swift

> Learn how to work with strings in Swift, including string literals, multi-line strings, interpolation, and concatenation, with beginner-friendly examples.

Author: Flavio Copes | Published: 2021-06-01 | Canonical: https://flaviocopes.com/swift-strings/

> This tutorial belongs to the [Swift](https://flaviocopes.com/swift-introduction/) series

Strings are one of the most popular tools in programming.

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

```swift
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:

```swift
let description = """
	a long
  	long 
      	long description
	"""
```

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

```swift
let age = 8

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

Concatenate two strings with the `+` operator:

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

Append text to a string with the `+=` operator:

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

Or using the `append(_:)` method:

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

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

```swift
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:

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

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

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

The index can be used also to get a substring:

```swift
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`.

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

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.