Why is not "9007199254740991" treated as an integer index?

Question

According to the specification, a string-valued property key whose numeric value is 2 ** 53 - 1 must be treated as an integer index. According to the specification, the [[OwnPropertyKeys]] internal method must enumerate property keys which is an integer index, in ascending numeric order. According to the specification, Reflect.ownKeys calls the [[OwnPropertyKeys]] internal method.

So, the following code should show property keys in ascending numeric order (i.e., ["9007199254740990", "9007199254740991"]) if my understanding is correct. However, all the existing implementations show property keys in ascending chronological order of property creation (i.e., ["9007199254740991", "9007199254740990"]).

console.log(Reflect.ownKeys({"9007199254740991": null, "9007199254740990": null}));

What is my mistake?

As far as I understand, as stated in `OrdinaryOwnPropertyKeys`, which is returned by `OwnPropertyKeys`, each key is added as last element. So you got exactly the same order that you are providing as input.. — Yuri, Mar 07 '18 at 08:34
@Yuri If so, why does `Reflect.ownKeys({"1": null, "0": null})` return `["0", "1"]`? — anqooqie, Mar 07 '18 at 08:37
I am getting `[ "9007199254740991", "9007199254740990"]` in my console — Yuri, Mar 07 '18 at 08:46
What is your question? why does `Reflect.ownKeys({"1": null, "0": null})` return `["0", "1"]`? OR Why is not “9007199254740991” treated as an integer index? — TessavWalstijn, Mar 07 '18 at 09:24

anqooqie · Accepted Answer · 2019-07-19T16:39:27.300

3

The specification of the [[OwnPropertyKeys]] internal method in ECMAScript 2017 (and in 2018) did not match the real behavior of all major JavaScript engines, so in ECMAScript 2019, the specification has been fixed. See the discussion on GitHub.

edited Jul 19 '19 at 16:39

answered Jul 19 '19 at 16:34

anqooqie

435
3
17

TessavWalstijn · Answer 2 · 2018-03-13T11:02:25.467

9007199254740991 is the maximum safe integer in JavaScript.

var x = Number.MAX_SAFE_INTEGER + 1,
  y = Number.MAX_SAFE_INTEGER + 2,
  z = Number.MAX_SAFE_INTEGER + 3,
  i = Number.MAX_SAFE_INTEGER + 4,
  j = Number.MAX_SAFE_INTEGER + 5;

console.log("max: "+Number.MAX_SAFE_INTEGER);
// expected output: 9007199254740991
// real output:     9007199254740991

console.log("x:   "+x);
// expected output: 9007199254740992
// real output:     9007199254740992

console.log("y:   "+y);
// expected output: 9007199254740993
// real output:     9007199254740992

console.log("z:   "+z);
// expected output: 9007199254740994
// real output:     9007199254740994

console.log("i:   "+i);
// expected output: 9007199254740995
// real output:     9007199254740996

console.log("j:   "+j);
// expected output: 9007199254740996
// real output:     9007199254740996

And some acts like expected.

Read on the following:

So what we know:

bitwise operators and shift operators operate on 32-bit ints, so in that case, the max safe integer is 2³¹-1, or 2147483647.

What I do not know is how the Reflect.ownKeys() sorts the indexes to numeric order.
Because of the following snippet:

const objs = [
    // does not work
    {
        9007199254740991: null,
        9007199254740990: null,
    },
    // works
    {
        2147483648: null,
        // max save bitwise number
        2147483647: null,
    },
    // works
    {
        4294967295: null,
        // max save bitwise number times 2
        4294967294: null,
    },
    // does not work
    {
        5368709118: null,
        // max save bitwise number times 2.5
        5368709117: null,
    }
];

const objkeys = [],
    max = objs.length;

for (let i = 0; i < max; i++) {
    objkeys.push(Reflect.ownKeys(objs[i]))
}

for (let i = 0; i < max; i++) {
    console.log(objkeys[i][0]+" < "+objkeys[i][1]);
}

I hoped you learned something about 9007199254740991 and JavaScript

My question is not why `Reflect.ownKeys` returns string values. According to the specification, each of `"9007199254740991"` and `"9007199254740990"` should be treated as an integer index, so `Reflect.ownKeys({"9007199254740991": null, "9007199254740990": null})` should return property keys in ascending numeric order, but the reality is not the case, why? — anqooqie, Mar 07 '18 at 09:51
@anqooqie Sorry for misunderstanding, I will edit the answer. — TessavWalstijn, Mar 07 '18 at 15:38

Why is not "9007199254740991" treated as an integer index?

2 Answers2