Hacker News Reader

Comment by xg15 | Hacker News Reader

I'm surprised this is done in JS. If you're doing any kind of calculation with floats (and use actual non-integer numbers, not just ints stored as floats) then it's generally difficult to get the same exact result every time on every system, due to rounding errors. That's why to my knowledge, any strict equality check on floats is generally frowned upon. (exceptions: you know all the floats are actually non-huge ints; You're comparing with a value the variable was explicitly set to at some time before)

View on HN

JavaScript conceptually only has floats (ignoring big integers, which isn't what most people use for numbers), so any map of numbers to values is using a float key. You refer to that, but yeah they're all floats.

> it's generally difficult to get the same exact result every time on every system, due to rounding errors

Floating point arithmetic is 100% entirely deterministic - you don't just get different values randomly.

This is so wrong

ECMAScript does not have maps where keys can be integers and neither can keys be floats.

Everything is a pointer to a value, and otherwise reflected with a symbol or string (which in return is a unique symbol). An object doesn't have object[1] because it is actually object[reference("1")]

This way boxing and unboxing of arrays is much cheaper, due to the arrays not needing a resizing of their cells once datatypes change.

(TypedArrays are optimized in a different manner, but we are speaking about the NaN use case, which implies either an Array or Object)

There are dozens of talks about e.g. v8's hidden classes on youtube that show up this very mechanism.

No idea where you got that float keys idea from.

> ECMAScript does not have maps where keys can be integers and neither can keys be floats.

  map = new Map();
  map[1] = 3;
  map[1]; // 3
  map[1.2] = 3.4;
  map[1.2]; // 3.4
  typeof(map.keys().next().value); // "number"

I'm not an expert in JavaScript. What am I missing?

A nitpick: You're setting object properties on a Map object, which only works "accidentally" but does not make use of the map at all[1]. So in this case, it likely works because the numbers are converted to strings before being used as keys.

But in general, using float keys does work - but can fail in unexpected ways due to rounding errors. E.g.:

  m = new Map();
  m.set(0.3, "foo");  // --> Map { 0.3 → "foo" }
  m.get(0.3); // --> "foo"
  m.get(0.1 + 0.2);  // --> undefined

That's because 0.1 + 0.2 == 0.30000000000000004 in IEEE floats, which is != 0.3. [2]

So using float keys which are derived from calculations and may contain non-integer numbers is a bad idea, because unless you have very good knowledge about floating point math, you can not easily predict what exact value the result of a calculation will be.

[1] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

[2] https://stackoverflow.com/questions/8503157/ieee-754-floatin...

Right - should be using set and get - was written out without running it.

But isn't this still a map that has float and integer keys? Why doesn't it count?

Object property names are always strings, even though you can set them via number literals (as the person you replied to said):

    const object = {}
    object[1] = 3

    console.log(object["1"]) // 3
    for (const key in object) {
      console.log(typeof key) // "string"
    }

This is different from keys of the Map data structure, which are actually able to be any type of value (even silly stuff like other Maps).

I don't know - I think that proves what I said - map keys can be floats.

For sure, I never disagreed with that (I even said "JavaScript maps absolutely can use numbers (or any type) as keys" in my other comment).

But object property names cannot be floats (which is what your example was, despite them being properties of a Map object).

from what I got, it's a very stupid interaction of different javascript language features.

Every object in JS has basic map functionality. Since version 1 of the language, you could always write things like:

  var o = new Object();
  o["foo"] = "bar";
  o["foo"] // --> "bar"

However, this functionality is relatively limited: It only supports strings (and symbols) as keys and it interacts badly with other methods and properties which are part of the object. Hence why an explicit "Map" type was added to the language much later.

The problem is, Maps are also objects, so they still inherit the "old" map functionality in addition to the new functionality. Those two systems are completely independent, even though they act on the same object. So writing

  mymap["foo"] = 1

and

  mymap.set("foo", 1)

both store the mapping "foo" -> 1, but in completely different places. Only the second one will actually put it into the store of the map, while the first one will just add it as a generic object property.

You can see it when trying to retrieve the value again:

  mymap["foo"] = 1
  mymap["foo"]; // --> 1
  mymap.get("foo"); // --> undefined

likewise:

  mymap.set("bar", 1);
  mymap.get("bar"); // --> 1
  mymap["bar"]; // --> undefined

Yes the square brackets were just a typo. But maps do support float keys - you can try it yourself!

  map = new Map();
  map.set(1.2, 3.4);
  log(typeof(map.keys().next().value));

That says the key is a number, and it's a floating point number. So what did they mean by "ECMAScript does not have maps where keys can be integers and neither can keys be floats"?

Ah, I misunderstood that, sorry.

I think the GP was wrong there. JS maps absolutely do support float keys, it's just generally a bad idea to use them if you don't restrict yourself to integers.

What runtime did you use for that?

JavaScript maps absolutely can use numbers (or any type) as keys, but that's not how its API works. Square brackets access object properties, but map entries are not stored like that, and that last `typeof` is `"undefined"` in every runtime I tried (not `"number"`). Try `map['set']` to see another example.

Here's what I think you meant:

    const map = new Map();
    map.set(1, 3);
    map.get(1); // 3
    map.set(1.2, 3.4);
    map.get(1.2); // 3.4
    typeof map.keys().next().value; // "number"

Square brackets were a typo - I didn't run it I just wrote it off the top of my head. Doesn't your correct prove what I said though?

We're certainly in agreement that cookiengineer's "ECMAScript does not have maps where keys can be integers and neither can keys be floats" assertion is dead wrong.

Where does Map.__proto__ point to? There's your answer :)

Everything in JS is an Object, therefore everything can have hashed keys. Including Arrays, because Array.__proto__ also points to Object.

You’re being pedantic. Nobody is talking about internal representations, they’re saying it’s literally possible to key into a map with a float, which is true.

No it's not, because they are talking about keying via Number.prototype.toString(), which is not keying via float but via its string representation.

And that's my point, it's even part of the ECMAScript spec. See 6.1.6.1 and 6.1.7.1 [1]

Additionally, a proof you can quickly tryout:

object={};

object[-0]=123;

object[+0]; // returns object["0"];

If Object key were a Number type, it would not use Number.prototype.toString().

You can literally create your own datatype and override valueOf() and toString() to play with this.

[1] https://262.ecma-international.org/13.0/

What do you think is happening when you use set with a float on a map?

How do you explain this?

    const map = new Map();
    map.set(1, 3);
    map.get(1); // 3
    map.set(1.2, 3.4);
    map.get(1.2); // 3.4
    typeof map.keys().next().value; // "number"

Where do you think ‘number’ comes from?

Read the spec - it supports primitives for keys and it doesn’t stringing them. As others have said in this thread - you’re just wrong.

It's done in JavaScript because there is not integer type. (Ok, ok, nowadays there is bigint, but historically.) So you do all int like calculations with number (which is IEEE double), but be sure to only do arithmetic where the result is still an integer. That's why you end up using a double as a numeric key. And I think a double can basically hold a 53 bit integer exactly.

Ok, that's different then. Using integers as keys should not be a problem, even if they are stored as floats. Problems start if you use non-integers or IEEE special values as keys.

This is definitely not my area of expertise, but my understanding was that the mantissa was actually the source of inexactness in floats? I know the power bits (10 bits?) are pretty close to actual twos complement ints, and you could always do things in a C-like union, but I wasn't aware you could directly treat the mantissa like an int

Reply on news.ycombinator.com