SharedTable

Mostrar obsoleto

*Este conteúdo é traduzido por IA (Beta) e pode conter erros. Para ver a página em inglês, clique aqui.

Representa una estructura de datos similar a una tabla que se puede compartir en contextos de ejecución. Mientras se puede usar para varios tipos de almacenamiento de datos genéricos, está diseñado específicamente para usar con Parallel Luau , donde se puede usar para compartir el estado entre los scripts padre en diferentes instancias Actor .

Hay algunas formas idiomáticas de comunicar tablas compartidas entre scripts. Un método es almacenar y recuperar objetos SharedTable en el SharedTableRegistry . El registro permite que cualquier script en el mismo modelo de datos obtenga o establezca un Datatype.SharedTable</

Al igual que una tabla Luau, un objeto SharedTable almacena un conjunto de par de valores de clave. A diferencia de una tabla Luau, solo los tipos seleccionados de objetos se pueden almacenar en un SharedTable, similar a otras limitaciones que encontrarás en el motor de Roblox.

Las llaves deben ser (1) una cadena o (2) un número de números no negativos menor que 2 32 . Otras clases de llaves no están soportadas.

Los valores deben tener uno de los siguientes tipos:Booleano, Número, Vector, Cuerda, SharedTable , o un introducirde datos serializable. La capacidad de almacenar un SharedTable como valor en otro SharedTable permite la construcción de estructuras de datos en capas.

SharedTable objetos son objetos distintos y diferentes SharedTable objetos nunca se comparan igual, incluso si tienen contenido que se compararía igual.

Al igual que una tabla Luau, un objeto de SharedTable puede congelarse, en cuyo caso es solo de lectura. Un intento de modificar un objeto congelado de SharedTable aumentará un error. Un objeto congel

Amostras de código

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

Resumo

Construtores

  • new()

    Regresa una nueva y vacía Datatype.SharedTable .

  • new(t : table)

    Devuelve una nueva Datatype.SharedTable que contiene elementos equivalentes a los que hay en la tabla Luau proporcionada.

Funções

Construtores

new

Regresa una nueva y vacía Datatype.SharedTable .


local st = SharedTable.new()

new

Devuelve una nueva Datatype.SharedTable que contiene elementos equivalentes a los que hay en la tabla Luau proporcionada.

Si la tabla Luau proporcionada contiene cualquier clave o valor que no se puede almacenar en un SharedTable , la construcción del SharedTable falla. Consulte la lista de valores en la parte superior de esta página para obtener una lista de los tipos de objetos que se pueden almacenar en un 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")

Tenga en cuenta que en algunos casos puede ser deseable almacenar un SharedTable en el SharedTableRegistry . El método Class.ShareTableRegistry:GetSharedTable() proporciona una manera conveniente de lograr esto.

Parâmetros

La tabla Luau cuyos elementos se almacenarán en la nueva SharedTable .

Funções

clear

void

Atómicamente elimina todos los elementos de una SharedTable .

Si el SharedTable está congelado, la operación falla y se producirá un error.


local st = SharedTable.new({"a", "b", "c"})
assert(SharedTable.size(st) == 3)
SharedTable.clear(st)
assert(SharedTable.size(st) == 0)

Parâmetros

El SharedTable para borrar.

Devolução

void

Crea un clon de un SharedTable y devuelve el clon.

Si el argumento opcional deep no está presente, o si está presente y su valor es false objeto, entonces se crea un clon profundo. Un clon profundo copia

La operación de clonación es atómica, por lo que el clon SharedTable contendrá un enlace de estado consistente del estado en el estado original SharedTable, incluso si está siendo modificado simultáneamente desde otros scripts.

Si el argumento opcional deep está presente y su valor es true , se crea un clon profundo. Un clon profundo copia recursivamente una estructura de SharedTable objetos, de modo que no hay estado compartido entre el original 1> Datatype.SharedTable1> y el clon.

El clon de cada SharedTable dentro del gráfico de SharedTable objetos es atómico, pero el clon profundo como un todo no es atómico. Por lo tanto, el clon de cada Datatype.SharedTable

