以下是引用片段：
// 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.

// 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.’

// 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.’

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();
});

// 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);
    });
  }
));