Having leveraged RequireJS as part of my preferred client-side web stack for some time now, I find it rather surprising how often I recall various features from the API docs which I have yet to use, and how they may apply to a specific solution I am implementing.
One such feature is the ability to define a module as a function. While at first this may seem a rather basic feature, and indeed it is, there are quite a few practical purposes in which returning a function as a module definition can prove useful.
Function Modules
As one may expect, returning a function as a Module in RequireJS is rather straight-forward. For example, a simple random function can be defined as a module as follows:
1 2 3 4 5 6 7 8 | // random.js define(function(){ return function(min, max){ return Math.floor((Math.random()*max)+min); } }); |
Then, the function module can simply be invoked as follows:
1 2 3 4 5 | require(['random'], function(random){ console.log(random(1,10)): }); |
Function Modules as Factories
Perhaps a more practical example of implementing a function module is in the context of a Factory Method.
For instance, a function module can be used as a convenient means of creating a specific type of object on a clients behalf based on certain conditions.
Take (an intentionally simple) example of a function module which, given a specific role type, returns a corresponding view implementation (in this example, a Backbone View) for an Editor feature:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | // app/views/editors/EditorFactory.js define(function(require){ var editors = { 'admin' : require('editors/AdminEditorView') , 'user' : require('editors/UserEditorView') , 'guest' : require('editors/GuestEditorView') , // additional implementations ... }; return function(role){ try { return new editors[role]; } catch(error) { throw new Error('Unknown Role Specified.'); } } }); |
Client code can then simply invoke the factory in order to retrieve the appropriate Editor view implementation based on the specified role type:
1 2 3 4 5 6 7 8 9 10 11 12 | define(function(require){ var factory = require('editors/EditorFactory'); return Backbone.View.extend({ render: function(){ // ... view rendering this.editor = factory(this.model.get('role')); this.editor.render(); } }); }); |
Defining modules as functions which serve as factory methods can help simplify client code implementations, as the responsibility of determining the type of object to create, configure, etc., can be delegated to a dedicated object; thus allowing for simpler designs which better facilitate code reuse, testing, and maintenance.
As a general rule of thumb, I typically reserve implementing modules as functions for cases in which a package level method would be appropriate, or for factory implementations. However, there are other scenarios in which function modules may apply, and so they are certainly worth noting.
You can fork the above example here.
{Sorry, Comments are currently Closed! }