inheritance-2.js

100%

inheritance-2.js

✓ Published0🌍 Public

Last edited Nov 22, 2014

Created on Nov 22, 2014

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.

AI-generated description

Similar vizzes

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

93% match

Loading thumbnail…

calling-without-new.js

This example shows a JavaScript workaround for calling a constructor function without the `new` keyword. It defines a `Student` constructor that checks `this instanceof Student` and, if false, automatically returns a new instance via `new Student(...)`. The code then invokes `Student('John', 18, 'MIT')` without `new`, demonstrating how the guard ensures proper instantiation. It uses plain JavaScript constructor logic, with a commented-out call to `Person.call` indicating an intended inheritance pattern. The example prints a result via `junior2.getInfoCard()`, though the method itself is not defined in the visible snippet.

Aalessioalex

73% match

Loading thumbnail…

inherit.js

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.

Aabernier

72% 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

70% 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

66% 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

63% match

Loading thumbnail…

Classes

This example shows how JavaScript classes can be constructed using three different patterns: functional, prototypal, and pseudoclassical. It uses plain JavaScript functions, the `Object.create` API, and the `new` keyword to demonstrate object creation and method delegation through the `Car.prototype` object. The code defines a `Car` class with a `move` method that increments a `loc` property, illustrating how each pattern achieves the same behavior with varying levels of syntactic convenience.

MMurithi

63% match