系统学习做汉堡

by Sihui Huang

黄思慧

您如何学习策略设计模式？ 做一个汉堡！ (How can you learn the Strategy Design Pattern? Make a hamburger!)

Do you know how to order a burger?

你知道如何点汉堡吗？

If so, I have good news for you. Then you know how to use one of the most commonly used design patterns, strategy pattern!

如果是这样，我对你有个好消息。 然后，您知道如何使用最常用的设计模式之一，即策略模式 ！

“How so?” you might ask. Well, let’s take a look at the features of strategy pattern.

“为何如此？” 你可能会问。 好吧，让我们看一下策略模式的功能。

• It defines a family of algorithms.它定义了一系列算法。
• It encapsulates each algorithm.它封装了每种算法。
• It makes the algorithms interchangeable within that family.它使算法在该系列中可以互换。

Strategy pattern lets the algorithm vary independently from clients that use it.

策略模式使算法可以独立于使用该算法的客户端而变化。

How does this have anything to do with burgers?

这与汉堡有什么关系？

Let’s think about burgers for a second.

让我们考虑一下汉堡。

There are many varieties of burgers: veggie burger, cheeseburger, grilled chicken burger, and double cheeseburger to name a few. All of them share the same format: the top bun + patty + bottom bun.

汉堡的种类很多：素食汉堡，芝士汉堡，烤鸡肉汉堡和双层芝士汉堡。 它们都共享相同的格式：顶部面包+小馅饼+底部面包。

It’s the patty that makes each burger different. A cheeseburger has cheese and a beef patty in the middle, whereas a grilled chicken burger has a grilled chicken breast patty.

是使每个汉堡与众不同的肉饼。 芝士汉堡的中间是奶酪和牛肉饼，而烤鸡肉汉堡的是烤鸡胸肉饼。

Let’s recap the strategy pattern definition in terms of burgers. What is the family of algorithms in terms of burgers? It’s the family of different patties:

让我们来回顾一下汉堡的战略模式定义。 关于汉堡的算法家族是什么？ 这是不同馅饼的家族：

• patty for a chicken burger = [grilled chicken breast]鸡肉汉堡小馅饼= [烤鸡胸肉]
• patty for a cheeseburger = [cheese + beef patty]芝士汉堡小馅饼= [奶酪+牛肉小馅饼]
• patty for a double cheeseburger = [cheese + beef patty + cheese + beef patty]双芝士汉堡的肉饼= [奶酪+牛肉饼+奶酪+牛肉饼]

They are encapsulated and interchangeable with each other. Swap out the chicken burger patty with the cheeseburger patty, and you get a cheeseburger.

它们被封装并且可以互换。 将鸡肉汉堡肉饼和芝士汉堡肉饼交换掉，您会得到一个芝士汉堡。

Strategy lets the algorithm vary independently from clients that use it.

策略使算法独立于使用该算法的客户端而变化。

You can order any burger you like. But for a chef, making a burger follows the same general procedure: prepare the bun, cook the patty, and then put the patty in-between the top and bottom buns.

您可以订购任何喜欢的汉堡。 但是对于厨师来说，制作汉堡的过程与一般相同：准备面包，煮小馅饼，然后将小馅饼放在上下面包之间。

A burger is a real-life example of using strategy pattern.

汉堡是使用策略模式的真实示例。

Let’s take a look at the code.

让我们看一下代码。

There are three participants in the strategy pattern.

该策略模式有三个参与者。

Strategy declares an interface common to all supported algorithms. Context uses this interface to call the algorithm defined by a concrete strategy.

策略声明了所有支持的算法通用的接口。 上下文使用此接口来调用由具体策略定义的算法。

Concrete strategy implements the algorithm using the StrategyInterface.

具体策略使用StrategyInterface实现算法。

Context is configured with a ConcreteStrategy Object; maintains a reference to a strategy object; may define an interface that lets strategy access its data.

上下文是用ConcreteStrategy对象配置的； 维护对策略对象的引用； 可以定义一个接口，让策略访问其数据。

GrilledChickenStuffing and BeefPattyStuffing are our concrete strategies. Each defines how its stuffing should be cooked. The Burger class is our context. It’s configured with a concrete strategy and it uses the concrete strategy later when a burger needs to be cooked.

GrilledChickenStuffing和BeefPattyStuffing是我们的具体策略。 每个都定义了馅料应该如何烹饪。 Burger班是我们的背景。 它配置有具体的策略，并且在以后需要烹饪汉堡时会使用具体的策略。

