inherit.js

100%

✓ Published0🌍 Public

Last edited Mar 13, 2015

Created on Mar 13, 2015

This example demonstrates classical inheritance for JavaScript constructors by providing an `inherit` utility function. The `inherit.js` file defines the helper, which copies a parent's static properties and sets up prototype chaining while exposing the parent's prototype as `child.uber`. The accompanying `index.html` shows a concrete usage where `Snake` inherits from `Animal`, calling the parent constructor via `Snake.uber.constructor.apply` and overriding the `move` method to invoke the parent's implementation. The example relies entirely on JavaScript's native prototype system, with no external libraries.

AI-generated description

Classical inheritance for constructors.

INSTALL

Client-side

<script src="inherit.js"></script>

Server-side

npm install https://gist.github.com/abernier/decf360c677a54aa415c/download

var inherit = require('inherit');

Usage

function A() {}
A.prototype.foo = function () {};

function B() {
  B.uber.constructor.apply(this, arguments);
}
inherit(B, A);
B.prototype.foo = function () {
  this.constructor.uber.foo.apply(this, arguments);
}

NB:

B.uber references to A.prototype
classically, you can access the ctor from prototype's methods thanks to constructor property.

ISC Licensed

Similar vizzes

Loading thumbnail…

inheritance-2.js

This example demonstrates JavaScript prototype-based inheritance by defining a Person constructor with a getInfoCard method, then creating a Student subclass that inherits from Person via `Object.create(Person.prototype)` and calls `Person.call(this, name, age)` to reuse the parent constructor. The code shows how Student instances, created with the `new` keyword, pass `instanceof Person` checks and access inherited methods like `getInfoCard`, while also adding their own `getName` method. It uses no external libraries, relying solely on native JavaScript constructors, prototypes, and object creation to illustrate classical-style inheritance patterns.

Aalessioalex

72% match

Loading thumbnail…

Holding for inheritance work

This example demonstrates JavaScript class inheritance and object-oriented programming concepts using a Dog and Animal class hierarchy. The code defines constructors, prototype methods like `bark()` and `cuddle()`, static methods, getters, and setters, showcasing how instance properties and computed values work. It extends an Animal base class with a Dog2 subclass using `super()` to initialize inherited properties. The example also includes commented-out template rendering code referencing Nunjucks and Handlebars libraries, though no data visualization or rendering is actively executed in the final output.

LLayne Smith

69% match

Loading thumbnail…

inheritance-0.js

The example demonstrates JavaScript prototype-based inheritance through a `Person` constructor function, where `getInfoCard` is defined on `Person.prototype` and returns a formatted name-and-age string. It shows how a `Student` constructor inherits this method, allowing an instance created with `new Student('John', 18, 'MIT')` to call it successfully. It also highlights a common pitfall: invoking `Student` without `new` assigns properties to the global object and causes `getInfoCard` to fail, since the returned value is not an object with that method. No external libraries are used; the code relies solely on core JavaScript constructors, `prototype`, and `instanceof` checks (commented out).

Aalessioalex

68% match

Loading thumbnail…

Example of prototype in JS

This example demonstrates JavaScript prototype-based inheritance and method overriding through a simple class hierarchy. It defines a parent `ClassA` and a child `ClassB` that inherits from it using `Object.create`, then overrides the `suchWow` method. The code also uses a global `App` object to track values shared across instances. After constructing instances of both classes and calling their methods, it outputs results using the console `log` API, showing how inherited methods affect instance and global state.

SServuc

66% match

Loading thumbnail…

Gist 7026512

This example demonstrates object-oriented JavaScript patterns for modeling zoo animals, showing how constructor functions and prototypes create shared behavior. The code defines an `Animal` constructor with `identify()` and `name()` methods on its prototype, while a `Zoo` object manages collections of animals. Although the zoo methods contain incomplete logic, the driver code tests animal identification, leg counts, and prototype method sharing across instances. The example uses plain JavaScript—no external libraries—relying on `console.log` for output and a custom `assert` function for validation. It illustrates inheritance and code reuse, though the zoo aggregation methods remain non-functional as written.

EElaineYu

64% match

Loading thumbnail…

Prototype Chains

Prototype Chains demonstrates JavaScript’s prototype-based inheritance through a series of code excerpts. It shows property lookup behavior, including failed lookups returning `undefined`, and contrasts one-time copying with `extend()` against ongoing delegation using `Object.create()`. The example illustrates how a linked object (rose) delegates missing property lookups to its prototype (gold), while copied objects (blue) do not reflect later additions. It also introduces the object prototype, the top-level fallback providing shared methods like `toString` for all objects.

MMurithi

63% match

Loading thumbnail…

Gist 247783

This visualization uses a single file of JavaScript notes to map three inheritance patterns in Douglas Crockford’s code—pseudoclassical, prototypal, and functional—as a branching, node-link diagram. The code renders each pattern as a cluster of objects and functions, with edges showing prototype chains and constructor relationships. It relies on native JavaScript APIs like `Object.create` and constructor functions, while the layout is drawn on an HTML canvas without external libraries. The source is a gist by DylanFM, and the visual emphasizes the structural differences between the patterns by positioning them in separate columns.

DDylanFM

62% match

Loading thumbnail…

Gist 7356491

This example demonstrates object-oriented JavaScript patterns for modeling a zoo’s animal inventory, using a custom `Animal` constructor and a `Zoo` object literal to organize data. The code filters animals by leg count through the `Array.prototype.filter` method, separating bipeds from quadrupeds, and includes an `identify` prototype method that returns a descriptive string. The driver code runs assertions to validate the logic, while the Zoo’s `init` method initializes the animal list. No external visualization libraries are used; the focus is on plain JavaScript structure and functional testing.

EElaineYu

58% match