calling-without-new.js

100%

calling-without-new.js

✓ Published0🌍 Public

Last edited Nov 22, 2014

Created on Nov 22, 2014

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.

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

75% match

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

73% match

Loading thumbnail…

JavaScript Fundamentals

This example demonstrates JavaScript fundamentals through a minimal web page that logs a created person object to the browser console. The code walks through variable assignment, function declarations, arrow functions, and object mutation, ultimately using a concise ES6 arrow function with shorthand property names to create and output a person with first and last names. The page contains no visualization or external libraries, relying solely on native JavaScript and the console API to illustrate core programming concepts.

Kkathrynrbernard

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

57% match

Loading thumbnail…

JavaScript Basics

This example demonstrates fundamental JavaScript syntax and programming concepts through a series of commented-out code snippets, with only the final function call active. The active code defines a `person` function that returns an object with `first` and `last` properties, then logs the result of calling it with `('Jane', 'Doe')` to the console. The rendered output is an empty SVG element, as the example focuses on console-based learning rather than visual output. It serves as a minimal HTML page using raw JavaScript, with no external libraries or frameworks.

HHayden-V

57% match

Loading thumbnail…

Hidden classes in JavaScript and Inline Caching

This example illustrates how the V8 JavaScript engine optimizes object property access through hidden classes and inline caching, using a Person constructor with `firstName` and `lastName` properties. The visualization shows the creation of hidden classes (C0, C1, C2) as objects are initialized, and demonstrates how adding an `age` property changes the class chain. It also depicts assembly-level code snippets showing how V8 replaces a call to the Inline Cache with a direct memory address for a ~20x speed improvement, and explains when deoptimizations occur. The source is a Markdown document from a gist by Jastor11.

JJastor11

56% match

Loading thumbnail…

JS Bin

This example demonstrates JavaScript object constructors and method definitions using plain functions and the `new` keyword. It creates a `Task` constructor with properties for `name` and `completed`, as well as `complete` and `save` methods that log actions to the console. Four task instances are instantiated, with one marked complete and the others saved. The code uses no external libraries or data sources, relying entirely on native JavaScript syntax and console output to illustrate basic object-oriented patterns.

JJaxonDvl

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

56% match