0

I have an object:

var object = { string1 : 'hello', string2 : 'world' }

And If I want to call the string2 property of the object is it slower to call it multiple times like:

...object.string2... ...object.string2...

or it would be faster to create a reference for it what holds the value of the parameter like:

var string2 = object.string2; ...string2... ...string2...

The reason why I think that the second one could be faster, because I think right now that the first one always scans the whole object to grab the value.

Improve this question
3
  • It is faster, by about 50 nanoseconds. To put that in perspective, that's how long it takes light to travel fifteen meters, the width of a city street. To put it another way, let's say you've spent 15 minutes writing this question and reading the answers. You could have done 18 billion object references in that time. Really, really, you are worried about the wrong thing. Commented Aug 18, 2011 at 15:53
  • @Malvolio "Many a little makes a mickle"... I would like to write as fast applications as it is possible. Commented Aug 18, 2011 at 15:57
  • Fair enough, but the most limited resource is your own time. If you have 15 minutes, spend it benchmarking. Track down the actual bottlenecks in your code and fix them. Aquila non captat muscas (the eagle doesn't hunt flies). Commented Aug 18, 2011 at 16:01

2 Answers 2

Reset to default
1

You are correct - the second one is faster, because JavaScript does not need to perform the lookup of string2 each time. The change is even more profound in something like this:

(do stuff with foo.bar.baz.qux)

versus

var property = foo.bar.baz.qux; (do stuff with property)

In that example, foo must be scanned for bar. Then bar must be scanned for baz. Et cetera.

In your example the gain will be minimal unless you are doing a lot of work with string2, but you are correct in saying that it is faster.

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

3 Comments

Ohh, great I was frustrated for weeks :D I was using the the first scheme because It's more readable and It's easier to see where the value comes from but it was a bit evident that It's slower. Thanks very much for your answer!
I downvoted this answer, not because it was wrong (it isn't wrong) but because of the OP's reaction, which, to paraphrase, was "Thanks, I'm going to use the less readable way because it saves me 0.00000005 seconds". Read my comment on the question. Perspective, people, perspective.
Agreed - for any noticeable gain, you'll need to be doing a lot of iterations with a property that's pretty hard to find. It is important to find even small optimizations (Steve Souders recommends having your JS execute for at most 50ms at a time), but most likely you will get the most bang for your buck by focusing on bigger bottlenecks.
1

In you case this does not matter . But for big object with big prototype chunks - you right. But you may win in speed but loose in functionality because var a = obje.property coping by value - not by reference and if obj.property will be change dynamically that variable a will have old value of obj.property

Improve this answer

2 Comments

You're right if the property will change then I will not get the changed value. But I don't really see real life examples where this could happen. Otherwise If I use a shorthand variable then I will work with that so that will be the variable what will change, and If I'm in a function then each time I call the function the shorthand will be regenerated.
many real examples. You have an object and some methods chnage his property and you have observer which display new onformationabout object if at least one of his properties was change. If you coopy property to variable in observer - you can't see the changes and correct display it. And 'with' operator is very bad dont' use it

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.