详解JavaScript的策略模式编程

 我喜欢策略设计模式。我尽可能多的试着去使用它。究其本质，策略模式使用委托去解耦使用它们的算法类。

这样做有几个好处。他可以防止使用大条件语句来决定哪些算法用于特定类型的对象。将关注点分离开来，因此降低了客户端的复杂度，同时还可以促进子类化的组成。它提高了模块化和可测性。每一个算法都可以单独测试。每一个客户端都可以模拟算法。任意的客户端都能使用任何算法。他们可以互调。就像乐高积木一样。

为了实现策略模式，通常有两个参与者：

该策略的对象，封装了算法。

客户端（上下文）对象，以即插即用的方式能使用任何策略。

这里介绍了我在javascrip里，怎样使用策略模式，在混乱无序的环境中怎样使用它将库拆成小插件，以及即插即用包的。

函数作为策略

一个函数提供了一种封装算法的绝佳方式，同时可以作为一种策略来使用。只需通过一个到客户端的函数并确保你的客户端能调用该策略。

我们用一个例子来证明。假设我们想创建一个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.'

通过使用类，我们与anexecutemethod对象定义了一个策略。客户端可以使用任何策略实现该接口。

同样注意我又是怎样创建greetingstrategy的。有趣的部分是对methodexecute的重载。它以其他函数的形式定义。现在类的后继子类可以改变特定的行为，如thesayhiorsaybyemethod，并不改变常规的算法。这种模式叫做模板方法，非常适合策略模式。

让我们看个究竟。
 

// 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 通过指定theexecutemethod的步骤，创建了一个类的算法。在上面的代码片段中，我们通过创建专门的算法从而利用了这一点。

没有使用子类，我们的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 http://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: "http://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例子中看到的一样，对于维护人员在将来增加另外的策略，将变得更加方便。