我很喜歡策略設計模式,並盡可能多地使用它。究其本質,策略模式透過委派(delegation)來解耦使用它們的演算法類別。
這樣做有幾個好處:它能避免用龐大的條件判斷式來決定哪種演算法適用於特定類型的物件;它把關注點分離開來,从而降低用戶端的複雜度,同時促進以組合取代子類化;它提升了模組化與可測試性——每個演算法都能獨立測試,每個用戶端都能模擬演算法,任何用戶端都能使用任何演算法,它們可以互相調用,就像樂高積木一樣。
要實作策略模式,通常有兩個參與者:
以下說明我在 JavaScript 中如何運用策略模式,以及在混亂的環境中如何用它把函式庫拆成小插件、實現即插即用的套件化。
一個函式提供了封裝演算法的絕佳方式,同時可以作為一種策略來使用。只需把一個函式傳給用戶端,並確保用戶端能呼叫該策略即可。
我們用一個例子來說明。假設我們想建立一個 Greeter 類別,它要做的事就是與人打招呼。我們希望 Greeter 能懂得不同的打招呼方式,於是為打招呼建立不同的策略:
// Greeter is a class of object that can greet people. // It can learn different ways of greeting people through // 'Strategies.' // // This is the Greeter constructor. var Greeter = function(strategy) { this.strategy = strategy; }; // Greeter provides a greet function that is going to // greet people using the Strategy passed to the constructor. Greeter.prototype.greet = function() { return this.strategy(); }; // Since a function encapsulates an algorithm, it makes a perfect // candidate for a Strategy. // // Here are a couple of Strategies to use with our Greeter. var politeGreetingStrategy = function() { console.log("Hello."); }; var friendlyGreetingStrategy = function() { console.log("Hey!"); }; var boredGreetingStrategy = function() { console.log("sup."); }; // Let's use these strategies! var politeGreeter = new Greeter(politeGreetingStrategy); var friendlyGreeter = new Greeter(friendlyGreetingStrategy); var boredGreeter = new Greeter(boredGreetingStrategy); console.log(politeGreeter.greet()); //=> Hello. console.log(friendlyGreeter.greet()); //=> Hey! console.log(boredGreeter.greet()); //=> sup. 在上面的例子中,Greeter 是用戶端,並有三種策略。如你所見,Greeter 知道怎麼使用演算法,卻對演算法的細節一無所知。
策略同樣可以是類別,特別是當演算法比上述例子更複雜的時候。使用類別,允許你為每一種策略定義一個介面。
下面的例子證實了這一點:
// We can also leverage the power of Prototypes in Javascript to create // classes that act as strategies. // // Here, we create an abstract class that will serve as the interface // for all our strategies. It isn't needed, but it's good for documenting // purposes. var Strategy = function() {}; Strategy.prototype.execute = function() { throw new Error('Strategy#execute needs to be overridden.') }; // Like above, we want to create Greeting strategies. Let's subclass // our Strategy class to define them. Notice that the parent class // requires its children to override the execute method. var GreetingStrategy = function() {}; GreetingStrategy.prototype = Object.create(Strategy.prototype); // Here is the `execute` method, which is part of the public interface of // our Strategy-based objects. Notice how I implemented this method in term of // of other methods. This pattern is called a Template Method, and you'll see // the benefits later on. GreetingStrategy.prototype.execute = function() { return this.sayHi() + this.sayBye(); }; GreetingStrategy.prototype.sayHi = function() { return "Hello, "; }; GreetingStrategy.prototype.sayBye = function() { return "Goodbye."; }; // We can already try out our Strategy. It requires a little tweak in the // Greeter class before, though. Greeter.prototype.greet = function() { return this.strategy.execute(); }; var greeter = new Greeter(new GreetingStrategy()); greeter.greet() //=> 'Hello, Goodbye.' 透過使用類別,我們以一個 execute 方法為物件定義了策略,用戶端可以使用任何實作該介面的策略。
同樣注意我是怎麼建立 GreetingStrategy 的。有趣的部分在於對 execute 方法的重載——它以其他函式的形式來定義。現在類別的後繼子類別可以改變特定行為,例如 sayHi 或 sayBye 方法,而不改變整體演算法。這種模式叫做模板方法,非常適合搭配策略模式。
讓我們看個究竟:
// Since the GreetingStrategy#execute method uses methods to define its algorithm, // the Template Method pattern, we can subclass it and simply override one of those // methods to alter the behavior without changing the algorithm. var PoliteGreetingStrategy = function() {}; PoliteGreetingStrategy.prototype = Object.create(GreetingStrategy.prototype); PoliteGreetingStrategy.prototype.sayHi = function() { return "Welcome sir, "; }; var FriendlyGreetingStrategy = function() {}; FriendlyGreetingStrategy.prototype = Object.create(GreetingStrategy.prototype); FriendlyGreetingStrategy.prototype.sayHi = function() { return "Hey, "; }; var BoredGreetingStrategy = function() {}; BoredGreetingStrategy.prototype = Object.create(GreetingStrategy.prototype); BoredGreetingStrategy.prototype.sayHi = function() { return "sup, "; }; var politeGreeter = new Greeter(new PoliteGreetingStrategy()); var friendlyGreeter = new Greeter(new FriendlyGreetingStrategy()); var boredGreeter = new Greeter(new BoredGreetingStrategy()); politeGreeter.greet(); //=> 'Welcome sir, Goodbye.' friendlyGreeter.greet(); //=> 'Hey, Goodbye.' boredGreeter.greet(); //=> 'sup, Goodbye.' GreetingStrategy 透過指定 execute 方法的步驟,建立了一套演算法。在上面的程式碼中,我們正是透過建立專門的演算法來利用了這一點。
沒有使用子類,我們的 Greeter 依然展現出多型行為,不必在 Greeter 的不同類型之間切換來觸發正確的演算法——這一切都綁定在每一個 Greeter 物件上。
var greeters = [ new Greeter(new BoredGreetingStrategy()), new Greeter(new PoliteGreetingStrategy()), new Greeter(new FriendlyGreetingStrategy()), ]; greeters.forEach(function(greeter) { // Since each greeter knows its strategy, there's no need // to do any type checking. We just greet, and the object // knows how to handle it. greeter.greet(); }); 我最喜歡的其中一個策略模式例子,實在 Passport.js 這個庫裡。Passport.js 提供了一種在 Node 中處理身份驗證的簡單方式,廣泛支援各家供應商(Facebook、Twitter、Google 等等),而每一個都作為一種策略來實作。
這個庫作為一個 npm 套件是可行的,其所有策略也一樣。庫的用戶可以為他們特有的用例決定安裝哪一個 npm 套件。下面是展示其如何實作的程式碼片段:
// Taken from https://passportjs.org var passport = require('passport') // Each authentication mechanism is provided as an npm package. // These packages expose a Strategy object. , LocalStrategy = require('passport-local').Strategy , FacebookStrategy = require('passport-facebook').Strategy; // Passport can be instanciated using any Strategy. passport.use(new LocalStrategy( function(username, password, done) { User.findOne({ username: username }, function (err, user) { if (err) { return done(err); } if (!user) { return done(null, false, { message: 'Incorrect username.' }); } if (!user.validPassword(password)) { return done(null, false, { message: 'Incorrect password.' }); } return done(null, user); }); } )); // In this case, we instanciate a Facebook Strategy passport.use(new FacebookStrategy({ clientID: FACEBOOK_APP_ID, clientSecret: FACEBOOK_APP_SECRET, callbackURL: "https://www.example.com/auth/facebook/callback" }, function(accessToken, refreshToken, profile, done) { User.findOrCreate(..., function(err, user) { if (err) { return done(err); } done(null, user); }); } )); Passport.js 只配備了一兩個簡單的身份驗證機制,除此之外,它並未超出「符合上下文物件的一個策略類別介面」這個範圍。這種機制讓它的使用者能輕易實作自己的身份驗證機制,而不對專案造成不利影響。
策略模式為你的程式碼提供了一種增加模組化與可測試性的方式。這並不意味著它總是適用——Mixins 同樣能被用來進行功能注入,例如在執行時為物件注入演算法;而扁平的老式 duck-typing 多型,有時也足夠簡單。
然而,使用策略模式讓你能在初期不引入龐大體系的情況下,隨著負載成長而擴展程式碼的規模。正如我們在 Passport.js 的例子中看到的,對於未來想新增策略的維護者而言,一切都會變得更加方便。