Introduction

Creating a String from NSData in Swift is mostly a matter of using the correct text encoding. The conversion itself is simple; the real source of failure is usually that the bytes do not match the encoding you assumed.

Prefer Data in Modern Swift

Although NSData still exists through Foundation bridging, Swift code usually works with Data. Fortunately, bridging between the two is easy.

If you already have NSData, you can treat it as Data and use Swift’s string initializers.

1import Foundation
2
3let nsData: NSData = "Hello".data(using: .utf8)! as NSData
4let data = nsData as Data
5
6if let text = String(data: data, encoding: .utf8) {
7    print(text)
8}

This is the normal modern approach.

The Core Initializer

The most common initializer is:

String(data: data, encoding: .utf8)

It returns an optional because decoding can fail.

1import Foundation
2
3let bytes = Data([72, 101, 108, 108, 111])
4let text = String(data: bytes, encoding: .utf8)
5
6print(text ?? "decode failed")

If the bytes are valid UTF-8, the result is a string. If not, the initializer returns nil.

The Encoding Must Match the Data

This is the most important rule: the correct initializer can still fail if you choose the wrong encoding.

For example:

1import Foundation
2
3let asciiData: NSData = Data([65, 66, 67]) as NSData
4
5if let text = String(data: asciiData as Data, encoding: .ascii) {
6    print(text)
7}

If the bytes were actually UTF-16, ISO-8859-1, or something else, decoding with .utf8 or .ascii may fail or produce the wrong result.

NSString Also Works, But It Is More Objective-C Style

If you are working in older Cocoa-style code, NSString has an initializer for this as well.

1import Foundation
2
3let nsData: NSData = "Hello".data(using: .utf8)! as NSData
4let text = NSString(data: nsData as Data, encoding: String.Encoding.utf8.rawValue)
5
6print(text ?? "decode failed")

This works, but if you are writing modern Swift, String(data:encoding:) is usually cleaner and more idiomatic.

Binary Data Is Not Always Text

Not every NSData value should become a string. Sometimes the bytes represent:

• an image
• compressed data
• encrypted content
• arbitrary binary protocol data

In those cases, trying to initialize a string is the wrong operation.

If you only need a debug representation, printing hexadecimal is often more honest than pretending the bytes are text.

1import Foundation
2
3let data = Data([0xDE, 0xAD, 0xBE, 0xEF])
4let hex = data.map { String(format: "%02X", $0) }.joined(separator: " ")
5print(hex)

A Small Helper Function

If this conversion happens often, wrap it in one place so the chosen encoding stays explicit.

1import Foundation
2
3func utf8String(from nsData: NSData) -> String? {
4    String(data: nsData as Data, encoding: .utf8)
5}
6
7let payload: NSData = "Swift".data(using: .utf8)! as NSData
8print(utf8String(from: payload) ?? "invalid text")

That also makes it easier to change the decoding rule later if the data source changes.

Common Pitfalls

The biggest mistake is assuming every NSData object contains UTF-8 text. Many byte buffers are not textual at all.

Another mistake is using the wrong encoding. The initializer is correct, but the assumption about the bytes is wrong.

Developers also sometimes treat failure as impossible and force unwrap the result. Because decoding can fail, optional handling is part of the API contract.

Finally, in modern Swift code, prefer Data as your working type unless an API specifically gives you NSData.

Summary

• Convert NSData to Data and use String(data:encoding:) in modern Swift.
• The decoding only succeeds if the chosen encoding matches the actual bytes.
• 'NSString can do the same job, but it is less idiomatic for current Swift code.'
• Not every byte buffer should be interpreted as text.
• Treat decoding failure as normal and handle the optional result explicitly.