How do you create an object of a function on the heap?

In JavaScript, functions themselves are objects. When you create a function, it's not directly allocated on the heap. Instead, the function's code, along with its associated scope, is stored in memory. When you instantiate an object using a constructor function, or class, using the new keyword, that's when an object is created on the heap. Let's break down how to accomplish this:

1. Define a Constructor Function (or Class):

- A constructor function (or class) serves as a blueprint for creating objects. It initializes the properties and methods of the new object. Here's an example:

function MyConstructor(name, age) {
 this.name = name;
 this.age = age;
 this.greet = function() {
  console.log("Hello, my name is " + this.name + " and I am " + this.age + " years old.");
 }
}

Or, using a class:

class MyClass {
 constructor(name, age) {
  this.name = name;
  this.age = age;
 }
 greet() {
  console.log("Hello, my name is " + this.name + " and I am " + this.age + " years old.");
 }
}

2. Instantiate the Object using new:

- When you use the new keyword with the constructor (or class), a new object is created on the heap, and the constructor function’s or class constructor is called, initializing that newly created object.

const obj1 = new MyConstructor("John Doe", 30);
const obj2 = new MyClass("Jane Doe", 25);

- In this example, obj1 and obj2 are now objects that exist on the heap. These objects have the properties and methods defined by the constructor or class.

3. Verify Object Creation:

console.log(obj1);
obj1.greet();
console.log(obj2);
obj2.greet();

- You will see the object logged to the console, and you can call the greet method on each. This proves that a new object has been created and allocated on the heap for each instance.

- The key point here is that the memory allocation for the new objects (obj1 and obj2) happens on the heap. The function/class itself is defined in memory, and these instances are created based on that definition on the heap using the new keyword.

Key Takeaways:

- Functions are themselves objects but they exist in memory. - The use of the new keyword with a constructor function or a class creates new objects that are allocated on the heap. - Each call with the new keyword creates a distinct instance with its allocated memory, allowing objects to have their state.

Learn more about this