We Keep Coding

Is there a way to convert a string larger than a length of 15 to a number, without rounding?

When converting a large string to a number, I noticed there is round after the 15th digit. Is there a way to convert a string to a number to in JS without rounding, regardless of the length?
Number("9223372036854775807")
// returns 9223372036854776000
+"9223372036854775807"
// returns 9223372036854776000
"9223372036854775807"*1
// returns 9223372036854776000

You can use the BigInt object which can hold numbers upto 2^53 - 1.
let hugeString = BigInt("9223372036854775807")
console.log(hugeString);
// outputs: 9223372036854775807n

Issue with combining large array of numbers into one single number

I am trying to convert an array of numbers into one single number, for example
[1,2,3] to 123.
However, my code can't handle big arrays since it can’t return exact number. Such as
[6,1,4,5,3,9,0,1,9,5,1,8,6,7,0,5,5,4,3] returns 6145390195186705000
Is there any way that I could properly convert into a single number.I would really appreciate any help.
var integer = 0;
var digits = [1,2,3,4]
//combine array of digits into int
digits.forEach((num,index,self) => {
integer += num * Math.pow(10,self.length-index-1)
});

The biggest integer value javacript can hold is +/- 9007199254740991. Note that the bitwise operators and shift operators operate on 32-bit ints, so in that case, the max safe integer is 2^31-1, or 2147483647.
In my opinion, you can choose one of the following:
store the numbers as strings and manipulate them as numbers; you might have to implement special functions to add/subtract/multiply/divide them (these are classic algorithmic problems)
use the BigInt; BigInts are a new numeric primitive in JavaScript that can represent integers with arbitrary precision. With BigInts, you can safely store and operate on large integers even beyond the safe integer limit. Unfortunately, they work only with Chrome right now. If you want to work with other browsers, you might check this or even this if you work with angularjs or nodejs.
Try the following code in the Chrome's console:
let x = BigInt([6,1,4,5,3,9,0,1,9,5,1,8,6,7,0,5,5,4,3].join(''));
console.log(x);
This will print 6145390195186705543n. The n suffix marks that it is a big integer.
Cheers!

You can use JavaScript Array join() Method and parse it into integer.
Example:
parseInt([6,1,4,5,3,9,0,1,9,5,1,8,6,7,0,5].join(''))
results:
6145390195186705
Edited: Use BigInt instead of parseInt , but it works only on chrome browser.

The largest number possible in Javascript is
+/- 9007199254740991
Use BigInt. Join all numbers as a string and pass it in BigInt global function to convert it into int
var integer = 0;
var digits = [1,2,3,4]
//combine array of digits into int
digits.forEach((num,index,self) => {
integer += num;
});
integer= BigInt(integer);
Note : Works only on Chrome as of now. You can use othee libraries like BigInteger.js or MathJS

Using sort() to get numbers in descending order

I'm trying to complete this kata. Trying to figure it out, I've seen this thread but I think I'm doing it as it says in there.
What am I doing wrong? Why doesn't it sort the numbers in descending order?
This is my code so far:
function descendingOrder(n){
let newN = n.toString().split(' ').sort(function(a,b){return b-a}).join();
return parseInt(newN);
}
Test Passed: Value == 0
Test Passed: Value == 1
Expected: 987654321, instead got: 123456789
Thanks in advance

You need to split the string with an empty string '' to get single digits and join it with an empty string.
Splitting with a character which is not part of the string results in an array with a single value. A later joined array returns this single element. That is why you get the same value as result as the input.
Array#join without a specified separator, returns a comma separated string with the values.
let newN = n.toString().split('').sort(function (a, b) { return b - a; }).join('');
At the end, you could take an unary plus +, like
return +newN;
for getting an numerical value.
BTW, with the use of parseInt, you may specify a radix, because strings with leading zero may be converted to an octal number.

Here is an explained answer
function descendingOrder(n) {
let result = n
.toString() // convert numbers to string
.split('') // split each string char in to an array of chars
.sort((a, b) => b - a) // sort that array descending
.join('') // regroup all items in that array into 1 string
return parseInt(result) // turn the group of strings into an array
}

function descendingOrder(n){
return +('' + n).split('').sort().reverse().join('');
}

Like the other answers have already stated you will need to call split with an empty string to properly create an array containing each character.
Also, when I tested join() I noticed commas in the output (chrome 65). I added a replace function to strip the commas, which passed the test.
function descendingOrder(n){
let newN = n.toString().split('').sort(function(a,b){return b-a}).join().replace(/,/g,'');
return parseInt(newN);
}

D3 parse number from string

I am new to using D3.js and I am having problems converting string data into a number. I am using a CSV with one column called "Belgium" composed by numbers like these ones: 54,345 or 1,234,567.
I tried to convert them into numbers by using
data.forEach(function(d) {
d.Belgium = +d.Belgium;
}
but I get NaN as a result. I also tried using
d.Belgium = parseInt(d.Belgium);
but it takes the figures before the first comma and removes the rest of the number. For example, if one number is 1,234,562, using parseInt() I just get 1. If the figure is 982,381, it remains 982.

Remove all , with string.replace(searchvalue, newvalue):
parseInt(str.replace(/,/g, ""))
so for example:
console.log(parseInt("1,234,562".replace(/,/g, "")))
As noted below, use parseFloat instead of parseInt if your numbers may contain decimals e.g. 3.141,592 to keep the floating point number.

I took a bit of a different approach. I used .split(",") to split the value into an array at every ,, then used .join("") to join each index of the array with empty spaces. Used the + operator for ease of use but could have been parseFloat() as well.
let stringNumber = "1,250,234.093";
let numStringNumber = +stringNumber.split(",").join("");
console.log(numStringNumber);
console.log(typeof numStringNumber);

Which javascript function can be used to covert an array of characters into a number?

There are a few Javascript functions available to convert anything into its equivalent number. Number() operates on an Object, valueOf(), parseFloat, parseInt() are also available.
I have an array which stores numbers 0-9 and decimal point, the elements of the array taken together represents a number. What is the best way to convert this array into a number, whole or fractional?
EDIT: Apologies if I were not clear before. The array, holding the 0-9 characters and possibly a decimal point, could represent either a whole number(without the decimal obviously) or a fractional number. So please suggest something that works for both cases. Thanks.

Try this
var a = [1,2,3,".",2,3];
var num = +a.join("");

What is the best way to convert this array into a number, whole or fractional?
Firstly to combine your array elements you should use Array.join().
You will then have a concatenated variable of your values and decimal. To convert this to a whole number, use parseInt(), and to a floating point number use parseFloat(). You can use the unary + operator (which acts similarly to parseFloat), however in my opinion it is not the best choice semantically here, as you seem to want a specific type of number returned.
Example:
var arr = ['1','.','9','1'];
var concat = arr.join();
var whole = parseInt(concat);
var floating = parseFloat(concat);
Also, parseInt will trim the decimal portion of your number, so if you need rounding you can use:
var rounded = Math.round(parseFloat(concat));

You could use the split property of the string. It splits all the characters into an zero based array.
var charSplits = "this is getting split.";
var splitArr = charSplits.split();
Console.log(splitArr);
// this returns i
Console.log(splitArr[2]);