Стратегия - это шаблон поведенческого проектирования, который превращает набор поведений в объекты и делает их взаимозаменяемыми внутри исходного объекта контекста.
Исходный объект, называемый контекстом, содержит ссылку на объект стратегии и делегирует это выполнение поведения. Чтобы изменить способ, которым контекст выполняет свою работу, другие объекты могут заменить текущий связанный объект стратегии другим.
Примеры использования: Шаблон стратегии имеет вид очень часто встречается в коде TypeScript. Он часто используется в различных средах, чтобы предоставить пользователям способ изменить поведение класса, не расширяя его.
Идентификация: Шаблон стратегии можно распознать с помощью метода, который позволяет вкладывать объект выполняет фактическую работу, а также установщик, который позволяет заменить этот объект другим.
Концептуальный пример Этот пример иллюстрирует структуру шаблона разработки Стратегии. Он сфокусирован на ответе на следующие вопросы: • Из каких классов он состоит? • Какие роли играют эти классы? • Каким образом связаны элементы шаблона?
index.ts: Концептуальный пример
/**
* The Context defines the interface of interest to clients.
*/
class Context {
/**
* @type {Strategy} The Context maintains a reference to one of the Strategy
* objects. The Context does not know the concrete class of a strategy. It
* should work with all strategies via the Strategy interface.
*/
private strategy: Strategy;
/**
* Usually, the Context accepts a strategy through the constructor, but also
* provides a setter to change it at runtime.
*/
constructor(strategy: Strategy) {
this.strategy = strategy;
}
/**
* Usually, the Context allows replacing a Strategy object at runtime.
*/
public setStrategy(strategy: Strategy) {
this.strategy = strategy;
}
/**
* The Context delegates some work to the Strategy object instead of
* implementing multiple versions of the algorithm on its own.
*/
public doSomeBusinessLogic(): void {
// ...
console.log('Context: Sorting data using the strategy (not sure how it\'ll do it)');
const result = this.strategy.doAlgorithm(['a', 'b', 'c', 'd', 'e']);
console.log(result.join(','));
// ...
}
}
/**
* The Strategy interface declares operations common to all supported versions
* of some algorithm.
*
* The Context uses this interface to call the algorithm defined by Concrete
* Strategies.
*/
interface Strategy {
doAlgorithm(data: string[]): string[];
}
/**
* Concrete Strategies implement the algorithm while following the base Strategy
* interface. The interface makes them interchangeable in the Context.
*/
class ConcreteStrategyA implements Strategy {
public doAlgorithm(data: string[]): string[] {
return data.sort();
}
}
class ConcreteStrategyB implements Strategy {
public doAlgorithm(data: string[]): string[] {
return data.reverse();
}
}
/**
* The client code picks a concrete strategy and passes it to the context. The
* client should be aware of the differences between strategies in order to make
* the right choice.
*/
const context = new Context(new ConcreteStrategyA());
console.log('Client: Strategy is set to normal sorting.');
context.doSomeBusinessLogic();
console.log('');
console.log('Client: Strategy is set to reverse sorting.');
context.setStrategy(new ConcreteStrategyB());
context.doSomeBusinessLogic();
Output.txt: Результат выполнения
Client: Strategy is set to normal sorting.
Context: Sorting data using the strategy (not sure how it'll do it)
a,b,c,d,e
Client: Strategy is set to reverse sorting.
Context: Sorting data using the strategy (not sure how it'll do it)
e,d,c,b,a