Unsigned Integer in JavaScript

How to declare an unsigned int variable in javascript?

If you really need them unsigned then check Uint32Array on MDN.

However, since you don't really gain anything from your values being unsigned, perhaps a simple modulus operation would be better?

//Create var as array of length 1var arr = new Uint32Array(1);//set first value to 1arr[0] = 1;//output contentsconsole.log(arr);//substract to "negative"arr[0] -= 2;//output contentsconsole.log(arr);

Unsigned Integer in Javascript

document.write( (1 << 31) +"<br/>");

The << operator is defined as working on signed 32-bit integers (converted from the native Number storage of double-precision float). So 1<<31 must result in a negative number.

The only JavaScript operator that works using unsigned 32-bit integers is >>>. You can exploit this to convert a signed-integer-in-Number you've been working on with the other bitwise operators to an unsigned-integer-in-Number:

document.write(( (1<<31)>>>0 )+'<br />');

Meanwhile:

document.write( (1 << 32) +"<br/>");

won't work because all shift operations use only the lowest 5 bits of shift (in JavaScript and other C-like languages too). <<32 is equal to <<0, ie. no change.

How can I get usable unsigned 32 bit integer to work with?

Most people are not aware that JavaScript works well with bit-wise operations. You need to pair it with an array buffer however.

let buffer = new ArrayBuffer(16); // create a buffer of length 16

let view = new Uint32Array(buffer); // treat buffer as a sequence of 32-bit integers

Node JS function that takes an unsigned integer and returns wrong number of '1' bits

When you call hammingWeight(101), you are not using the binary string 101₂ (4+1 = 5), but the decimal number 101₁₀ (one hundred and one). Try instead hammingWeight(0b101).

JavaScript C Style Type Cast From Signed To Unsigned

You can try a = arg1>>>0, but I'm not sure it will do what you are looking for.

See this question for more details.

How do I pack unsigned integers in js?

How about this?

const output = document.getElementById('output');
function bigEndianOf(n){    return Uint8Array.from([        (n & 0xFF000000) >>> 24,        (n & 0x00FF0000) >>> 16,        (n & 0x0000FF00) >>>  8,        (n & 0x000000FF) >>>  0,    ]);}
document.getElementById('text').addEventListener('change', e => {  const prefix = new TextDecoder('utf-8').decode(bigEndianOf(e.target.value.length));  output.value = prefix;})

text: <input id="text" /><br />length prefix string: <input id="output" readonly />

24 Bit Unsigned Integer

Short answer

left << shifting is a padding of significant bits with zeros for future conjunction into single value;
right >> shifting is part of extracting of value's segment into smaller data type (goes after applying mask);

Abstract

Shift & sum is the way to pack/unpack values when reading/writing frame is less of value's length. Let's say we have 4 bit value: 1011. And we able read it only by 2 bit frames: [10], [11].

Let's assume that we are reading stream from left to right.

# offset 0 bits
a = stream(0)      # a = 10
a << 2             # a = 1000

b = stream (2)     # b = 11

return a + b       # 1000 + 11 = 1011

Also you should pay attention to BE/LE (Big/Little Endian). In different Endians value 1011 may be presented in stream as 10, 11 or 11, 10.

getUint24 example

In case of getUint24 example we have 24 bit value packed as sequence like [16 bit, 8 bit]. Let's draw it as [XY, Z] where single letter is 1 byte.

# offset 0 bytes
a = DataView(bytes.buffer).getUint16(0)      # a = XY
a << 8                                       # a = XY0

# offset 2 bytes
b = DataView(bytes.buffer).getUint8(2)       # b = Z

return a + b                                 # XY0 + Z = XYZ

And again bytes.buffer may keep value either as [XY, Z] or [Z, XY]. The getUintX(offset) hides this details from us. But if you'd like to write own converter, you need investigate what format is in your case.

ToBytesInt32BigEndian example

Here we see another concern of packing values - apply mask.

For say we have 32 bit value AB CD EF 12. We can apply mask to extract needed segment of the value.

For example, if we have 3 bit value 011 and would like get value of second bit we need apply &-mask where subject bits evaluated against 1 keep original value while rest bits evaluated against 0 turn any value into 0.

masked    = 011 & 010    # 010
bit_value = masked >> 1  # 001

In the same way with our ABCDEF12

x = 0xABCDEF12 & 0xFF000000   # x = 0xAB000000
x >> 24                       # x = 0x000000AB
...

This way we will get array [0xAB, 0xCD, 0xEF, 0x12]. Without shifting we were get array [0xAB000000, 0x00CD0000, 0x0000EF00, 0x00000012] which is not what we want.

What is 32-bit integer in JavaScript?

The upper bound of a signed integer is not 2³² - 1, but 2³¹ - 1, since the first bit is the sign bit.

If you make that comparison, you'll see your test gives the right result.

Be aware that JavaScript uses IEEE-754 floating point representation for numbers, even when they are integers. But the precision of floating point is more than enough to perform exact calculations on 32-bit integers. As you realised, you'll need to make the necessary test to detect 32-bit overflow.

Some notes about your code: it passes an argument to the Array#reverse method, which is a method that does not take an argument. Here is how I would write it -- see comments in code:

// Name argument n instead of x, as that latter is commonly used for decimal numbers function reverse(n) {    // Array#reverse method takes no argument.    // You can use `Math.abs()` instead of changing the sign if negative.    // Conversion of string to number can be done with unary plus operator.    var reverseN = +String(Math.abs(n)).split('').reverse().join('');    // Use a number constant instead of calculating the power    if (reverseN > 0x7FFFFFFF) {        return 0;    }    // As we did not change the sign, you can do without the boolean isNegative.    // Don't multiply with -1, just use the unary minus operator.    // The ternary operator might interest you as well (you could even use it    //    to combine the above return into one return statement)    return n < 0 ? -reverseN : reverseN;}
console.log(reverse(-123));console.log(reverse(1563847412));