Are Interfaces in JavaScript necessary?

I suppose this could apply to any dynamic language, but the one I’m using is JavaScript. We have a situation where we’re writing a couple of controls in JavaScript that need to expose a Send() function which is then called by the page that hosts the JavaScript. We have an array of objects that have this Send function defined so we iterate through the collection and call Send() on each of the objects.

In an OO language, if you wanted to do something similar, you’d have an IControl interface that has a Send() function that must be implemented by each control and then you’d have a collection of IControl implementations that you’d iterate through and call the send method on.

My question is, with JavaScript being a dynamic language, is there any need to define an interface that the controls should inherit from, or is it good enough to just call the Send() function exposed on the controls?

Dynamic languages often encourage Duck Typing, in which methods of the object dictate how it should be used rather than an explicit contract (such as an interface).

This is the same for PHP; you don’t really need interfaces. But they exist for architectural needs. In PHP, you can specify type hints for functions which can be useful.

Second, an interface is a contract. It’s a formal contract that all objects from this interface have those functions. Better to ensure that your classes meet those requirements than to remember: “mm, this class has isEnabled() but the other one is checkIfEnabled()“. Interfaces help you to standardise. Others working on the derived object don’t have to check whether the name is isEnabled or checkIfEnabled (better to let the interpreter catch those problems).

Read More:   Is there a better jQuery solution to this.form.submit();?

Since you can call any method on any object in a dynamic language, I’m not sure how interfaces would come into play in any truly useful way. There are no contracts to enforce because everything is determined at invocation time – an object could even change whether it conforms to a “contract” through its life as methods are added and removed throughout runtime. The call will fail if the object doesn’t fulfill a contract or it will fail if it doesn’t implement a member – either case is the same for most practical purposes.

We saw a nice implementation in the page below, this is ours (short version of it)

var Interface = function (methods) {
    var self = this;
    self.methods = [];

    for (var i = 0, len = methods.length; i < len; i++) {

    this.implementedBy = function (object) {

        for (var j = 0, methodsLen = self.methods.length; j < methodsLen; j++) {
            var method = self.methods[j];
            if (!object[method] || typeof object[method] !== 'function') {
                return false;
        return true;

var IWorkflow = new Interface(['start', 'getSteps', 'end']);
if (IWorkflow.implementedBy(currentWorkFlow)) {

The whole example is at:

Another alternative to the interfaces is offered by bob.js:

1. Check if the interface is implemented:

var iFace = { say: function () { }, write: function () { } };  
var obj1 = { say: function() { }, write: function () { }, read: function () { } }; 
var obj2 = { say: function () { }, read: function () { } }; 
console.log('1: ' + bob.obj.canExtractInterface(obj1, iFace)); 
console.log('2: ' + bob.obj.canExtractInterface(obj2, iFace)); 
// Output: 
// 1: true 
// 2: false 

2. Extract interface from the object and still execute the functions properly:

var obj = {  
    msgCount: 0, 
    say: function (msg) { console.log(++this.msgCount + ': ' + msg); }, 
    sum: function (a, b) { console.log(a + b); } 
var iFace = { say: function () { } }; 
obj = bob.obj.extractInterface(obj, iFace); 
obj.say('How is your day?'); 
obj.say('Good bye!'); 
// Output: 
// 1: Hello! 
// 2: How is your day? 
// 3: Good bye! 

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Similar Posts