SharedTable

แสดงที่เลิกใช้งานแล้ว

*เนื้อหานี้แปลโดยใช้ AI (เวอร์ชัน Beta) และอาจมีข้อผิดพลาด หากต้องการดูหน้านี้เป็นภาษาอังกฤษ ให้คลิกที่นี่

แทนที่โครงสร้างข้อมูลเช่นตารางที่สามารถแบ่งปันได้ในบริบทการดําเนินการแม้ว่าจะสามารถใช้สำหรับการจัดเก็บข้อมูลทั่วไปหลายประเภทได้ แต่ก็ถูกออกแบบมาเพื่อใช้กับ Parallel Luau โดยเฉพาะ ซึ่งสามารถใช้เพื่อแบ่งปันสถานะระหว่างสคริปต์ที่ได้รับการผลิตภายใต้สถานการณ์ที่แตกต่างกัน Actor

มีวิธีการสื่อสารภาษาอันเป็นที่นิยมสองสามวิธีระหว่างตารางที่แชร์ระหว่างสคริปต์วิธีหนึ่งคือการจัดเก็บและดึงวัตถุ SharedTable ใน SharedTableRegistryทะเบียนช่วยให้สคริปต์ในโมเดลข้อมูลเดียวกันสามารถรับหรือตั้ง SharedTable โดยใช้ชื่อวิธีอื่นหนึ่งคือการใช้ Actor:SendMessage() เพื่อส่งโต๊ะร่วมกันไปยังอีก Actor ภายในข้อความ

เช่นโต๊ะ Luau วัตถุ SharedTable จะเก็บชุดของคู่คีย์-ค่าองค์ประกอบไม่เหมือนกับโต๊ะ Luau เฉพาะประเภทของวัตถุที่เลือกเท่านั้นที่สามารถจัดเก็บไว้ใน SharedTable ซึ่งคล้ายกับข้อจํากัดอื่นๆ ที่คุณจะพบใน Roblox Engine อื่นๆ

กุญแจต้องเป็น (1) สตริงหรือ (2) ตัวเลขเชิงลบน้อยกว่า 2 32 ประเภทอื่น ๆ ของกุญแจไม่ได้รับการสนับสนุน

ค่าต้องมีหนึ่งในประเภทต่อไปนี้: Boolean, Number, Vector, String, SharedTable พิมพ์SharedTable เป็นค่าในอีก SharedTable ช่วยให้สามารถสร้างโครงสร้างข้อมูลที่ซ้อนกันและทฤษฎีได้

SharedTable วัตถุมีความแตกต่างและแตกต่างกัน SharedTable วัตถุไม่เคยเปรียบเทียบเท่ากันแม้ว่าพวกเขาจะมีเนื้อหาที่เทียบเท่ากันก็ตาม

เช่นโต๊ะ Luau วัตถุ SharedTable อาจถูกแช่แข็ง ในกรณีนี้จะอ่านได้เท่านั้นความพยายามในการแก้ไขแช่แข็ง SharedTable จะเกิดข้อผิดพลาดแช่แข็ง SharedTable สามารถสร้างได้โดยการสร้างแรก (ไม่แช่แข็ง, สามารถแก้ไขได้) SharedTable ด้วยเนื้อหาที่ต้องการแล้วเรียก SharedTable.cloneAndFreeze() เพื่อสร้างโคลนแช่แข็งของมัน

ตัวอย่างโค้ด

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

สรุป

คอนสตรัคเตอร์

  • new()

    ส่งคืนใหม่ว่างเปล่า SharedTable

  • new(t : table)

    คืนค่าใหม่ SharedTable ที่มีองค์ประกอบเทียบเท่ากับองค์ประกอบในตาราง Luau ที่ให้มา

ฟังก์ชัน

คอนสตรัคเตอร์

new

ส่งคืนใหม่ว่างเปล่า SharedTable

local st = SharedTable.new()

new

คืนค่าใหม่ SharedTable ที่มีองค์ประกอบเทียบเท่ากับองค์ประกอบในตาราง Luau ที่ให้มา

หากตาราง Luau ที่ให้มามีกุญแจหรือค่าใดที่ไม่สามารถเก็บไว้ใน SharedTable การสร้างของ SharedTable จะล้มเหลวดูสรุปที่ด้านบนของหน้านี้สำหรับรายการประเภทของวัตถุที่สามารถจัดเก็บไว้ใน SharedTableหากตาราง Luau มีตารางใดเป็นค่า ตารางนั้นจะถูกแปลงเป็น SharedTable ใหม่

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

