SharedTable
*Dieser Inhalt wurde mit KI (Beta) übersetzt und kann Fehler enthalten. Um diese Seite auf Englisch zu sehen, klicke hier.
Repräsentiert eine tabellenartige Datenstruktur, die über mehrere Ausführungs-Kontexts geteilt werden kann. Während es für verschiedene Arten von allgemeinen Datenspeicherung verwendet werden kann, ist es speziell für den Gebrauch mit Parallel Luau , wo es verwendet werden kann, um den Zustand über Skripte unter verschiedenen Actor Instanzen zu teilen.
Es gibt ein paar idiomatische Möglichkeiten, zwischen Skripten geteilte Tabellen zu kommunizieren. Eine Methode ist es, Tabellen in der SharedTable zu speichern und abzurufen SharedTableRegistry. Die Registrierung ermöglicht es jedem Skript im selben Datenmodell,
Wie eine Luau-Tabelle speichert ein SharedTable-Objekt eine Reihe von Schlüsselwertpaaren. Im Gegensatz zu einer Luau-Tabelle können nur ausgewählte Arten von Objekten in einem SharedTable gespeichert werden, ähnlich wie andere Einschränkungen, die Sie in der Roblox-Engine finden.
Schlüssel müssen entweder (1) eine Zeichenfolge oder (2) eine nicht negative Zahl sein, die weniger als 2 32 ist. Andere Arten von Schlüsseln werden nicht unterstützt.
Werte müssen einen der folgenden Arten haben:Boolean, Number, Vector, String, SharedTable , oder einen serIALisierten eingeben. Die Fähigkeit, einen SharedTable als Wert in einem anderen SharedTable zu speichern, ermöglicht die Konstruktion von verschachtelten und recursiven Datenstrukturen.
SharedTable Objekte sind unterschiedlich und nicht identisch SharedTable Objekte vergleichen niemals gleich, auch wenn sie Inhalte haben, die gleich sein sollten.
Wie eine Luau-Tabelle kann ein SharedTable-Objekt möglicherweise eingefroren werden, in dem es nur für die Lektüre gelesen wird. Ein Versuch, ein eingefrorenes SharedTable zu modifizieren, wird einen Fe
Code-Beispiele
Elements in a SharedTable are accessed in the same way as elements of Luau tables, using the st[k] syntax or, for string keys, st.k.
local st = SharedTable.new()
st[1] = "a"
st["x"] = true
st.y = 5
assert(st[1] == "a")
assert(st["x"] == true)
assert(st.x == true)
assert(st["y"] == 5)
assert(st.y == 5)
-- true is not a valid SharedTable key, so attempting to set that key
-- fails:
assert(not pcall(function() st[true] = 100 end))
-- A function is not a valid SharedTable value, so attempting to set a
-- value to a function fails:
assert(not pcall(function() st["f"] = function() end end))
The for loop can be used to iterate over the elements of a SharedTable. The elements of the SharedTable are not iterated directly. Instead, a shallow clone is made of the SharedTable, and its elements are iterated. This is done to ensure that a consistent view of the SharedTable is maintained throughout the iteration. Thus, both of the following for loops have the same behavior.
Note that this means that if the SharedTable is accessed directly from within the body of the iteration loop, its state may not be consistent with the state observed through the iteration.
The iteration order is partially specified. Elements with numeric keys are iterated before elements with string keys. Elements with numeric keys are iterated in ascending numeric order. Elements with string keys are iterated in an unspecified order.
local st = SharedTable.new({"a", "b", "c"})
for k, v in SharedTable.clone(st, false) do
print(k, ": ", v)
end
for k, v in st do
print(k, ": ", v)
end
Zusammenfassung
Konstrukteure
- new()
Kehrt eine neue, leere SharedTable zurück.
Gibt eine neue SharedTable zurück, die Elemente enthält, die der in der angegebenen Luau-Tabelle enthaltenen Elemente entsprechen.
Funktionen
Entfernt alle Elemente aus dem SharedTable .
Erstellt und gibt einen Klon des angegebenen SharedTable zurück.
Erstellt und gibt einen gefrorenen (nur für Lesen) Klon des angegebenen SharedTable zurück.
Fügt delta dem Wert mit dem angegebenen Schlüssel hinzu und gibt den ursprünglichen Wert zurück.
Gibt true zurück, wenn der SharedTable eingefroren ist (nur für Lesen).
Gibt die Anzahl der Elemente, die in der SharedTable gespeichert sind, zurück.
Aktualisiert den Wert mit der angegebenen Schlüsselfunktion über die angegebene Aktualisierungsfunktion.
Konstrukteure
new
Gibt eine neue SharedTable zurück, die Elemente enthält, die der in der angegebenen Luau-Tabelle enthaltenen Elemente entsprechen.
Wenn die angegebene Luau-Tabelle irgendwelche Schlüssel oder Werte enthält, die nicht in einem SharedTable gespeichert werden können, fehlert die Konstruktion des SharedTable. Siehe die Zusammenfassung oben auf dieser Seite für eine Liste von Objektarten, die in einem Datatype.
local t = {}t.x = 1t.y = 2t.z = {"a", "b", "c"}local st = SharedTable.new(t)assert(st.x == 1)assert(st.y == 2)assert(st.z[1] == "a")assert(st.z[2] == "b")assert(st.z[3] == "c")
Beachten Sie, dass in einigen Fällen vielleicht sinnvoll ist, ein SharedTable in den SharedTableRegistry zu speichern. Die Methode Class.ShareTableRegistry:GetSharedTable() bietet einen praktischen Weg, dies zu erreichen.
Parameter
Die Luau-Tabelle, deren Elemente in der neuen SharedTable gespeichert werden sollen.
Funktionen
clear
Atomar entfernt alle Elemente aus einer SharedTable .
Wenn der SharedTable eingefroren ist, fehlscht die Operation und ein Fehler wird angezeigt.
local st = SharedTable.new({"a", "b", "c"})assert(SharedTable.size(st) == 3)SharedTable.clear(st)assert(SharedTable.size(st) == 0)
Parameter
Der SharedTable zum löschen.
Rückgaben
clone
Erstellt einen Klon eines SharedTable und gibt den Klon zurück.
Wenn das optionale deep Objektnicht vorhanden ist, oder wenn es vorhanden ist und sein Wert false ist, wird ein kleiner Klon erstellt
Die Operation der sch shalligen Klonierung ist atomar, so dass der Klon SharedTable enthalten wird ein konsistenten Snapshot des Zustands im ursprünglichen SharedTable , auch wenn er derzeit von anderen Skripten modifiziert wird.
Wenn das optionale deep -Argument vorhanden ist und sein Wert true ist, wird ein Deep Clone erstellt. Ein Deep Clone kopiert dann wiederkehrend eine Struktur von SharedTable -Objekten, sodass zwischen dem ursprünglichen 1> Datatype.SharedTable1> und dem Clone kein Zustand geteilt wird.
Die Klonung jeder SharedTable innerhalb des Grapfes von SharedTable Objekten ist atomar, aber die tiefe Klonierung als Ganzes nicht atomar ist. Daher enthält die Klonung jeder
Das SharedTable -Objekt(s), das geklont wird, kann eingefroren (nur Lesen) oder nicht. Unabhängig davon sind die neu erstellten Klone nicht eingefroren (und sind daher modifizierbar). Um gefrorene Klone zu erstellen, verwenden Sie die Funktion SharedTable.cloneAndFreeze.
Um den Unterschied zwischen einem oberflächlichen Klon und einem tiefen Klon zu veranschaulichen, betrachten Sie die folgenden Beispiele. Dieser erste Beispiel erstellt einen oberflächlichen Klon und der zweite erstellt einen tiefen Klon.
Parameter
Das SharedTable-Objekt zum Klonen.
Ob Sie einen tiefen Clone erstellen ( true ) oder einen oberflächlichen Clone erstellen ( false ).
Rückgaben
Code-Beispiele
This code sample creates a shallow clone of a SharedTable.
local original = SharedTable.new()
original["a"] = "original a"
original["b"] = "original b"
original["c"] = SharedTable.new()
original["c"]["d"] = "original d"
local clone = SharedTable.clone(original, false)
clone["a"] = "new a"
clone["b"] = "new b"
clone["c"]["d"] = "new d"
assert(original["a"] == "original a")
assert(original["b"] == "original b")
-- Because this was a shallow clone, original["c"] and clone["c"] are
-- the same SharedTable object.
assert(original["c"] == clone["c"])
assert(original["c"]["d"] == "new d")
This code sample creates a deep clone of a SharedTable.
local original = SharedTable.new()
original["a"] = "original a"
original["b"] = "original b"
original["c"] = SharedTable.new()
original["c"]["d"] = "original d"
local clone = SharedTable.clone(original, true)
clone["a"] = "new a"
clone["b"] = "new b"
clone["c"]["d"] = "new d"
assert(original["a"] == "original a")
assert(original["b"] == "original b")
-- Because this was a deep clone, clone["c"] is a clone of original["c"];
-- they are distinct SharedTable objects.
assert(original["c"] ~= clone["c"])
assert(original["c"]["d"] == "original d")
cloneAndFreeze
Erstellt einen eingefrorenen (nur lesenden) Klon eines SharedTable und gibt den Klon zurück. Das Verhalten dieser Funktion ist wie das Verhalten eines Clones, mit der Ausnahme, dass der Klon eingefroren ist.
Wenn ein tiefer Clone angefordert wird, werden alle der klonierten SharedTable Objekte eingefroren.
Parameter
Das SharedTable-Objekt zum Klonen.
Ob Sie einen tiefen Clone erstellen ( true ) oder einen oberflächlichen Clone erstellen ( false ).
Rückgaben
increment
Atomar erhöht den Wert eines Elements. Ein Element mit dem angegebenen Schlüssel muss in der SharedTable , und es muss ein Typ number sein. Der angegebene delta wird dem Wert hinzugefügt und der ursprüngliche Wert zurückgegeben.
Die SharedTable.update-Funktion kann auch für diesen Zweck verwendet werden; diese increment-Funktion existiert für die Bequemlichkeit und Leistung (im Allgemeinen ist increment viel schneller als 1> Update1>, daher sollte es möglichst bevorzugt werden). Die folgenden zwei Funktionsaufrufe haben dieselben Effekte:
local st = SharedTable.new()
st["x"] = 1
local oldValue = SharedTable.increment(st, "x", 1)
SharedTable.update(st, "x", function(v)
oldValue = v
return v + 1
end)
Wenn der SharedTable eingefroren ist, fehlscht die Operation und ein Fehler wird angezeigt.
Parameter
Das SharedTable-Objekt, das aktualisiert werden soll.
Der Schlüssel des Elements in der SharedTable Objekt, um aktualisiert zu werden.
Der Wert, der dem Element in der SharedTable hinzugefügt werden soll.
Rückgaben
Der ursprüngliche Wert des Elements, bevor delta hinzugefügt wurde.
Code-Beispiele
This code sample demonstrates usage of SharedTable.increment().
local st = SharedTable.new()
st["x"] = 1
local oldValue = SharedTable.increment(st, "x", 1)
assert(oldValue == 1)
assert(st["x"] == 2)
-- The value of the specified key must be a number. If it is not a
-- number, the call will fail:
st["y"] = "test"
assert(not pcall(function() SharedTable.increment(st, "y", 1) end))
isFrozen
Gibt true zurück, wenn der SharedTable eingefroren ist (nur für Lesen).
local st1 = SharedTable.new({"a", "b", "c"})assert(not SharedTable.isFrozen(st1))local st2 = SharedTable.cloneAndFreeze(st1)assert(SharedTable.isFrozen(st2))
Parameter
Das SharedTable-Objekt, dessen eingefrorener Zustand abgerufen werden soll.
Rückgaben
size
Gibt die Anzahl der Elemente zurück, die in der SharedTable gespeichert sind. Beachten Sie, dass wenn andere Skripte der SharedTable gleichzeitig ändern, die zurückgegebene Größe möglicherweise nicht mehr richtig sein, da andere Skripte Elemente aus der SharedTable hinzugefügt oder entfernt haben.
local st = SharedTable.new({"a", "b", "c"})assert(SharedTable.size(st) == 3)st[2] = nilassert(SharedTable.size(st) == 2)
Parameter
Das SharedTable-Objekt, dessen Größe abgerufen werden soll.
Rückgaben
update
Atomar aktualisiert den Wert eines Elements.
Wenn ein SharedTable von Skripts, die in verschiedenen Ausführungskontexten laufen, gleichzeitig aufgerufen wird, ist es möglich, dass ihre Zugriffe unvorhersehbar überlappen. Aufgrund dessen ist der Code wie der folgende generell falsch, da der Wert zwischen der Lektüre in der ersten Zeile und der Aktualisierung in der zweiten Zeile geändert werden kann:
local oldValue = st["x"]st["x"] = oldValue .. ",x"
Die Aktualisierungsfunktion ermöglicht es, eine atomare Aktualisierung auf ein Element durchzuführen. Es erfordert eine Funktion, die mit dem aktuellen Wert des Elements aufgerufen wird. Die Funktion kann dann den neuen Wert berechnen und zurückgeben. Beachten Sie, dass die Funktion möglicherweise mehrfach aufgerufen wird, wenn der SharedTable von anderen Skripten gleichzeitig modifiziert wird.
Wenn der SharedTable eingefroren ist, fehlscht die Operation und ein Fehler wird angezeigt.
Parameter
Das SharedTable-Objekt, das aktualisiert werden soll.
Der Schlüssel des Elements in der SharedTable Objekt, um aktualisiert zu werden.
Die Funktion, die berechnet werden soll, um den neuen Wert für das Element.
Rückgaben
Code-Beispiele
This code sample demonstrates usage of SharedTable.update().
local st = SharedTable.new()
st["x"] = "abcd"
SharedTable.update(st, "x", function(v)
assert(v == "abcd")
return v .. "e"
end)
assert(st["x"] == "abcde")