Mappa Sortata memorizzata

La struttura dei dati della mappa ordinata dei memorabili store consente di memorizzare dati di frequente in-Memory come coppie chiave con una chiave di sort opzionale e mantenere un ordine specifico in base ai chiavi e alle chiavi. A differenza delle code, l'ordine delle chiavi che entrano in una mappa non determina l'ordine di elaborazione, rendendo le mappe sortite utili per la classificazione dei dat

Limitazioni

Oltre ai limiti di dimensioni della struttura dei dati, le mappe sortite hanno un limite di dimensioni della chiave di 128 caratteri, un limite di dimensioni del valore di 32 KB e un limite di dimensioni della chiave di 128 caratteri.

Se hai bisogno di memorizzare dati che superano questo limite per la tua esperienza, puoi adottare la tecnica di frammentamento per spaccare e distribuire attraverso Prefisso chiave in più strutture di dati. I magazzini di memoria possono anche aiutare a migliorare la scalabilità del tuo sistema.

Ottenere una mappa ordinata

Per ottenere una mappa ordinata, chiama MemoryStoreService:GetSortedMap() con un nome che vuoi definire per la mappa. Il nome è globale all'interno dell'esperienza, quindi puoi accedere alla stessa mappa ordinata su qualsiasi script usando il nome.

Ottenere una mappa ordinata
local MemoryStoreService = game:GetService("MemoryStoreService")

local sortedMap = MemoryStoreService:GetSortedMap("SortedMap1")

Dopo aver ottenuto una mappa ordinata, chiama una delle seguenti funzioni per leggere o scrivere dati in essa:

Aggiungere o sovrascrivere dati

Per aggiungere una nuova chiave o sovrascrivere il valore o la chiave di sorta di una chiave nella mappa sortita, chiama MemoryStoreSortedMap:SetAsync() con il nome della chiave , il suo valore , un tempo di scadenza in second

Nell'ordine di classificazione delle tue chiavi, un'area di classificazione prende la precedenza su una chiave. Ad esempio, quando si classifica in ordine crescente, le chiavi di classificazione numeriche sortono prima, seguite da chiavi di classificazione di striscia, seguite da elementi senza chiave. Tutti gli elementi con chiavi di classificazione sono sortiti per chiave, se la

Esempio di alcuni dati ordinati in modo ascendente -

{Key: "player1", Value: someValue1, SortKey: -1}
{Key: "player2", Value: someValue2, SortKey: 0}
{Key: "player4", Value: someValue3, SortKey: 1}
{Key: "player5", Value: someValue4, SortKey: 1}
{Key: "player3", Value: someValue5, SortKey: 3.14}
{Key: "player6", Value: someValue6, SortKey: "someString"}
{Key: "player0", Value: someValue7}
{Key: "player7", Value: someValue8}

Nota come player0 sorta dopo tutte le chiavi con una chiave di sorta. player6 sorta dopo tutte le chiavi con una chiave numerica. player4 e 1> player51> hanno lo stesso sort key, quindi vengono sortiti in ordine crescente per chiave.

Aggiungere dati a una mappa ordinata
local MemoryStoreService = game:GetService("MemoryStoreService")

local sortedMap = MemoryStoreService:GetSortedMap("SortedMap1")

local setSuccess, _ = pcall(function()
	return sortedMap:SetAsync("User_1234", 1000, 30, 3.14152)
end)
if setSuccess then
	print("Set succeeded.")
end

Ottenere dati

Puoi ottenere un valore di dati e ordinare la chiave associata a una chiave specifica o ottenere più valori e ordinare le chiavi per le chiavi all'interno di un intervallo.

Ottenere i dati con una chiave

Per ottenere un valore e ordinare la chiave associata a una chiave dalla mappa ordinata, chiama MemoryStoreSortedMap:GetAsync() con la chiave nome .

Ottenere una chiave in particolare da una mappa ordinata
local MemoryStoreService = game:GetService("MemoryStoreService")

local sortedMap = MemoryStoreService:GetSortedMap("SortedMap1")

local setSuccess, _ = pcall(function()
	return sortedMap:SetAsync("User_1234", 1000, 30, 3.14152)
end)
if setSuccess then
	print("Set succeeded.")
end

local item
local getSuccess, getError = pcall(function()
	item = sortedMap:GetAsync("User_1234")
end)
if getSuccess then
	print(item)
else
	warn(getError)
end

Ottenere i dati con più chiavi

Per ottenere i dati per più chiavi dalla mappa ordinata come singola operazione, chiama MemoryStoreSortedMap:GetRangeAsync() . Questa funzione elenca tutti i valori predefiniti, ma puoi

Ottenere una gamma di chiavi da una mappa ordinata
local MemoryStoreService = game:GetService("MemoryStoreService")

local sortedMap = MemoryStoreService:GetSortedMap("SortedMap1")

local lowerBound = {}
lowerBound["key"] = "10"
lowerBound["sortKey"] = 100
local upperBound = {}
upperBound["key"] = "50"
upperBound["sortKey"] = 500

