CODEWITHSUNDEEP
javascriptstringintegerbigintegerdata-conversion
Vikram Kumar
Vikram Kumar

Reputation: 310

Convert a string to a big integer in Javascript?

I am trying to convert a string to a big integer to perform some arithmetic calculations. However, when I try this:

Number("9007199254740993")

...I am getting this unexpected result:

9007199254740992

I suspect that this is probably because of the limit on the size of integers that Number is capable of working with.

Basically, I want to check if two strings are consecutive numbers or not. Since Number is not returning the correct value, I am getting the incorrect difference for "9007199254740993" and "9007199254740992". Specifically, I am expecting 1, but getting 0.

One possibility I considered is dividing each number by a factor to make each of them smaller. Is there any other solution?

Upvotes: 6

Views: 12141

Answers (4)

FK82
FK82

Reputation: 5075

I you don't want to rely on BigInt and only have positive integers in mind, you can also write the successor test yourself. Full code in the snippet below.

Notes

A string representation of a positive integer is easily convertible to a decimal array where the index represents the exponent to the base 10. For example "42" ~> [2, 4] (since 42 = 2*10^0 + 4*10^1). You can also just as easily convert it back.

Now for the successor test you just need to define the increment operation (which is just adding 1 with carry). With that you can just compare if the increment of one number is equal to the unincremented other number (and vice versa).

Code

// Convert a string representation of positive decimal integer to an array of decimals.
const toArray = numberString => Array.from(numberString, c => parseInt(c))
    .reverse();

// Convert the array representation of a positive decimal integer string back to the corresponding string representation (this is the inverse of `toArray`).
const fromArray = numberArray => numberArray.map(String)
    .reverse()
    .join('');

console.log(fromArray(toArray("9007199254740993")) === "9007199254740993"); // true

// Perform the increment operation on the array representation of the positive decimal integer.
const increment = numberArray => {
  let carry = 1;
  const incrementedNumberArray = [];
  numberArray.forEach(i => {
      let j;
      if (carry === 0) {
          j = i;
      } else if (carry === 1) {
          if (i === 9) {
              j = 0;
          } else {
              j = i + 1;
              carry = 0;
          }
      }
      incrementedNumberArray.push(j);
  });

  if (carry === 1) { 
    incrementedNumberArray.push(1);
  }

  return incrementedNumberArray;
};

console.log(fromArray(increment(toArray("9007199254740993"))) === "9007199254740994"); // true
console.log(fromArray(increment(toArray("9999999999999999"))) === "10000000000000000"); // true

// Test if two strings represent positive integers where one is the other's successor.  
const isSuccessor = (a, b) => {
  const a_ = increment(toArray(a));
  const b_ = increment(toArray(b));
  return fromArray(a_) === b || fromArray(b_) === a;
};

console.log(isSuccessor("9007199254740993", "9007199254740994")); // true
console.log(isSuccessor("9007199254740994", "9007199254740993")); // true
console.log(isSuccessor("9999999999999999", "10000000000000000")); // true
console.log(isSuccessor("10000000000000000", "9999999999999999")); // true
console.log(isSuccessor("10000000000000000", "10000000000000002")); // false

Upvotes: 1

Niraj Kaushal
Niraj Kaushal

Reputation: 1502

Note: I recommend you to use BigInt(as suggested by @Andreas in comment), if you are dealing with Big Numbers.

UPDATED

Use this code to compare big positive integers(The arguments should be in string format)

function compareBigNumber(num1, num2) {
  if (num1 > Number.MAX_SAFE_INTEGER && num2 > Number.MAX_SAFE_INTEGER) {
    var newNum1 = num1.split('').reverse();
    var newNum2 = num2.split('').reverse();
  
    do {
      newNum1.pop();
      newNum2.pop();
    } while (newNum1[newNum1.length-1] === '0' || newNum2[newNum2.length-1] === '0')
    
    return compareBigNumber(newNum1.reverse().join(''), newNum2.reverse().join(''));
  } else if(num1 > Number.MAX_SAFE_INTEGER){ 
    return 'num1 is greater' 
  } else if (num2 > Number.MAX_SAFE_INTEGER) {
    return 'num2 is greater'
  }
  else {
    var num1Int = parseInt(num1);
    var num2Int = parseInt(num2);
    if (num1Int > num2Int) {
      return 'Num1 is greater';
    } else if (num2Int > num1Int){
      return 'Num2 is greater'
    } else {
      return 'Num1 is equal to Num2';
    }
  }
}

console.log(compareBigNumber("9007199254740992", "9007199254740993"))
console.log(compareBigNumber("100000000000000000000", "0"))

Upvotes: 1

Rajan Lagah
Rajan Lagah

Reputation: 2528

You can use BIG integer library like one in JAVA. check here 

npm install big-integer

var bigInt = require("big-integer");
var largeNumber1 = bigInt("9007199254740993");
var largeNumber2 = bigInt("9007199254740994"); // any other number
var ans = largeNumber1.minus(largeNumber2);
if(ans == 1 || ans == -1){
console.log('consecutive ')
}else{
console.log('not consecutive ')
}

Upvotes: 1

jh314
jh314

Reputation: 27792

Javascript's Number type is a numeric data type in the double-precision 64-bit floating point format (IEEE 754).

If you are dealing with large integers, use a BigInt or a corresponding library.

Upvotes: 3

Related Questions