Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How much memory does one array-element take?

Tags:

javascript

I think there can be a difference between browers,

but how do I find out how much memory an array or one element of it takes in Javascript?

I want to figure out how much space I save when using a typed array.

Thanks in advance!

like image 623
kaljak Avatar asked Dec 17 '12 14:12

kaljak


People also ask

Does an array take up memory?

Unless it's a VLA, array size is a compile time constant, so it does not matter how much memory you're actually using, it will take up the amount of memory same as the size of the array given at the time of definition.

How many bytes is an array of elements?

An array is an object which also has an overhead of 24 bytes plus 4 bytes for the length plus data. An int[] array thus uses 28 bytes plus 4 bytes for each int. An Integer[] array uses 28 bytes plus 4-8 bytes to reference each Integer object plus 28 byte for each unique Integer object.

How much memory does an array use in C?

If the array is a character array, then its elements will occupy 1 byte of memory each. If it is a float array then its elements will occupy 8 bytes of memory each.

How do you determine the size of an array memory?

Using size and itemsize attributes of NumPy array size: This attribute gives the number of elements present in the NumPy array. itemsize: This attribute gives the memory size of one element of NumPy array in bytes.


1 Answers

This depends on a wide number of aspects.

  • The length of the reference used to store the variable can vary in size (If you are not using associative arrays, which don't actually exist in JS, but that's a different discussion).
  • The item itself can also vary in size. Basically, the binary representation used to store the certain type of object is what makes the memory.
    • An 8 bit int uses 1 byte.
    • A 16 bit int uses 2 bytes.
    • A character in a string uses either 2 or 4 bytes (because of UTF-16).
  • If you want a better insight on size/speed/execution times, I think the only accurate way to go is to use the profiling tools that come with the browser, or use addons like FireBug.

The reality is different. You shouldn't worry much about client side storage. Not in this way at least. The only memory specific control you really need is memoization. Other than that, all you need to do is to clean up your traces, so to speak. If you are in an OOP environment, make sure to always delete instance references and null your COM and DOM references once you are done with them.

 

If you wish to empty a collection (array), simply use the delete operator. If you are not defining the collection as an instance property, but instead you are using var as defining it as a context variable, use myArray.length = 0; which will delete the entire storage in the array.

 

If you are dealing with large collections, direct assignment is faster than using the Array.prototype.push(); method. myArray[i] = 0; is faster than myArray.push(0); according to jsPerf.com test cases.

 

The amount of time it takes to iterate over an array can vastly change depending on how you reference the array length, as well as the internet browser you use.

// Option 1
for (var i = 0; i < someArray.length; i++) {
    // do something;
};
// Option 2
var l =  myArray.length;
for(var i = 0; i < l; i++) {
    // do something
};
// Option 3
for (var i = 0, ii = someArray.length; i < ii; i++) {
    // do something;
};

Test cases for the above are available here.

As of June 6, 2015, the relative speeds are as follows:

+--------+------------+---------------+----------------------+
| Option | Firefox    | Google Chrome | Internet Explorer 11 |
+--------+------------+---------------+----------------------+
| 1      | Fastest    | 0.35% Slower  | 46% Slower           |
| 2      | 21% Slower | 0.15% Slower  | 0.09% Slower         |
| 3      | 21% Slower | Fastest       | Fastest              |
+--------+------------+---------------+----------------------+

 

When defining arrays, there is absolutely no point to specify the length, especially if you are doing deferred initialization.

// Doing this is pointless in JS. It will result in an array with 100 undefined values.
var a = new Array(100);

// Not even this is the best way.
var a = new Array();

// Using the array literal is the fastest and easiest way to do things.
var a = [];

Test cases for array definition are available here.

like image 198
flavian Avatar answered Oct 09 '22 15:10

flavian