Edit: This question is out of date as the Polyfill example has been updated. I\'m leaving the question here just for reference. Read the correct answer for usef
The result is, indeed, converted back to a number, i.e., a 64-bit precision floating point number. However, before it is converted back, both operands are converted to UInt32
, then the right shift operation is performed. This is specified in ECMAScript here:
http://www.ecma-international.org/ecma-262/5.1/#sec-11.7.3
The net result of length >>> 0
is therefore, because >>> 0
itself is a no-op, to convert length
to a UInt32
then back to a double. What is it good for? It forces the loss of precision, and effectively forces the value to be 1) and integer and 2) in the range [0, 2^32-1]. For example, if it was -1, it will become 2^32-1 == 4294967295. If it was, 3.6, it will become 3.
If you run this test, Math.floor will do the same. Those hacks should be avoided if you want to understand your own code in a month or so.
var a=3.6, b = a >>> 0;
console.log(b);
console.log(Math.floor(a));
The ECMAScript specification states that the value is converted to UInt32 in step 5 and 8 of http://www.ecma-international.org/ecma-262/5.1/#sec-11.7:
11.7.3 The Unsigned Right Shift Operator ( >>> )
Performs a zero-filling bitwise right shift operation on the left operand by the amount > specified by the right operand.
The production
ShiftExpression : ShiftExpression >>> AdditiveExpression
is evaluated as follows:
- Let
lref
be the result of evaluatingShiftExpression
.- Let
lval
beGetValue(lref)
.- Let
rref
be the result of evaluatingAdditiveExpression
.- Let
rval
beGetValue(rref)
.- Let
lnum
beToUint32(lval)
.- Let
rnum
beToUint32(rval)
.- Let
shiftCount
be the result of masking out all but the least significant 5 bits ofrnum
, that is, computernum & 0x1F
.- Return the result of performing a zero-filling right shift of
lnum
byshiftCount
bits. Vacated bits are filled with zero. The result is an unsigned 32-bit integer.