具有继承的基于对象的类

var baseObject = 
{
     // Replication / Constructor function
     new : function(){
         return Object.create(this);   
     },

    aProperty : null,
    aMethod : function(param){
      alert("Heres your " + param + "!");
    },
}


newObject = baseObject.new();
newObject.aProperty = "Hello";

anotherObject = Object.create(baseObject); 
anotherObject.aProperty = "There";

console.log(newObject.aProperty) // "Hello"
console.log(anotherObject.aProperty) // "There"
console.log(baseObject.aProperty) // null

简单，甜蜜，搞定。

//新方法使用this和new 人员(姓名){ This.name = name; 这一点。Greeting = function() { 警报('你好!I\'m ' + this.name + '.'); }; ｝ var gee=新人员(“gee”); gee.greeting (); var gray=新人员(“灰色”); gray.greeting (); / /老方法 函数createPerson(名字){ var obj = {}; obj.name =名称; obj。Greeting = function(){ console.log("hello I am"+obj.name); }; 返回obj; ｝ var吉塔= createPerson(“吉塔”); gita.greeting ();

我更喜欢使用Daniel X. Moore的{SUPER: SYSTEM}。这是一个提供诸如真正的实例变量、基于特征的继承、类层次结构和配置选项等好处的规程。下面的例子说明了真正实例变量的使用，我认为这是最大的优势。如果你不需要实例变量，并且只喜欢公共或私有变量，那么可能有更简单的系统。

function Person(I) {
  I = I || {};

  Object.reverseMerge(I, {
    name: "McLovin",
    age: 25,
    homeState: "Hawaii"
  });

  return {
    introduce: function() {
      return "Hi I'm " + I.name + " and I'm " + I.age;
    }
  };
}

var fogel = Person({
  age: "old enough"
});
fogel.introduce(); // "Hi I'm McLovin and I'm old enough"

哇，这本身并不是很有用，但是看看添加一个子类:

function Ninja(I) {
  I = I || {};

  Object.reverseMerge(I, {
    belt: "black"
  });

  // Ninja is a subclass of person
  return Object.extend(Person(I), {
    greetChallenger: function() {
      return "In all my " + I.age + " years as a ninja, I've never met a challenger as worthy as you...";
    }
  });
}

var resig = Ninja({name: "John Resig"});

resig.introduce(); // "Hi I'm John Resig and I'm 25"

另一个优点是能够拥有基于模块和trait的继承。

// The Bindable module
function Bindable() {

  var eventCallbacks = {};

  return {
    bind: function(event, callback) {
      eventCallbacks[event] = eventCallbacks[event] || [];

      eventCallbacks[event].push(callback);
    },

    trigger: function(event) {
      var callbacks = eventCallbacks[event];

      if(callbacks && callbacks.length) {
        var self = this;
        callbacks.forEach(function(callback) {
          callback(self);
        });
      }
    },
  };
}

一个让person类包含可绑定模块的例子。

function Person(I) {
  I = I || {};

  Object.reverseMerge(I, {
    name: "McLovin",
    age: 25,
    homeState: "Hawaii"
  });

  var self = {
    introduce: function() {
      return "Hi I'm " + I.name + " and I'm " + I.age;
    }
  };

  // Including the Bindable module
  Object.extend(self, Bindable());

  return self;
}

var person = Person();
person.bind("eat", function() {
  alert(person.introduce() + " and I'm eating!");
});

person.trigger("eat"); // Blasts the alert!

披露:我是丹尼尔·x·摩尔，这是我的{SUPER: SYSTEM}。这是用JavaScript定义类的最佳方式。

ES2015类

在ES2015规范中，你可以使用类语法，它只是原型系统的糖纸。

class Person {
  constructor(name) {
    this.name = name;
  }
  toString() {
    return `My name is ${ this.name }.`;
  }
}

class Employee extends Person {
  constructor(name, hours) {
    super(name);
    this.hours = hours;
  }
  toString() {
    return `${ super.toString() } I work ${ this.hours } hours.`;
  }
}

好处

主要的好处是静态分析工具发现更容易定位这种语法。对于那些来自基于类的语言的人来说，使用这种语言作为一种多语言也更容易。

警告

要警惕它目前的局限性。要实现私有属性，必须使用符号或弱映射。在未来的版本中，类很可能会被扩展，以包含这些缺失的特性。

支持

目前浏览器的支持还不是很好(除了IE，几乎所有浏览器都支持)，但是现在你可以通过像Babel这样的编译器来使用这些特性。

资源

ECMAScript 6中的类(最终语义) 什么?等待。真的吗?哦，不!(一篇关于ES6类和隐私的文章) 兼容性表-类 巴别塔-班级

基于tritych的例子，这可能更简单:

    // Define a class and instantiate it
    var ThePerson = new function Person(name, gender) {
        // Add class data members
        this.name = name;
        this.gender = gender;
        // Add class methods
        this.hello = function () { alert('Hello, this is ' + this.name); }
    }("Bob", "M"); // this instantiates the 'new' object

    // Use the object
    ThePerson.hello(); // alerts "Hello, this is Bob"

这只创建了一个对象实例，但如果你想在一个类中封装一堆变量和方法的名称，这仍然是有用的。通常构造函数中不会有“Bob, M”参数，例如，如果方法将调用具有自己数据的系统，例如数据库或网络。

我仍然太新与JS看到为什么这不使用原型的东西。

我认为你应该阅读Douglas Crockford的《JavaScript中的原型继承》和《JavaScript中的经典继承》。

来自他的页面的例子:

Function.prototype.method = function (name, func) {
    this.prototype[name] = func;
    return this;
};

效果吗?它将允许你以更优雅的方式添加方法:

function Parenizor(value) {
    this.setValue(value);
}

Parenizor.method('setValue', function (value) {
    this.value = value;
    return this;
});

我也推荐他的视频: 先进的JavaScript。

你可以在他的个人主页http://javascript.crockford.com/上找到更多视频 在John Reisig的书中，你可以从Douglas Crockfor的网站上找到许多例子。