Check out the book 'JavaScript design patterns' authored by Dustin Diaz. It includes insightful chapters on employing JavaScript interfaces using Duck Typing. It's not just informative, but also an enjoyable read. Please note that there is no built-in interface implementation in the language itself; you need to adhere to the principles of Duck Typing.

// example duck typing method
var hasMethods = function(obj /*, method list as strings */){
    var i = 1, methodName;
    while((methodName = arguments[i++])){
        if(typeof obj[methodName] != 'function') {
            return false;
        }
    }
    return true;
}

// in your code
if(hasMethods(obj, 'quak', 'flapWings','waggle')) {
    //  IT'S A DUCK, do your duck thang
}

There is an interesting feature in JavaScript (ECMAScript edition 3) known as the implements reserved word that seems to be saved for future use, according to Mozilla's documentation. While this feature was likely intended for a specific purpose, it was not fully defined at the time of specification release. As a result, browsers currently do not make use of it and may even generate warnings if attempted.

Nevertheless, it is entirely feasible to craft your own method like Object.implement(Interface), which verifies whether a given object includes a certain set of properties or functions, thus mimicking interface implementation.

In one of my articles on object-orientation, I introduced a personal notation strategy for achieving this goal (found here):

// Define a 'Dog' class inheriting from 'Animal'
// and implementing the 'Mammal' interface
var Dog = Object.extend(Animal, {
    constructor: function(name) {
        Dog.superClass.call(this, name);
    },
    bark: function() {
        alert('woof');
    }
}).implement(Mammal);

While there are various approaches to tackle this concept, the example above showcases the method I personally favor for Interface implementation. It is clear, concise, and straightforward to utilize. Although it involves adding an 'implement' method to Function.prototype, some individuals may find this approach efficient and effective.

Function.prototype.implement = function() {
    // Iterate through each interface provided and validate 
    // their presence in the context object (this).
    for(var i = 0; i < arguments.length; i++) {
       // .. Validate member logic ..
    }
    // Return the tested class
    return this;
}

JavaScript and Interface Emulation:

While JavaScript lacks a built-in interface type, there is often a need for it due to the language's dynamic nature and Prototypical-Inheritance usage. Ensuring consistent interfaces across classes can be challenging but achievable through various emulation methods.

There are several ways to emulate Interfaces in JavaScript, each with its own strengths and weaknesses. Some approaches may be more cumbersome than others, leading developers to seek a balance between robustness and ease of implementation.

The following presents an approach to creating Interfaces and Abstract Classes in JavaScript that strikes a balance between simplicity and flexibility:

function resolvePrecept(interfaceName) {
    var interfaceName = interfaceName;
    return function curry(value) {
        console.warn('%s requires an implementation for ...', interfaceName);
        return value;
    };
}

var iAbstractClass = function AbstractClass() {
    var defaultTo = resolvePrecept('iAbstractClass');

    this.datum1 = this.datum1 || defaultTo(new Number());
    this.datum2 = this.datum2 || defaultTo(new String());

    this.method1 = this.method1 || defaultTo(new Function('return new Boolean();'));
    this.method2 = this.method2 || defaultTo(new Function('return new Object();'));

};

var ConcreteImplementation = function ConcreteImplementation() {

    this.datum1 = 1;
    this.datum2 = 'str';

    this.method1 = function method1() {
        return true;
    };
    this.method2 = function method2() {
        return {};
    };

    //Apply Interface (Implement iAbstractClass Interface)
    iAbstractClass.apply(this);  
};

Key Players

Precept Resolver

The resolvePrecept function is a utility used within the Abstract Class to handle precepts like data and behavior. It allows for customized handling of implementations by assigning default values or issuing warnings/errors.

iAbstractClass

This class defines the interface and establishes an agreement with its Implementor. By assigning precepts within a shared namespace, it ensures consistency while allowing customization when necessary.

Implementor

The Implementor agrees with the Interface and applies it through Constructor-Hijacking. By defining its data and behavior before applying the Interface, the Implementor retains control over overrides and benefits from the interface's warnings and defaults.

While this approach offers a simple yet effective way to maintain consistency in software development, it does not provide true interfaces but rather emulates them. Further improvements could include assertions for return types, signatures, object immutability, and other specific needs within the JavaScript community.

Overall, I hope this methodology proves as valuable to you as it has been for my team and me.

An example of an abstract interface:

const Interface = {
  save: () => { throw "save method must be implemented in concrete types"},
  display: function() { console.log(this.save()) }
}

To create a new instance:

function ConcreteType() {
  this.save = () => "saved data"
}
ConcreteType.prototype = Interface

Then, you can use it like this:

let object = new ConcreteType()
object.display()

I hope that this information helps anyone still searching for an answer.

If you're interested, you can explore using a Proxy in JavaScript (which has been standard since ECMAScript 2015): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy

latLngLiteral = new Proxy({},{
    set: function(obj, prop, val) {
        //only 'lng' and 'lat' are allowed properties to be set
        if(['lng','lat'].indexOf(prop) == -1) {
            throw new ReferenceError('Key must be "lat" or "lng"!');
        }

        //values must be numbers for the decimal format
        if(typeof val !== 'number') {
            throw new TypeError('Value must be numeric');
        }

        //latitude range is between 0 and 90
        if(prop == 'lat' && !(0 < val && val < 90)) {
            throw new RangeError('Position is out of range!');
        }
        //longitude range is between 0 and 180
        else if(prop == 'lng' && !(0 < val && val < 180)) {
            throw new RangeError('Position is out of range!');
        }

        obj[prop] = val;

        return true;
    }
});

Then you could simply do:

myMap = {}
myMap.position = latLngLiteral;

In case you want to use `instanceof` (as asked by @Kamaffeather), you can encapsulate it within an object like this:

class LatLngLiteral {
    constructor(props)
    {
        this.proxy = new Proxy(this, {
            set: function(obj, prop, val) {
                //only 'lng' and 'lat' are allowed properties to be set
                if(['lng','lat'].indexOf(prop) == -1) {
                    throw new ReferenceError('Key must be "lat" or "lng"!');
                }

                //values must be numbers for the decimal format
                if(typeof val !== 'number') {
                    throw new TypeError('Value must be numeric');
                }

                //latitude range is between 0 and 90
                if(prop == 'lat' && !(0 < val && val < 90)) {
                    throw new RangeError('Position is out of range!');
                }
                //longitude range is between 0 and 180
                else if(prop == 'lng' && !(0 < val && val < 180)) {
                    throw new RangeError('Position is out of range!');
                }

                obj[prop] = val;

                return true;
            }
        })
        return this.proxy
    }
}

This can also be achieved without using `Proxy`, but instead utilizing classes with getters and setters:

class LatLngLiteral {
    #latitude;
    #longitude;

    get lat()
    {
        return this.#latitude;
    }

    get lng()
    {
        return this.#longitude;
    }
    
    set lat(val)
    {
        //values must be numbers for the decimal format
        if(typeof val !== 'number') {
            throw new TypeError('Value must be numeric');
        }

        //latitude range is between 0 and 90
        if(!(0 < val && val < 90)) {
            throw new RangeError('Position is out of range!');
        }
        
        this.#latitude = val
    }
    
    set lng(val)
    {
        //values must be numbers for the decimal format
        if(typeof val !== 'number') {
            throw new TypeError('Value must be numeric');
        }

        //longitude range is between 0 and 180
        if(!(0 < val && val < 180)) {
            throw new RangeError('Position is out of range!');
        }
        
        this.#longitude = val
    }
}

Interfaces are essential in Java due to its static typing nature, where the interaction between classes must be defined at compile time. On the other hand, JavaScript operates with dynamic typing, allowing you to simply check for specific methods on an object and execute them as needed.

If you're considering using a transcompiler, TypeScript is worth exploring. It has the ability to support upcoming ECMA features (referred to as "protocols") similar to other languages like coffeescript or babel.

In TypeScript, an interface can be defined as:

