inherits

What is inherits?

The inherits npm package is a simple utility module that allows you to implement inheritance in JavaScript. It facilitates the prototype chain linkage between a constructor function (child) and another constructor function (parent) to achieve classical inheritance patterns.

What are inherits's main functionalities?

Inheritance

This code demonstrates how to use the inherits package to set up classical inheritance between a custom constructor MyStream and the built-in EventEmitter constructor. It allows instances of MyStream to inherit methods and properties from EventEmitter.

var inherits = require('inherits');
var EventEmitter = require('events').EventEmitter;

function MyStream() {
  EventEmitter.call(this);
}

inherits(MyStream, EventEmitter);

MyStream.prototype.write = function(data) {
  this.emit('data', data);
};

var stream = new MyStream();
console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true

Other packages similar to inherits

util

The util package is a core Node.js module that provides a variety of utilities including the 'util.inherits' method, which is similar to the 'inherits' package. It allows you to set up inheritance between constructor functions. However, 'util.inherits' does not support ES6 classes and is considered a legacy feature in Node.js.

extend

The extend package is a utility to shallowly extend one object with one or more others. It is similar to inherits in that it is used to extend objects, but it does not set up the prototype chain for classical inheritance. Instead, it copies properties from source objects to a target object.

class-extend

The class-extend package provides helper functions for dealing with inheritance in JavaScript, specifically designed for ES6 classes. It offers a more modern approach compared to inherits, which is more suited for constructor functions rather than ES6 classes.

README

Browser-friendly inheritance fully compatible with standard node.js inherits.

This package exports standard inherits from node.js util module in node environment, but also provides alternative browser-friendly implementation through browser field. Alternative implementation is a literal copy of standard one located in standalone module to avoid requiring of util. It also has a shim for old browsers with no Object.create support.

While keeping you sure you are using standard inherits implementation in node.js environment, it allows bundlers such as browserify to not include full util package to your client code if all you need is just inherits function. It worth, because browser shim for util package is large and inherits is often the single function you need from it.

It's recommended to use this package instead of require('util').inherits for any code that has chances to be used not only in node.js but in browser too.

usage

var inherits = require('inherits');
// then use exactly as the standard one

note on version ~1.0

Version ~1.0 had completely different motivation and is not compatible neither with 2.0 nor with standard node.js inherits.

If you are using version ~1.0 and planning to switch to ~2.0, be careful:

• new version uses super_ instead of super for referencing superclass
• new version overwrites current prototype while old one preserves any existing fields on it