โปรดทราบว่าในบางกรณีอาจเป็นที่ต้องการที่จะเก็บ SharedTable ใน SharedTableRegistryวิธี Class.ShareTableRegistry:GetSharedTable() ให้วิธีที่สะดวกในการทําสําเร็จนี้

พารามิเตอร์

t: table

ตาราง Luau ที่องค์ประกอบจะถูกจัดเก็บใน SharedTable ใหม่

ฟังก์ชัน

clear

()

ลบองค์ประกอบทั้งหมดออกจาก SharedTable อะตอม

หาก SharedTable ถูกแช่แข็ง การดำเนินการจะล้มเหลวและจะมีการเพิ่มข้อผิดพลาด

local st = SharedTable.new({"a", "b", "c"})

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



SharedTable.clear(st)

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

พารามิเตอร์

st: SharedTable

The SharedTable ล้างข้อมูล

ส่งค่ากลับ

()

clone

SharedTable

สร้างสําเนาของ SharedTable และส่งคืนสําเนา

หากอาร์กิวเมนต์ตัวเลือก deep ไม่ปรากฏหรือหากปรากฏและมีค่าเป็น false แล้วจะสร้างโคลนตื้นสำเนาโคลนตื้นเพียงคัดลอกวัตถุระดับสูง SharedTableหากมีค่าใด ๆ ใน SharedTable ตัวเองเป็น SharedTable แล้วทั้งต้นฉบับ SharedTable และโคลน SharedTable จะอ้างถึงเดียวกัน SharedTable

การดําเนินการโคลนตื้นจะเป็นอะตอม ดังนั้นการโคลน SharedTable จะมีภาพสเก็ตช์ที่สอดคล้องของสถานะในต้นฉบับ SharedTable แม้ว่าจะถูกดัดแปลงพร้อมกันจากสคริปต์อื่นก็ตาม

หากอาร์กิวเมนต์ตัวเลือก deep มีอยู่และมีค่าเป็น true จะสร้างสำเนาลึกการโคลนลึกจะคัดลอกโครงสร้างของวัตถุ SharedTable โดยที่ไม่มีสถานะที่แชร์ระหว่างต้นฉบับ SharedTable และโคลน

โคลนของแต่ละ SharedTable ภายในกราฟของวัตถุ SharedTable เป็นอะตอม แต่โคลนลึกทั้งหมดไม่ใช่อะตอมดังนั้นคลอนของแต่ละ ภายในกราฟจะมีภาพสแน็ปช็อตที่สอดคล้องกันของสถานะของวัตถุเดิม ที่ถูกคลอน แต่สถานะของวัตถุที่แตกต่างกันอาจไม่สอดคล้องกันหากกราฟถูกแก้ไขพร้อมกันจากสคริปต์อื่น

วัตถุ SharedTable ที่ถูกโคลนอาจถูกแช่แข็ง (อ่านเฉพาะ) หรือไม่ไม่ว่าอย่างไรก็ตาม โคลนที่สร้างขึ้นใหม่จะไม่ แช่แข็ง (และจึงสามารถแก้ไขได้)เพื่อสร้างโคลนแช่แข็งใช้ฟังก์ชัน SharedTable.cloneAndFreeze

เพื่อสะท้อนความแตกต่างระหว่างโคลนตื้นและโคลนลึก โปรดพิจารณาตัวอย่างต่อไปนี้ตัวอย่างแรกนี้สร้างโคลนตื้นและตัวอย่างที่สองสร้างโคลนลึก

พารามิเตอร์

st: SharedTable

วัตถุ SharedTable ที่จะโคลนออก

deep: boolean

ว่าจะสร้างโคลนลึก ( true ) หรือโคลนตื้น ( false )

ค่าเริ่มต้น: false

ส่งค่ากลับ

SharedTable

ตัวอย่างโค้ด

ตัวอย่างโค้ดนี้สร้างโคลนตื้นของ 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")



-- เนื่องจากนี่เป็นการโคลนตื้น ดั้งเดิม ["c"] และโคลน ["c"] จะ

-- วัตถุ SharedTable เดียวกัน

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

สร้างโคลนแช่แข็ง (อ่านได้เท่านั้น) ของ SharedTable และส่งคืนโคลนพฤติกรรมของฟังก์ชันนี้เป็นเช่นเดียวกับพฤติกรรมของโคลน ยกเว้นว่าโคลนถูกแช่แข็ง

หากขอสําเนาลึกก็จะแช่แข็งวัตถุทั้งหมดที่สําเนาได้ SharedTable

พารามิเตอร์

st: SharedTable

วัตถุ SharedTable ที่จะโคลนออก

deep: boolean

ว่าจะสร้างโคลนลึก ( true ) หรือโคลนตื้น ( false )