In our burger example, we don’t have a specific class that declares what interface the concrete strategies should implement. That’s because we don’t need to, thanks to Ruby’s duck typing. If it walks like a duck and talks like a duck, it’s a duck. If it can be cooked as a burger patty, it is a burger patty.

在我们的汉堡示例中，我们没有特定的类来声明具体策略应实现的接口。 这是因为由于Ruby的鸭子输入，我们不需要。 如果它走路像鸭子，说话像鸭子，那就是鸭子。 如果可以将其制成汉堡肉饼，则为汉堡肉饼。

Strategy declares the interface for which a concrete strategy should implement and for which context can use. As you can see in the above code, both GrilledChickenStuffing and BeefPattyStuffing implements the cook method, and that’s the method the user of a concrete strategy, aka the context, expects a concrete strategy to provide.

策略声明接口，具体策略应针对该接口实施，并且上下文可以使用。 如您在上面的代码中看到的，GrilledChickenStuffing和BeefPattyStuffing都实现了cook方法，这就是具体策略(也称为上下文)的用户所期望的一种具体策略。

战略模式的关键思想 (The key idea of the strategy pattern)

The key to the strategy pattern is to pull the varying algorithms out into a separate object. These objects become a family of algorithms the context can choose from. Each of these objects, aka the strategies, does the same job and supports the same interface.

策略模式的关键是将各种算法引入单独的对象中。 这些对象成为上下文可以选择的一系列算法。 这些对象(也称为策略)均执行相同的工作并支持相同的接口。

In our burger example, we have different patty strategies for a burger. And each of the concrete burger patty strategy supports the same interface by implementing the cook method.

在我们的汉堡示例中，我们对汉堡有不同的馅饼策略。 每个具体的汉堡肉饼策略都通过实现cook方法来支持相同的界面。

It’s all about composition. The user has a strategy and delegates. The user of the strategy delegates the job. In our example, a burger has a patty, and it delegates the job of cooking.

一切都与构图有关。 用户有一个策略和代表。 策略的用户委派工作。 在我们的示例中，一个汉堡有一块馅饼，它委派了烹饪工作。

战略模式的优势 (Advantages of the strategy pattern)

• It achieves better separation of concerns by pulling out a set of strategies from a class and relives the Burger class of any responsibility for our knowledge of the stuffing.

  它通过从班级中撤出一套策略来更好地分离问题，并使Burger班级对我们对馅料的了解负有任何责任。

• It makes it easy to switch strategies at runtime because the pattern is based on composition and delegation, rather than on inheritance.它使运行时切换策略变得容易，因为该模式基于组成和委派而不是继承。

考虑使用策略模式时需要注意的事项 (Things to watch out for while considering using the strategy pattern)

• Data passing between context and strategy. If the implementation of a concrete strategy requires data from the context, you can either pass the data as parameters to a concrete strategy or pass the context itself into a concrete strategy. This is so that the concrete strategy can have access to the data through the context. Whichever way you choose, watch out for the tangling of the context and the concrete strategy.在上下文和策略之间传递数据。 如果具体策略的实施需要上下文中的数据，则可以将数据作为参数传递给具体策略，也可以将上下文本身传递到具体策略中。 这样，具体策略就可以通过上下文访问数据。 无论选择哪种方式，请注意上下文和具体策略的纠缠。

• Double check if you actually need the strategy pattern, the template method, or the decorator pattern.

  仔细检查您是否确实需要策略模式， 模板方法或装饰器模式 。

策略模式中使用的设计原则 (Design principles used in the strategy pattern)

• Encapsulate what varies封装变化
• Favor composition over inheritance偏重于继承而不是继承
• Program to interfaces, not implementation程序到接口，而不是实现

Now you have learned about the strategy pattern.

现在您已经了解了策略模式。

Here’s an important question: what’s your favorite burger strategy? :)

这是一个重要的问题：您最喜欢的汉堡策略是什么？ :)

I publish to sihui.io weekly.

我每周出版sihui.io 。

Subscribe so you won’t miss the next article from the series.

订阅，这样您就不会错过该系列的下一篇文章。

Next time we will take a look at the template method and …

下次，我们将看一下模板方法和…

翻译自: https://www.freecodecamp.org/news/how-can-you-learn-the-strategy-design-pattern-make-a-hamburger-a6ad4332b838/

系统学习做汉堡