Differences between 'extends' in coffeescript and 'util.inherits' in node.js

coffeescript, node.js

Solution

Yes, you can use `extends` in place of it.

As for the differences? Let's start with a look at CoffeeScript:

class B extends A

Let's look at the JavaScript the CoffeeScript compiler produces for this JavaScript:

var B,
  __hasProp = {}.hasOwnProperty,
  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

B = (function(_super) {

  __extends(B, _super);

  function B() {
    return B.__super__.constructor.apply(this, arguments);
  }

  return B;

})(A);

So, `__extends` is used to declare the inheritence relationship between `B` and `A`.

Let's restate `__extends` a bit more readably, in CoffeeScript:

coffee__extends = (child, parent) ->
  child[key] = val for own key, val of parent

  ctor = ->
    @constructor = child
    return
  ctor.prototype = parent.prototype

  child.prototype = new ctor
  child.__super__ = parent.prototype

  return child

(You can check that this is a faithful reproduction by compiling it back to JavaScript.)

Here's what's happening:

- All the keys found directly on `parent` are set on `child`.

- A new prototype constructor `ctor` is created, with its instances' `constructor` properties set to the child, and its `prototype` set to the parent.

- The child class's `prototype` is set to an instance of `ctor`. `ctor`'s `constructor` will be set to `child`, and `ctor`'s prototype itself is `parent`.

- The child class's `__super__` property is set to `parent`'s `prototype`, for use by CoffeeScript's `super` keyword.

node's documentation describes `util.inherits` as follows:

Inherit the prototype methods from one constructor into another. The prototype of constructor will be set to a new object created from superConstructor.

As an additional convenience, superConstructor will be accessible through the constructor.super_ property.

In conclusion, you don't need to use `util.inherits` if you're using CoffeeScript's classes; just use the tools CS gives you, and you get bonuses like the `super` keyword.

Problem

Original source