JavaScript 面向对象范式是基于原型的。没有“类”，只有对象。

您可以通过不同的方式实现继承。两种更流行的选择是“伪经典”和“原型”形式。例如：

伪经典继承

我认为这是最流行的方式。您创建与new运算符一起使用的构造函数，并通过构造函数原型添加成员。

// Define the Person constructor function
function Person() {}

Person.prototype.sayHello = function(){
    alert ('hello');
};

// Define the Student constructor function
function Student() {}

// Inherit from Person
Student.prototype = new Person();

// Correct the constructor pointer, because it points to Person
Student.prototype.constructor = Student;

// Replace the sayHello method (a polymorphism example)
Student.prototype.sayHello = function () {
    alert('hi, I am a student');
}

var student1 = new Student();
student1.sayHello();

原型继承

基本上我们创建了一个辅助函数，它将一个对象作为参数并返回一个从旧对象继承的空新对象，对象从对象继承。

// Helper function
if (typeof Object.create !== 'function') {
    Object.create = function (o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}

var person = {
    sayHello : function () {
        alert('Person object');
    },
    walk : function () {
        alert('walk');
    }
};

var student1 = Object.create(person);
student1.sayHello = function () {
    alert('hello I am a student');
};

另一种有趣的形式是寄生继承。在“派生”构造函数中，您创建一个“基础”对象实例。该对象被扩充并返回新实例：

// Person constructor function
function Person(name) {
    this.name = name;
}

function Student(value) {
    var that = new Person(value);
    that.sayHello = function () {
        alert('hello I am a student');
    };
    return that;
}

如果你在 JavaScript 中做过面向对象编程，你就会知道你可以创建一个类，如下所示：

Person = function(id, name, age){
    this.id = id;
    this.name = name;
    this.age = age;
    alert('A new person has been accepted');
}

到目前为止，我们的类 person 只有两个属性，我们将给它一些方法。一个干净的方法是使用它的“原型”对象。从 JavaScript 1.1 开始，原型对象被引入 JavaScript。这是一个内置对象，可简化向对象的所有实例添加自定义属性和方法的过程。让我们使用其“原型”对象向我们的类添加 2 个方法，如下所示：

Person.prototype = {
    /** wake person up */
    wake_up: function() {
        alert('I am awake');
    },

    /** retrieve person's age */
    get_age: function() {
        return this.age;
    }
}

现在我们已经定义了我们的类 Person。如果我们想定义另一个名为 Manager 的类，它继承了 Person 的一些属性，该怎么办？当我们定义我们的 Manager 类时，重新定义所有这些属性是没有意义的，我们可以将它设置为从类 Person 继承。JavaScript 没有内置继承，但我们可以使用一种技术来实现继承，如下所示：

Inheritance_Manager = {};//我们创建一个继承管理器类（名字随意）

现在让我们给我们的继承类一个名为 extend 的方法，它接受 baseClass 和 subClassas 参数。在extend 方法中，我们将创建一个称为继承函数inheritance() { } 的内部类。我们使用这个内部类的原因是为了避免 baseClass 和 subClass 原型之间的混淆。接下来，我们使继承类的原型指向 baseClass 原型，如下代码所示：inheritance.prototype = baseClass。原型; 然后我们将继承原型复制到子类原型中，如下： subClass.prototype = new inherit(); 接下来是为我们的子类指定构造函数，如下所示： subClass.prototype.constructor = subClass; 完成子类原型设计后，我们可以指定接下来的两行代码来设置一些基类指针。

subClass.baseConstructor = baseClass;
subClass.superClass = baseClass.prototype;

这是我们的扩展功能的完整代码：

Inheritance_Manager.extend = function(subClass, baseClass) {
    function inheritance() { }
    inheritance.prototype = baseClass.prototype;
    subClass.prototype = new inheritance();
    subClass.prototype.constructor = subClass;
    subClass.baseConstructor = baseClass;
    subClass.superClass = baseClass.prototype;
}

现在我们已经实现了我们的继承，我们可以开始使用它来扩展我们的类。在这种情况下，我们要将 Person 类扩展为 Manager 类，如下所示：

我们定义了Manager类

Manager = function(id, name, age, salary) {
    Person.baseConstructor.call(this, id, name, age);
    this.salary = salary;
    alert('A manager has been registered.');
}

我们让它继承形式 Person

Inheritance_Manager.extend(Manager, Person);

如果您注意到，我们刚刚调用了 Inheritance_Manager 类的扩展方法，并在我们的例子中传递了子类管理器，然后是基类 Person。请注意，这里的顺序非常重要。如果您交换它们，继承将不会按您的预期工作，如果根本没有。另请注意，在实际定义我们的子类之前，您需要指定此继承。现在让我们定义我们的子类：

我们可以添加更多方法，如下所示。我们的 Manager 类将始终具有 Person 类中定义的方法和属性，因为它继承自它。

Manager.prototype.lead = function(){
   alert('I am a good leader');
}

现在为了测试它，让我们创建两个对象，一个来自类 Person，一个来自继承的类 Manager：

var p = new Person(1, 'Joe Tester', 26);
var pm = new Manager(1, 'Joe Tester', 26, '20.000');

请随时在以下位置获取完整代码和更多评论：http : //www.cyberminds.co.uk/blog/articles/how-to-implement-javascript-inheritance.aspx

JavaScript 继承是通过原型完成的。您不使用class关键字定义任何内容，而是创建一个函数，用作构建新对象的构造函数（使用new关键字 ）。

function person(name) {
    this.name = name;
}

person.prototype.getName = function() {
    return this.name;
}

var john = new person('john');
alert( john.getName() );

您可以通过以下方式访问此原型方法：

person.prototype.getName

所有新创建的对象都是基于核心构造函数（有时被来自经典继承语言的人称为类，或核心对象）如Object构造的，因此 JavaScript 中的每个对象都可以访问Object.prototype. 如果您要为所有对象创建自定义方法，您会这样做：

Object.prototype.foo = function(){};
alert( typeof ({}).foo ) // 'function'

要点：

• 的this字被用于指当前对象，所以this.name设置对象的名称属性时被创建new person被调用。
• 您可以在定义构造函数constructorName.prototype.nameOfMethod = function(){} 后在构造函数上定义新的原型方法。您不需要在构造函数内部定义它，这样更有效。
• 除非你在对象上明确定义属性，所以对于john我制作的对象，由于没有getName直接附加到john对象的方法，解释器需要向上移动到john对象的原型，也就是person.prototype从那里访问方法。您可以使用hasOwnProperty查看对象是否直接拥有属性。

参考：

• 重新审视继承
• JavaScript 中的经典继承

JavaScript 是基于原型的继承。但是，如果您使用 Ext-js，它将允许您拥有更经典的继承语法的语法。请注意，它仍在底层进行原型设计，因此您应该注意一些细微差别。主要是加载和运行，因此加载脚本的顺序很重要，并且类定义基本上位于内存中。

那里有一些很好的教程。我建议阅读初始文档并观看此视频。Ext 在让 JavaScript 感觉更像 Java 或 C# 以及减少您编写的标记数量方面做得非常好。然而，代价是你有一个更高的自定义组件的学习曲线。一旦您对语言的范围有了更深入的了解，您将能够更好地使用 mixins、函数来减少继承的需要。

下面是一个简单的继承示例。ClassA 是父类，ClassB 是子类，常见的任务是通过 ClassB 调用 ClassA 的打印方法，因此这里首先初始化构造函数，然后为父类创建原型方法。

var ClassA = function() {
this.name = "class A";
 }
var a = new ClassA();
ClassA.prototype.print = function() {
alert(this.name);
}

var inheritsFrom = function (child, parent) {
 child.prototype = Object.create(parent.prototype);
 };
var ClassB = function() {
     this.name = "class B";
     this.surname = "I'm the child";
 }

 inheritsFrom(ClassB, ClassA);
 var b = new ClassB();
 b.print();