在 JavaScript 或 TypeScript 中分配大量对象时如何避免 memory 碎片？

Question

Here is the examble code in TypeScript:

class Cell {
    public index: number = 0;
    public m: number = -1;
    public n: number = -1;
    public g: number = 0;
    public h: number = 0;
    public prev: Cell = null;
}

let cellArray: Array<Cell> = new Array<Cell>();
for (let i = 0; i < 99999; i++) {
    cellArray.push(new Cell());
}

The 999999 Cell objects in stack will cause the problem of memory fragment. In C++, I could do like this to allocate one large continuous memory:

new Cell[999999];

Is there any solution to this problem in JavaScript or TypeScript?

Answer 1

You can't control memory allocation explicitly in JS/TS. But, to ensure all object will be in the consecutive order implicitly, you can use ArrayBuffer and one of so called TypedArray . ArrayBuffer allocates single chunk of data in the heap, which you can access via one of the TypedArrays. Since class Cell have exactly the same number of properties of the same type in each instance, you can save those properties in the buffer, like this:

const propsPerObject = 4; // 4 values per Cell object, since index property can be calculated. Nothing stops you from saving them though
const numberOfObjects = 10; // max number of Cell objects which buffer could contain
const bytesPerProperty = 1; // depends on how big should numbers be in Cell instances. Check TypedArray reference to choose required size 
const bytes = propsPerObject * bytesPerProperty * numberOfObjects;
const buffer = new ArrayBuffer(bytes);

const int8 = new Int8Array(buffer); // I used this type according to bytesPerProperty variable

//write data for the third "object":
const index = propsPerObject * 3;
int8[index] = 0; // m property
int8[index + 1] = -1; // n property and so on...

I suggest you should create a class which will handle things such read/write etc. This wouldn't work with reference properties, though.

PS: instatiation of ArrayBuffer with huge number of elements can create an out of memory exception more easily than typical arrays.