Are Interfaces in JavaScript necessary?

Question

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?

Answer 1

I found an interesting link on the topic here: http://stackoverflow.com/questions/91618/is-there-any-point-for-interfaces-in-dynamic-languages

this basically answers my question, so feel free to close this question as a duplicate

Answer 2

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.

Answer 3

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 has 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. Otheres working on the dedrived object don't have to check whether the name is isEnabled or checkIfEnabled (better to let the intertper catch those problems)

Answer 4

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).