John Resig的Javascript继承代码段是否已被弃用？ [英] Is John Resig's Javascript inheritance snippet deprecated?

问题描述

我正在寻找一种简单的方法来创建两个类，一个继承自另一个类，子项重新定义父方法之一，并在新方法中调用父类。

I'm looking for a simple way of creating two classes, one inheriting from the other, and the child redefining one of the parent's methods, and inside the new method, calling the parent's.

例如，有一个类 Animal 和 Dog ，其中Animal类定义了一个方法 makeSound（）确定如何输出声音，Dog然后在其自己的 makeSound（）方法中覆盖一个低音的声音，但同时也调用Animal的 makeSound（）来输出那个低音。

For example, having a class Animal and Dog, where the Animal class defines a method makeSound() which establishes how to output a sound, which Dog then overrides in its own makeSound() method to make a "woof" sound, but while also calling Animal's makeSound() to output that woof.

我看了John Resig的模型这里，但它使用原生的 arguments.callee 属性，这在ECMA脚本5中显然已经折旧了。这是否意味着我不应该使用John Resig的代码？

I looked at John Resig's model here, but it uses the native arguments.callee property which is apparently depreciated in ECMA script 5. Does that mean I shouldn't use John Resig's code?

使用Javascript的原型继承模型编写动物/狗代码的简洁方法是什么？

What would one neat, simple way of writing my animal/dog code using Javascript's prototype inheritance model?

推荐答案

这是否意味着我不应该使用John Resig的代码？

Does that mean I shouldn't use John Resig's code?

正确，而不是在严格模式下使用ES5时。但是，它可以很容易地适应：

Correct, not when you are using ES5 in strict mode. However, it can be easily adapted:

/* Simple JavaScript Inheritance for ES 5.1
 * based on http://ejohn.org/blog/simple-javascript-inheritance/
 *  (inspired by base2 and Prototype)
 * MIT Licensed.
 */
(function(global) {
  "use strict";
  var fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;

  // The base Class implementation (does nothing)
  function BaseClass(){}

  // Create a new Class that inherits from this class
  BaseClass.extend = function(props) {
    var _super = this.prototype;

    // Set up the prototype to inherit from the base class
    // (but without running the init constructor)
    var proto = Object.create(_super);

    // Copy the properties over onto the new prototype
    for (var name in props) {
      // Check if we're overwriting an existing function
      proto[name] = typeof props[name] === "function" && 
        typeof _super[name] == "function" && fnTest.test(props[name])
        ? (function(name, fn){
            return function() {
              var tmp = this._super;

              // Add a new ._super() method that is the same method
              // but on the super-class
              this._super = _super[name];

              // The method only need to be bound temporarily, so we
              // remove it when we're done executing
              var ret = fn.apply(this, arguments);        
              this._super = tmp;

              return ret;
            };
          })(name, props[name])
        : props[name];
    }

    // The new constructor
    var newClass = typeof proto.init === "function"
      ? proto.hasOwnProperty("init")
        ? proto.init // All construction is actually done in the init method
        : function SubClass(){ _super.init.apply(this, arguments); }
      : function EmptyClass(){};

    // Populate our constructed prototype object
    newClass.prototype = proto;

    // Enforce the constructor to be what we expect
    proto.constructor = newClass;

    // And make this class extendable
    newClass.extend = BaseClass.extend;

    return newClass;
  };

  // export
  global.Class = BaseClass;
})(this);

这篇关于John Resig的Javascript继承代码段是否已被弃用？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！