CODEWITHSUNDEEP
javascriptperformance
imkost
imkost

Reputation: 8163

Does creating shortcuts in JS slows performance down

By shortcut I mean expression like: var do = some.thing.do

For example I have this code with shortcuts:

MyModule3 = {
  doSmth3 : function() {
    var doSmth1 = MyModule1.doings.doSmth1,
        doSmth2 = MyModule2.doings.doSmth2;

    doSmth1();
    doSmth2();
  }
}

And this one without shortcuts:

MyModule3 = {
  doSmth3 : function() {
    MyModule1.doings.doSmth1();
    MyModule2.doings.doSmth2();
  }
}

Will the first code be slower than the second one? I guess the answer is "yes, the first one is slower, but there is no reason to worry about it, because difference in performance will not be significant".

But what if I have hundreds of functions with shortcuts? Can this difference become critical at some moment?

=======

I tried to test it, but I've got strange result.

When I run:

testWithShortcuts();
testWithoutShortcuts();

then the first test runs faster than the second one. But If I run it in reversed order:

testWithoutShortcuts();  
testWithShortcuts();

then again first test runs faster.

I'm not familiar with performance testing. Maybe my test does not actually do what it is supposed to do.

Upvotes: 3

Views: 91

Answers (3)

Guffa
Guffa

Reputation: 700630

Yes, the code where you create the shortcuts will be slightly slower, but the difference is not significant.

For the difference to be significant, assigning the value to the variable would have to be a reasonably large part of what you are doing. Just calling a function is quite more expensive than assigning a value to a variable (even if the function doesn't do much), so creating the shortcut will never be significant.

Upvotes: 1

Sukima
Sukima

Reputation: 10084

TL;DR

No.

Real answer

Yes however, the measerable difference is so small that the concern is non-sensical in 99% of the time.

Discussion

To drive home the point it is better to optimise for maintainability, understandability, and clearity then it is to worry about a few extra pointers in memory. Infact once compiled to machinecode they are the same pointer it only impact would be in the JIT step which these days are measured in fractions of a millisecond.

It is better to code for readbility and only if the app starts to slow a little run some profiling find the slow parts and optimise that part. Chances are the slow issue is something completly different then the extra alias you made.

Upvotes: 3

Benjamin De Cock
Benjamin De Cock

Reputation: 230

Nope, that will never become critical. I'm tempted to take Paul Irish's words and say you're not even allowed to care about the performance of something like this ;)

Upvotes: 1

Related Questions