Home / Questions / 304423
Accepted
RazerJs
Asked: 2020-10-30 01:17:39 +0800 CST 2020-10-30 01:17:39 +0800 CST

.map(parseInt) with weird results

  • 772

I came across this while solving a problem... It was a fix something like that...

ar =[1.5,2,11.4,22,3,5,2]

Try: arr.map(parseInt)==[1, NaN, 3, 8, 3, NaN, 2]

I get curious...

Analyzing the result a bit (only the first digits) I verified that the first number effectively converts it to numbermy expected integer... but the second result always returns NaN so insert the same number ( [1,1]==[1,NaN]) .. and the 3rd a 3?? Then I keep trying things.

[1,2,4]== [1, NaN, NaN]but.. [1,2,11]== [1, NaN, 3]??? I turned 3 into 11?? It has something to do with the fact that I already use 1...

More things if the array contains two stringconsecutive ones at the beginning it doesn't return anything eg: ['1.5','2',22]==
but... ['1.5',2,22,3,5,2]== [ 1, NaN, NaN, NaN, NaN, 2 ]????? If all the results returned in the examples are analyzed, strange things continue to be found, such as changes of NaNalternate numbers depending on the previous numbers of the array... I found it interesting to share this, I am investigating because it happens... if someone already knows it and can remove the doubts I would appreciate it..

javascript

2 Answers

  1. Best Answer

    The parameters passed by the .map are(currentValue, index, array)

    And the parameters that .parseInt receives are(string, base)

    Therefore, knowing the parameters of each one, the problem can be inferred, El .map(parseInt)is equal to.map(parseInt(currentValue, index, array))

    And since parseIntit only expects 2 parameters, the 3 ignores it, so it parseInt(string, base, array)would be equal toparseInt(string, base)

    When you do:

    [1.5,2,11.4,22,3,5,2].map(parseInt);

    The following is actually executed:

    parseInt('1.5', 0, [1, 2, 11, 22, 3, 5, 2]);
//Parsea 1 con base 10 (base 0 es ignorado y toma el valor por defecto)

parseInt('2', 1, [1, 2, 11, 22, 3, 5, 2]);
//Base 1 es incorrecto, con lo que devuelve NaN

parseInt('11.4', 2, [1, 2, 11, 22, 3, 5, 2]);
//Parsea 11 en base 2, que es 3 en decimal

parseInt('22', 3, [1, 2, 11, 22, 3, 5, 2]);
//parsea 22 en base 3, que es 8

parseInt('3', 4, [1, 2, 11, 22, 3, 5, 2]);
//parsea 3 en base 4

parseInt('5', 5, [1, 2, 11, 22, 3, 5, 2]);
//5 en base 5 no se puede parsear, NaN

parseInt('2', 6, [1, 2, 11, 22, 3, 5, 2]);
//2 en base 6

    Your code should be:

    [1.5,2,11.4,22,3,5,2].map(e=>parseInt(e));

    A longer version of this question/answer:

    Why ['1', '7', '11'].map(parseInt) returns [1, NaN, 3] in Javascript

    Regarding the comment:

    As you say, the most intuitive thing is that parseInt('11.4', 2, [1, 2, 11, 22, 3, 5, 2]);or what is the same parseInt('11.4', 2), the result is NaNsince it 11.4is not a feasible number for base 2.

    It seems that in these cases it parses as much as it can until it comes across a character other than 0or 1:

    parseInt("11asd",2); // Output: 3
parseInt("asd11",2); // Output: NaN
parseInt("11asd1",2); // Output: 3 (aun que tenga otro 1, ya es ignorado)
    • 5

  2. As @x3k_js says, what happens is that you are passing the index of the element as the base of parseIntthe test would be:

    const arr = ['1.5',2,22,3,5,2];

const res = arr.map(argumentos);

function argumentos(...args){//<-- Asi se ejecutaría parseInt()
    console.log(args);
}

    The base parameter of parseIntis the base in which the number passed by parameter is expressed, not the result, and this must be between 2 and 36. Outside of these values, it is assumed to be base 10 if the string does not begin with "0x" neither with "0" or is undefined, 1 should perhaps return base 10 but apparently it is executed as true, so it does not recognize any symbol, which gives NaN.

    So what happens is that if we put base 3, it means that the number we pass as a parameter has to be formed with the digits 0, 1, 2. Otherwise it is NaN. Examples:

    console.log(parseInt("1010",2));//< -- parámetro en base 2 
console.log(parseInt("2020",3));//< -- parámetro en base 3
console.log(parseInt("FA0",16));//< -- parámetro en base 16


console.log(parseInt("2020",2));//< -- el simbolo 2 no es base 2 
console.log(parseInt("4040",3));//< -- el simbolo 4 no es base 3
console.log(parseInt("Z00",16));//< -- el simbolo Z no es base 16

    So the strange behavior you have is fundamentally because symbols are passed that are not within the specified base.

    • '1.5' base 0 means base 10
    • 2 base 1 is alwaysNaN
    • 22 base 2 only uses the symbols 0,1 soNaN
    • 3 base 3 just use 0,1,2 soNaN
    • 5 base 4 just use 0,1,2,3 soNaN
    • 2 base 5 uses 0,1,2,3,4 returns 2 which is 2 also in base 5
    • 1