Question: What's the difference between `|` and `||` in Javascript?

Furthermore, what's the difference between `&` and `&&`?

Answer: 
* `&` is [the bitwise AND operator](http://rx4ajax-jscore.com/resource/glossary/glossb.html#bitwise_and_operator)
* `|` is [the bitwise OR operator](http://rx4ajax-jscore.com/resource/glossary/glossb.html#bitwise_or_operator)
* `&&` is [the logical AND operator](http://www.devguru.com/technologies/ecmascript/quickref/logical_operators.html)
* `||` is [the logical OR operator](http://www.devguru.com/technologies/ecmascript/quickref/logical_operators.html)

The difference is that logical operators only consider each input at face value, treating them as whole, while [bitwise operators work at the bit level](http://en.wikipedia.org/wiki/Bitwise_operation):

```
var thetruth = false;
var therest = true;

var theuniverse = thetruth && therest; //false
var theparallel = thetruth && thetruth; //true

var theindifferent = thetruth || therest; //true
var theideal = thetruth || thetruth; // false

var thematrix = 5346908590;
var mrsmith = 2354656767;

var theoracle = thematrix & mrsmith; //202445230
var theone = thematrix | mrsmith; //7499120127

```
In Javascript perspective, there is more to it.

```
var a = 42;
var b = "abc";
var c = null;

a || b;     // 42
a && b;     // "abc"

c || b;     // "abc"
c && b;     // null

```

Both || and && operators perform a boolean test on the first operand (a or c). If the operand is not already boolean (as it's not, here), a normal ToBoolean coercion occurs, so that the test can be performed.

For the || operator, if the test is true, the || expression results in the value of the first operand (a or c). If the test is false, the || expression results in the value of the second operand (b).

Inversely, for the && operator, if the test is true, the && expression results in the value of the second operand (b). If the test is false, the && expression results in the value of the first operand (a or c).

The result of a || or && expression is always the underlying value of one of the operands, not the (possibly coerced) result of the test. In c && b, c is null, and thus falsy. But the && expression itself results in null (the value in c), not in the coerced false used in the test.