Question

 ap = Array.prototype,
 aps = ap.slice,
 apsp = ap.splice,

I often see code like above in different frameworks. What are the benefits of this?
Why not use it directly?

Answer 1

Several benefits:

1. Faster at run-time (fewer lookups to get the final result)
2. Smaller code before minification
3. Easier to reduce even more with minification
4. Less typing when coding

One should note that I think it makes the code less readable to people not already familiar with the code or its conventions because the code isn’t as self documenting. Everyone knows what Array.prototype.splice is but strangers don’t know what aps is until they study the code, track down its definition and remember what it is.

---

I was asked in a comment to explain the fewer lookups issue:

For the interpreter to resolve Array.prototype.splice, it has to do the following:

1. Look in the local scope for the Array name. It doesn’t find it.
2. Look in any closures (e.g. parent scope) for the Array name. It doesn’t find it.
3. Look in the global scope for the Array name. It finds it.
4. On the Array object, look for the prototype property.
5. On the prototype property, look for the splice property and now it finally has the function it needs.

For the interpreter to resolve aps, it has to do this:

1. Look in the local scope for the aps name. It finds it and not it has the function it needs.

The pre-assignment to aps has essentially pre-done the lookups so that they are already resolved at runtime. This removes some flexibility because if the value of the splice or prototype properties are changed, the variable aps won’t reflect that change, but if you know they aren’t supposed to change (something the run-time interpreter doesn’t know), then you can take advantage of this shortcut.