SharedTable

Veraltete anzeigen

*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.

Element Access
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.

Element Iteration
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.

  • new(t : table)

    Gibt eine neue SharedTable zurück, die Elemente enthält, die der in der angegebenen Luau-Tabelle enthaltenen Elemente entsprechen.

Funktionen

Konstrukteure

new

Kehrt eine neue, leere SharedTable zurück.

local st = SharedTable.new()

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 = 1

t.y = 2

t.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

t: table

Die Luau-Tabelle, deren Elemente in der neuen SharedTable gespeichert werden sollen.

Funktionen

clear

void

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

st: SharedTable

Der SharedTable zum löschen.

Rückgaben

void

clone

SharedTable

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

st: SharedTable

Das SharedTable-Objekt zum Klonen.

deep: bool

Ob Sie einen tiefen Clone erstellen ( true ) oder einen oberflächlichen Clone erstellen ( false ).

Standardwert: false

Rückgaben

SharedTable

Code-Beispiele

This code sample creates a shallow clone of a SharedTable.

Shallow Clone
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.

Deep Clone
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

SharedTable

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

st: SharedTable

Das SharedTable-Objekt zum Klonen.

deep: bool

Ob Sie einen tiefen Clone erstellen ( true ) oder einen oberflächlichen Clone erstellen ( false ).

Standardwert: false

Rückgaben

SharedTable

increment

number

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

st: SharedTable

Das SharedTable-Objekt, das aktualisiert werden soll.

key: string | number

Der Schlüssel des Elements in der SharedTable Objekt, um aktualisiert zu werden.

delta: number

Der Wert, der dem Element in der SharedTable hinzugefügt werden soll.

Rückgaben

number

Der ursprüngliche Wert des Elements, bevor delta hinzugefügt wurde.

Code-Beispiele

This code sample demonstrates usage of SharedTable.increment().

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

bool

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

st: SharedTable

Das SharedTable-Objekt, dessen eingefrorener Zustand abgerufen werden soll.

Rückgaben

bool

size

number

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] = nil

assert(SharedTable.size(st) == 2)

Parameter

st: SharedTable

Das SharedTable-Objekt, dessen Größe abgerufen werden soll.

Rückgaben

number

update

void

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

st: SharedTable

Das SharedTable-Objekt, das aktualisiert werden soll.

key: string | number

Der Schlüssel des Elements in der SharedTable Objekt, um aktualisiert zu werden.

f: function

Die Funktion, die berechnet werden soll, um den neuen Wert für das Element.

Rückgaben

void

Code-Beispiele

This code sample demonstrates usage of SharedTable.update().

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")