SWPatterns.com

Mediator - Swift

The Mediator pattern defines an object that encapsulates how a set of objects interact. This promotes loose coupling by having objects communicate through the mediator, rather than directly with each other. This makes it easier to change the objects’ interactions without modifying those objects themselves.

In …

Iterator - Swift

The Iterator pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. It defines an interface for traversing a collection, allowing you to add new iterators without modifying the collection itself. This example utilizes Swift’s built-in …

Interpreter - Swift

The Interpreter pattern defines a way to evaluate a language, usually a simple one, by defining a class for each expression in the language. This allows for the building of more complex expressions by composing simpler ones. The code implements a basic arithmetic expression interpreter that can evaluate addition and …

Command - Swift

The Command pattern encapsulates a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations. This implementation uses a protocol to define the command interface, with concrete commands implementing specific actions on a receiver …

Chain of Responsibility - Swift

The Chain of Responsibility pattern is a behavioral design pattern that allows you to pass a request along a chain of handlers. Each handler decides either to process the request or to pass it to the next handler in the chain. This allows you to avoid coupling the sender of a request to its receiver, giving multiple …

Extension Object - Swift

The Extension Object pattern allows you to add functionality to an existing class without subclassing or using categories (as in Objective-C). It achieves this by creating a separate object that encapsulates the new behavior and holds an instance of the original class. The original class remains untouched, adhering to …

Module - Swift

The Module Pattern is a way to encapsulate related functionality within a single object, exposing only a public API while hiding internal implementation details. This promotes code organization, prevents naming conflicts, and enhances maintainability. In Swift, this is naturally achieved using modules (files) and …

Proxy - Swift

The Proxy pattern provides a surrogate or placeholder for another object to control access to it. This is useful for adding security, logging, or other cross-cutting concerns without modifying the original object. The proxy has the same interface as the real object, allowing clients to interact with it transparently. …

Flyweight - Swift

The Flyweight pattern aims to minimize memory usage by sharing as much data as possible between similar objects. It separates the object’s state into intrinsic (shared) and extrinsic (unique) components. Intrinsic state is stored in the flyweight object, while extrinsic state is passed to the flyweight as …

Facade - Swift

The Facade pattern provides a simplified interface to a complex subsystem. It defines a high-level interface that hides the intricacies of the underlying components, making the system easier to use. This example demonstrates a Facade for ordering a pizza. The PizzaOrderFacade encapsulates the interactions with the …