Converting Swift Array to String: A Complete Guide for Beginners

How to Convert Swift Array to String? Full Tutorial with Examples

Hello, future iOS developer! If you've ever wondered "How do I convert a Swift Array to a String?" — you're not alone. This question has gathered thousands of views on Stack Overflow, and today we'll settle it once and for all. Why is this needed? Imagine: you're collecting data from a form, logging errors, or preparing text to send to a server. In all these cases, you need to turn an array into a readable string. Let's go!

The Simplest Way: The joined() Method

In Swift, to combine an array of strings into a single string, use the joined() method. This is the shortest path from an array to a string. Take a look at the basic example:

let fruits = ["Apple", "Banana", "Orange"]\nlet fruitsString = fruits.joined()\nprint(fruitsString) // Output: "AppleBananaOrange"

However, the result looks clumped together. To make the string readable, use joined(separator:) — it adds a separator between elements:

let fruits = ["Apple", "Banana", "Orange"]\nlet fruitsString = fruits.joined(separator: ", ")\nprint(fruitsString) // Output: "Apple, Banana, Orange"

Important: joined() works only with arrays containing strings ([String]). If you have an array of numbers or other types, you first need to convert each element.

The Universal Method: map() + joined()

What do you do if you have an array of integers ([Int]), floating-point numbers ([Double]), or, say, custom structures? The map() method comes to the rescue. This method transforms each element according to a given rule, and then we combine the result:

let numbers = [1, 2, 3, 4, 5]\nlet numbersString = numbers.map { String($0) }.joined(separator: ", ")\nprint(numbersString) // Output: "1, 2, 3, 4, 5"

Here, map { String($0) } turns each number into a string. After that, the array of strings is easily combined using joined().

Example with Complex Objects

Let's say you have an array of users, and you need to get a string with their names:

struct User {\n    let name: String\n    let age: Int\n}\n\nlet users: [User] = [\n    User(name: "Anna", age: 25),\n    User(name: "Boris", age: 30),\n    User(name: "Victoria", age: 28)\n]\n\nlet namesString = users.map { $0.name }.joined(separator: ", ")\nprint(namesString) // Output: "Anna, Boris, Victoria"

The Advanced Way: reduce(into:)

The reduce(into:) method is a more flexible tool. It allows you to build a string with full control over the process. For example, you can add a prefix, suffix, or number the elements:

let colors = ["Red", "Green", "Blue"]\nlet result = colors.reduce(into: "My colors: ") { (partialResult, color) in\n    partialResult += color + ", "\n}\n// Remove the last ", " if needed\nlet finalString = String(result.dropLast(2))\nprint(finalString) // Output: "My colors: Red, Green, Blue"

Note: we manually remove the last two characters (comma and space). This makes the code less elegant than joined(), but reduce is indispensable when complex assembly logic is needed.

Handling Optional Values (Optionals)

In real projects, arrays often contain nil. If you simply call joined(), the compiler will throw an error. The solution is to filter out nil using compactMap():

let optionalStrings: [String?] = ["Hello", nil, "World", nil, "Swift"]\nlet safeString = optionalStrings.compactMap { $0 }.joined(separator: " ")\nprint(safeString) // Output: "Hello World Swift"

compactMap { $0 } automatically discards all nil values and returns