与较小的类相比，大型类具有许多未使用的方法的数组需要更多的时间来计算吗？

如何解决与较小的类相比，大型类具有许多未使用的方法的数组需要更多的时间来计算吗？

我想知道以下事情：

我有一个2D游戏的“弹丸”类数组。每个弹丸的工作原理都略有不同，因此需要不同的方法。我开始意识到“弹丸”类可能会爆炸并采用多达100-200种不同的方法。当遍历数组时，大多数弹丸将不需要大多数方法，因此我想知道运行时间是否会由于大量“可能”的方法而变慢。或者，如果使用大型类的大型阵列内存会爆炸。我正在使用Javascript并尝试优化程序，但总体上要求。

现在，我知道在较小的类中继承弹丸类是有意义的（无论如何，im出于其他原因也在这样做），但问题仍然存在。或者，如果根本有问题，解决这个问题的最明智的方法是什么？

解决方法

创建大类的许多实例并不会增加内存使用量，因为所有方法都附加到实例原型，因此它只是多个实例引用的一个原型（包含方法）。

这是一个示范：

class BigClass {
  method1() {}
  method2() {}
  method3() {}
  // ...
}

const instance1 = new BigClass;
const instance2 = new BigClass;

console.log(Object.getOwnPropertyNames(BigClass.prototype));
console.log(Object.getPrototypeOf(instance1) === BigClass.prototype); // true
console.log(Object.getPrototypeOf(instance1) === Object.getPrototypeOf(instance2)); // true
console.log(instance1.method1 === instance2.method1); // true

拥有构造函数时，属性会附加到实例本身，从而与实例数量成比例地增加内存使用量。

演示：

class SomeClass {
  constructor(arg1,arg2,arg3) {
    this.arg1 = arg1;
    this.arg2 = arg2;
    this.arg3 = arg3;
  }
}

const instance1 = new SomeClass({});
const instance2 = new SomeClass({});

console.log(instance1.arg1 === instance2.arg1); // false

// Note: that is not true when you pass an argument as a reference
const obj = {};

const instance3 = new SomeClass(obj);
const instance4 = new SomeClass(obj);

// In that case,obj is shared between the two instances

console.log(instance3.arg1 === instance4.arg1); // true

instance3.arg1.test = 'value';
console.log(instance4.arg1); // { test: 'value' }