SharedTable
*Questo contenuto è tradotto usando AI (Beta) e potrebbe contenere errori. Per visualizzare questa pagina in inglese, clicca qui.
Rappresenta una struttura dati simile a una tabella che può essere condivisa tra contesti di esecuzione. Mentre può essere utilizzato per varie sorte di dati di archiviazione generici, è progettato specificamente per l'uso con Parallel Luau , dove può essere utilizzato per condividere lo stato tra gli script parented under different Actor istanze.
Ci sono un paio di modi idiomatici per comunicare tabelle condivise tra gli script. Un metodo è archiviare e recuperare oggetti SharedTable negli SharedTableRegistry . Il registro consente a qualsiasi script nel modello di dati stesso di ottenere
Come una tabella Luau, un oggetto SharedTable memorizza un insieme di coppie di valori chiave. A differenza di una tabella Luau, solo i tipi di oggetti selezionati possono essere memorizzati in una SharedTable, simile alle altre restrizioni che troverai altrove nel motore Roblox.
Le chiavi devono essere (1) una stringa o (2) un numero non negativo inferiore a 2 32 . Altri tipi di chiavi non sono supportati.
I valori devono avere uno dei seguenti tipi:Boolean, Number, Vector, String, SharedTable , o un inserisci / scrividi dati serializzabile. La capacità di memorizzare un SharedTable come valore in un altro SharedTable consente la costruzione di strutture di dati innesitate e递orsi.
SharedTable oggetti sono distinti e diversi SharedTable oggetti non sono mai paragonabili, anche se hanno contenuti che potrebbero paragonarsi.
Come una tabella Luau, un oggetto SharedTable può essere congelato, in cui caso è letto solo. Un tentativo di modificare un congelato SharedTable avrà un errore. Un congelato Datatype
Campioni di codice
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)
endSommario
Costruttori
- new()
Restituisce un nuovo, vuoto SharedTable .
Restituisce una nuova SharedTable contenente elementi equivalenti a quelli nella tabella Luau fornita.
Funzioni
Rimuove tutti gli elementi dalla SharedTable .
Crea e restituisce un clone del SharedTable fornito.
Crea e restituisce un clone congelato (senza lettura) del SharedTable fornito.
Aggiunge delta al valore con la chiave fornita e restituisce il valore originale.
Restituisce true se il SharedTable è congelato (solo lettura).
Restituisce il numero di elementi memorizzati nel SharedTable .
Aggiorna il valore con la chiave fornita tramite la funzione di aggiornamento fornita.
Costruttori
new
Restituisce una nuova SharedTable contenente elementi equivalenti a quelli nella tabella Luau fornita.
Se la tabella Luau fornita contiene chiavi o valori che non possono essere memorizzati in una SharedTable , la costruzione della SharedTable fallisce. Vedi la somma nella parte superiore di questa pagina per una lista di tipi di oggetti che possono essere memorizzati in una Datatype.SharedTable
Nota che in alcuni casi potrebbe essere desiderabile archiviare un SharedTable nel SharedTableRegistry . Il metodo Class.ShareTableRegistry:GetSharedTable() fornisce un modo conveniente per compiere questo.
Parametri
La tabella Luau cuyos elementos sono da essere memorizzati nel nuovo SharedTable .
Funzioni
clear
Atomisticamente rimuove tutti gli elementi da un SharedTable .
Se il SharedTable è congelato, l'operazione non ha successo e viene visualizzato un errore.
Parametri
Il SharedTable per la Eliminare/Pulire.
Restituzioni
clone
Crea un clone di un SharedTable e restituisce il clone.
Se l'argomento opzionale deep non è presente, o se è presente e il suo valore è false, allora viene creato un clone shallow. Un clone
L'operazione di clonazione superficiale è atomica, quindi il clone SharedTable contenuto un backup coerente dello stato nell'originale SharedTable, anche se viene modificato contemporaneamente da altri script.
Se l'argomento opzionale deep è presente e il suo valore è true , viene creato un clone profondo. Un clone profondo si ripetisce in modo ricorsivo una struttura di SharedTable oggetti, in modo che non ci sia uno stato condiviso tra l'originale 1> Datatype.SharedTable1> e il clone.
Il clone di ciascun SharedTable dentro il grafico di SharedTable oggetti è atomico, ma il deep clone come insieme non è atomico. Quindi, il clone di ciascun Datatype.Shared
L'oggetto SharedTable che viene clonato potrebbe essere congelato (solo lettura) o non essere congelato. Indipendentemente da ciò, i cloni appena creati non sono non congelati (e quindi modificabili). Per creare i cloni congelati, usa la funzione SharedTable.cloneAndFreeze.
Per illustrare la differenza tra un clone superficiale e un clone profondo, considera i seguenti esempi. Questo primo esempio crea un clone superficiale e il secondo crea un clone profondo.
Parametri
L'oggetto SharedTable da clonare.
Se creare un clone profondo ( true ) o un clone superficiale ( false ).
Restituzioni
Campioni di codice
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
Crea una clonazione congelata (solo lettura) di un SharedTable e restituisce la clonazione. Il comportamento di questa funzione è lo stesso della funzione clonare, ad eccezione che la clonazione è congelata.
Se viene richiesto un clone profondo, allora tutti gli oggetti SharedTable clonati sono congelati.
Parametri
L'oggetto SharedTable da clonare.
Se creare un clone profondo ( true ) o un clone superficiale ( false ).
Restituzioni
increment
Aumenta atomisticamente il valore di un elemento. Un elemento con la chiave specificata deve esistere nel SharedTable , e deve essere di tipo number . Il valore specificato delta viene aggiunto al valore e il valore originale viene restituito.
La funzione SharedTable.update può essere utilizzata anche per questo scopo; questa funzione increment esiste per convenienza e prestazioni (in Generale, increment è molto più veloce di 1> Aggiornarmento1>, quindi dovrebbe essere preferito dove possibile). Le seguenti due chiamate di funzione hanno lo stesso effetto:
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)
Se il SharedTable è congelato, l'operazione non ha successo e viene visualizzato un errore.
Parametri
L'oggetto SharedTable da aggiornare.
La chiave dell'elemento nell'oggetto SharedTable da aggiornare.
Il valore da aggiungere all'elemento in SharedTable .
Restituzioni
Il valore originale dell'elemento, prima che delta fosse aggiunto a lui.
Campioni di codice
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
Restituisce true se il SharedTable è congelato (solo lettura).
Parametri
L'oggetto SharedTable il cui stato congelato deve essere richiesto.
Restituzioni
size
Restituisce il numero di elementi memorizzati nella SharedTable. Nota che se altri script stanno modificando contemporaneamente la SharedTable, la dimensione restituita potrebbe non essere più corretta dopo il suo ritorno, poiché altri script potrebbero aver aggiunto o rimosso elementi dalla SharedTable.
Parametri
L'oggetto SharedTable la cui dimensione è richiesta.
Restituzioni
update
Aggiorna automaticamente il valore di un elemento.
Quando un SharedTable viene accessato contemporaneamente da script in esecuzione in diversi contesti di esecuzione, è possibile che i loro accessi interagiscano in modo imprevedibile. A causa di questo, il codice come il seguente è generalmente errato, poiché il valore potrebbe essere cambiato tra il read nella prima riga e l'aggiornamento nella seconda riga:
La funzione update rende possibile eseguire un aggiornamento atomico a un elemento. Richiede una funzione che chiamerà con il valore attuale dell'elemento. La funzione può quindi calcolare e restituire il nuovo valore. Nota che la funzione può essere chiamata più volte se la SharedTable viene modificata contemporaneamente da altri script.
Se il SharedTable è congelato, l'operazione non ha successo e viene visualizzato un errore.
Parametri
L'oggetto SharedTable da aggiornare.
La chiave dell'elemento nell'oggetto SharedTable da aggiornare.
La funzione che verrà chiamata per calcolare il nuovo valore per l'elemento.
Restituzioni
Campioni di codice
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")