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