I've read some articles about V8's hidden classes. However, I still have a few questions in my head:
If, let's say, there are two objects:
var a = { }
a.x = 5
a.y = 6
var b = { }
b.y = 7
b.x = 8
Do they end up with the same hidden class or separate just because one went 0 + x + y
and the other 0 + y + x
? As I understood, they get different classes but just wanna make sure I got it.
Then, we have this case:
function Point(x, y) {
this.x = x
this.y = y
}
var a = new Point(7, 8)
var b = { }
b.x = 6
b.y = 8
var c = {
x: 8,
y: 9
}
var d = {
y: 9,
x: 80
}
Do we end up with the same hidden class? I might guess that a
, b
and c
do but d
doesn't. Unless there is some sorting done on such object expressions (similarly to array's short declaration being analysed for the type).
Finally, we have this:
function PointA(x, y) {
this.x = x
this.y = y
}
var a = new PointA(7, 8)
function PointB(x, y) {
this.x = x
this.y = y
}
var b = new PointB(7, 8)
It is sorta similar to the second case. These objects seem the same except that their origin (instanceof...
) is different. However, do there objects end up with the same hidden class?
You can easily check by using V8's debugging shell
d8
.Then run
You'll get the expected output:
For you second example:
All 4 objects have different hidden classes:
And last but not least:
a
andb
have different hidden classes, butb
andc
the same.If you download V8 and build the debug version you can pass those objects randomly to a function in an infinite loop and have it print the optimized disassembly and see if they were treated as having the same class.
In first case you are right that they will have different hidden classes.
In the second case you are wrong, you will end up with 4 different classes, so none of them share a class.
Firstly, fields that are added to an object outside constructor or object literal, will not be stored directly on the object but in an array external to the object. So that's why
b
will have different hidden class from everyone.A unique constructor will construct objects of unique class, so
a
will have different hidden class from everyone. The object literals have properties in different order which is the same case as in the first case.However object literals with exactly the same layout will share a hidden class, so if we added object
e
:Then
c
would share same hidden class withe
.In third case they will have different hidden classes for the same reason as in the second case, unique constructors construct objects of different classes.
You might also find this interesting https://codereview.stackexchange.com/a/28360/9258