SWPatterns.com

Decorator - Swift

The Decorator pattern dynamically adds responsibilities to an object. It provides a flexible alternative to subclassing for extending functionality. Instead of inheriting from a base class to add features, we wrap the original object with one or more decorator objects, each adding a specific behavior.

This Swift …

Composite - Swift

The Composite pattern allows you to treat individual objects and compositions of objects uniformly. It’s useful for representing hierarchical structures like file systems, organizational charts, or UI elements. In this example, we represent a graphical shape hierarchy where shapes can be primitives (like Circle …

Bridge - Swift

The Bridge pattern is a structural design pattern that lets you split an abstraction from its implementation so that the two can vary independently. It’s useful when you have an abstraction with multiple, potentially varying implementations. This avoids a proliferation of classes caused by combining each …

Adapter - Swift

The Adapter pattern converts the interface of a class into another interface clients expect, letting incompatible classes work together. It’s a structural pattern acting as a wrapper. In this Swift example, we have a JSONData provider that needs to integrate with a UserData display system expecting Dictionary inputs. …

Service Locator - Swift

The Service Locator pattern provides a centralized way to access services within an application. Instead of a component directly creating or locating its dependencies, it asks a “locator” for them. This promotes loose coupling, makes testing easier by allowing dependency injection through the locator, and …

Dependency Injection - Swift

Dependency Injection (DI) is a design pattern that promotes loose coupling by providing dependencies to a class instead of the class creating them itself. This improves testability, maintainability, and reusability. Our Swift example demonstrates DI through initializer injection. The NetworkService protocol defines the …

Lazy Initialization - Swift

The Lazy Initialization pattern delays the initialization of a property until it is first accessed. This improves performance, particularly when initialization is expensive, as it avoids unnecessary computation if the property remains unused. In Swift, this is achieved using the lazy keyword. The property is declared …

Object Pool - Swift

The Object Pool pattern aims to reduce object creation/destruction overhead by maintaining a pool of reusable objects. Instead of creating new instances when needed, the pool provides existing ones, and returns them to the pool when finished. This is especially useful for expensive-to-create objects frequently used and …

Multiton - Swift

The Multiton pattern ensures a restricted number of instances of a class. Unlike a Singleton which allows only one instance, a Multiton allows a small, predefined set. This is useful when you need a few, globally accessible instances representing distinct, but related, states or roles.

This Swift implementation uses a …

Singleton - Swift

The Singleton pattern ensures a class has only one instance and provides a global point of access to it. This is useful for managing shared resources or configurations. In Swift, we achieve this using a static instance property and a private initializer to prevent external instantiation. The example demonstrates a …