El objeto(s) SharedTable que se clonan puede(n) ser congelado(s) (sólo de lectura) o no. Independientemente de esto, los clones recién creados no son congelados (y por lo tanto son modificables). Para crear clones congelados, usa la función Datatype.SharedTable.cloneAndFreeze.

Para ilustrar la diferencia entre un clon profundo y uno superficial, considere los siguientes ejemplos. Este primer ejemplo crea un clon profundo y el segundo crea un clon profundo.

Parâmetros

El objeto SharedTable para clonear.

deep: bool

¿Quieres crear un clon profundo ( true ) o un clon superficial ( false ).

Valor Padrão: false

Devolução

Amostras de código

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

Crea una clonación congelada (solo de lectura) de un SharedTable y devuelve la clonación. El comportamiento de esta función es el mismo que el comportamiento de la clonación, excepto que la clonación está congelada.

Si se solicita un clon profundo, todos los objetos de clon de SharedTable congelados.

Parâmetros

El objeto SharedTable para clonear.

deep: bool

¿Quieres crear un clon profundo ( true ) o un clon superficial ( false ).

Valor Padrão: false

Devolução

increment

Aumenta atómicamente el valor de un elemento. Un elemento con la clave especificada debe existir en el SharedTable , y debe ser de tipo number . El valor especificado delta se agrega al valor y se devuelve el valor original.

La función SharedTable.update también se puede utilizar para este propósito; esta función increment existe para conveniencia y rendimiento (en general, increment es mucho más rápido que 1> actualización1>, por lo que se recomienda preferiblemente donde sea posible). Las siguientes dos llamadas de función tienen el mismo efecto:


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)

Si el SharedTable está congelado, la operación falla y se producirá un error.

Parâmetros

El objeto SharedTable para actualizar.

key: string | number

La clave del elemento en el objeto SharedTable para actualizar.

delta: number

El valor a agregar al elemento en el SharedTable .

Devolução

El valor original del elemento, antes de que se agregara delta a él.

Amostras de código

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

Devuelve true si el Datatype.SharedTable está congelado (solo de lectura).


local st1 = SharedTable.new({"a", "b", "c"})
assert(not SharedTable.isFrozen(st1))
local st2 = SharedTable.cloneAndFreeze(st1)
assert(SharedTable.isFrozen(st2))

Parâmetros

El objeto SharedTable cuyo estado congelado se solicitará.

Devolução

size

Devuelve el número de elementos almacenados en la Tabla Compartida. Tenga en cuenta que si otros scripts están modificando simultáneamente la Tabla Compartida, el tamaño devuelto puede ya no ser correcto después de que se devuelva, ya que otros scripts pueden haber añadido o eliminado elementos de la Tabla Compartida.


local st = SharedTable.new({"a", "b", "c"})
assert(SharedTable.size(st) == 3)
st[2] = nil
assert(SharedTable.size(st) == 2)

Parâmetros

El objeto SharedTable cuyo tamaño se solicitará.

Devolução

update

void

Actualiza atómicamente el valor de un elemento.

Cuando se accede simultáneamente a un SharedTable desde scripts que se ejecutan en diferentes contextos de ejecución, es posible que sus accesos se interfieran inesperadamente. Debido a esto, el código como el siguiente generalmente no es incorrecto, porque el valor puede haber cambiado entre la primera línea de la lectura y la actualización en la segunda línea:


local oldValue = st["x"]
st["x"] = oldValue .. ",x"

La función de actualización hace posible realizar una actualización atómica a un elemento. Requiere una función que se llamará con el valor actual del elemento. La función entonces puede calcular y devolver el nuevo valor. Nota que la función puede ser llamada varias veces si la SharedTable está siendo modificada simultáneamente desde otros scripts.

Si el SharedTable está congelado, la operación falla y se producirá un error.

Parâmetros

El objeto SharedTable para actualizar.

key: string | number

La clave del elemento en el objeto SharedTable para actualizar.

La función que se llamará para calcular el nuevo valor para el elemento.

Devolução

void

Amostras de código

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