Why does << 32 not result in 0 in javascript?

Question

This is false:

(0xffffffff << 31 << 1) === (0xffffffff << 32)

It seems like it should be true. Adding >>> 0 anywhere does not change this.

Why is this and how can I correctly write code that handles << 32?

Answer 1

The shift operators always effectively has a right operand in the range 0-31.

From the Mozilla docs:

Shift operators convert their operands to 32-bit integers in big-endian order and return a result of the same type as the left operand. The right operand should be less than 32, but if not only the low five bits will be used.

Or from the ECMAscript 5 standard:

The production ShiftExpression : ShiftExpression << AdditiveExpression is evaluated as follows:

1. Let lref be the result of evaluating ShiftExpression.
2. Let lval be GetValue(lref).
3. Let rref be the result of evaluating AdditiveExpression.
4. Let rval be GetValue(rref).
5. Let lnum be ToInt32(lval).
6. Let rnum be ToUint32(rval).
7. Let *shiftCount be the result of masking out all but the least significant 5 bits of > rnum, that is, compute rnum & 0x1F.
8. Return the result of left shifting lnum by shiftCount bits. The result is a signed 32-bit integer.

(And likewise for other shift operators.)

It's not entirely clear to me why this is the case, but Java and C# work the same way for their 32-bit integer types. (For 64-bit integer types, the operand is in the range 0-63.) See JLS 15.19 for example.

My guess is that this is efficient on common processor platforms, but I don't have evidence of that...