Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Dictionary

包含鍵值對的內建資料結構。

說明

Dictionaries are associative containers that contain values referenced by unique keys. Dictionaries will preserve the insertion order when adding new entries. In other programming languages, this data structure is often referred to as a hash map or an associative array.

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

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 value by referencing its corresponding 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_enum("White", "Yellow", "Orange") var my_color: String
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:

var 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, untyped 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" },
}

The keys of a dictionary can be iterated with the for keyword:

var groceries = { "Orange": 20, "Apple": 2, "Banana": 4 }
for fruit in groceries:
    var amount = groceries[fruit]

To enforce a certain type for keys and values, you can create a typed dictionary. Typed dictionaries can only contain keys and values of the given types, or that inherit from the given classes:

# Creates a typed dictionary with String keys and int values.
# Attempting to use any other type for keys or values will result in an error.
var typed_dict: Dictionary[String, int] = {
    "some_key": 1,
    "some_other_key": 2,
}

# Creates a typed dictionary with String keys and values of any type.
# Attempting to use any other type for keys will result in an error.
var typed_dict_key_only: Dictionary[String, Variant] = {
    "some_key": 12.34,
    "some_other_key": "string",
}

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().

Note: Erasing elements while iterating over dictionaries is not supported and will result in unpredictable behavior.

Note: In a boolean context, a dictionary will evaluate to false if it's empty ({}). Otherwise, a dictionary will always evaluate to true.

備註

使用 C# 操作此 API 時有顯著差異，詳見 C# API 與 GDScript 的不同。

教學

建構子

Dictionary

Dictionary()

Dictionary

Dictionary(base: Dictionary, key_type: int, key_class_name: StringName, key_script: Variant, value_type: int, value_class_name: StringName, value_script: Variant)

Dictionary

Dictionary(from: Dictionary)

方法

void

assign(dictionary: Dictionary)

void

clear()

Dictionary

duplicate(deep: bool = false) const

Dictionary

duplicate_deep(deep_subresources_mode: int = 1) const

bool

erase(key: Variant)

Variant

find_key(value: Variant) const

Variant

get(key: Variant, default: Variant = null) const

Variant

get_or_add(key: Variant, default: Variant = null)

int

get_typed_key_builtin() const

StringName

get_typed_key_class_name() const

Variant

get_typed_key_script() const

int

get_typed_value_builtin() const

StringName

get_typed_value_class_name() const

Variant

get_typed_value_script() const

bool

has(key: Variant) const

bool

has_all(keys: Array) const

int

hash() const

bool

is_empty() const

bool

is_read_only() const

bool

is_same_typed(dictionary: Dictionary) const

bool

is_same_typed_key(dictionary: Dictionary) const

bool

is_same_typed_value(dictionary: Dictionary) const

bool

is_typed() const

bool

is_typed_key() const

bool

is_typed_value() const

Array

keys() const

void

make_read_only()

void

merge(dictionary: Dictionary, overwrite: bool = false)

Dictionary

merged(dictionary: Dictionary, overwrite: bool = false) const

bool

recursive_equal(dictionary: Dictionary, recursion_count: int) const

bool

set(key: Variant, value: Variant)

int

size() const

void

sort()

Array

values() const

運算子

bool

operator !=(right: Dictionary)

bool

operator ==(right: Dictionary)

Variant

operator [](key: Variant)

建構子說明

Dictionary Dictionary() 🔗

建構空的 Dictionary。

Dictionary Dictionary(base: Dictionary, key_type: int, key_class_name: StringName, key_script: Variant, value_type: int, value_class_name: StringName, value_script: Variant)

Creates a typed dictionary from the base dictionary. A typed dictionary can only contain keys and values of the given types, or that inherit from the given classes, as described by this constructor's parameters.

Dictionary Dictionary(from: Dictionary)

返回與 from 相同的字典。如果你需要該字典的副本，請使用 duplicate()。

方法說明

void assign(dictionary: Dictionary) 🔗

Assigns elements of another dictionary into the dictionary. Resizes the dictionary to match dictionary. Performs type conversions if the dictionary is typed.

void clear() 🔗

清空該字典，移除其中的所有條目。

Dictionary duplicate(deep: bool = false) const 🔗

Returns a new copy of the dictionary.

By default, a shallow copy is returned: all nested Array, Dictionary, and Resource keys and values are shared with the original dictionary. Modifying any of those in one dictionary will also affect them in the other.

If deep is true, a deep copy is returned: all nested arrays and dictionaries are also duplicated (recursively). Any Resource is still shared with the original dictionary, though.

Dictionary duplicate_deep(deep_subresources_mode: int = 1) const 🔗

Duplicates this dictionary, deeply, like duplicate() when passing true, with extra control over how subresources are handled.

deep_subresources_mode must be one of the values from DeepDuplicateMode. By default, only internal resources will be duplicated (recursively).

bool erase(key: Variant) 🔗

如果字典中存在與鍵對應的條目，則將其移除。如果給定的鍵 key 在字典中存在，則返回 true ，否則返回 false 。

注意：請勿在走訪字典時擦除條目。你可以改為走訪 keys() 陣列。

Variant find_key(value: Variant) const 🔗

找到並返回關聯值等於 value 的第一個鍵，如果沒有找到，則返回 null。

注意：null 也是有效的鍵。如果字典中包含這個鍵，則 find_key() 可能會給出誤導性的結果。

Variant get(key: Variant, default: Variant = null) const 🔗

Returns the corresponding value for the given key in the dictionary. If the key does not exist, returns default, or null if the parameter is omitted.

Note: If the default argument is computationally expensive or has unwanted side effects, consider using the has() method instead:

# Always calls `expensive_function()`.
dict.get("key", expensive_function())
# Calls `expensive_function()` only if the key does not exist.
dict.get("key") if dict.has("key") else expensive_function()

Variant get_or_add(key: Variant, default: Variant = null) 🔗

Gets a value and ensures the key is set. If the key exists in the dictionary, this behaves like get(). Otherwise, the default value is inserted into the dictionary and returned.

int get_typed_key_builtin() const 🔗

Returns the built-in Variant type of the typed dictionary's keys as a Variant.Type constant. If the keys are not typed, returns @GlobalScope.TYPE_NIL. See also is_typed_key().

StringName get_typed_key_class_name() const 🔗

Returns the built-in class name of the typed dictionary's keys, if the built-in Variant type is @GlobalScope.TYPE_OBJECT. Otherwise, returns an empty StringName. See also is_typed_key() and Object.get_class().

Variant get_typed_key_script() const 🔗

Returns the Script instance associated with this typed dictionary's keys, or null if it does not exist. See also is_typed_key().

int get_typed_value_builtin() const 🔗

Returns the built-in Variant type of the typed dictionary's values as a Variant.Type constant. If the values are not typed, returns @GlobalScope.TYPE_NIL. See also is_typed_value().

StringName get_typed_value_class_name() const 🔗

Returns the built-in class name of the typed dictionary's values, if the built-in Variant type is @GlobalScope.TYPE_OBJECT. Otherwise, returns an empty StringName. See also is_typed_value() and Object.get_class().

Variant get_typed_value_script() const 🔗

Returns the Script instance associated with this typed dictionary's values, or null if it does not exist. See also is_typed_value().

bool has(key: Variant) const 🔗

Returns true if the dictionary contains an entry with the given key.

var my_dict = {
    "Godot" : 4,
    210 : null,
}

print(my_dict.has("Godot")) # Prints true
print(my_dict.has(210))     # Prints true
print(my_dict.has(4))       # Prints false

In GDScript, this is equivalent to the in operator:

if "Godot" in { "Godot": 4 }:
    print("The key is here!") # Will be printed.

Note: This method returns true as long as the key exists, even if its corresponding value is null.

bool has_all(keys: Array) const 🔗

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

var data = { "width": 10, "height": 20 }
data.has_all(["height", "width"]) # Returns true

int hash() const 🔗

Returns a hashed 32-bit integer value representing the dictionary contents.

var dict1 = { "A": 10, "B": 2 }
var dict2 = { "A": 10, "B": 2 }

print(dict1.hash() == dict2.hash()) # Prints true

Note: Dictionaries with the same entries but in a different order will not have the same hash.

Note: Dictionaries with equal hash values are not guaranteed to be the same, because of hash collisions. On the contrary, dictionaries with different hash values are guaranteed to be different.

bool is_empty() const 🔗

如果該字典為空（大小為 0），則返回 true。另見 size()。

bool is_read_only() const 🔗

如果該字典是唯讀的，則返回 true 。見 make_read_only()。用 const 關鍵字宣告的字典自動唯讀。

bool is_same_typed(dictionary: Dictionary) const 🔗

Returns true if the dictionary is typed the same as dictionary.

bool is_same_typed_key(dictionary: Dictionary) const 🔗

Returns true if the dictionary's keys are typed the same as dictionary's keys.

bool is_same_typed_value(dictionary: Dictionary) const 🔗

Returns true if the dictionary's values are typed the same as dictionary's values.

bool is_typed() const 🔗

Returns true if the dictionary is typed. Typed dictionaries can only store keys/values of their associated type and provide type safety for the [] operator. Methods of typed dictionary still return Variant.

bool is_typed_key() const 🔗

Returns true if the dictionary's keys are typed.

bool is_typed_value() const 🔗

Returns true if the dictionary's values are typed.

Array keys() const 🔗

返回該字典中的鍵列表。

void make_read_only() 🔗

使該字典唯讀，即禁用字典內容的修改。不適用於巢狀內容，例如內嵌字典的內容。

void merge(dictionary: Dictionary, overwrite: bool = false) 🔗

Adds entries from dictionary to this dictionary. By default, duplicate keys are not copied over, unless overwrite is true.

var dict = { "item": "sword", "quantity": 2 }
var other_dict = { "quantity": 15, "color": "silver" }

# Overwriting of existing keys is disabled by default.
dict.merge(other_dict)
print(dict)  # { "item": "sword", "quantity": 2, "color": "silver" }

# With overwriting of existing keys enabled.
dict.merge(other_dict, true)
print(dict)  # { "item": "sword", "quantity": 15, "color": "silver" }

Note: merge() is not recursive. Nested dictionaries are considered as keys that can be overwritten or not depending on the value of overwrite, but they will never be merged together.

Dictionary merged(dictionary: Dictionary, overwrite: bool = false) const 🔗

Returns a copy of this dictionary merged with the other dictionary. By default, duplicate keys are not copied over, unless overwrite is true. See also merge().

This method is useful for quickly making dictionaries with default values:

var base = { "fruit": "apple", "vegetable": "potato" }
var extra = { "fruit": "orange", "dressing": "vinegar" }
# Prints { "fruit": "orange", "vegetable": "potato", "dressing": "vinegar" }
print(extra.merged(base))
# Prints { "fruit": "apple", "vegetable": "potato", "dressing": "vinegar" }
print(extra.merged(base, true))

bool recursive_equal(dictionary: Dictionary, recursion_count: int) const 🔗

Returns true if the two dictionaries contain the same keys and values, inner Dictionary and Array keys and values are compared recursively.

bool set(key: Variant, value: Variant) 🔗

Sets the value of the element at the given key to the given value. Returns true if the value is set successfully. Fails and returns false if the dictionary is read-only, or if key and value don't match the dictionary's types. This is the same as using the [] operator (dict[key] = value).

int size() const 🔗

返回該字典中條目的數量。空字典（{ }）始終返回 0。另見 is_empty()。

void sort() 🔗

Sorts the dictionary in ascending order, by key. The final order is dependent on the "less than" (<) comparison between keys.

var numbers = { "c": 2, "a": 0, "b": 1 }
numbers.sort()
print(numbers) # Prints { "a": 0, "b": 1, "c": 2 }

This method ensures that the dictionary's entries are ordered consistently when keys() or values() are called, or when the dictionary needs to be converted to a string through @GlobalScope.str() or JSON.stringify().

Array values() const 🔗

返回該字典中的值列表。

運算子說明

bool operator !=(right: Dictionary) 🔗

如果兩個字典包含的鍵、值不同，則返回 true 。

bool operator ==(right: Dictionary) 🔗

如果兩個字典包含的鍵、值心相同，則返回 true 。條目順序並不重要。

注意：在 C# 中，按照慣例，這個運算子進行的是按引用比較。如果你需要按值比較，請走訪這兩個字典。

Variant operator [](key: Variant) 🔗

返回該字典中與給定的鍵 key 對應的值。如果條目不存在或者失敗，則返回 null。為了更安全的存取，請使用 get() 或 has()。