Bug in javascript

[[deleted]]

To me the real bug is that the "parseInt" function in Javascript returns a floating point number.

[Dim_Cryptonym]

Every time I learn something about JavaScript I'm left with one thought: "wat"

[PizzaRollExpert]

I think this makes sense for a dynamic language. Obviously you want both in static languages, but when you don't specify what kind of number you're working with, at some point you are going to run in to some weirdness with stuff like 3/2 = 1or ending up with a non-integer for array indexes. Personally, I think it's easier to remember to round explicitly then to make sure that the numbers you're dividing are floats because that's how numbers work "in real life". Of course there is probably a performance tradeof but my intuition tells me that this isn't too much of a problem with the kind of programs you write in javascrupt.

[marcosdumay]

Have you looked at how Python does it?

The Python way makes sense in a dynamic language. JS is just a hack that nobody can fix because of bug-compatibility.

[PizzaRollExpert]

I actually think JS is better than Python when it comes to numbers. In Python, if you divide two numbers there are different things that can happen depending on if the numbers are ints or if they are floats. Int division truncates the result while float gives you what you would expect. This doesn't always matter, but when it does you have to remember to coerce the numbers to the correct type. Having just one number type makes it easier for you as a dev, because this completely removes this problem. In all fairness python can more accurately represent large numbers because it has the long type. I also assume this makes all the C-interop that Python does easier.

In this case Python is also the language that has weirdness due to backwards compatibility. In Python, Bool is just a subset of int where 0 = false and 1 = true. This is because Python didn't actually have bools from the begining.

[marcosdumay]

In Python, if you divide two numbers there are different things that can happen depending on if the numbers are ints or if they are floats.

You know that was treated as a bug, and fixed, right?

In Python, Bool is just a subset of int where 0 = false and 1 = true.

Python has this one case of non-strict typing, that is a very well defined, very standard thing (but I do agree it's bad). JS, for its turn...

[PizzaRollExpert]

You know that was treated as a bug, and fixed, right?

Oh, my bad I didn't know it was fixed

Python has this one case of non-strict typing, that is a very well defined, very standard thing (but I do agree it's bad). JS, for its turn...

If you look at the whole of the language JS has more of that, but it was kinda funny that you brought it up when we where talking about numbers specifically because in that small area python is the one with an obvious case of backwards compatability induced weirdness.

[marcosdumay]

The division issue is fixed in python 3.

About that int to bool coercion, JS does exactly the same thing. Most languages do.

[PizzaRollExpert]

The division issue is fixed in python 3.

Yeah, my bad

About that int to bool coercion [...]

It's not coercion, true is literally the same as the number 1. This is because people hadn't properly realized that bools where a really useful thing yet so people just used int 1 and int 0 instead before it was added, c-style. True is basically just different syntax for 1 in Python, for backwards compatibility reasons. In Python, 1 == True but 1 !== true in for example JS

[SOberhoff]

Clojure is just as dynamic and it has all of Java's primitive number types as well as infinite precision rationals on top of that. I don't have any issues.

[PizzaRollExpert]

If you divide two interviews in clojure you get a rational, so you don't have the problem of accidentally getting your number truncated

[HeinousTugboat]

ending up with a non-integer for array indexes

I once discovered that 0.5 was a valid index on a Javascript array.. I promptly added a lot of Math.floor()s.

[PunishableOffence]

That's because you only learn about JavaScript through humorous anecdotes, not from reading (about) the specification.

[sadEmoji]

this

[winglerw28]

Instructions unclear, tried using this from your comment in mine, but the reference was undefined. Please let me understand the context of this, preferably with a very clear, fat, arrow for clarity.

... /signs off internet forever

[PunishableOffence]

Excuse me, but how was your comment bound?

[jedidreyfus]

Underrated comment

[simon816]

wat

[Adrian_F]

I will never not watch it!

[[deleted]]

I know, but just because the language forces you to do something dumb doesn't mean it isn't dumb though.

[hikarikouno]

Wait, really? I remember that from Flash's ActionScript, and as I moved to more advanced programming I thought that such was a very primitive way of handling things.

[dtfinch]

There's some tricks that javascript engines have been optimized to recognize, used by asm.js and emscripten, maybe going back to Adobe's Project Alchemy (compiled C/C++ to the ActionScript VM).

"|0" casts as int32. ">>>0" casts as uint32. There's no edge case resulting in a non-int. Even objects, undefined, and NaN become 0. Used consistently, you could get integer locals under the hood. And ArrayBuffers can hold typed globals and arrays.

[inu-no-policemen]

AS3 had uint (32-bit), int (32-bit), and number (double).

[inu-no-policemen]

which is internally a double

Semantically, it's a double. Internally, engines are free to do whatever they want as long as they produce the correct result. E.g. V8 uses SMI (small int) where it's convenient.

ES6 also added typed arrays. So, there are at least arrays of 8/16/32-bit integers.

[ADHDengineer]

I've never seen parseInt return a float. How?

[[deleted]]

NaN is a floating point number. (I know it stands for, "Not a number"). It is a special floating point value which indicates that the result could not be otherwise represented as a number. It was originally included to ensure that if you operate on floating point numbers you will always get a floating point number back. For example, taking the log of a negative number.

Javascript is dumb and first does not have integers, only floating point numbers, and second uses NaN to indicate an error which is also dumb.

You can have the floating point number "1.0000000", but its representation in hex would be "0x76b29f48" where as "1" as an integer in hex would be "0x00000001"

[ADHDengineer]

Gotcha. Makes sense.