Dictionary

Dictionary type.

Description

Dictionary type. Associative container which contains values referenced by unique keys. Dictionaries are composed of pairs of keys (which must be unique) and values. Dictionaries will preserve the insertion order when adding elements, even though this may not be reflected when printing the dictionary. In other programming languages, this data structure is sometimes referred to as a hash map or associative array.

You can define a dictionary by placing a comma-separated list of key: value pairs in curly braces {}.

Erasing elements while iterating over them is not supported and will result in undefined behavior.

Note: Dictionaries are always passed by reference. To get a copy of a dictionary which can be modified independently of the original dictionary, use duplicate.

Creating a dictionary:

var my_dict = {} # Creates an empty dictionary.

var dict_variable_key = "Another key name"
var dict_variable_value = "value2"
var another_dict = {
    "Some key name": "value1",
    dict_variable_key: dict_variable_value,
}

var points_dict = {"White": 50, "Yellow": 75, "Orange": 100}

# Alternative Lua-style syntax.
# Doesn't require quotes around keys, but only string constants can be used as key names.
# Additionally, key names must start with a letter or an underscore.
# Here, `some_key` is a string literal, not a variable!
another_dict = {
    some_key = 42,
}

You can access a dictionary's values by referencing the appropriate key. In the above example, points_dict["White"] will return 50. You can also write points_dict.White, which is equivalent. However, you'll have to use the bracket syntax if the key you're accessing the dictionary with isn't a fixed string (such as a number or variable).

export(string, "White", "Yellow", "Orange") var my_color
var points_dict = {"White": 50, "Yellow": 75, "Orange": 100}
func _ready():
    # We can't use dot syntax here as `my_color` is a variable.
    var points = points_dict[my_color]

In the above code, points will be assigned the value that is paired with the appropriate color selected in my_color.

Dictionaries can contain more complex data:

my_dict = {"First Array": [1, 2, 3, 4]} # Assigns an Array to a String key.

To add a key to an existing dictionary, access it like an existing key and assign to it:

var points_dict = {"White": 50, "Yellow": 75, "Orange": 100}
points_dict["Blue"] = 150 # Add "Blue" as a key and assign 150 as its value.

Finally, dictionaries can contain different types of keys and values in the same dictionary:

# This is a valid dictionary.
# To access the string "Nested value" below, use `my_dict.sub_dict.sub_key` or `my_dict["sub_dict"]["sub_key"]`.
# Indexing styles can be mixed and matched depending on your needs.
var my_dict = {
    "String Key": 5,
    4: [1, 2, 3],
    7: "Hello",
    "sub_dict": {"sub_key": "Nested value"},
}

Note: Unlike Arrays, you can't compare dictionaries directly:

var array1 = [1, 2, 3]
var array2 = [1, 2, 3]

func compare_arrays():
    print(array1 == array2) # Will print true.

var dict1 = {"a": 1, "b": 2, "c": 3}
var dict2 = {"a": 1, "b": 2, "c": 3}

func compare_dictionaries():
    print(dict1 == dict2) # Will NOT print true.

You need to first calculate the dictionary's hash with hash before you can compare them:

var dict1 = {"a": 1, "b": 2, "c": 3}
var dict2 = {"a": 1, "b": 2, "c": 3}

func compare_dictionaries():
    print(dict1.hash() == dict2.hash()) # Will print true.

Note: When declaring a dictionary with const, the dictionary itself can still be mutated by defining the values of individual keys. Using const will only prevent assigning the constant with another value after it was initialized.

Methods

Dictionary

Dictionary ( ) constructor

Dictionary

Dictionary ( Dictionary from ) constructor

void

clear ( )

Dictionary

duplicate ( bool deep=false ) const

bool

erase ( Variant key )

Variant

get ( Variant key, Variant default=null ) const

bool

has ( Variant key ) const

bool

has_all ( Array keys ) const

int

hash ( ) const

bool

is_empty ( ) const

Array

keys ( ) const

bool

operator != ( ) operator

bool

operator != ( Dictionary right ) operator

bool

operator == ( ) operator

bool

operator == ( Dictionary right ) operator

Variant

operator [] ( Variant key ) operator

int

size ( ) const

Array

values ( ) const

Method Descriptions

Constructs an empty Dictionary.


Constructs a Dictionary as a copy of the given Dictionary.


  • void clear ( )

Clear the dictionary, removing all key/value pairs.


Creates a copy of the dictionary, and returns it. The deep parameter causes inner dictionaries and arrays to be copied recursively, but does not apply to objects.


Erase a dictionary key/value pair by key. Returns true if the given key was present in the dictionary, false otherwise.

Note: Don't erase elements while iterating over the dictionary. You can iterate over the keys array instead.


Returns the current value for the specified key in the Dictionary. If the key does not exist, the method returns the value of the optional default argument, or null if it is omitted.


Returns true if the dictionary has a given key.

Note: This is equivalent to using the in operator as follows:

# Will evaluate to `true`.
if "godot" in {"godot": "engine"}:
    pass

This method (like the in operator) will evaluate to true as long as the key exists, even if the associated value is null.


Returns true if the dictionary has all the keys in the given array.


  • int hash ( ) const

Returns a hashed integer value representing the dictionary contents. This can be used to compare dictionaries by value:

var dict1 = {0: 10}
var dict2 = {0: 10}
# The line below prints `true`, whereas it would have printed `false` if both variables were compared directly.
print(dict1.hash() == dict2.hash())

Note: Dictionaries with the same keys/values but in a different order will have a different hash.


  • bool is_empty ( ) const

Returns true if the dictionary is empty.


Returns the list of keys in the Dictionary.


  • bool operator != ( ) operator



  • bool operator == ( ) operator




  • int size ( ) const

Returns the number of keys in the dictionary.


Returns the list of values in the Dictionary.