ES6内部类内存疑问：构造函数内定义内部类会重复分配内存吗？

Great questions! Let's break them down clearly with examples tied to your code:

1. Do inner classes in ES6 use more memory? #

It depends entirely on where you define the inner class:

• If you define the inner class inside the outer class's body (not the constructor), it's attached to the outer class's prototype (or as a static member) and shared across all instances of the outer class. This uses a single chunk of memory for the inner class.
• If you define the inner class inside the outer class's constructor (like your Element class), every time you create a new instance of the outer class, a brand new inner class is created. This means each outer instance gets its own copy of the inner class, which does use additional memory.

2. If an inner class is created in the outer class's constructor, does each outer class instance get its own separate memory allocation? #

Yes, absolutely. Let's use your PriorityQueue code to explain why:

In your constructor, you're doing this.Element = class { ... }. Classes in JavaScript are just syntactic sugar for functions and their associated prototype objects. Every time the PriorityQueue constructor runs (i.e., every time you call new PriorityQueue()), a new function object (and its unique prototype chain) is created for Element.

You can test this easily:

const pq1 = new PriorityQueue();
const pq2 = new PriorityQueue();
console.log(pq1.Element === pq2.Element); // Logs false!

This confirms that pq1.Element and pq2.Element are entirely separate class objects, each taking up their own memory space.

A quick optimization tip #

If your Element class doesn't need to access instance-specific properties of PriorityQueue (like maxSize), you should move it outside the constructor to avoid redundant memory usage. For example, you can make it a static private class:

class PriorityQueue {
  // Static private inner class - shared across all instances
  static #Element = class {
    constructor(data, priority) {
      this.data = data;
      this.priority = priority;
    }
  }

  constructor(maxSize) {
    this.maxSize = isNaN(maxSize) ? 10 : maxSize;
    this.container = [];
  }

  // Example method using the inner class
  enqueue(data, priority) {
    const element = new PriorityQueue.#Element(data, priority);
    // Rest of your enqueue logic...
  }
}

Now all PriorityQueue instances share the same #Element class, so you only use memory for it once.

内容的提问来源于stack exchange，提问作者ayushgp