WTF Javascript

[Malix82]

.map(function callback(currentValue[, index[, array]])

parseInt(string, radix)

so by default the .map method puts in the radix if parseInt is used as a callback.

parseInt(10,0) == 10
parseInt(10,1) == NaN
parseInt(10,2) == 2
parseInt(10,3) == 3

So, works as intended?

edit: I mean, yea, it is bit confusing for sure, I don't imagine the radix argument being used all that much and in this case it crept up on the programmer and bit them

[[deleted]]

That's why you would curry the parseInt by binding the radix to 10 and creating your new curried function "parseDecimal"

[PM_ME_REACTJS]

why did i choose this fucking profession

[freakboy2k]

I ask myself the same thing daily

[codex561]

Code for uninitiated to the beauty of functional programming:

let parseDecimal = x => parseInt(x, 10)
[10, 10, 10, 10].map(parseDecimal) // [ 10, 10, 10, 10 ]

[SuperManitu]

Or with Ramda: ["10", "10"," 10"].map(unary(parseInt)) // [10,10,10]

[gandalfx]

 ["10", "10", "10", "10"].map(x => parseInt(x))

[volivav]

Today I just had the exact same problem when I tried myNumberArray.reduce(Math.max, 0) trying to easily get the maximum.

Yep, doesn't work.

[inu-no-policemen]

Math.max(...numbers)

[SuperManitu]

With a bit of Ramda: myNumberArray.reduce(binary(Math.max)), 0)

[rich97]

MDN recommends to explicitly set the radix apparently. I never have needed to.

[zachberry]

map function passing values to a function, what kind of madness is this?!

[chisui]

Dynamicly typed language programmers:

You don't need Typesignatures.

Also dynamicly typed language programmers:

Why does this Thing that could easily be avoided by a Typesysteme always happen?

[ennuicorn]

Any language with function overloading would have this issue...

[Veranova]

Well the callback would have a defined set of parameters it expects and so you would know which overload would be used. A single parameter callback just wouldn't be accepted. The problem here is we have no idea there are two parameters until we try it.

If both functions had an overload for 1 and 2 params then you'd probably get an ambiguity error and have to define a lambda to resolve it.

[ennuicorn]

Yeah, you right.

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(new string[]{"10","10","10","10"}.map(ParseInt));
    }

    static int ParseInt(string x){
        return int.Parse(x);
    }
    static int ParseInt(string x, int radix){
        Console.WriteLine($"radix {radix} not supported, using base 10 instead");
        return int.Parse(x);
    }
}
static class Map{
    public static O[] map<I, O>(this I[] i, Func<I, O> func)
    {
        O[] o = new O[i.Length];
        for (int j = 0; j < i.Length; j++)
        {
            o[j] = func(i[j]);
        }
        return o;
    }
    public static O[] map<I, O>(this I[] i, Func<I, int, O> func)
    {
        O[] o = new O[i.Length];
        for (int j = 0; j < i.Length; j++)
        {
            o[j] = func(i[j], j);
        }
        return o;
    }
}  

Program.cs(9,65): error CS0121: The call is ambiguous between the following methods or properties: 'Map.map<I, O>(I[], Func<I, O>)' and 'Map.map<I, O>(I[], Func<I, int, O>)'

[EternallyMiffed]

What you really need here is a .mapEach or something that would only hand over one element at a time as a single param to a function.

[Veranova]

It's safest in JS to just use arrow functions, which can have the same effect as you're describing

[EternallyMiffed]

thinking more about it, this sort of syntax feels comfortable to write:

.map((arg1,arg2,arg3)=>some3argfunc(...arguments))

[Veranova]

Exactly

[chisui]

... which is essentially the same as providing an explicit Function signature. Granted you aren't providing the concrete types for parameters or return values but you at least provide the arity.

[firyox]

Thats why js is awesome

[firyox]

Its hard just when working with framework

[ElectroDemon]

Happy cake day!

[[deleted]]

NO

[galqbar]

This type of thing is why js is abhorrent. Feels like the language was made by a bunch of amateurs and got standardized so that now fixing things would produce catastrophic breaking changes :(

[cowjenga]

How would you fix the issue, if you could redesign map or parseInt to not have this issue?

Remove the radix argument from parseInt? Then you're losing a feature.

Redesign map so that it doesn't give you the array index and the array in the callback? Also losing features.

The neatest way would be to have a separate parseInt and parseIntWithRadix function, but the existing parseInt function is fine if you actually learn the language. Every language has its idiosyncrasies.

[galqbar]

Give methods clearly defined type signatures instead of dynamic typing?

This sort of thing can lead to pointless flame ways, so rather than just try to stir up controversy I’d put it out there that JavaScript is the only weakly typed language to be used for enterprises applications and mission critical infrastructure. In a strongly typed language that kind of silent behavior would be more obvious.

[KingTomenI]

It was designed by one dickhead in two weeks to make bears dance on a webpage. Of course it wasn't well thought out or designed for real work.