CODEWITHSUNDEEP
javascriptsign
mythbu
mythbu

Reputation: 657

Javascript: convert a (hex) signed integer to a javascript value

I have a signed value given as a hex number, by example 0xffeb and want convert it into -21 as a "normal" Javascript integer.

I have written some code so far:

function toBinary(a) { //: String
    var r = '';
    var binCounter = 0;
    while (a > 0) {
        r = a%2 + r;
        a = Math.floor(a/2);
    }
    return r;
}

function twoscompl(a) { //: int
    var l = toBinaryFill(a).length;
    var msb = a >>> (l-1);

    if (msb == 0) {
        return a;
    }

    a = a-1;
    var str = toBinary(a);
    var nstr = '';
    for (var i = 0; i < str.length; i++) {
        nstr += str.charAt(i) == '1' ? '0' : '1';
    }
    return (-1)*parseInt(nstr);
}

The problem is, that my function returns 1 as MSB for both numbers because only at the MSB of the binary representation "string" is looked. And for this case both numbers are 1:

-21 => 0xffeb => 1111 1111 1110 1011
 21 => 0x15   =>              1 0101

Have you any idea to implement this more efficient and nicer?

Greetings, mythbu

Upvotes: 18

Views: 26771

Answers (7)

FyKnight
FyKnight

Reputation: 111

An even simpler solution is to take advantage of the signed right shift operator which runs on 32 bit integers in JavaScript:

parseInt(a) << 16 >> 16

So first you move the sign bit from bit 15 into bit 31, then bring it back to its original location, utilising the >> operator to propagate the sign bit down for you.

parseInt('0xffeb') << 16 >> 16   =>  -21

This can easily be extended for inputs of any width (up to 32)

function parseSignedInt(str,bitwidth) {
    return parseInt(str) << (32-bitwidth) >> (32-bitwidth);
}

If you know you are dealing with 32-bit signed integers you can just do one 'no-op' shift by 0 bits to trigger the conversions:

parseInt('0xffffffcc')     =>  4294967244
parseInt('0xffffffcc')>>0  =>  -52

Upvotes: 0

Jianwu Chen
Jianwu Chen

Reputation: 6023

Based on the accepted answer, expand to longer number types:

  function parseSignedShort(str) {
    const i = parseInt(str, 16);
    return i >= 0x8000 ? i - 0x10000 : i;
  }
  parseSignedShort("0xffeb");  // -21

  function parseSignedInt(str) {
    const i = parseInt(str, 16);
    return i >= 0x80000000 ? i - 0x100000000 : i;
  }
  parseSignedInt("0xffffffeb");  // -21

  // Depends on new JS feature. Only supported after ES2020
  function parseSignedLong(str) {
    if (!str.toLowerCase().startsWith("0x"))
      str = "0x" + str;
    const i = BigInt(str);
    return Number(i >= 0x8000000000000000n ? i - 0x10000000000000000n : i);
  }
  parseSignedLong("0xffffffffffffffeb");  // -21

Upvotes: 0

Bart Friederichs
Bart Friederichs

Reputation: 33511

Use parseInt() to convert (which just accepts your hex string):

parseInt(a);

Then use a mask to figure out if the MSB is set:

a & 0x8000

If that returns a nonzero value, you know it is negative.

To wrap it all up:

a = "0xffeb";
a = parseInt(a, 16);
if ((a & 0x8000) > 0) {
   a = a - 0x10000;
}

Note that this only works for 16-bit integers (short in C). If you have a 32-bit integer, you'll need a different mask and subtraction.

Upvotes: 29

Kostynha
Kostynha

Reputation: 145

Based on @Bart Friederichs I've come with:

function HexToSignedInt(num, numSize) {
    var val = {
        mask: 0x8 * Math.pow(16, numSize-1), //  0x8000 if numSize = 4
        sub: -0x1 * Math.pow(16, numSize)    //-0x10000 if numSize = 4
    }
    if((parseInt(num, 16) & val.mask) > 0) { //negative
        return (val.sub + parseInt(num, 16))
    }else {                                 //positive
        return (parseInt(num,16))
    }
 }

so now you can specify the exact length (in nibbles).

var numberToConvert = "CB8";
HexToSignedInt(numberToConvert, 3);
//expected output: -840

Upvotes: 6

Noman_1
Noman_1

Reputation: 530

As I had to turn absolute numeric values to int32 values that range from -2^24 to 2^24-1, I came up with this solution, you just have to change your input into a number through parseInt(hex, 16), in your case, nBytes is 2.

function toSignedInt(value, nBytes) { // 0 <= value < 2^nbytes*4, nBytes >= 1, 
  var hexMask = '0x80' + '00'.repeat(nBytes - 1);
  var intMask = parseInt(hexMask, 16);
  if (value >= intMask) {
    value = value - intMask * 2;
  }
  return value;
}

var vals = [       // expected output
  '0x00',          // 0
  '0xFF',          // 255
  '0xFFFFFF',      // 2^24 - 1 = 16777215
  '0x7FFFFFFF',    // 2^31 -1 = 2147483647
  '0x80000000',    // -2^31 = -2147483648
  '0x80000001',    // -2^31 + 1 = -2147483647
  '0xFFFFFFFF',    // -1
];
for (var hex of vals) {
  var num = parseInt(hex, 16);
  var result = toSignedInt(num, 4);
  console.log(hex, num, result);
}

var sampleInput = '0xffeb';
var sampleResult = toSignedInt(parseInt(sampleInput, 16), 2);
console.log(sampleInput, sampleResult); // "0xffeb", -21

Upvotes: 0

Kitani Islam
Kitani Islam

Reputation: 144

function hexToSignedInt(hex) {
    if (hex.length % 2 != 0) {
        hex = "0" + hex;
    }
    var num = parseInt(hex, 16);
    var maxVal = Math.pow(2, hex.length / 2 * 8);
    if (num > maxVal / 2 - 1) {
        num = num - maxVal
    }
    return num;
}

function hexToUnsignedInt(hex){
    return parseInt(hex,16);
}

the first for signed integer and the second for unsigned integer

Upvotes: 3

milosmns
milosmns

Reputation: 3793

I came up with this

function hexToInt(hex) {
    if (hex.length % 2 != 0) {
        hex = "0" + hex;
    }
    var num = parseInt(hex, 16);
    var maxVal = Math.pow(2, hex.length / 2 * 8);
    if (num > maxVal / 2 - 1) {
        num = num - maxVal
    }
    return num;
}

And usage:

var res = hexToInt("FF"); // -1
res = hexToInt("A"); // same as "0A", 10
res = hexToInt("FFF"); // same as "0FFF", 4095
res = hexToInt("FFFF"); // -1

So basically the hex conversion range depends on hex's length, ant this is what I was looking for. Hope it helps.

Upvotes: 20

Related Questions