Javascript: what's difference between | and ||?

I'm looking at some Javascript code that is:

if ( a>2 | b>4 ) { ... }

(ignore the ... above). What's the | doing? I assume it's logical OR, but all the references I could find online speak about ||, and I can't find 开发者_C百科anything mentioning just |. Thanks in advance

It's the bitwise or. || is logical or.

The bitwise or (|) coerces the values to 32 bit integers and returns the 32 bit integer with each bit set to 1 if either of the two bits in the corresponding locations is 1 and 0 if they are both 0.

Logical or (||) evaluates to the first value if it's not falsey, otherwise it evaluates to the second value.

You almost definitely want || instead of |.

The difference between || and | is already explained in the other answers.

However, in the above code, | has the same effect as || due to type conversion.

true and false are mapped to 1 and 0 and we have

0 | 0 = 0
1 | 0 = 1
0 | 1 = 1
1 | 1 = 1

The same goes into the other direction, 1 evaluates to true and 0 to false.

So in this example,

if ( a>2 | b>4 )

will have the same result as

if ( a>2 || b>4 )

Note: This really only works with the two values 0 and 1.

This could be some kind of micro-optimization.

Update:

However, a short test reveals that using the bitwise OR for this purpose is way slower (at least in Chrome 9):

http://jsperf.com/js-or-test

Conclusion: Don't use it instead of logical OR :) Mostly likely someone forgot the second | and is just lucky that the code produces the same result.

Use boolean operators for boolean operations and bitwise operators for fancy bit masking. This might be worth reading: MDC - Bitwise Operators.

Single | is a bitwise-OR while double (||) is a logical-OR.

Bitwise-OR takes the binary representation of the two source values and ORs them together so that if either of the values has a bit set, the resulting value's bit will also be set (repeat for all the bits in the two source values).

Logical-OR concerns itself with true and false values (where 0 maps to false and non-zero maps to true - that's simplified, JavaScript has more specific rules). If either source value is true then the result is true.

Looks like second pipe just got lost, otherwise it is a smelly hack. See what really happens:

if ( Boolean( Number(a>2) | Number(b>4) ) ) { ... }

(Number is special here because bitwise operators are working with 32-bit integers) It works because Number(true) === 1 && Number(false) === 0.