function inherits(Child, Parent) {
  Child.prototype = Object.create(Parent.prototype);
  Child.prototype.constructor = Child;
}

function Interface(){};
function Class(){};

inherits(Class, Interface);

Interface.prototype.someValue = 1;
Class.prototype.someValue = 2;

alert((new Interface()).someValue);
alert((new Class()).someValue);

Child.prototype.constructor = Child;

Object.prototype.extends = function(parent)
{
  this.prototype = Object.create(parent);
  this.prototype.constructor = this;
};

var Interface =
{
  fd : "default descriptor"
};

function Class1() {};
Class1.extends(Interface);

function Class2() {};
Class2.extends(Interface);

Class1.prototype.fd = "class1 descriptor";

var obj1 = new Class1();
var obj2 = new Class2();
//var obj = new Interface(); //ошибка, так как нельзя создать экземпляр виртуального класса

alert(obj1.fd);
alert(obj2.fd);

Object.prototype.extends = function(){ alert('extends') };
var newObj = {foo: 'bar'};
for(var key in newObj) alert(key);

Object.defineProperty(Object.prototype, 'extends', {
  value: function(){},
  enumerable: *!*false*/!*,
  writable: true,
  configurable: true
});

Object.prototype.extends = function(){ alert('extends') };
var newObj = {foo: 'bar'};
for(var key in newObj) {if(!(newObj.hasOwnProperty(key))) break; alert(key)};

Object.prototype._=function(f){return f(this)}

show=function(x){console.log(x)}
sum=function(x){console.log(x+x)}

;({a: 1})._(show) // { a: 1 }
;1.._(sum) // 2

class Parent {
  someMethod();
}
class Child prototype Parent.prototype {};

console.log((new Child).__proto__ == Parent.prototype); //true

alert(Object.prototype===({}.__proto__)) // true

Object.__proto__.one=1
Object.prototype.ten=10
alert([{}.one, {}.ten])

Object.defineProperty(Function.prototype, "extends", {
  writable: true,
  configurable: true,
  enumerable: false,
  value: function(){}
});

Function.prototype.extends=function(){}
console.log(function(){}.extends, ({}).extends, "foo".extends)
// [Function] undefined undefined

//C++ code:
#include <stdio.h>
#include <string>

class IODevice
{
  protected:
    std::string descriptor;

  public:
    virtual int open() = 0;
    virtual ~IODevice() {}
};

class Device1 : public IODevice
{
  public:
    Device1(std::string _descriptor) //constructor
    {
      descriptor = _descriptor;
    }

    int open()
    {
      printf("%s opening...\n", descriptor.c_str());
      return 0;
    }
    ~Device1() {}
};

class Device2 : public IODevice
{
  public:
    Device2(std::string _descriptor) //constructor
    {
      descriptor = _descriptor;
    }

    int open()
    {
      printf("%s opening...\n", descriptor.c_str());
      return 0;
    }
};

int main()
{
  Device1* dev1 = new Device1("Device1");
  Device2* dev2 = new Device2("Device2");

  //IODevice* dev = new IODevice(); //error: cannot allocate an object of abstract type 'IODevice'

  dev1->open();
  dev2->open();

  delete dev2;
  delete dev1;
  return 0;
}

"use strict";

Object.defineProperty(Object.prototype, "extends",
{
	value: function(parent)
	{
		this.prototype = Object.create(parent.prototype,
		{
			constructor:
			{
				value: 				this,
				writable: 		true,
				configurable: true,
				enumerable: 	false
			}
		});
		
		arguments[1] === "INTERFACE" ? this.__interfaced__ = true : undefined;
	},
	enumerable: 	false,
	writable: 		true,
	configurable: true
});


function IODevice(fd)
{
	if(this.constructor.hasOwnProperty("__interfaced__"))
	{
		this._descriptor = fd;
	}
	else
	{
		alert("Warning: cannot allocate an object of abstract type " + "\"" + this.constructor.name + "\"");
		return new Error("Cannot allocate an object of abstract type " + "\"" + this.constructor.name + "\"");	
	}
}

function Device1(fd)
{
	IODevice.call(this, fd);
}
Device1.extends(IODevice, "INTERFACE");

Device1.prototype.open = function()
{
	console.log(this._descriptor + " opening...");
};


function Device2(fd)
{
	IODevice.call(this, fd);
}
Device2.extends(IODevice,  "INTERFACE");

Device2.prototype.open = function()
{
	console.log(this._descriptor + " opening...");
};


var dev1 = new Device1("Device1");
var dev2 = new Device2("Device2");
var dev = new IODevice("dev");

dev1.open();
dev2.open();
console.log(dev);

Object.defineProperty(Function.prototype, "extends", {
    value: function(parent) {
        *!*var inheritFrom = typeof parent == "function" ? parent.prototype : parent;*/!*
        this.prototype = Object.create(inheritFrom, {
            constructor: {
                value: this,
                writable: true,
                configurable: true,
                enumerable: false
            }
        });
    },
    enumerable: false,
    writable: true,
    configurable: true
});

var IODevice = {

};

function Device1() {}
Device1.extends(IODevice);

function Device2() {}
Device2.extends(IODevice);

new Device1();
new Device2();
new IODevice(); //TypeError: IODevice is not a constructor

var IODevice = {};
class Device1 prototype IODevice {

}
class Device2 prototype IODevice {

}