Inheritance in JavaScript

function Extend(subclass, superclass)
{
	// Define a private function
	function F(){}
 
	/*
	 * This means that any new instances of "F"
	 * will have their prototype pointing to the superclass prototype.
	 */
	F.prototype = superclass.prototype;
 
	/*
	 * The following code basically means that any new instances of the subclass
	 * will mean its prototype will point to the "F" instance.
	 *
	 * The prototype for "F" then points to the superclass' prototype.
	 * This means that changes to superclass.prototype will
	 * propagate to all subclass instances (through the inheritance chain).
	 *
	 * Also, because we have created a 'new' object for
	 * the subclass' prototype property (i.e. we've created a new instance of F() rather than just point to the prototype object),
	 * we can add to subclass.prototype without affecting the superclass prototype.
	 */
	subclass.prototype = new F();
 
	/*
	 * Also, whenever you create a new object instance in JavaScript,
	 * that instance's local "constructor" property points to
	 * the function (Constructor) that was invoked to create the instance.
	 *
	 * But sometimes this property can display the incorrect data.
	 * So to prevent any confusion when it comes to checking an instance's constructor value (for the purposes of type checking)
	 * it is best to reset the constructor property to point to the subclass constructor.
	 */
	subclass.prototype.constructor = subclass;
 
	/*
	 * The final two lines are used as convenience properties
	 * when invoking ancestor constructors and methods.
	 */
	subclass.superclass = superclass;
	subclass.superproto = superclass.prototype;
}
 
function Person(name, age)
{
	this.name = name;
	this.age = age;
}
 
function Employee(name, age, department)
{
	Employee.superclass.call(this, name, age);
	this.department = department;
}
 
/*
 * Call the Extend function
 * (which ensures "Employee" inherits from the "Person" object/class)
 */
Extend(Employee, Person);
 
// Add a new method to the Employee object/class
Employee.prototype.display = function()
{
	console.log(this.name + "\n" + this.age + "\n" + this.department);
};
 
// Create a new instance of the Employee object/class.
var employee = new Employee("Mark McDonnell", 27, "Digital Media");
 
// Display the "employee" data
employee.display();

function Clone(object)
{
	function F() {}
 
	/*
	 * If any method or property lookup on the current Object instance fails,
	 * that lookup will then look to the prototype object
	 */
	F.prototype = object;
	return new F;
}
 
var Person = {
	name: null,
	age: null,
	getName: function()
	{
		return this.name;
	},
	getAge: function()
	{
		return this.age;
	}
};
 
/*
 * To create Author, you don’t make a subclass of Person.
 * Instead you make a clone:
 */
var Author = Clone(Person);
Author.books = [];
Author.getBooks = function()
{
	return this.books;
};
 
// Now create some more objects based on "Author"
var author = [ Clone(Author), Clone(Author) ];
 
author[0].name = "Mark McDonnell";
author[0].age = 27;
author[0].books = ["Book 1","Book 2"];
 
author[1].name = "Joe Bloggs";
author[1].age = 39;
author[1].books = ["Book A","Book B","Book C","Book D"];
 
// Display the "author" data
console.log(author[0].getName() + "\n" +  author[0].getAge() + "\n" + author[0].getBooks());
console.log(author[1].getName() + "\n" +  author[1].getAge() + "\n" + author[1].getBooks());