I have changed how I do this now, I try to avoid using constructor functions and their prototype property, but my old answer from 2010 is still at the bottom. I now prefer Object.create(). Object.create is available in all modern browsers.

I should note that Object.create is usually much slower than using new with a function constructor.

//The prototype is just an object when you use `Object.create()`
var Base = {};


//This is how you create an instance:
var baseInstance = Object.create(Base);


//If you want to inherit from "Base":
var subInstance = Object.create(Object.create(Base));


//Detect if subInstance is an instance of Base:
console.log(Base.isPrototypeOf(subInstance)); //True

jsfiddle

One of the big benefits of using Object.create is being able to pass in a defineProperties argument, which gives you significant control over how properties on the class can be accessed and enumerated over, and I also use functions to create instances, these serve as constructors in a way, as you can do initialization at the end instead of just returning the instance.

var Base = {};


function createBase() {
return Object.create(Base, {
doSomething: {
value: function () {
console.log("Doing something");
},
},
});
}


var Sub = createBase();


function createSub() {
return Object.create(Sub, {
doSomethingElse: {
value: function () {
console.log("Doing something else");
},
},
});
}


var subInstance = createSub();
subInstance.doSomething(); //Logs "Doing something"
subInstance.doSomethingElse(); //Logs "Doing something else"
console.log(Base.isPrototypeOf(subInstance)); //Logs "true"
console.log(Sub.isPrototypeOf(subInstance)); //Logs "true

jsfiddle

This is my original answer from 2010:

function Base ( ) {
this.color = "blue";
}


function Sub ( ) {


}
Sub.prototype = new Base( );
Sub.prototype.showColor = function ( ) {
console.log( this.color );
}


var instance = new Sub ( );
instance.showColor( ); //"blue"

you can't (in the classical sense). Javascript is a prototypical language. You will observe that you never declare a "class" in Javascript; you merely define the state and methods of an object. To produce inheritance, you take some object and prototype it. The prototype is extended with new functionality.

In JavaScript you don't have classes but you can get inheritance and behavior reuse in many ways:

Pseudo-classical inheritance (through prototyping):

function Super () {
this.member1 = 'superMember1';
}
Super.prototype.member2 = 'superMember2';


function Sub() {
this.member3 = 'subMember3';
//...
}
Sub.prototype = new Super();

Should be used with the new operator:

var subInstance = new Sub();

Function application or "constructor chaining":

function Super () {
this.member1 = 'superMember1';
this.member2 = 'superMember2';
}




function Sub() {
Super.apply(this, arguments);
this.member3 = 'subMember3';
}

This approach should also be used with the new operator:

var subInstance = new Sub();

The difference with the first example is that when we apply the Super constructor to the this object inside Sub, it adds the properties assigned to this on Super, directly on the new instance, e.g. subInstance contains the properties member1 and member2 directly (subInstance.hasOwnProperty('member1') == true;).

In the first example, those properties are reached through the prototype chain, they exist on an internal [[Prototype]] object.

Parasitic inheritance or Power Constructors:

function createSuper() {
var obj = {
member1: 'superMember1',
member2: 'superMember2'
};


return obj;
}


function createSub() {
var obj = createSuper();
obj.member3 = 'subMember3';
return obj;
}

This approach is based basically on "object augmenting", you don't need to use the new operator, and as you can see, the this keyword is not involved.

var subInstance = createSub();

ECMAScript 5th Ed. Object.create method:

// Check if native implementation available
if (typeof Object.create !== 'function') {
Object.create = function (o) {
function F() {}  // empty constructor
F.prototype = o; // set base object as prototype
return new F();  // return empty object with right [[Prototype]]
};
}


var superInstance = {
member1: 'superMember1',
member2: 'superMember2'
};


var subInstance = Object.create(superInstance);
subInstance.member3 = 'subMember3';

The above method is a prototypal inheritance technique proposed by Crockford.

Object instances inherit from other object instances, that's it.

This technique can be better than simple "object augmentation" because the inherited properties aren't copied over all the new object instances, since the base object is set as the [[Prototype]] of the extended object, in the above example subInstance contains physically only the member3 property.

You can't inherit from a class in JavaScript, because there are no classes in JavaScript.

Well, in JavaScript there is no "class inheritance", there is just "prototype inheritance". So you don't make a class "truck" and then mark it as a subclass of "automobile". Instead, you make an object "Jack" and say that it uses "John" as a prototype. If John knows, how much "4+4" is, then Jack knows it, too.

I suggest you read Douglas Crockford's article about prototypal inheritance here: http://javascript.crockford.com/prototypal.html He also shows how you can make JavaScript have "look-alike" inheritance as in other OO languages and then explains that this actually means breaking javaScript in a way it was not meant to be used.

You can use .inheritWith and .fastClass library. It is faster than most popular libraries and sometimes even faster than the native version.

Very easy to use:

function Super() {
this.member1 = "superMember";//instance member
}.define({ //define methods on Super's prototype
method1: function() { console.log('super'); } //prototype member
}.defineStatic({ //define static methods directly on Super function
staticMethod1: function() { console.log('static method on Super'); }
});


var Sub = Super.inheritWith(function(base, baseCtor) {
return {
constructor: function() {//the Sub constructor that will be returned to variable Sub
this.member3 = 'subMember3'; //instance member on Sub
baseCtor.apply(this, arguments);//call base construcor and passing all incoming arguments
},
method1: function() {
console.log('sub');
base.method1.apply(this, arguments); //call the base class' method1 function
}
}

Usage

var s = new Sub();
s.method1(); //prints:
//sub
//super

I find this quote to be the most enlightening:

In essence, a JavaScript "class" is just a Function object that serves as a constructor plus an attached prototype object. (Source: Guru Katz)

I like using constructors rather than objects, so I'm partial to the "pseudo-classical inheritance" method described here by CMS. Here is an example of multiple inheritance with a prototype chain:

// Lifeform "Class" (Constructor function, No prototype)
function Lifeform () {
this.isLifeform = true;
}


// Animal "Class" (Constructor function + prototype for inheritance)
function Animal () {
this.isAnimal = true;
}
Animal.prototype = new Lifeform();


// Mammal "Class" (Constructor function + prototype for inheritance)
function Mammal () {
this.isMammal = true;
}
Mammal.prototype = new Animal();


// Cat "Class" (Constructor function + prototype for inheritance)
function Cat (species) {
this.isCat = true;
this.species = species
}
Cat.prototype = new Mammal();


// Make an instance object of the Cat "Class"
var tiger = new Cat("tiger");


console.log(tiger);
// The console outputs a Cat object with all the properties from all "classes"


console.log(tiger.isCat, tiger.isMammal, tiger.isAnimal, tiger.isLifeform);
// Outputs: true true true true


// You can see that all of these "is" properties are available in this object
// We can check to see which properties are really part of the instance object
console.log( "tiger hasOwnProperty: "
,tiger.hasOwnProperty("isLifeform") // false
,tiger.hasOwnProperty("isAnimal")   // false
,tiger.hasOwnProperty("isMammal")   // false
,tiger.hasOwnProperty("isCat")      // true
);


// New properties can be added to the prototypes of any
// of the "classes" above and they will be usable by the instance
Lifeform.prototype.A    = 1;
Animal.prototype.B      = 2;
Mammal.prototype.C      = 3;
Cat.prototype.D         = 4;


console.log(tiger.A, tiger.B, tiger.C, tiger.D);
// Console outputs: 1 2 3 4


// Look at the instance object again
console.log(tiger);
// You'll see it now has the "D" property
// The others are accessible but not visible (console issue?)
// In the Chrome console you should be able to drill down the __proto__ chain
// You can also look down the proto chain with Object.getPrototypeOf
// (Equivalent to tiger.__proto__)
console.log( Object.getPrototypeOf(tiger) );  // Mammal
console.log( Object.getPrototypeOf(Object.getPrototypeOf(tiger)) ); // Animal
// Etc. to get to Lifeform

Here is another good resource from MDN, and here is a jsfiddle so you can try it out.

function Person(attr){
this.name = (attr && attr.name)? attr.name : undefined;
this.birthYear = (attr && attr.birthYear)? attr.birthYear : undefined;


this.printName = function(){
console.log(this.name);
}
this.printBirthYear = function(){
console.log(this.birthYear);
}
this.print = function(){
console.log(this.name + '(' +this.birthYear+ ')');
}
}


function PersonExt(attr){
Person.call(this, attr);


this.print = function(){
console.log(this.name+ '-' + this.birthYear);
}
this.newPrint = function(){
console.log('New method');
}
}
PersonExt.prototype = new Person();


// Init object and call methods
var p = new Person({name: 'Mr. A', birthYear: 2007});
// Parent method
p.print() // Mr. A(2007)
p.printName() // Mr. A


var pExt = new PersonExt({name: 'Mr. A', birthYear: 2007});
// Overwriten method
pExt.print() // Mr. A-2007
// Extended method
pExt.newPrint() // New method
// Parent method
pExt.printName() // Mr. A

After reading many posts, i came up with this solution (jsfiddle here). Most of the time i don't need something more sophisticated

var Class = function(definition) {
var base = definition.extend || null;
var construct = definition.construct || definition.extend || function() {};


var newClass = function() {
this._base_ = base;
construct.apply(this, arguments);
}


if (definition.name)
newClass._name_ = definition.name;


if (definition.extend) {
var f = function() {}
f.prototype = definition.extend.prototype;
newClass.prototype = new f();
newClass.prototype.constructor = newClass;
newClass._extend_ = definition.extend;
newClass._base_ = definition.extend.prototype;
}


if (definition.statics)
for (var n in definition.statics) newClass[n] = definition.statics[n];


if (definition.members)
for (var n in definition.members) newClass.prototype[n] = definition.members[n];


return newClass;
}




var Animal = Class({


construct: function() {
},


members: {


speak: function() {
console.log("nuf said");
},


isA: function() {
return "animal";
}
}
});




var Dog = Class({  extend: Animal,


construct: function(name) {
this._base_();
this.name = name;
},


statics: {
Home: "House",
Food: "Meat",
Speak: "Barks"
},


members: {
name: "",


speak: function() {
console.log( "ouaf !");
},


isA: function(advice) {
return advice + " dog -> " + Dog._base_.isA.call(this);
}
}
});




var Yorkshire = Class({ extend: Dog,


construct: function(name,gender) {
this._base_(name);
this.gender = gender;
},


members: {
speak: function() {
console.log( "ouin !");
},


isA: function(advice) {
return "yorkshire -> " + Yorkshire._base_.isA.call(this,advice);
}
}
});




var Bulldog = function() { return _class_ = Class({ extend: Dog,


construct: function(name) {
this._base_(name);
},


members: {
speak: function() {
console.log( "OUAF !");
},


isA: function(advice) {
return "bulldog -> " + _class_._base_.isA.call(this,advice);
}
}
})}();




var animal = new Animal("Maciste");
console.log(animal.isA());
animal.speak();


var dog = new Dog("Sultan");
console.log(dog.isA("good"));
dog.speak();


var yorkshire = new Yorkshire("Golgoth","Male");
console.log(yorkshire.isA("bad"));
yorkshire.speak();


var bulldog = new Bulldog("Mike");
console.log(bulldog.isA("nice"));
bulldog.speak();

Javascript inheritance is a bit different from Java and PHP, because it doesn't really have classes. Instead it has prototype objects that provide methods and member variables. You can chain those prototypes to provide object inheritance. The most common pattern I found when researching this question is described on the Mozilla Developer Network. I've updated their example to include a call to a superclass method and to show the log in an alert message:

// Shape - superclass
function Shape() {
this.x = 0;
this.y = 0;
}


// superclass method
Shape.prototype.move = function(x, y) {
this.x += x;
this.y += y;
log += 'Shape moved.\n';
};


// Rectangle - subclass
function Rectangle() {
Shape.call(this); // call super constructor.
}


// subclass extends superclass
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;


// Override method
Rectangle.prototype.move = function(x, y) {
Shape.prototype.move.call(this, x, y); // call superclass method
log += 'Rectangle moved.\n';
}


var log = "";
var rect = new Rectangle();


log += ('Is rect an instance of Rectangle? ' + (rect instanceof Rectangle) + '\n'); // true
log += ('Is rect an instance of Shape? ' + (rect instanceof Shape) + '\n'); // true
rect.move(1, 1); // Outputs, 'Shape moved.'
alert(log);

Personally, I find inheritance in Javascript awkward, but this is the best version I've found.

Thanks to CMS's answer and after fiddling for a while with prototype and Object.create and what not, I was able to come up with a neat solution for my inheritance using apply as shown here:

var myNamespace = myNamespace || (function() {
return {


BaseClass: function(){
this.someBaseProperty = "someBaseProperty";
this.someProperty = "BaseClass";
this.someFunc = null;
},


DerivedClass:function(someFunc){
myNamespace.BaseClass.apply(this, arguments);
this.someFunc = someFunc;
this.someProperty = "DerivedClass";
},


MoreDerivedClass:function(someFunc){
myNamespace.DerivedClass.apply(this, arguments);
this.someFunc = someFunc;
this.someProperty = "MoreDerivedClass";
}
};
})();

For those who reach this page in 2019 or after

With the latest version of the ECMAScript standard (ES6), you can use the keyword class.

Note that the class definition is not a regular object; hence there are no commas between class members. To create an instance of a class, you must use the new keyword. To inherit from a base class, use extends:

class Vehicle {
constructor(name) {
this.name = name;
this.kind = 'vehicle';
}
getName() {
return this.name;
}
}


// Create an instance
var myVehicle = new Vehicle('rocky');
myVehicle.getName(); // => 'rocky'

To inherit from a base class, use extends:

class Car extends Vehicle {
constructor(name) {
super(name);
this.kind = 'car'
}
}


var myCar = new Car('bumpy');


myCar.getName(); // => 'bumpy'
myCar instanceof Car; // => true
myCar instanceof Vehicle; // => true

From the derived class, you can use super from any constructor or method to access its base class:

• To call the parent constructor, use super().
• To call another member, use, for example, super.getName().

There’s more to using classes. If you want to dig deeper into the subject, I recommend “Classes in ECMAScript 6” by Dr. Axel Rauschmayer.*

source

From ES2015, that's exactly how you do inheritance in JavaScript

class Sub extends Base {


}

1. https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes
2. http://exploringjs.com/es6/ch_classes.html

function Base() {
this.doSomething = function () {
}
}


function Sub() {
Base.call(this); // inherit Base's method(s) to this instance of Sub
}


var sub = new Sub();
sub.doSomething();

ES6 classes:

Javascript does not have classes. Classes in javascript are is just syntactical sugar build on top of the prototypal inheritance pattern that javascript. You can use the JS class to enforce prototypal inheritance but it is important to realize that you are actually still using constructor functions under the hood.

These concepts also apply when you are extending from a es6 'class' using the extends keyword. This just creates an additional link in the prototype chain. The __proto__

Example:

class Animal {
makeSound () {
console.log('animalSound');
}
}


class Dog extends Animal {
makeSound () {
console.log('Woof');
}
}




console.log(typeof Dog)  // classes in JS are just constructor functions under the hood


const dog = new Dog();


console.log(dog.__proto__ === Dog.prototype);
// First link in the prototype chain is Dog.prototype


console.log(dog.__proto__.__proto__ === Animal.prototype);
// Second link in the prototype chain is Animal.prototype
// The extends keyword places Animal in the prototype chain
// Now Dog 'inherits' the makeSound property from Animal

Object.create()

Object.create() is also a way to create inheritance in JS in javascript. Object.create() is a function which creates a new object, an takes an existing object as an argument. It will assign the object which was received as an argument to the __proto__ property of the newly created object. Again it is important to realize we are bound to the prototypal inheritance paradigm which JS embodies.

Example:

const Dog = {
fluffy: true,
bark: () => {
console.log('woof im a relatively cute dog or something else??');
}
};


const dog = Object.create(Dog);


dog.bark();