Swift Extensions

Extensions in Swift allow you to add new functionality to an existing class, structure, enumeration, or protocol type. You can use an extension to extend the behavior of a type without subclassing it.


Here is the basic syntax for declaring an extension in Swift:

1extension Type { 2 // new functionality to add to Type goes here 3}

Here, Type can be any valid class, structure, enumeration, or protocol type.


Let's see an example of how to use an extension to add new functionality to an existing class:

1// Define the original class 2class MyClass { 3 var myProperty: String 4 5 init(property: String) { 6 myProperty = property 7 } 8} 9 10// Define an extension 11extension MyClass { 12 func myMethod() { 13 print("My property is \(myProperty)") 14 } 15} 16 17// Create an instance of MyClass 18let myObject = MyClass(property: "Hello, world!") 19 20// Call the extension method 21myObject.myMethod() // Output: My property is Hello, world!

In this example, we have defined a new method called myMethod in an extension for the class MyClass. This method can be called on any instance of MyClass.

Extensions for Protocols

You can also use extensions to add new functionality to a protocol type. This can be useful when you want to add default behavior to a protocol that all conforming types can use.

Here is an example of extending the CustomStringConvertible protocol:

1extension CustomStringConvertible { 2 var description: String { 3 return "This is a custom description." 4 } 5} 6 7// Create an object that conforms to CustomStringConvertible 8class MyClass: CustomStringConvertible { 9 var myProperty: String 10 11 init(property: String) { 12 myProperty = property 13 } 14} 15 16let myObject = MyClass(property: "Hello, world!") 17print(myObject.description) // Output: This is a custom description.

In this example, we have extended the CustomStringConvertible protocol to add a default implementation for the description property. Then we have created a class MyClass that conforms to this protocol and can use the default implementation.


Extensions have some limitations in Swift. Here are a few things to keep in mind:

  • You cannot add stored properties to an existing type using an extension. You can only add computed properties or methods.
  • You cannot override existing methods or properties using an extension. If you need to change the behavior of an existing type, you will need to subclass it instead.


Extensions in Swift are a powerful tool that allow you to add new functionality to existing types. They can be used to extend classes, structures, enumerations, or protocol types. By understanding how to use extensions, you can write more modular and reusable code.