BO - Strategy: defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
BO - Observer: defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
SO - Decorator: attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
Factory
CO - Abstract Factory: provide an interface for creating families of related or dependent objects without specifying their concrete classes.
CC - Factory Method: define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to the subclasses.
CO - Singleton: ensure a class only has one instance and provide a global point of access to it.
BO - Command: encapsulates a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
SC - Adapter: converts the interface of a class into another interface clients expect. Lets classes work together that couldn't otherwise because of incompatible interfaces.
SO - Facade: provides a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.
BC - Template Method: define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.
BO - Iterator: provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
SO - Composite: compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
BO - State: allow an object to alter its behavior when its internal state changes. The object will appear to change its class.
SO - Proxy: provide a surrogate or placeholder for another object to control access to it.
XX - Compound: combines two or more patterns into a solution that solves a recurring or general problem.
XX - Model-view-controller: is a software design pattern commonly used for developing user interfaces that divides the related program logic into three interconnected elements.
XX - Anti-Pattern: tells you how to go from a problem to a BAD solution.
SO - Bridge: use the Bridge Pattern to vary not only your implementations, but also your abstractions.
CO - Builder: use the Builder Pattern to encapsulate the construction of a product and allow it to be constructed in steps.
SO - Flyweight: use the Flyweight Pattern when one instance of a class can be used to provide many "virtual instances".
CO - Prototype: use the Prototype pattern when creating an instance of a given class is either expensive or complicated.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent