Return to Answer

for ( a; b; c ) 

a; while ( b ) { ... c; } 

for(x=y=n;!z;x--,y++)z=i(x)?x:i(y)?y:0 for(a=b=1;b<n;c=a+b,a=b,b=c); 

a=b=1; 

a='30'; b='10'; c = a + b; //failure c = parseInt(a) + parseInt(b) //too long c = -(-a-b); //try these c = ~~a+~~b; c = +a+ +b; c = a- -b; 

a( realParam1, realParam2, fizz='buzz' ) 

a = a - 1; foo(a); 

foo(a); a = a - 1; 

foo(--a); 

foo(a--); 

a.longFunctionName(b) a.longFunctionName(c) //42 

a[f='longFunctionName'](b) a[f](c) //34 

len | i ======== 1 | ∞ 2 | ∞ 3 | 7 4 | 4 5 | 3 6 | 3 7 | 3 8+ | 2 

for ( a; b; c ) 

a; while ( b ) { ... c; } 

for(x=y=n;!z;x--,y++)z=i(x)?x:i(y)?y:0 for(a=b=1;b<n;c=a+b,a=b,b=c); 

a=b=1; 

a='30'; b='10'; c = a + b; //failure c = parseInt(a) + parseInt(b) //too long c = -(-a-b); //try these c = ~~a+~~b; c = +a+ +b; c = a- -b; 

a( realParam1, realParam2, fizz='buzz' ) 

a = a - 1; foo(a); 

foo(a); a = a - 1; 

foo(--a); 

foo(a--); 

a.longFunctionName(b) a.longFunctionName(c) //42 

a[f='longFunctionName'](b) a[f](c) //34 

len | i ======== 1 | ∞ 2 | ∞ 3 | 7 4 | 4 5 | 3 6 | 3 7 | 3 8+ | 2 

###Use Array-Access for repeat function calls

This is definitely a balancing act between variable/function name length and number of invocations. Instead of calling a.longFunctionName() twice, it's shorter to save the name and call the function via array-access:

f='longFunctionName' a[f](b) a[f](c) //34 

this is especially effective with functions like document.getElementById which can be reduced to d[e]().

For a single call, the relative cost* is 8 + name.length characters. Each subsequent call has a relative cost of 2 characters.

For standard invocation, all calls cost name.length characters.

Use this method if 8 + name.length + (2 * invocations) < invocations * name.length

i = invocations len = minimum function length to get advantage

i | len ======= 1 | ∞ 2 | 12 3 | 7 4 | 6 5 | 5 6 | 4 

_{* relative cost doesn't include the calling object, perens, or parameters. Essentially: a.XXX() vs a[XXX]()}

###Use bracket notation for repeat property access

This is definitely a balancing act between property name length and number of accesses. Instead of calling a.longFunctionName() with dot notation twice, it's shorter to save the name and call the function via bracket notation:

a[f='longFunctionName'](b) a[f](c) //34 

this is especially effective with functions like document.getElementById which can be reduced to d[e].

With bracket notation, the cost is 6 + name.length characters the first time. Each subsequent access has a cost of 3 characters.

For dot notation, all accesses cost name.length + 1 (+1 for the .) characters.

Use this method if 6 + name.length + (3 * (accesses - 1)) < accesses * (name.length + 1).

len = length of property name
i = minimum accesses to take advantage

len | i  ======== 1 | ∞  2  | ∞  3 | 7  4  | 4 5  | 3 6  | 3 7 | 3 8+ | 2 

The number of accesses can also span multiple objects. If you access .length 4 or more times on different arrays, you can use the same variable holding the string 'length'.

A couple examples I've written:

A couple examples I've written: