Buzz Lightyear shipped with a laser and retractable wings. But what if you wanted to give him a jetpack, a grappling hook, or a karaoke mode — without rebuilding him from scratch? In Swift, extensions let you bolt new functionality onto any existing type, even types you didn’t write.

In this guide, you’ll learn how to add methods, computed properties, and protocol conformances through extensions. We won’t cover protocol extensions with default implementations — that’s covered in Protocols in Swift.

What You’ll Learn

• What Are Extensions?
• Adding Methods
• Computed Properties
• Protocol Conformances via Extension
• Extending Types You Don’t Own
• Common Mistakes
• What’s Next?

What Are Extensions?

An extension adds new functionality to an existing type — a struct, class, enum, or even a protocol. You don’t need access to the type’s original source code. The new capabilities become available on every instance of that type, just as if they were part of the original definition.

Think of it like upgrading Buzz Lightyear. You can’t go back in time and redesign him at the Pixar factory, but you can attach new gadgets to the existing toy. Extensions work the same way — they add to what’s already there without changing the original blueprint.

You write an extension with the extension keyword followed by the type name:

extension String {
    // new capabilities go here
}

Apple Docs: Extensions — The Swift Programming Language

Adding Methods

The most common use of extensions is adding new methods to existing types. Here’s an extension that gives every String a shout() method:

extension String {
    func shout() -> String {
        return self.uppercased() + "!!!"
    }
}

let catchphrase = "to infinity and beyond"
print(catchphrase.shout())

TO INFINITY AND BEYOND!!!

The method is now available on every String in your project. You can also add methods to your own types:

struct ToyBox {
    var toys: [String]
}

extension ToyBox {
    func roll() {
        print("Rolling call: \(toys.joined(separator: ", "))")
    }
}

let andysBox = ToyBox(toys: ["Woody", "Buzz", "Rex"])
andysBox.roll()

Rolling call: Woody, Buzz, Rex

Tip: Extensions are great for organizing code. You can group related methods in separate extensions, keeping each one focused on a single responsibility.

Computed Properties

Extensions can add computed properties — properties that calculate a value on the fly rather than storing it.

extension Double {
    var minutes: Double { self * 60 }
    var hours: Double { self * 3600 }
}

let movieLength = 1.5
print("\(movieLength) hours = \(movieLength.hours) seconds")

1.5 hours = 5400.0 seconds

This makes numeric conversions read naturally. Here’s another example with Int:

extension Int {
    var asMovieRating: String {
        switch self {
        case 1...3: return "⭐ Skip it"
        case 4...6: return "⭐⭐ Decent"
        case 7...8: return "⭐⭐⭐ Great"
        case 9...10: return "⭐⭐⭐⭐ Pixar-level!"
        default: return "Not rated"
        }
    }
}

let rating = 9
print("Inside Out 2: \(rating.asMovieRating)")

Inside Out 2: ⭐⭐⭐⭐ Pixar-level!

Warning: Extensions cannot add stored properties. You can only add computed properties — ones that calculate their value from existing data. If you need to store new data, you’ll need to modify the original type definition.

Protocol Conformances via Extension

One of the most powerful uses of extensions is making an existing type conform to a new protocol. This keeps your conformance code separate from your model code, making both easier to read.

struct Movie {
    let title: String
    let year: Int
}

extension Movie: CustomStringConvertible {
    var description: String {
        "\(title) (\(year))"
    }
}

let movie = Movie(title: "Coco", year: 2017)
print(movie)

Coco (2017)

Without the extension, print(movie) would show something like Movie(title: "Coco", year: 2017). By conforming to CustomStringConvertible in an extension, you get a clean display string.

This pattern is especially useful when a type conforms to multiple protocols — you can organize each conformance in its own extension:

extension Movie: Equatable {
    static func == (lhs: Movie, rhs: Movie) -> Bool {
        lhs.title == rhs.title && lhs.year == rhs.year
    }
}

let a = Movie(title: "Up", year: 2009)
let b = Movie(title: "Up", year: 2009)
print(a == b)

true

Tip: Organizing protocol conformances into separate extensions is a widely used Swift convention. It keeps your code clean and makes each conformance easy to find.

Extending Types You Don’t Own

Extensions truly shine when you add functionality to types from the Swift standard library or other frameworks — types whose source code you can’t modify.

extension Array where Element == String {
    func asCredits() -> String {
        "Starring: " + self.joined(separator: ", ")
    }
}

let cast = ["Woody", "Buzz", "Jessie"]
print(cast.asCredits())

Starring: Woody, Buzz, Jessie

You can also extend Foundation types:

extension Int {
    var isEven: Bool { self % 2 == 0 }
}

let toyCount = 6
print("Even number of toys? \(toyCount.isEven)")

Even number of toys? true

Note: When you add a protocol conformance to a type you don’t own (like making Array conform to a custom protocol), this is called retroactive conformance. Use it carefully — if a future Swift update adds the same conformance, you’ll get a conflict.

Common Mistakes

Trying to Add a Stored Property in an Extension

Extensions cannot add stored properties — only computed ones:

// ❌ Compile error: extensions must not contain
// stored properties
// extension Movie {
//     var isFavorite: Bool = false
// }

// ✅ Use a computed property instead
extension Movie {
    var isClassic: Bool {
        year < 2000
    }
}

let toyStory = Movie(title: "Toy Story", year: 1995)
print("\(toyStory.title) is classic? \(toyStory.isClassic)")

Toy Story is classic? true

If you truly need to store new data, add the property to the original type definition instead.

Dumping Everything into One Giant Extension

// ❌ One extension doing everything — hard to navigate
// extension Movie {
//     var description: String { ... }
//     static func == (...) { ... }
//     func toJSON() -> String { ... }
//     var isClassic: Bool { ... }
// }

// ✅ Group by responsibility or protocol conformance
extension Movie: CustomStringConvertible {
    // description goes here
}

extension Movie: Equatable {
    // equality logic goes here
}

extension Movie {
    // utility methods go here
}

Organizing by protocol conformance makes each extension focused and easy to find when your codebase grows.

What’s Next?

• Extensions add new methods, computed properties, and protocol conformances to existing types.
• You can extend types you didn’t write, including Swift standard library types.
• Extensions cannot add stored properties — only computed ones.
• Organize extensions by responsibility — one per protocol conformance is a clean pattern.
• Use extensions to keep your type definitions lean and your conformances separate.

Things don’t always go according to plan — network calls fail, files go missing, and users do unexpected things. Head to Error Handling in Swift to learn how Swift helps you handle failures gracefully with do, try, and catch.

Related Posts

• Protocols in Swift
• Error Handling in Swift