13

I'm having trouble understanding how shifting works. I would expect that a and b would be the same but that's not the case:

a = 0xff000000;
console.log(a.toString(16));
b = 0xff << 24;
console.log(b.toString(16));

resulting in:

ff000000
-1000000

I came to this code while trying to create a 32bit number from 4 bytes.

Ivar
  • 6,138
  • 12
  • 49
  • 61
benathon
  • 7,455
  • 2
  • 41
  • 70

2 Answers2

22

Bitwise operators convert their operands to signed 32 bit numbers. That means the most significant bit is the sign bit, which gives you only 31 bits for the number value.

0xff000000 by itself is interpreted as 64bit floating point value. But truncating this to a 32bit signed integer produces a negative value since the most significant bit is 1:

0xff000000.toString(2);
> "11111111000000000000000000000000"

(0xff000000 | 0).toString(16)
> -1000000

According to Bitwise operations on 32-bit unsigned ints? you can use >>> 0 to convert the value back to an unsigned value:

0xff << 24 >>> 0
> 4278190080

From the spec:

The result is an unsigned 32-bit integer.

Felix Kling
  • 795,719
  • 175
  • 1,089
  • 1,143
  • If this is the case, how can I do my shifts in 64 bits? – benathon Jan 03 '19 at 22:42
  • 1
    Did you mean `0xff000000` is interpreted as an unsigned 32 bit integer? – ic3b3rg Jan 03 '19 at 22:50
  • 3
    @ic3b3rg: No. JavaScript only has one number type, 64 bit floating point. https://www.ecma-international.org/ecma-262/9.0/index.html#sec-ecmascript-language-types-number-type . However: *"Some ECMAScript operators deal only with integers in specific ranges such as -2^31 through 2^31-1, inclusive, or in the range 0 through 2^16-1, inclusive. These operators accept any value of the Number type but first convert each such value to an integer value in the expected range. See the descriptions of the numeric conversion operations in 7.1."* – Felix Kling Jan 03 '19 at 22:57
  • 1
    I suggest that it's more correct to say that the `0x` literal form is *interpreted* as an unsigned integer of x bytes where x is the length of the literal (minus the `0x` part), i.e. `0xH` has a range of 0 - 15 (4 bit unsigned integer). The interpreted number is stored (as all JS numbers are) as a 64 bit floating point – ic3b3rg Jan 03 '19 at 23:25
  • @ic3b3rg: Fair enough. The spec calls this a *"HexIntegerLiteral"* indeed. – Felix Kling Jan 03 '19 at 23:28
3

So it turns out this is as per the spec. Bit shift operators return signed, 32-bit integer results.

The result is a signed 32-bit integer.

From the latest ECMAScript spec.

Because your number is already 8 bits long, shifting it left by 24 bits and then interpreting that as a signed integer means that the leading 1 bit is seen as making it a negative number.

GregL
  • 37,147
  • 8
  • 62
  • 67