SWPatterns.com

Decorator - PHP

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 responsibility. This …

Composite - PHP

The Composite pattern allows you to treat individual objects and compositions of objects uniformly. It’s useful when you have hierarchical structures where you want to perform the same operation on both individual elements and groups of elements. Here, we represent a file system structure, with files and …

Bridge - PHP

The Bridge pattern is a structural design pattern that lets you split an abstraction from its implementation so that objects can have different implementations. This is useful when you want to avoid a tight coupling between abstract and concrete classes, allowing you to change implementations independently without …

Adapter - PHP

The Adapter pattern converts the interface of a class into another interface clients expect. This allows classes with incompatible interfaces to collaborate. Here, we adapt a legacy LegacyRectangle class (providing area calculation in a specific, older format) to the Shape interface (a more modern, consistent …

Service Locator - PHP

The Service Locator is a design pattern that centralizes the retrieval of dependencies (services) for an application. Instead of a component directly creating or locating its dependencies, it asks the Service Locator for them. This promotes loose coupling and makes it easier to substitute different implementations of …

Dependency Injection - PHP

Dependency Injection (DI) is a design pattern where a class receives its dependencies from external sources rather than creating them itself. This promotes loose coupling, making the class more testable, reusable, and maintainable. Our example demonstrates Constructor Injection, a common DI technique. The …

Lazy Initialization - PHP

The Lazy Initialization pattern delays the creation of an expensive object until its first use. This improves performance by avoiding unnecessary object creation if the object’s methods are never called. The provided PHP code implements this using a private static property to hold the instance and a public static …

Object Pool - PHP

The Object Pool pattern manages a group of reusable objects, reducing the performance overhead of frequent object creation and destruction. Instead of creating a new object each time one is needed, the pool provides a pre-instantiated object from its collection. When the object is no longer needed, it’s returned to the …

Multiton - PHP

The Multiton pattern ensures a restricted number of instances of a class are created, and provides a global access point to these instances. It’s a variation of the Singleton pattern, allowing for more than one instance but still controlling instantiation. This implementation uses a static array to store the …

Singleton - PHP

The Singleton pattern ensures a class has only one instance and provides a global point of access to it. This is useful for managing resources that should only exist once, like database connections or configuration settings. The PHP implementation utilizes a static method getInstance() to control instance creation, …