2

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 anything mentioning just |. Thanks in advance

demongolem
  • 9,474
  • 36
  • 90
  • 105
ggkmath
  • 4,188
  • 23
  • 72
  • 129
  • 2
    See the answers to this question http://stackoverflow.com/questions/3439951/why-is-the-output-different-in-case-of – The Scrum Meister Feb 17 '11 at 01:21
  • 2
    The same as in most other programming languages ;) – Felix Kling Feb 17 '11 at 01:22
  • Imo you should accept @aaronasterling's answer as it actually describes how `|` works. My answer is merely an extended comment ;) – Felix Kling Feb 17 '11 at 01:49
  • While it's not present in any of the answers below... `|` *always* evaluates both arguments, where as `||` (and `&&`) are *short-circuit* operators and only evaluate as much as needed. e.g. `var res = true || thisIsNeverExecuted()` -- `||` (and `&&`) are usually [always] correct for dealing with logic, but sometimes (and very questionably so!), the short-circuit behavior is not wanted. Some people use `|` or `&` to get about this in a pinch. I'd argue for maintainable code instead though :) –  Feb 17 '11 at 02:10

4 Answers4

4

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 |.

aaronasterling
  • 68,820
  • 20
  • 127
  • 125
3

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.

Felix Kling
  • 795,719
  • 175
  • 1,089
  • 1,143
  • 1
    It is also important to note that || shortcircuits, | does not. – david Feb 17 '11 at 01:38
  • 1
    I have a hard time believing that this is a micro-optimization and not simply somebody not knowing the difference between the two. `||` can short circuit and doesn't require coercion. Neither of the two is true for `|`. – aaronasterling Feb 17 '11 at 01:38
  • 1
    @aaronasterling: Yes, using `|` is indeed an order of magnitud slower. – Felix Kling Feb 17 '11 at 01:40
2

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.

typo.pl
  • 8,812
  • 2
  • 28
  • 29
  • 3
    That is not true in JavaScript. The **value** of an overall "||" expression is the value of either the left side or the right side, depending on which of the two is not **falsy**. The left side is evaluated first, and if it's not **falsy** then that's the value of the "||"" expression. Otherwise the value is that of the right side. The distinction is that unlike, say, Java, the **type** of the result is not necessarily boolean - it can be **any** type. – Pointy Feb 17 '11 at 01:30
0

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.

Free Consulting
  • 4,300
  • 1
  • 29
  • 50