interface IMyInterface {
    id: number; // TypeScript types are lowercase
    name: string;
    callback: (key: string; value: any; array: string[]) => void;
    type: "test" | "notATest"; // known as "union type"
}

However, there are limitations in TypeScript such as:

• Inability to define RegExp patterns for type value
• Lack of validation capabilities for string length restrictions
• Absence of support for defining number ranges
• And so forth.

Here's a suggestion: Create an interface described as a class, and utilize the @implements JSDoc tag to indicate that a specific class implements the defined interface. If the class fails to implement all properties of the interface, you will notice red squiggly lines on the class name in your code editor. I personally tried this out using VSCode.

// @ts-check

// Define the interface using a class
class CustomInterface {
    size = 4;
    description() {}
    display(){ }
}

/**
 * @implements CustomInterface
 */
class ImplementedCustom {
    size = 4;
    description() {
        console.log('Providing a description')
    }
    display(){
        console.log('Displaying something')
    }
}       

const impl = new ImplementedCustom();
impl.description();

By utilizing an interface, you can incorporate polymorphism into your code. Javascript does not require the use of interfaces to achieve this flexibility due to its dynamically typed nature. For instance, consider an array containing classes with similar methods:

Circle()
Square()
Triangle()

To gain a better understanding of how polymorphism functions, refer to David Kruglinsky's MFC Book (specifically written for C++).

In these classes, by implementing the draw() method and pushing instances into the array to then call the draw() methods in a loop, you essentially create an implicit implementation of an abstract class. While not explicitly defined, Javascript allows for this approach without issues regarding interface method implementation requirements.

An interface serves as a contract that mandates the implementation of all specified methods, which is necessary when utilizing static typing.

The transition from dynamic to static typing in languages like Javascript may spark debate, as the latter is inherently designed to be dynamic. Experienced developers are accustomed to and comfortable working within Javascript's dynamic framework.

It remains unclear to me why one would opt for Typescript over Javascript, especially considering the efficient and cost-effective enterprise website development opportunities offered by NodeJS in tandem with Javascript and MongoDB.

Typescript was developed by Anders Hejlsberg, known for also creating C#. Conversely, another developer at Microsoft explored a different path by infusing C# with dynamic capabilities akin to Javascript - where dynamics manifest at runtime rather than compile time.

I possess 40 years of development experience spanning both C-like languages and Javascript and observe Visual Studio facing challenges such as slow compiling and lackluster hot reload features, while Nodejs shines and excels in performance.

Moving forward, reliance on interim solutions like sass, less, angular, react, and typescript may become obsolete as native Javascript emerges as the preferred choice. Javascript has reached maturity, and successful integration requires adept software architects driving innovation.

While JavaScript does not have native interfaces, it is possible to simulate them using different methods. I recently developed a package that achieves this functionality.

To explore the implementation further, you can visit this link.

Although this solution may be dated, I have recently found myself in need of a convenient API for verifying objects against interfaces. As a result, I developed my own tool: https://github.com/tomhicks/methodical

You can also easily access it through NPM: npm install methodical

This tool essentially covers all the features mentioned earlier, while providing additional options for stricter enforcement, eliminating the need for repetitive

if (typeof x.method === 'function')

Hopefully, someone out there will find this tool beneficial.

Unlike some other programming languages, Javascript does not have explicit interfaces. However, it is possible to achieve similar functionality through duck typing. You can see an example of this concept in action by visiting the following link:

This question may be old, but it continues to intrigue me.

While many responses online focus on "enforcing" interfaces, I propose a different perspective:

I particularly notice the absence of interfaces when working with multiple classes that share similar behaviors (i.e. implement an interface).

For instance, I have an Email Generator that requires Email Sections Factories which are responsible for generating content and HTML for the sections. Therefore, they all need to have methods like getContent(id) and getHtml(content).

The closest approach to interfaces that I could think of (although still a workaround) is using a class that accepts 2 arguments defining the interface methods.

The challenge with this approach is that the methods must be either static or require the instance itself as an argument to access its properties. Despite this limitation, there are situations where I find this compromise worthwhile.

class Filterable {
  constructor(data, { filter, toString }) {
    this.data = data;
    this.filter = filter;
    this.toString = toString;
    // You can also enforce here an Iterable interface, for example,
    // which feels much more natural than having an external check
  }
}

const evenNumbersList = new Filterable(
  [1, 2, 3, 4, 5, 6], {
    filter: (lst) => {
      const evenElements = lst.data.filter(x => x % 2 === 0);
      lst.data = evenElements;
    },
    toString: lst => `< ${lst.data.toString()} >`,
  }
);

console.log('The whole list:    ', evenNumbersList.toString(evenNumbersList));
evenNumbersList.filter(evenNumbersList);
console.log('The filtered list: ', evenNumbersList.toString(evenNumbersList));

While JavaScript does not include interfaces, TypeScript offers this valuable feature!

Although JavaScript does not have a built-in interface like Java, you can simulate its behavior by following the code outlined below. An interface essentially represents a contract that enforces certain rules, which can be manually implemented in JavaScript.

The code provided consists of three classes: an interface, parent, and child class.

• The Interface class contains methods to verify the existence of required methods and properties.

• The Parent class is responsible for enforcing these required methods and properties on the child class using the Interface class.

• The Child class is subjected to the rules established by the parent.

Upon properly setting up the structure, any missing method or property in the child class will trigger an error in the console, while correct implementation of the contract will not prompt any errors.

class Interface {  
    // Methods for checking required methods and properties
}

class Parent extends Interface {
    constructor() {
        super()
        // Check required properties and methods
    }
}

class Child extends Parent {
    // Define properties and methods
    constructor() {
        super();
    }
}

new Child()

Trying to find a way to replicate interfaces with minimal impact has been a challenge for me as well.

One possible solution is to create a tool :

/**
@parameter {Array|object} required : list of method names or types of members by their name
@constructor
*/
let Interface=function(required){
    this.obj=0;
    if(required instanceof Array){
        this.obj={};
        required.forEach(r=>this.obj[r]='function');
    }else if(typeof(required)==='object'){
        this.obj=required;
    }else {
        throw('Interface invalid parameter required = '+required);
    }
};
/** check constructor instance
@parameter {object} scope : instance to check.
@parameter {boolean} [strict] : if true -> throw an error if errors are found.
@constructor
*/
Interface.prototype.check=function(scope,strict){
    let err=[],type,res={};
    for(let k in this.obj){
        type=typeof(scope[k]);
        if(type!==this.obj[k]){
            err.push({
                key:k,
                type:this.obj[k],
                inputType:type,
                msg:type==='undefined'?'missing element':'bad element type "'+type+'"'
            });
        }
    }
    res.success=!err.length;
    if(err.length){
        res.msg='Class bad structure :';
        res.errors=err;
        if(strict){
            let stk = new Error().stack.split('\n');
            stk.shift();
            throw(['',res.msg,
                res.errors.map(e=>'- {'+e.type+'} '+e.key+' : '+e.msg).join('\n'),
                '','at :\n\t'+stk.join('\n\t')
            ].join('\n'));

        }
    }
    return res;
};

Example of how it can be used :

// creating the interface tool
let dataInterface=new Interface(['toData','fromData']);
// abstract constructor
let AbstractData=function(){
    dataInterface.check(this,1);// checking extended elements
};
// extended constructor
let DataXY=function(){
    AbstractData.apply(this,[]);
    this.xy=[0,0];
};
DataXY.prototype.toData=function(){
    return [this.xy[0],this.xy[1]];
};

// this should result in an error because 'fromData' is missing
let dx=new DataXY();

Using classes:

class AbstractData{
    constructor(){
        dataInterface.check(this,1);
    }
}
class DataXY extends AbstractData{
    constructor(){
        super();
        this.xy=[0,0];
    }
    toData(){
        return [this.xy[0],this.xy[1]];
    }
}

While it may slightly impact performance and require dependency on the Interface class, it can prove to be useful for debugging or open API purposes.