ค่าเริ่มต้น: false

ส่งค่ากลับ

SharedTable

increment

number

เพิ่มมูลค่าขององค์ประกอบโดยอตอมองค์ประกอบที่มีกุญแจที่ระบุต้องมีอยู่ใน SharedTable และต้องเป็นประเภท numberค่าที่ระบุ delta จะถูกเพิ่มลงในค่าและค่าเดิมจะถูกส่งคืน

ฟังก์ชัน SharedTable.update สามารถใช้สำหรับวัตถุประสงค์นี้ได้เช่นกัน; ฟังก์ชัน increment มีอยู่เพื่อความสะดวกและประสิทธิภาพ (โดยทั่วไปแล้ว increment จะเร็วกว่า update ดังนั้นจึงควรใช้เมื่อใดก็ได้ที่เป็นไปได้)การเรียกฟังก์ชันสองครั้งต่อไปมีผลเดียวกัน:

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)

หาก SharedTable ถูกแช่แข็ง การดำเนินการจะล้มเหลวและจะมีการเพิ่มข้อผิดพลาด

พารามิเตอร์

st: SharedTable

วัตถุ SharedTable ที่จะได้รับการอัปเดต

key: string | number

กุญแจขององค์ประกอบในวัตถุ SharedTable ที่จะได้รับการอัปเดต

delta: number

มูลค่าที่จะเพิ่มลงในองค์ประกอบใน SharedTable

ส่งค่ากลับ

number

มูลค่าเดิมขององค์ประกอบก่อนที่ delta จะถูกเพิ่มลงในมัน

ตัวอย่างโค้ด

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

boolean

คืน true หาก SharedTable ถูกแช่แข็ง (อ่านได้เท่านั้น)

local st1 = SharedTable.new({"a", "b", "c"})

assert(not SharedTable.isFrozen(st1))



local st2 = SharedTable.cloneAndFreeze(st1)

assert(SharedTable.isFrozen(st2))

พารามิเตอร์

st: SharedTable

วัตถุ SharedTable ที่สถานะแช่แข็งจะต้องถูกค้นหา

ส่งค่ากลับ

boolean

size

number

คืนจํานวนองค์ประกอบที่เก็บไว้ใน SharedTableโปรดทราบว่าหากสคริปต์อื่นแก้ไข SharedTable พร้อมกัน ขนาดที่ส่งคืนอาจไม่ถูกต้องอีกต่อไปหลังจากส่งคืนแล้ว เนื่องจากสคริปต์อื่นอาจเพิ่มหรือลบองค์ประกอบออกจาก SharedTable

local st = SharedTable.new({"a", "b", "c"})

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



st[2] = nil

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

พารามิเตอร์

st: SharedTable

วัตถุ SharedTable ที่ขนาดจะถูกสอบถาม

ส่งค่ากลับ

number

update

()

อัปเดตค่าขององค์ประกอบอย่างอะตอม

เมื่อ SharedTable ได้รับการเข้าถึงพร้อมกันจากสคริปต์ที่ทำงานในบริบทการดําเนินการที่แตกต่างกัน ก็เป็นไปได้ที่การเข้าถึงของพวกเขาจะสลับกันไม่สามารถคาดการณ์ได้เนื่องจากเหตุนี้โค้ดเช่นต่อไปนี้มักจะไม่ถูกต้องเพราะค่าอาจมีการเปลี่ยนแปลงระหว่างการอ่านในบรรทัดแรกและการอัปเดตในบรรทัดที่สอง:

local oldValue = st["x"]

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

ฟังก์ชันการอัปเดตทำให้เป็นไปได้ที่จะดำเนินการอัปเดตอะตอมไปยังองค์ประกอบมันใช้ฟังก์ชันที่จะเรียกด้วยมูลค่าปัจจุบันขององค์ประกอบฟังก์ชันสามารถคำนวณและส่งคืนค่าใหม่ได้โปรดทราบว่าฟังก์ชันอาจถูกเรียกหลายครั้งหาก SharedTable ถูกแก้ไขพร้อมกันจากสคริปต์อื่น

หาก SharedTable ถูกแช่แข็ง การดำเนินการจะล้มเหลวและจะมีการเพิ่มข้อผิดพลาด

พารามิเตอร์

st: SharedTable

วัตถุ SharedTable ที่จะได้รับการอัปเดต

key: string | number

กุญแจขององค์ประกอบในวัตถุ SharedTable ที่จะได้รับการอัปเดต

f: function

ฟังก์ชันที่จะเรียกเพื่อคำนวณมูลค่าใหม่สำหรับองค์ประกอบ

ส่งค่ากลับ

()

ตัวอย่างโค้ด

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