-- Ottieni fino a 20 oggetti a partire dall'inizio
local getSuccess, items = pcall(function()
	return sortedMap:GetRangeAsync(
		Enum.SortDirection.Ascending, 20, lowerBound, upperBound)
end)
if getSuccess then
	for _, item in items do
		print(item.key)
		print(item.sortKey)
	end
end

Aggiornamento dei dati

Per recuperare il valore e la chiave di un key da una mappa sorta e aggiornarlo, chiama MemoryStoreSortedMap:UpdateAsync() con la chiave nome , una funzione callback per aggiornare il valore e la chiave per questo key, e un 1> tempo di scadenza1> in secondi. Il tempo massimo di scadenza è 3,8

Per la maggior parte delle esperienze, più server possono aggiornare la stessa chiave contemporaneamente e cambiare il valore. Come UpdateAsync() sempre modifica il valore più recente prima di aggiornare, dovresti usarlo per leggere il valore più recente come input per la tua funzione di richiamata.

Ad esempio, il seguente codice di esempio aggiorna il punteggio in una classifica per un giocatore in un Gioco. Il punteggio viene calcolato come uccisioni / morti. UpdateAsync() garantisce che le uccisioni e le morti vengono aggiornate per i valori più recenti anche se più server di gioco aggiornano lo stesso oggetto contemporaneamente. Un Giocatore's ucc

Aggiornamento del punteggio della classifica per un giocatore in una mappa sortita
local MemoryStoreService = game:GetService("MemoryStoreService")

local sortedMap = MemoryStoreService:GetSortedMap("Leaderboard")

local function updateLeaderboard(itemKey, killsToAdd, deathsToAdd)
	local success, newStats, newScore = pcall(function()
		return sortedMap:UpdateAsync(itemKey, function(playerStats, playerScore)
			playerStats = playerStats or { kills = 0, deaths = 0 }
			playerStats.kills += killsToAdd
			playerStats.deaths += deathsToAdd
			if playerStats then
				-- `playerScore` è la chiave di sorting usata per sortire gli elementi nella mappa
				playerScore = playerStats.kills / math.max(playerStats.deaths, 1)
				return playerStats, playerScore
			end
			return nil
		end, 30)
	end)
	if success then
		print(newStats)
		print(newScore)
	end
end

La latenza per UpdateAsync() è simile a GetAsync() e SetAsync() a meno che non ci sia alcuna eccezione.

Quando si verifica la limitazione, il sistema riprova automaticamente l'operazione fino a quando una di queste tre cose non accade: l'operazione ha successo, il callback funziona nulla o il numero massimo di riprove è raggiunto. Se il sistema raggiunge il numero massimo di riprove, restituisce un conflitto.

Rimozione dei dati

Puoi usare MemoryStoreSortedMap:RemoveAsync() per entrambi la rimozione di una chiave dalla mappa sorta e la cancellazione di tutte le dati in una mappa sorta memorizzata.

Rimuovere una chiave

Per rimuovere una chiave dalla mappa ordinata, chiama MemoryStoreSortedMap:RemoveAsync() con un nome chiave.

Rimuovi una chiave da una mappa ordinata
local MemoryStoreService = game:GetService("MemoryStoreService")

local sortedMap = MemoryStoreService:GetSortedMap("SortedMap1")

local setSuccess, _ = pcall(function()
	return sortedMap:SetAsync("User_1234", 1000, 30, "someStringSortKey")
end)
if setSuccess then
	print("Set succeeded.")
end

local removeSuccess, removeError = pcall(function()
	sortedMap:RemoveAsync("User_1234")
end)
if not removeSuccess then
	warn(removeError)
end

Eliminazione di tutte le informazioni

Per eliminare la memoria nelle mappe sortite, elenca tutte le tue chiavi con MemoryStoreSortedMap:GetRangeAsync() , quindi rimuovili con MemoryStoreSortedMap:RemoveAsync() .

Eliminare la memoria in una mappa ordinata
local MemoryStoreService = game:GetService("MemoryStoreService")

local sortedMap = MemoryStoreService:GetSortedMap("SortedMap1")

-- Il valore iniziale di zero inizia a essere fuso dal primo Articolo
local exclusiveLowerBound = nil

while true do
	-- Ottieni fino a 100 oggetti a partire dal limite inferiore attuale
	local getRangeSuccess, items = pcall(function()
		return sortedMap:GetRangeAsync(Enum.SortDirection.Ascending, 100, exclusiveLowerBound)
	end)
	if getRangeSuccess then
		local removeSuccess = true
		local removeError = nil

		for _, item in items do
			removeSuccess, removeError = pcall(function()
				sortedMap:RemoveAsync(item.key)
			end)
		end

		-- Se ci fosse un errore nel rimuovere gli oggetti, riprova con gli stessi limiti di basso esclusivi
		if not removeSuccess then
			warn(removeError)
		-- Se la portata è inferiore a un centinaio di oggetti, la fine della mappa viene raggiunta
		elseif #items < 100 then
			break
		else
			-- L'ultima chiave recuperata è l'esclusiva chiave di basso per il prossimo incremento
			exclusiveLowerBound = {}
			exclusiveLowerBound["key"] = items[#items].key
			exclusiveLowerBound["sortKey"] = items[#items].sortKey
		end
	end
end