Variable "long" type in Java and NodeJS

I have a Java function:

private static int buildKey(String keystr) {
	char[] primes = { '5', 'r', '2', '7', '3', '%', '5', ')' };
  
	int len = keystr.length(); int i; long key;
	for (key = 1L, i = 0; i < len; i++)
		key += (keystr.charAt(i) * primes[i & 0x8]); 
	return (int)key % 64;
}

I want change it to NodeJS but I don't know how to define "key" with long variable type because in NodeJS don't have "long" type.

This's my current NodeJS function, but it's return wrong with Java function upper:

function buildKey(keystr) {
    var primes = ["5", "8r", "2", "7", "3", "%", "5", ")"];
    var len = keystr.length;
    var key = 1;
    for (let i = 0; i < len; i++) {
      key += keystr.charAt(i) * primes[i + 8];
      console.log(parseInt(keystr.charAt(i)));
    }

    return key % 64;
}

Anybody share me suggestion? Thanks.

There is no equivalent to Java's long datatype in ECMAScript.

There are only two numeric datatypes in ECMAScript: number and bigint. ECMAScript number is equivalent to Java double (i.e. an IEEE 754-2019 binary64 double precision signed 64 bit binary floating point number) and ECMAScript bigint is equivalent to Java BigInteger (an arbitrary precision signed binary integer).

Neither of the two can replace a Java long (64 bit signed binary integer with "wraparound"): a number can only accurately represent integers with a precision of 53 bit and a biginteger doesn't wrap around.

Now, in the end, you are actually only using 7 bits of your key anyway, so if you are careful, you can probably arrange your computations in such a way that you can circumvent those limitations. For example, you could move the modulo operation into the loop, so that the size of key never exceeds 7 bit in the first place.

If we can prove that the long in your Java code never overflows, then we can use bigint in ECMAScript, and if we can prove that we are actually only using 53 bits of the long, then we can use either bigint or number.

It's easy to see that in the worst case, we are using 56 bits. That means, we cannot guarantee that it will work with number, but it should work with bigint. If we can make assumptions about the length and/or contents of keystr, then we can bring that down even further.

I solved my question as with below function:

function buildKey(keystr) {
  var primes = ["2", "0", "2", "0", "5", "3", "3", ")"];
  var len = keystr.length;
  let key = 0;
  for (let i = 0; i < len; i++) {
    key += keystr.charAt(i).charCodeAt(0) * primes[i & 8].charCodeAt(0);
  }
  return key % 64;
}

Node.js supports BigInts since version 10.4

You can learn more from the docs:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt

Or this overview here, which is more relevant to node:

http://thecodebarbarian.com/an-overview-of-bigint-in-node-js.html