JavaScript Memory – Memory Needed to Store a Function in JavaScript

functionsjavascriptmemory

I have been using sizeof.js to investigate the size of various objects in javascript. It appears from this that the size of a function is essentially zero bytes, regardless of how many instructions the function executes. Why is this so?

Best Answer

In most languages, code and data are different things. They occupy different parts of memory and don't interact with each other.

When you ask the code "how big is this" you are asking about "how big is the instantiated object". When looking at this you through tools like sizeof.js, you are asking the question "how big is the object representing the function pointer". And in this case, the object doesn't have any additional properties its size is negligible.

Asking how big something in a language like javascript which is often not compiled down too far becomes one of "how big is this parse tree", which doesn't have any real meaning at runtime... nor is it always accessible.

Some languages such as Lisp, where the data and code can mix a bit more freely (the code is data), such a question can be slightly more meaningful, though not really. While I'm sure if I fought with it long enough (my lisp is a bit rusty and I never delved into that realm of lisp metaprogramming), I could come up with:

(defun double (x) (* x 2))

(print (somefunc 'double))

such that it would print out a value of 2, or 4 depending on how you wanted to define that. But it's not a meaningful number in most cases.

Nor is the "how big is that function?" question asked of a javascript function pointer. It is. And whats more, under different javascript engines, if you could get a number, it would likely be different.

So:

The question you are asking of sizeof.js is giving you back the right number.
The object that represents the function pointer has no appreciable size associated with it.
Hypothetically, it could have data that wasn't the code associated with it and you would get back a different number.
The code lives in a different spot in memory than the data that sizeof.js may not have a way to access.
The size of the code isn't a meaningful number within the runtime.

Related Solutions

Java – Why did memory-managed languages like Java, Javascript, and C# retain the `new` keyword

Your observations are correct. C++ is a complicated beast, and the new keyword was used to distinguish between something that needed delete later and something that would be automatically reclaimed. In Java and C#, they dropped the delete keyword because the garbage collector would take care of it for you.

The problem then is why did they keep the new keyword? Without talking to the people who wrote the language it's kind of difficult to answer. My best guesses are listed below:

It was semantically correct. If you were familiar with C++, you knew that the new keyword creates an object on the heap. So, why change expected behavior?
It calls attention to the fact that you are instantiating an object rather than calling a method. With Microsoft code style recommendations, method names start with capital letters so there can be confusion.

Ruby is somewhere in between Python and Java/C# in it's use of new. Basically you instantiate an object like this:

f = Foo.new()

It's not a keyword, it's a static method for the class. What that means is that if you want a singleton, you can override the default implementation of new() to return the same instance every time. It's not necessarily recommended, but it's possible.

Memory Usage – Analyzing Memory Usage in Java vs C++

It depends on the platform and implementation.

C++ guarantees that the size of char is exactly one byte and at least 8 bits wide. Then, size of a short int is at least 16 bits and not smaller than char. Size of an int is at least as big as size of short int. Size of long int is at least 32 bits and not smaller than int.

sizeof(char) == 1; sizeof(long int) >= sizeof(int) >= sizeof(short int) >= sizeof(bool) >= sizeof(char).

The actual memory model of C++ is very compact and predictable though. For example there is no metadata in objects, arrays or pointers. Structures and classes are contiguous just like arrays are, but padding may be placed where necessary and needed.

Frankly though, such comparison is silly at best as the Java memory usage depends more on the Java implementation than on the code it runs.

Best Answer

Related Solutions

Java – Why did memory-managed languages like Java, Javascript, and C# retain the `new` keyword

Memory Usage – Analyzing Memory Usage in Java vs C++

Related Topic