0

Let's suppose there's a scope where variables are created in a loop... e.g, loop that is always executed in a repetitive call of game frame.

for(var i = 0; i !== 10; i ++) {
    for(var b = 0; b !== 10; b ++);
}

And if the variable i and the variables b (created 10 times on each time the loop block executes) in this code aren't removed from memory? JavaScript garbage collector shouldn't work equally in browsers.

I need to know what happens to these temporary variables created many times.

Improve this question

2 Answers 2

Reset to default
3

var variables are function scoped. Their declaration will be moved to the top of the function, and will only happen once. This is called hoisting.

Then, your code will become something like

var i, b;
// ...
for(i = 0; i !== 10; i ++) {
    for(b = 0; b !== 10; b ++);
}

And of course, creating 2 variables is not problematic.

Improve this answer
Sign up to request clarification or add additional context in comments.

10 Comments

So if the original code used let instead of var, would that be bad for performance?
@nnnnnn I don't think it would be really bad, but when you use let or const in a loop, a new binding is created at each iteration. (Well, at least this is what should happen. Firefox didn't do it last time I checked). So if a browser didn't implement this in an optimized way, it could be a bit slower.
And these i and b will be created everytime a game frame loop function is being called? (Suppose these loops are declared into a game loop function.) I didn't know about that, though.
I don't think it would be bad either, just thought it worth mentioning. But obviously JS engines expect to create variables and know how to optimise the more common patterns. Bottom line is I create the variables I need and don't worry too much unless performance is bad in practice.
@CoolMan,well that should really increase the memory-usage, and drop the overall performance. That's really the wrong point to optimize anything. The only way local variables may affect the performance in a bad way, is when you have to many (like 50+) diferent variables in one function so that the JIT-compiler doesn't even try to optimize this function anymore. But to this point, EVERYTHING ELSE in your code should be considered more than this "problem".
|
-1

Variables of number type take up very little memory, relatively speaking. What you should really worry about is repeatedly initiating bigger objects, like variables that require to be initiated with var foo = new ObjType(), for instance. Declaring simple counter variables in for loops is unnoticeable in today's computers.

If you're really worried about maximum optimization, you could do something like:

var i, b; function onFrame(){ for(i = 0; i !== 10; i++){ for(b = 0; b !== 10; b++){ } } }

That way you only declare those variables once. Although the difference in performance will be negligible.

Improve this answer

15 Comments

Small note: JS doesn't have integers, only 64 bit floating point numbers.
I do something of kind, but I want to do it different in my compiler of Lua to JS. To avoid problems I should create variables for each variable created in the user program.
@Marco Del Valle, in your example i and b are global vars; it's generally a bad practice to declare what should clearly be function-scoped globally, not just from memory management / performance considerations, but from the standpoint of ease of accidentally changing these values elsewhere in code - a recipe for headaches... Since in JS all vars are function-scoped anyway, it would be sufficient to declare them in the loop: for(var i = 0; i < 10; i++) { ... }
Good point, @CoolBots. I agree that declaring the variables in the loop would be easiest, cleanest, and less prone to mistakes, but since Cool Man is really worried about declaring them only once, I gave him a solution that would only declare those vars once, and reuse them.
@Oriol, basically it's true, but not entirely. JS knows only numbers, no ints, no doubles. But the underlying engines know them, and they utilize them. When you're doing bit-operations for example. Also when storing (signed) integers with values < 31!!! bits, the Array is optimized for this data-type (behind the scenes) That means lower memory-footprint and it's way faster. So actually JS uses 32-bit signed ints, although it doesn't know them. >>> actually even creates an 32bit uint.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.