speed of getter function vs direct access

Question

I have recently begun using more getter functions as opposed to direct access to make my code more flexible. I am curious what the cost of this is in terms of speed. Suppose that earth is an object and we have the following parent object:

var star={}
star.planet=earth
star.getPlanet=function(){
  return this.planet
}

Is there a non-negligible difference in speed between the following two statements?

print(star.planet)
print(star.getPlanet())

In a simple object literal a getter that just returns a property is redundant. — elclanrs, Sep 16 '13 at 22:44
It does add flexibility. If later you decide to change the property name or the exact location in which it is stored a getter means you only need to change a single piece of code rather than every point in your project where it is referenced. — gloo, Sep 16 '13 at 22:48

score 19 · Accepted Answer · answered Sep 17 '13 at 05:29

In V8:

A function that is so short and doesn't have context allocated variables will get inlined. Unless of course too much inlining has already accumulated, in which case the call is still very cheap as the entire executing part of function fits in a 64 byte instruction cache line.

Context allocated variables happen when your function uses for example arguments without being in strict mode or defines inner functions that reference the function's variables. Another problem is that on x64 functions cannot be inlined if the caller and callee cannot share the same context, so all in all, avoid closures like the plague.

See: http://jsperf.com/312319sakd although it looks like firefox uses dead code elimination (which is frustrating cos why waste time doing that?).

Bonus: this jsperf deliberately makes the getter function non-inlinable (through the huge comment which will make the function-size heuristic fail) in current V8. You can see that even if the function wasn't inlined, it's still only 25% slower than referencing the prop directly.

Note that when a function cannot be inlined it is considered a black box whose side effects are not known to the calling function, so the speed is highly context sensitive to the code.

[Too bad this doesn't seem to be true anymore](http://jsperf.com/getter-performance) — LJᛃ, Mar 17 '16 at 16:36
I did a bench with a getter if you are interested https://jsperf.com/getter-vs-direct-prop-access — dagatsoin, Nov 01 '17 at 13:44

score 4 · Answer 2 · answered Jul 14 '17 at 07:19

You don't need to create redundant getters/setters functions like this in JavaScript. If you at a later stage require some validation when setting a property or some preparation when getting a property you can do this.

var star = {
    get planet() {
        this._planet.prepare()
        return this._planet
    },
    set planet(planet) {
        if (! isPlanet(planet))
            throw Error('Not a planet')
        this._planet = planet
    }
}

star.planet = earth

... and not alter the usage of the object.

speed of getter function vs direct access

2 Answers2

Linked