Chain of Responsibility pattern chains the steps of processing and performs the process step by step. So the processing does not depend on a single object, but multiple objects are responsible for the processing, which is decided on the fly while processing. This article demonstrates Chain of Responsibility pattern implementations in Golang.
Proxy pattern represents remote objects locally, this way the local object is used as a proxy of the remote object. The local one can be used in all cases where the remote object is required. The local object can also add some additional functionality/checking while referring to the remote object. This article demonstrates Proxy pattern implementations in Golang.
Flyweight pattern uses a shared object for multiple object generation, which has some common criteria, then populates the different properties while using that object. Using the shared object for generating multiple object output, saves resources and memory usage. This article demonstrates Flyweight pattern implementations in GoLang.
Facade pattern adds a new layer on top of any complex subsystem. That way the client does not need to know all the complexity while using the implementation. Facade not necessarily covers all the functionality of the subsystems, only the required functionalities are covered. This article demonstrates Facade pattern implementations in GoLang.
Decorator pattern add new functionality to an existing implementation by adding a new layer. The responsibility/functionality is added to individual objects. This article demonstrates Decorator pattern implementations in Go.
Using Composite pattern we can make an object and a group of objects, behave the same way. The client will not know any difference between an object and object group/list while using it. This article demonstrates Composite pattern implementations in GoLang.
Bridge pattern is used to provide flexibility to an implementation, that has frequent changes in the implementation. Bridge pattern archives that by decoupling implementation and abstraction. This article demonstrates Bridge pattern implementation in Go.
Adapter pattern helps by enabling an interface to adapt to a new interface. This is useful when we have an existing interface, and some new requirement comes or we need to adapt to some interface that is developed separately. By following the Open/Closed principle, the adapter pattern keeps the existing interface as is, ads the adapter implementation as a bridge to then new interface. This article demonstrates Adapter pattern implementations in Go.
Prototype pattern clones an existing object to create a new object, instead of building a new object at runtime. This helps reduce resource usage, as the complex object creation/initiation process is replaced with cloning existing objects. This is very useful for keeping object cached and/or default object. This article demonstrates Prototype pattern implementations in Go.
This article demonstrates the Abstract factory pattern in Go. Abstract factory pattern is used to generate the class factories, which in turn will generate item objects.