Dictionaries are compared by reference with `==`, unlike Arrays which are compared by value

[AlexDarigan]

Godot 3.1

In Python (for example), if you were to compare Dictionaries they would evaluate to true as long as key-value pairs were the same. In GDScript, Dictionary comparison is based on a reference to the same Dictionary Object.

var x = {0: 10}
var y = x
print(x == y) // Outputs true

var x = {0: 10}
var y = {0: 10}
print(x == y) // Outputs false

Is this the intended behaviour?

[Jummit]

This is intended. You look if the references of two dictionaries are the same, so creating two with the same values won't work.

[AlexDarigan]

This is intended. You look if the references of two dictionaries are the same, so creating two with the same values won't work.

I mean, why do dicts comparison treat it via ref to the same object whereas Arrays are based on values.

[Zylann]

@CodeDarigan arrays used to be compared by ref too in the past. Then there was requests to make arrays compared by value and now they are by value ¯\_(ツ)_/¯

[Calinou]

This can be worked around thanks to the Dictionary.hash() method:

var x = {0: 10}
var y = {0: 10}
print(x.hash() == y.hash()) # Outputs `true`

[akien-mga]

See also #29222.

[razcore-rad]

This can be worked around thanks to the Dictionary.hash() method:

var x = {0: 10}
var y = {0: 10}
print(x.hash() == y.hash()) # Outputs `true`

Actually no, this doesn't quite work, cause the order matters since some other ppl complained that there wasn't order preservation with dicts.

So we get something like:

var d1 := {x = 0, y = 1}
var d2 := {y = 1, x = 0}
print(d1.hash() == d2.hash()) # False

Is there a way to preserve ordering and have the hashes be the same? I would think not, but honestly... I prefer unordered dicts because of this comparison issue.

Unordered dicts are the default in many languages.

[Calinou]

@razcore-art Dictionaries are ordered since Godot 3.0, but there's no way to opt out of that behvior.

[FeralBytes]

I just wanted to chime in that this recently bit me, as the order matters and so for complicated Dictionaries comparison via hash() is useless if just one element is out of order.

Tracking how many times I have stumbled upon this issue. Hopefully one day I will remember this. Different ways i have encountered this: "==", "in", "has()", "get()".
Lesson learned: Use hash(), Don't trust hash() either. Do a deep per key/value comparison if it is needed.

I have been here: 9 times, because of run ins with this bug in various ways.

The reason that you can not trust hash() is because if the dictionaries have the same keys and the same values, but the order of the keys is different then the hash() will also be different. This really makes zero sense, especially since by definition dictionaries are not ordered.
If you do Array.has(Dictionary), you have to realize you will only find the Dictionary if it is the exact in memory Dictionary. So if you send something across the network it will be at a different spot in memory and as such, has() will return false.
This is just not what any sane programmer would expect. At-least that is my opinion.