Javascript variable what is less efficient

Question

I am learning Javascript currently.I was wondering if there is any difference between:

var factor=0.1;
var limit=10;
var x;
var y;
x= limit*factor;
y= limit*factor;
//or
var limit=10;
var x;
var y;
x=limit *0.1;
y=limit*0.1;

Does it make any difference (when looking at performance for example)? If so, why it is different? The second example looks less promising to me, because I keep thinking that I am declaring the variable 0.1 twice. Thanks for your help in advance.

• binariedMe: in second example you are not declaring "0.1" twice and second would be more performant.
• Aluan Haddad: Do not start with optimization.
• dfsq: If you change 0.1 to 0.2 you will need to update it in all places where you use it. So the first version is better.
• binariedMe: inline function, variable are always more performant but less reusable
• XCS: No, there's no difference. The JavaScript engine should optimize both versions. Also, if there would be any difference it can safely be ignored. Just go for the one that is more readable.

Answer 1

There is a very small difference. When you use factor in the two multiplications, the JavaScript engine has to go look up the value of factor in the current lexical environment object each time — in theory, anyway; optimization may well be able to get rid of that, if and when the code is chosen for optimization by the JavaScript engine.

But regardless: Worry about performance problems when you have a performance problem to worry about. Instead, concentrate on readability and maintainability. If x and y are meant to be multiplied by the same value, put that value in something (a var, or perhaps a const with ES2015+), and use it in both places.

• Kaiido: I always wondered (even though I know it's of very tiny nano small difference), but is it harder for js engines to get hardcoded values than one declared in a variable before hand ? I mean, I always use the variable way because for me it's less pain, and that I don't care so much how interpreter will suffer, but still, your answer doesn't tell exactly in which way this tiny difference goes. It could make sense that a declared variable is easier to clean, but it could also make sense that avoiding to declare something also avoids the need to clean it up.
• T.J. Crowder: @Kaiido: I have no idea how much more/less work it is for the parser to parse 0.1 vs. factor. I doubt there's any real difference. But the code only gets parsed once when loaded, after which the parsed result is either interpreted or compiled. So that parsing difference, if there is one, isn't going to matter, whereas the symbol lookup could. (Just a few months ago I would have said that virtually no JavaScript engine uses an interpreter anymore, but recently V8 went back to interpretation -- bytecode-level, like Java -- for code that's only used rarely.)
• samid: @T.J Crowder I see , I did not really expect that it would be looked up twice.. But the first example is much more readible, so I will consider readibilty.. thanks for replying!
• T.J. Crowder: @samid: Well, if there's any optimization applied, it probably won't be. :-)
• samid: PS: (And of course maintainability, If I had alot of multiplications the first would damage my fingers less.

Answer 2

I would suggest you go ahead with the first example, but with a modification. Variables are meant to hold dynamic data, it is better to hold 0.1 in a variable, so you can change it over time if required.

// have a function so that you don't repeat the code
function getFactor(factor, limit) {
 return limit * factor;
}
//declare the variables and set the required default values
var factor = 0.1,
 limit = 10,
 x, y;
//assign getFactor to x and y variables
x = y = getFactor(factor, limit);

• T.J. Crowder: Question must have been updated, both examples use var.
• Mr. Alien: @T.J.Crowder zzzz, unfortunately, yes, thanks... will modify my answer.
• samid: @Mr.Alien My mistake, but thanks for anwering in any case!