[Question]
  [
What general tips do you have for golfing in JavaScript? I'm looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to JavaScript (e.g. "remove comments" is not an answer).
> 
> **Note:** Also see [Tips for Golfing in ECMAScript 6 and above](https://codegolf.stackexchange.com/questions/37624/tips-for-golfing-in-ecmascript-6)
> 
> 
> 
  
[Answer]
[Splitting with numbers to save the quotemarks:](https://github.com/jed/140bytes/wiki/Byte-saving-techniques#split-using-0)
```
"alpha,bravo,charlie".split(",") // before
"alpha0bravo0charlie".split(0)   // after
```
[Answer]
### Fancy For Loops
you can use the standard for loop in non-standard ways
```
for ( a; b; c )
```
is essentially equivalent to:
```
a;
while ( b )
{
  ...
  c;
}
```
so a good trick is to write your code with a `while` loop, and then split it into the `a,b,c` parts in a `for` loop.
A couple examples [I've written](https://codegolf.stackexchange.com/questions/1977/what-is-the-average-of-n-the-closest-prime-to-n-the-square-of-n-and-the-closest/1978#1978):
```
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);
```
### Chain your setters
If you're initializing or resetting multiple values, chain the value to all the variables that need it:
```
a=b=1;
```
### Implicit Casting
Don't check your types, just use them as they are. `parseInt()` costs `10` characters. If you need to cast out of a string, be creative:
```
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;
```
### Avoid Semicolons
JavaScript has automatic semi-colon insertion. Use it often and well.
### One-liners
Save on brackets by shoving as much as possible into single lines, or parameters:
```
a( realParam1, realParam2, fizz='buzz' )
```
### Increment/Decrement operators
```
a = a - 1;
foo(a);
```
and
```
foo(a);
a = a - 1;
```
can easily be rewritten as
```
foo(--a);
```
and
```
foo(a--);
```
respectively.
### Use `this` or `self` instead of `window` in global context
self explanatory 2 character savings.
### 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.longFunctionName(b)
a.longFunctionName(c)
//42
```
-vs-
```
a[f='longFunctionName'](b)
a[f](c)
//34
```
this is especially effective with functions like `document.getElementById` which can be reduced to `d[e]`.
Note:
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'`.
[Answer]
Use the comma operator to avoid braces (also [applies to C](https://codegolf.stackexchange.com/questions/2203/tips-for-golfing-in-c)):
```
if(i<10)m+=5,n-=3;
```
Instead of
```
if(i<10){m+=5;n-=3}
```
which is one character longer.
[Answer]
# Shorter random number generation
If you need a random boolean (`0` or `1`):
```
new Date&1 // equivalent to Math.random()<0.5
```
If you need a random integer `0 <= n < 1337`:
```
new Date%1337 // equivalent to Math.floor(Math.random()*1337))
```
This works because a `Date` is stored internally in JavaScript as the amount of milliseconds since an epoch, so the `new Date` is being coerced into `123somebignumber456` when you try to do integer math on it.
Of course, these "random" numbers really won't be as random, especially if you call them multiple times in quick succession, so keep that in mind.
[Answer]
You can use the object literal form of get/set to avoid using the keyword `function`.
```
var obj = {
  get f(){
    console.log("just accessing this variable runs this code");
    return "this is actually a function";
  },
  set f(v){
    console.log("you can do whatever you want in here, passed: " + v);
  }
};
1 && obj.f; // runs obj.[[get f]]
obj.f = Infinity; // runs obj.[[set f]](Infinity)
```
[Answer]
This one is lesser known and lesser used, but can be impressive if used in the right situation. Consider a function that takes no arguments and always returns a different number when called, and the returned number will be used in a calculation:
```
var a = [ 
    Math.random()*12|0,
    Math.random()*11|0,
    Math.random()*10|0,
    /* etc... */ 
];
```
You might normally shorten this function using a single-letter variable name:
```
var r=Math.random,a=[r()*12|0,r()*11|0,r()*10|0,r()*9|0,r()*8|0,r()*7|0,r()*6|0,r()*5|0];
```
A better way to reduce the length is by abusing `valueOf`, which gives you a saving of 2 characters per invocation. Useful if you call the function more than 5 times:
```
var r={valueOf:Math.random},a=[r*12|0,r*11|0,r*10|0,r*9|0r*8|0,r*7|0,r*6|0,r*5|0];
```
[Answer]
### Taking advantage of short-circuit operators
Rather than long `if` statements or using ternary operators, you can make use of `&&` and `||` to shorten your code. For instance:
```
var match = RegExp('[?&]' + name + '=([^&]*)').exec(window.location.search);
return match ? decodeURIComponent(match[1].replace(/\+/g, ' ')) : null;
```
can become
```
var match = RegExp('[?&]' + name + '=([^&]*)').exec(window.location.search);
return match && decodeURIComponent(match[1].replace(/\+/g, ' '));
```
The `||` operator is often used in this way for setting defaults:
```
evt = evt || window.event;
```
This is the same as writing 
```
if (!evt)
    evt = window.event;
```
### Creating repetitive strings using *Array*
If you want to initialize a long string of a particular character, you can do so by creating an array with a length of *n+1*, where *n* is the number of times you wish to repeat the character:
```
// Create a string with 30 spaces
str = "                              ";
// or
str = Array(31).join(" ");
```
The larger the string, the bigger the saving.
### Parsing numbers
Use `+` and `~` operators instead of `parseFloat()` or `parseInt()` when coalescing a string type that is *just a number* to a number type:
```
var num = "12.6";
parseFloat(num) === +num;  // *+* is **10** characters shorter than *parseFloat()*
var num2 = "12"
parseInt(num2) === +num2;   // *+* is **8** characters shorter than *parseInt()*
var num3 = "12.6"
parseInt(num3) === ~~num3;  // *~~* is **7** characters shorter than *parseInt()*
var num4 = "12.6"
parseInt(num4) === num4|0;  // *|0* is **7** characters shorter than *parseInt()*
```
Be wary though, other types can be coalesced with these operators (for instance, `true` would become `1`) an empty string or a string containing just white space would become `0`. This could be useful in certain circumstances, however.
[Answer]
**Unicode shortcuts**
If you use a hell of a built-in property at a big golfing challenge you can alias every property to a one character equivalent:
```
[Math,Number,S=String,Array].map(b=>
    Object.getOwnPropertyNames(b).map((p,i)=>
        b.prototype[S.fromCharCode(i+248)]=b[p]
    )
)
```
After executing the code above you can use it like this:  
`"foo".Č(/.*/,'bar') // replaces foo with bar`
**This costs 118 bytes, so it might not be useful in certain situations**
It may be browser dependent and i'm not sure if it's shorter than `with(Array){join(foo),...}` or defining variables as used properties `with(Array){j=join,m=map...}` but still it is worth mentioning. 
```
    Math        Number              String              Array
ø   toSource    prototype           prototype           prototype
ù   abs         NaN                 quote               join
ú   acos        POSITIVE_INFINITY   substring           reverse
û   asin        NEGATIVE_INFINITY   toLowerCase         sort
ü   atan        MAX_VALUE           toUpperCase         push
ý   atan2       MIN_VALUE           charAt              pop
þ   ceil        MAX_SAFE_INTEGER    charCodeAt          shift
ÿ   clz32       MIN_SAFE_INTEGER    contains            unshift
Ā   cos         EPSILON             indexOf             splice
ā   exp         isFinite            lastIndexOf         concat
Ă   floor       isInteger           startsWith          slice
ă   imul        isNaN               endsWith            filter
Ą   fround      toInteger           trim                isArray
ą   log         parseFloat          trimLeft            lastIndexOf
Ć   max         parseInt            trimRight           indexOf
ć   min         length              toLocaleLowerCase   forEach
Ĉ   pow         name                toLocaleUpperCase   map
ĉ   random      arguments           normalize           every
Ċ   round       caller              match               some
ċ   sin                             search              reduce
Č   sqrt                            replace             reduceRight
č   tan                             split   
Ď   log10                           substr  
ď   log2                            concat  
Đ   log1p                           slice   
đ   expm1                           fromCharCode    
Ē   cosh                            fromCodePoint   
ē   sinh                            localeCompare   
Ĕ   tanh                            length  
ĕ   acosh                           name    
Ė   asinh                           arguments   
ė   atanh                           caller  
Ę   hypot           
ę   trunc           
Ě   sign            
ě   cbrt            
Ĝ   E           
ĝ   LOG2E           
Ğ   LOG10E          
ğ   LN2         
Ġ   LN10            
ġ   PI          
Ģ   SQRT2           
ģ   SQRT1_2         
```
[Answer]
Combine nested for loops:
```
// before:
for(i=5;i--;)for(j=5;j--;)dosomething(i,j)
// after:
for(i=25;i--;)dosomething(0|i/5,i%5)
```
Example with different values for `i`/`j`:
```
// before:
for(i=4;i--;)for(j=7;j--;)dosomething(i,j)
// after:
for(i=28;i--;)dosomething(0|i/7,i%7)
```
[Answer]
Sneak variable initialization into the prompt() call for getting user input
```
n=prompt(i=5);     // sets i=5 at the same time as getting user input
```
instead of using
```
n=prompt();i=5;
```
As a side-effect, it displays the input value in the prompt window while saving 1 character.
[Answer]
### Use `^` instead of `!=` or `==` when comparing to an integer
```
//x!=3?a:b
  x^3?a:b
//x==3?a:b
  x^3?b:a
```
### Replace calls to built-in Math functions with shorter expressions
```
//Math.ceil(n)
  n%1?-~n:n
//Math.floor(n)
  ~~n
  0|n
//Math.abs(n)
  n<0?-n:n
//Math.round(n)
  n+.5|0
//Math.min(x,y)
  x<y?x:y
//Math.max(x,y)
  y<x?x:y
```
[Answer]
# Array sum / product / quotient
**ES5**: 17 bytes
```
eval(a.join('+'))
```
**ES6**: 15 bytes
```
eval(a.join`+`)
```
Of course you can swap the `+` for anything you want, e.g., `*` for product or `/` for quotient. 
[Answer]
## Exception abusing
in case string/character literals are prohibited, you can use a try catch block:
```
try{something0}catch(e){str=e.message.split(0)[0]}
```
now `str` equals `"something"`
if more strings are needed you can chain it with a number (e.g. zeros)
```
try{something0foo0bar0}catch(e){arr=e.message.split(0)}
```
now `arr` equals `["something", "foo", "bar", " is not defined"]`
[Answer]
# Abuse literals
The recent sample: Check whether `"c"` is uppercase or lowercase, doesn't matter if not letter
```
"c"<{} // returns false, lower case
"C"<{} // returns true, upper case
```
[Answer]
If you need to check for NaN, don't use `isNaN(x)`, but use `x!=x`, which is shorter and also works.
```
if(isNaN(x)){
if(x!=x){
```
Note that this only works if `typeof(x) === "number"`; if it's a string for example, `isNaN("string")` returns `true`, but `"string" != "string"` returns `false`. Thanks to Cyoce for pointing this out!
[Answer]
Converting a `while` loop into a `for` loop is often equivalent:
```
while(i--);
for(;i--;);
```
But the second form can have variable initialization combined:
```
i=10;while(i--);
for(i=10;i--;);
```
Notice the second form is one character shorter than the first form.
[Answer]
If you're initializing a variable to `1` in every iteration of a loop (for example, resetting a variable in an outer loop for an inner loop), like the following (from [my answer to this question](https://codegolf.stackexchange.com/questions/4630/finding-not-quite-prime-numbers/4632#answer-4632)):
```
for(j=n-2;p=1,j++<=n;r|=p)for(i=1;++i<j;)p=j%i?p:0;
          ^^^^
```
Since the result of a condition like `j++<=n` is `1` whenever its true, you can just assign the condition directly to the variable (because when it becomes false, the loop will stop executing and will no longer matter):
```
for(j=n-2;p=j++<=n;r|=p)for(i=1;++i<j;)p=j%i?p:0;
          ^^^^^^^^
```
You can usually **save 2 characters** using this method. Regards to `@ugoren` for the idea in the comments to that answer.
---
For another example, I also applied this trick to [my answer here](https://codegolf.stackexchange.com/questions/4665/find-columns-where-all-characters-are-the-same/4669#4669) with the expression `w=r=++c<S.length` in my outer for loop, saving a total of 4 characters.
[Answer]
If you can accept Spidermonkey (for now) specific scripts, you can use [ECMAScript 6 arrow functions](http://wiki.ecmascript.org/doku.php?id=harmony%3aarrow_function_syntax). Insteading of writing code like the following.
```
a.map(function(x){return x*2}) // function? return?
```
You can shorten it like this.
```
a.map(x=>x*2)
```
[Answer]
# Rounding
I know that alternatives to `Math.floor()` have been posted, but what about the others?
## Flooring:
```
Math.floor(x) //before
0|x           //after
```
## Rounding:
```
Math.round(x) //before
0|x+.5        //after
```
## Ceiling:
```
Math.ceil(x) //before
x%1?-~x:x    //after - credits to @Tomas Langkaas
```
[Answer]
Use a bitwise operation to round a number toward zero:
```
// do this
T=Math.random()*6+1|0
// or do this
T=~~(Math.random()*6+1)
```
(Source: [Random dice tipping](https://codegolf.stackexchange.com/questions/958/random-dice-tipping/959#959))
[Operator precedence](https://developer.mozilla.org/en/JavaScript/Reference/Operators/Operator_Precedence) determines which will be shorter in your program.
[Answer]
**Looping Tip I**
You can save `1` character when looping by changing the `i` on the last time used:
```
//not so god
for(i=0;i<3;i++){
  alert(i);
}
//best
for(i=0;i<3;){
  alert(i++);
}
```
**Note:** works with `--` too (but modify the loop accordingly to avoid infinite looping)
---
**Looping Tip II**
There are certain scenarios where you can save one character by playing with the incrementing operator and values:
```
for(i=0;i++<9;)
for(i=0;++i<10;)
```
**Note:** you need to pay attention when for example `0 to -1`. and `9 to 10, 99 to 100`, so play around until you find a way to save the character
[Answer]
Very simple one, even so, no one had mentioned it.
If you're using `Math.min()` or `Math.max()` you can save 6 chars by doing this:
```
Math.min(a,b)  // 13 chars
a<b?a:b        //  7 chars
Math.max(a,b)
a>b?a:b
```
[Answer]
### Free commas!
Often you'll want to include a comma in a string, perhaps like so:
```
f=(x,y,z)=>x+","+y+z
```
By abusing the string representation of arrays, this can be shortened by two bytes:
```
f=(x,y,z)=>[x,y]+z
```
This particular instance only works if you have three variables you want to concatenate as shown. You can use the same trick with two, but you need to be careful. There are three variants you might try:
```
f=(x,y)=>[x,y]
f=(x,y)=>[x,]+y
f=(x,y)=>x+[,y]
```
The first one will return an actual array rather than a string, which defeats the purpose. The second one *looks* like it will work, but in fact most modern browsers will remove the trailing comma when parsing the array. The third one will work though, at the same byte count as the second.
---
To put this to good use, say you have a function which creates the range `[0...n]`:
```
f=x=>x?[...f(x-1),x]:[0]
```
If returning a string with a separator is allowed, you might do something like this, saving a few bytes:
```
f=x=>x?f(x-1)+" "+x:0
```
However, you can save another byte with an array literal:
```
f=x=>x?f(x-1)+[,x]:0
```
Note that depending on how you arrange the recursion, you may end up with a leading or trailing separator, so you'll need to make sure your output format is allowed by the challenge.
[Example usage](https://codegolf.stackexchange.com/a/113056/42545)
[Answer]
# Prefer `.map` over `.reduce`
Consider the following code for summing an array:
```
a.reduce(function(x,y){return x+y})
```
Pretty long, right? What if I told you that you could get rid of the `return`? Well, you can:
```
a.map(function(x){t+=x},t=0)    // 7 bytes saved
```
(Although an even shorter way is `eval(a.join("+"))`.)
How about reducing by multiplication, where you have to specify the starting number anyway?
```
a.reduce(function(x,y){return x*y},1)  // Looooong
a.map(function(x){t*=x},t=1)    // An easy 9 bytes shorter
```
(Again, `eval(a.join("*"))` works as well.)
Here, let's try one that doesn't work with `eval(a.join())`:
```
a.reduce(function(x,y){return x+f(y)})
a.map(function(x){t+=f(x)},t=0)
```
Note that this doesn't work *quite* as well with ES6, although it's still a little shorter:
```
a.reduce((x,y)=>x+f(y))
a.map(x=>t+=f(x),t=0)
```
**Note:** in all of the `.map` versions, you will need to call `t` afterwards to get the actual value.
[Answer]
## Converting an array of strings into numbers
Take the array `["32", "0x30", "0o10", "7.642", "1e3"]`. The simple way to convert this to numbers would be `.map(n=>+n)` or `.map(Number)`.
However, assuming you know everything is a valid number, you can simply use `.map(eval)`, saving at least a byte.
[Answer]
Something worth noting is that you can use a string in place of zero in some instances to save a couple of bytes here and there in loops:
```
s='';for(i=0;i++<9;)s+=i
for(i=s='';i++<9;)s+=i
// s="123456789", i=10
```
[Answer]
**How to compare a number with help of how numbers turn into booleans:**
If you are going to check if something is equal to a *positive number*, you can subtract that amount and reverse what was inside the `if` and `else` blocks:
```
//simplified examples:
x==3?"y":"n"; <- 13 Chars
x-3?"n":"y"; <- 12 Chars
//expanded examples:
if(x==3){
    yes();
}else{
    no();
}
if(x-3){
    no();
}else{
    yes();
}
```
And in case you are wanting to compare with a *negative number* (\*different than `-1`), you just simply need to *add* this number instead of subtracting.
\*well, you can surely use `x.indexOf(y) + 1`, but in the special case of `-1` you have the opportunity to use `~x.indexOf(y)` instead.
[Answer]
In cases where you are using the ternary operator to chose between two *numbers*, and the conditional is either a *boolean* or *number* `1 or 0`, you can do math operations instead:
```
(x ? num1 : num2) conclusions:
    1)if num1 equals num2, there ARE savings
    2)if num1 is (+1) or (-1) than num2, there ARE savings
    3)if either num1 or num2 equals to 0, there ARE savings
    4)it is MORE LIKELY to find greater savings on num1>num2 instead of num1<num2
    5)in method (*A) and (*B), savings are NOT GUARANTEED
    a)num1>num2
        i)(num1==(num2+1))
            ex1: (x?5:4) to (x+4)
            ex2: (x?8:7) to (x+7)
        ii)num2==0
            ex1: (x?3:0) to (x*3)
            ex2: (x?7:0) to (x*7)
        iii)
            (*A) or (*B) //one might be shorter
    b)num1<num2
        i)((num1+1)==num2)
            ex1: (x?4:5) to (5-x)
            ex2: (x?7:8) to (8-x)
        ii)num1==0
            ex1: (x?0:3) to (!x*3)
            ex2: (x?0:7) to (!x*7)
        iii)
            (*A) or (*B) //one might be shorter
    c)num1==num2
        i)
            ex1: (x?5:5) to (5)
            ex2: (x?-3:-3) to (-3)
    (*A) use ((x*(num1-num2))+num2)
        ex1: (x?8:4)   to ((x*4)+4)
        ex2: (x?4:8)   to ((x*-4)+8)
        ex3: (x?6:-4)  to ((x*10)-4)
        ex4: (x?-4:6)  to ((x*-10)+6)
        ex5: (x?4:-6)  to ((x*10)-6)
        ex6: (x?-6:4)  to ((x*-10)+4)
        ex7: (x?-5:-9) to ((x*4)-9)
        ex8: (x?-9:-5) to ((x*-4)-5)
    (*B) use ((!x*(num2-num1))+num1)
        ex1: (x?8:4)   to ((!x*-4)+8)
        ex2: (x?4:8)   to ((!x*4)+4)
        ex3: (x?6:-4)  to ((!x*-10)+6)
        ex4: (x?-4:6)  to ((!x*10)-4))
        ex5: (x?4:-6)  to ((!x*-10)+4)
        ex6: (x?-6:4)  to ((!x*10)-6)
        ex7: (x?-5:-9) to ((!x*-4)-5)
        ex8: (x?-9:-5) to ((!x*4)-9)
```
**Note:** In addition to this, you will need to remove the unnecessary `0-`, `+0`, `+-` etc.
**Note2:** there is an isolated case where `(x) !== (x?1:0)`, as `x` must be `typeof === "number"` for it to work. However, in the case of `(-x)` it works just fine.
**Note3:** In case you don't find savings, simply use the former `(x?y:z)`
Previously I thought method B couldn't ever beat A, however exceptions do exist:
```
(x?97:100) //original
(-3*x+100)
(3*!x+97)
```
I created a [github project](https://github.com/ajax333221/Ternary-Optimizer) that makes the simplification for us ([**jsFiddle demo**](http://jsfiddle.net/Q7T2a/1/embedded/result/))
[Answer]
Instead of writing `true` you can use `!0`.
[Answer]
**Transforming to a Boolean**:
```
if(b){b=true}else{b=false}
b=b?true:false;
b=b?!0:!1;
b=!!b;
```
**Note:** This changes `0`, `""`,`false`, `null`, `undefined` and `NaN` to `false` (everything else to `true`)
]