mirror of
https://github.com/godotengine/godot.git
synced 2024-11-27 09:16:35 +08:00
f7c611ab71
- Removed empty paragraphs in XML. - Consistently use bold style for "Example:", on a new line. - Fix usage of `[code]` when hyperlinks could be used (`[member]`, `[constant]`). - Fix invalid usage of backticks for inline code in BBCode. - Fix some American/British English spelling inconsistencies. - Other minor fixes spotted along the way, including typo fixes with codespell. - Don't specify `@GlobalScope` for `enum` and `constant`.
347 lines
14 KiB
XML
347 lines
14 KiB
XML
<?xml version="1.0" encoding="UTF-8" ?>
|
|
<class name="Dictionary" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
|
|
<brief_description>
|
|
Dictionary type.
|
|
</brief_description>
|
|
<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. 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 [code]key: value[/code] pairs in curly braces [code]{}[/code].
|
|
Erasing elements while iterating over them [b]is not supported[/b] and will result in undefined behavior.
|
|
[b]Note:[/b] Dictionaries are always passed by reference. To get a copy of a dictionary which can be modified independently of the original dictionary, use [method duplicate].
|
|
Creating a dictionary:
|
|
[codeblocks]
|
|
[gdscript]
|
|
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,
|
|
}
|
|
[/gdscript]
|
|
[csharp]
|
|
var myDict = new Godot.Collections.Dictionary(); // Creates an empty dictionary.
|
|
var pointsDict = new Godot.Collections.Dictionary
|
|
{
|
|
{"White", 50},
|
|
{"Yellow", 75},
|
|
{"Orange", 100}
|
|
};
|
|
[/csharp]
|
|
[/codeblocks]
|
|
You can access a dictionary's values by referencing the appropriate key. In the above example, [code]points_dict["White"][/code] will return [code]50[/code]. You can also write [code]points_dict.White[/code], 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).
|
|
[codeblocks]
|
|
[gdscript]
|
|
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]
|
|
[/gdscript]
|
|
[csharp]
|
|
[Export(PropertyHint.Enum, "White,Yellow,Orange")]
|
|
public string MyColor { get; set; }
|
|
public Godot.Collections.Dictionary pointsDict = new Godot.Collections.Dictionary
|
|
{
|
|
{"White", 50},
|
|
{"Yellow", 75},
|
|
{"Orange", 100}
|
|
};
|
|
|
|
public override void _Ready()
|
|
{
|
|
int points = (int)pointsDict[MyColor];
|
|
}
|
|
[/csharp]
|
|
[/codeblocks]
|
|
In the above code, [code]points[/code] will be assigned the value that is paired with the appropriate color selected in [code]my_color[/code].
|
|
Dictionaries can contain more complex data:
|
|
[codeblocks]
|
|
[gdscript]
|
|
my_dict = {"First Array": [1, 2, 3, 4]} # Assigns an Array to a String key.
|
|
[/gdscript]
|
|
[csharp]
|
|
var myDict = new Godot.Collections.Dictionary
|
|
{
|
|
{"First Array", new Godot.Collections.Array{1, 2, 3, 4}}
|
|
};
|
|
[/csharp]
|
|
[/codeblocks]
|
|
To add a key to an existing dictionary, access it like an existing key and assign to it:
|
|
[codeblocks]
|
|
[gdscript]
|
|
var points_dict = {"White": 50, "Yellow": 75, "Orange": 100}
|
|
points_dict["Blue"] = 150 # Add "Blue" as a key and assign 150 as its value.
|
|
[/gdscript]
|
|
[csharp]
|
|
var pointsDict = new Godot.Collections.Dictionary
|
|
{
|
|
{"White", 50},
|
|
{"Yellow", 75},
|
|
{"Orange", 100}
|
|
};
|
|
pointsDict["blue"] = 150; // Add "Blue" as a key and assign 150 as its value.
|
|
[/csharp]
|
|
[/codeblocks]
|
|
Finally, dictionaries can contain different types of keys and values in the same dictionary:
|
|
[codeblocks]
|
|
[gdscript]
|
|
# 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"},
|
|
}
|
|
[/gdscript]
|
|
[csharp]
|
|
// This is a valid dictionary.
|
|
// To access the string "Nested value" below, use `((Godot.Collections.Dictionary)myDict["sub_dict"])["sub_key"]`.
|
|
var myDict = new Godot.Collections.Dictionary {
|
|
{"String Key", 5},
|
|
{4, new Godot.Collections.Array{1,2,3}},
|
|
{7, "Hello"},
|
|
{"sub_dict", new Godot.Collections.Dictionary{{"sub_key", "Nested value"}}}
|
|
};
|
|
[/csharp]
|
|
[/codeblocks]
|
|
[b]Note:[/b] Unlike [Array]s, you can't compare dictionaries directly:
|
|
[codeblocks]
|
|
[gdscript]
|
|
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.
|
|
[/gdscript]
|
|
[csharp]
|
|
// You have to use GD.Hash().
|
|
|
|
public Godot.Collections.Array array1 = new Godot.Collections.Array{1, 2, 3};
|
|
public Godot.Collections.Array array2 = new Godot.Collections.Array{1, 2, 3};
|
|
|
|
public void CompareArrays()
|
|
{
|
|
GD.Print(array1 == array2); // Will print FALSE!!
|
|
GD.Print(GD.Hash(array1) == GD.Hash(array2)); // Will print true.
|
|
}
|
|
|
|
public Godot.Collections.Dictionary dict1 = new Godot.Collections.Dictionary{{"a", 1}, {"b", 2}, {"c", 3}};
|
|
public Godot.Collections.Dictionary dict2 = new Godot.Collections.Dictionary{{"a", 1}, {"b", 2}, {"c", 3}};
|
|
|
|
public void CompareDictionaries()
|
|
{
|
|
GD.Print(dict1 == dict2); // Will NOT print true.
|
|
}
|
|
[/csharp]
|
|
[/codeblocks]
|
|
You need to first calculate the dictionary's hash with [method hash] before you can compare them:
|
|
[codeblocks]
|
|
[gdscript]
|
|
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.
|
|
[/gdscript]
|
|
[csharp]
|
|
// You have to use GD.Hash().
|
|
public Godot.Collections.Dictionary dict1 = new Godot.Collections.Dictionary{{"a", 1}, {"b", 2}, {"c", 3}};
|
|
public Godot.Collections.Dictionary dict2 = new Godot.Collections.Dictionary{{"a", 1}, {"b", 2}, {"c", 3}};
|
|
|
|
public void CompareDictionaries()
|
|
{
|
|
GD.Print(GD.Hash(dict1) == GD.Hash(dict2)); // Will print true.
|
|
}
|
|
[/csharp]
|
|
[/codeblocks]
|
|
[b]Note:[/b] When declaring a dictionary with [code]const[/code], the dictionary itself can still be mutated by defining the values of individual keys. Using [code]const[/code] will only prevent assigning the constant with another value after it was initialized.
|
|
</description>
|
|
<tutorials>
|
|
<link title="GDScript basics: Dictionary">$DOCS_URL/tutorials/scripting/gdscript/gdscript_basics.html#dictionary</link>
|
|
<link title="3D Voxel Demo">https://godotengine.org/asset-library/asset/676</link>
|
|
<link title="OS Test Demo">https://godotengine.org/asset-library/asset/677</link>
|
|
</tutorials>
|
|
<constructors>
|
|
<constructor name="Dictionary">
|
|
<return type="Dictionary" />
|
|
<description>
|
|
Constructs an empty [Dictionary].
|
|
</description>
|
|
</constructor>
|
|
<constructor name="Dictionary">
|
|
<return type="Dictionary" />
|
|
<param index="0" name="from" type="Dictionary" />
|
|
<description>
|
|
Constructs a [Dictionary] as a copy of the given [Dictionary].
|
|
</description>
|
|
</constructor>
|
|
</constructors>
|
|
<methods>
|
|
<method name="clear">
|
|
<return type="void" />
|
|
<description>
|
|
Clear the dictionary, removing all key/value pairs.
|
|
</description>
|
|
</method>
|
|
<method name="duplicate" qualifiers="const">
|
|
<return type="Dictionary" />
|
|
<param index="0" name="deep" type="bool" default="false" />
|
|
<description>
|
|
Creates a copy of the dictionary, and returns it. The [param deep] parameter causes inner dictionaries and arrays to be copied recursively, but does not apply to objects.
|
|
</description>
|
|
</method>
|
|
<method name="erase">
|
|
<return type="bool" />
|
|
<param index="0" name="key" type="Variant" />
|
|
<description>
|
|
Erase a dictionary key/value pair by key. Returns [code]true[/code] if the given key was present in the dictionary, [code]false[/code] otherwise.
|
|
[b]Note:[/b] Don't erase elements while iterating over the dictionary. You can iterate over the [method keys] array instead.
|
|
</description>
|
|
</method>
|
|
<method name="find_key" qualifiers="const">
|
|
<return type="Variant" />
|
|
<param index="0" name="value" type="Variant" />
|
|
<description>
|
|
Returns the first key whose associated value is equal to [param value], or [code]null[/code] if no such value is found.
|
|
[b]Note:[/b] [code]null[/code] is also a valid key. If you have it in your [Dictionary], the [method find_key] method can give misleading results.
|
|
</description>
|
|
</method>
|
|
<method name="get" qualifiers="const">
|
|
<return type="Variant" />
|
|
<param index="0" name="key" type="Variant" />
|
|
<param index="1" name="default" type="Variant" default="null" />
|
|
<description>
|
|
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 [code]null[/code] if it is omitted.
|
|
</description>
|
|
</method>
|
|
<method name="has" qualifiers="const">
|
|
<return type="bool" />
|
|
<param index="0" name="key" type="Variant" />
|
|
<description>
|
|
Returns [code]true[/code] if the dictionary has a given key.
|
|
[b]Note:[/b] This is equivalent to using the [code]in[/code] operator as follows:
|
|
[codeblocks]
|
|
[gdscript]
|
|
# Will evaluate to `true`.
|
|
if "godot" in {"godot": "engine"}:
|
|
pass
|
|
[/gdscript]
|
|
[csharp]
|
|
// You have to use Contains() here as an alternative to GDScript's `in` operator.
|
|
if (new Godot.Collections.Dictionary{{"godot", "engine"}}.Contains("godot"))
|
|
{
|
|
// I am executed.
|
|
}
|
|
[/csharp]
|
|
[/codeblocks]
|
|
This method (like the [code]in[/code] operator) will evaluate to [code]true[/code] as long as the key exists, even if the associated value is [code]null[/code].
|
|
</description>
|
|
</method>
|
|
<method name="has_all" qualifiers="const">
|
|
<return type="bool" />
|
|
<param index="0" name="keys" type="Array" />
|
|
<description>
|
|
Returns [code]true[/code] if the dictionary has all the keys in the given array.
|
|
</description>
|
|
</method>
|
|
<method name="hash" qualifiers="const">
|
|
<return type="int" />
|
|
<description>
|
|
Returns a hashed 32-bit integer value representing the dictionary contents. This can be used to compare dictionaries by value:
|
|
[codeblocks]
|
|
[gdscript]
|
|
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())
|
|
[/gdscript]
|
|
[csharp]
|
|
var dict1 = new Godot.Collections.Dictionary{{0, 10}};
|
|
var dict2 = new Godot.Collections.Dictionary{{0, 10}};
|
|
// The line below prints `true`, whereas it would have printed `false` if both variables were compared directly.
|
|
// Dictionary has no Hash() method. Use GD.Hash() instead.
|
|
GD.Print(GD.Hash(dict1) == GD.Hash(dict2));
|
|
[/csharp]
|
|
[/codeblocks]
|
|
[b]Note:[/b] Dictionaries with the same keys/values but in a different order will have a different hash.
|
|
[b]Note:[/b] Dictionaries with equal content will always produce identical hash values. However, the reverse is not true. Returning identical hash values does [i]not[/i] imply the dictionaries are equal, because different dictionaries can have identical hash values due to hash collisions.
|
|
</description>
|
|
</method>
|
|
<method name="is_empty" qualifiers="const">
|
|
<return type="bool" />
|
|
<description>
|
|
Returns [code]true[/code] if the dictionary is empty.
|
|
</description>
|
|
</method>
|
|
<method name="keys" qualifiers="const">
|
|
<return type="Array" />
|
|
<description>
|
|
Returns the list of keys in the [Dictionary].
|
|
</description>
|
|
</method>
|
|
<method name="merge">
|
|
<return type="void" />
|
|
<param index="0" name="dictionary" type="Dictionary" />
|
|
<param index="1" name="overwrite" type="bool" default="false" />
|
|
<description>
|
|
Adds elements from [param dictionary] to this [Dictionary]. By default, duplicate keys will not be copied over, unless [param overwrite] is [code]true[/code].
|
|
</description>
|
|
</method>
|
|
<method name="size" qualifiers="const">
|
|
<return type="int" />
|
|
<description>
|
|
Returns the number of keys in the dictionary.
|
|
</description>
|
|
</method>
|
|
<method name="values" qualifiers="const">
|
|
<return type="Array" />
|
|
<description>
|
|
Returns the list of values in the [Dictionary].
|
|
</description>
|
|
</method>
|
|
</methods>
|
|
<operators>
|
|
<operator name="operator !=">
|
|
<return type="bool" />
|
|
<param index="0" name="right" type="Dictionary" />
|
|
<description>
|
|
Returns [code]true[/code] if the dictionaries differ, i.e. their key or value lists are different (including the order).
|
|
</description>
|
|
</operator>
|
|
<operator name="operator ==">
|
|
<return type="bool" />
|
|
<param index="0" name="right" type="Dictionary" />
|
|
<description>
|
|
Returns [code]true[/code] if both dictionaries have the same contents, i.e. their keys list and value list are equal.
|
|
</description>
|
|
</operator>
|
|
<operator name="operator []">
|
|
<return type="Variant" />
|
|
<param index="0" name="key" type="Variant" />
|
|
<description>
|
|
Returns a value at the given [param key] or [code]null[/code] and error if the key does not exist. For safe access, use [method get] or [method has].
|
|
</description>
|
|
</operator>
|
|
</operators>
|
|
</class>
|