《战场兄弟》游侠LMAO 3.5汉化补丁下载发布！

--------------------------------------------------------------------------------
--                                   TableTools                               --
--                                                                            --
-- Este módulo inclui várias fun??es para lidar com tabelas Lua.              --
-- é um metamódulo, destinado a ser chamado a partir de outros módulos Lua, e --
-- n?o deve ser chamado diretamente a partir de "#invoke".                    --
--------------------------------------------------------------------------------

local libraryUtil = require('libraryUtil')

local p = {}

-- Define variáveis e fun??es usadas com frequência.
local floor = math.floor
local infinity = math.huge
local checkType = libraryUtil.checkType
local checkTypeMulti = libraryUtil.checkTypeMulti

--------------------------------------------------------------------------------
-- isPositiveInteger
--
-- Esta fun??o retorna "true" se o valor fornecido for um número inteiro 
-- positivo e "false" se n?o. Embora n?o opere em tabelas, ela é incluída aqui 
-- porque ela é útil para determinar se uma determinada chave de tabela está na 
-- parte de arranjo ou na parte de 'hash' de uma tabela.
--------------------------------------------------------------------------------
function p.isPositiveInteger(v)
	return type(v) == 'number' and v >= 1 and floor(v) == v and v < infinity
end

--------------------------------------------------------------------------------
-- isNan
--
-- Essa fun??o retorna "true" se o número fornecido for um valor de "NaN" e 
-- "false" se n?o. Embora n?o opere em tabelas, ela é incluída aqui porque ela 
-- é útil para determinar se um valor pode ser uma chave de tabela válida. Lua 
-- irá gerar um erro se um "NaN" for usado como uma chave de tabela.
--------------------------------------------------------------------------------
function p.isNan(v)
	return type(v) == 'number' and v ~= v
end

--------------------------------------------------------------------------------
-- shallowClone
--
-- Essa fun??o retorna um clone de uma tabela. O valor retornado é uma nova 
-- tabela, mas todas as subtabelas e fun??es s?o compartilhadas. Os metamétodos 
-- s?o respeitados, mas a tabela retornada n?o terá metatabela própria.
--------------------------------------------------------------------------------
function p.shallowClone(t)
	checkType('shallowClone', 1, t, 'table')
	local ret = {}
	for k, v in pairs(t) do
		ret[k] = v
	end
	return ret
end

--------------------------------------------------------------------------------
-- removeDuplicates
--
-- Essa fun??o remove os valores duplicados de um arranjo. As chaves de  
-- números inteiros que n?o s?o positivos s?o ignoradas. O valor mais antigo é 
-- mantido e todos os valores duplicados subsequentes s?o removidos, mas caso 
-- n?o, a ordem do arranjo permanece inalterada.
--------------------------------------------------------------------------------
function p.removeDuplicates(arr)
	checkType('removeDuplicates', 1, arr, 'table')
	local isNan = p.isNan
	local ret, exists = {}, {}
	for _, v in ipairs(arr) do
		if isNan(v) then
			-- Os "NaN"s n?o podem ser chaves de tabela e também s?o únicos,
			-- portanto n?o precisamos verificar a existência.
			ret[#ret + 1] = v
		elseif not exists[v] then
			ret[#ret + 1] = v
			exists[v] = true
		end
	end
	return ret
end

--------------------------------------------------------------------------------
-- numKeys
--
-- Essa fun??o pega uma tabela e retorna um arranjo contendo os números 
-- de quaisquer chaves numéricas que tenham valores que n?o s?o nulos,
-- classificados em ordem numérica.
--------------------------------------------------------------------------------
function p.numKeys(t)
	checkType('numKeys', 1, t, 'table')
	local isPositiveInteger = p.isPositiveInteger
	local nums = {}
	for k in pairs(t) do
		if isPositiveInteger(k) then
			nums[#nums + 1] = k
		end
	end
	table.sort(nums)
	return nums
end

--------------------------------------------------------------------------------
-- affixNums
--
-- Essa fun??o pega uma tabela e retorna um arranjo contendo os números 
-- de chaves com o prefixo e sufixo especificados. Por exemplo, para a tabela
-- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} e o prefixo "a", "affixNums" retornará
-- {1, 3, 6}.
--------------------------------------------------------------------------------
function p.affixNums(t, prefix, suffix)
	checkType('affixNums', 1, t, 'table')
	checkType('affixNums', 2, prefix, 'string', true)
	checkType('affixNums', 3, suffix, 'string', true)

	local function cleanPattern(s)
		-- Limpa um padr?o ('pattern') para que os caracteres mágicos "()%.[]*+-?^$"
		-- sejam interpretados literalmente.
		return s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1')
	end

	prefix = prefix or ''
	suffix = suffix or ''
	prefix = cleanPattern(prefix)
	suffix = cleanPattern(suffix)
	local pattern = '^' .. prefix .. '([1-9]%d*)' .. suffix .. '$'

	local nums = {}
	for k in pairs(t) do
		if type(k) == 'string' then
			local num = mw.ustring.match(k, pattern)
			if num then
				nums[#nums + 1] = tonumber(num)
			end
		end
	end
	table.sort(nums)
	return nums
end

--------------------------------------------------------------------------------
-- numData
--
-- Dada uma tabela com chaves como {"foo1", "bar1", "foo2", "baz2"}, essa 
-- fun??o retorna uma tabela de subtabelas no formato
-- {[1] = {foo = 'texto', bar = 'texto'}, [2] = {foo = 'texto', baz = 'texto'}}.
-- As chaves que n?o terminam com um número inteiro s?o armazenadas em uma 
-- subtabela chamada "other". A op??o "compress" comprime a tabela para que 
-- ela possa ser iterada com "ipairs".
--------------------------------------------------------------------------------
function p.numData(t, compress)
	checkType('numData', 1, t, 'table')
	checkType('numData', 2, compress, 'boolean', true)
	local ret = {}
	for k, v in pairs(t) do
		local prefix, num = mw.ustring.match(tostring(k), '^([^0-9]*)([1-9][0-9]*)$')
		if num then
			num = tonumber(num)
			local subtable = ret[num] or {}
			if prefix == '' then
				-- Os parametros posicionais correspondem à sequência em branco; 
				-- coloca-os no início da subtabela.
				prefix = 1
			end
			subtable[prefix] = v
			ret[num] = subtable
		else
			local subtable = ret.other or {}
			subtable[k] = v
			ret.other = subtable
		end
	end
	if compress then
		local other = ret.other
		ret = p.compressSparseArray(ret)
		ret.other = other
	end
	return ret
end

--------------------------------------------------------------------------------
-- compressSparseArray
--
-- Essa fun??o pega um arranjo com um ou mais valores nulos e  
-- remove os valores nulos enquanto preserva a ordem, para que o arranjo
-- possa ser percorrido com seguran?a com "ipairs".
--------------------------------------------------------------------------------
function p.compressSparseArray(t)
	checkType('compressSparseArray', 1, t, 'table')
	local ret = {}
	local nums = p.numKeys(t)
	for _, num in ipairs(nums) do
		ret[#ret + 1] = t[num]
	end
	return ret
end

--------------------------------------------------------------------------------
-- sparseIpairs
--
-- Esta fun??o é uma iteradora para arranjos esparsos. Ela pode ser 
-- usada como "ipairs", mas pode manipular valores nulos.
--------------------------------------------------------------------------------
function p.sparseIpairs(t)
	checkType('sparseIpairs', 1, t, 'table')
	local nums = p.numKeys(t)
	local i = 0
	local lim = #nums
	return function ()
		i = i + 1
		if i <= lim then
			local key = nums[i]
			return key, t[key]
		else
			return nil, nil
		end
	end
end

--------------------------------------------------------------------------------
-- size
--
-- Essa fun??o retorna o tamanho de uma tabela de pares chave/valor. Ela 
-- também funcionará em arranjos, mas para arranjos é mais eficiente usar o 
-- operador #.
--------------------------------------------------------------------------------
function p.size(t)
	checkType('size', 1, t, 'table')
	local i = 0
	for _ in pairs(t) do
		i = i + 1
	end
	return i
end

local function defaultKeySort(item1, item2)
	-- número < sequência, ent?o os números ser?o ordenados antes das 
	-- sequências.
	local type1, type2 = type(item1), type(item2)
	if type1 ~= type2 then
		return type1 < type2
	elseif type1 == 'table' or type1 == 'boolean' or type1 == 'function' then
		return tostring(item1) < tostring(item2)
	else
		return item1 < item2
	end
end
--------------------------------------------------------------------------------
-- keysToList
--
-- Essa fun??o retorna um arranjo das chaves em uma tabela, ordenada usando
-- uma fun??o de compara??o padr?o ou uma fun??o "keySort" personalizada.
--------------------------------------------------------------------------------
function p.keysToList(t, keySort, checked)
	if not checked then
		checkType('keysToList', 1, t, 'table')
		checkTypeMulti('keysToList', 2, keySort, {'function', 'boolean', 'nil'})
	end

	local arr = {}
	local index = 1
	for k in pairs(t) do
		arr[index] = k
		index = index + 1
	end

	if keySort ~= false then
		keySort = type(keySort) == 'function' and keySort or defaultKeySort
		table.sort(arr, keySort)
	end

	return arr
end

--------------------------------------------------------------------------------
-- sortedPairs
--
-- Essa fun??o itera por meio de uma tabela, com as chaves ordenadas usando a 
-- fun??o "keysToList". Se houver apenas chaves numéricas, "sparseIpairs" 
-- provavelmente será mais eficiente.
--------------------------------------------------------------------------------
function p.sortedPairs(t, keySort)
	checkType('sortedPairs', 1, t, 'table')
	checkType('sortedPairs', 2, keySort, 'function', true)

	local arr = p.keysToList(t, keySort, true)

	local i = 0
	return function ()
		i = i + 1
		local key = arr[i]
		if key ~= nil then
			return key, t[key]
		else
			return nil, nil
		end
	end
end

--------------------------------------------------------------------------------
-- isArray
--
-- Essa fun??o retorna "true" se o valor fornecido for uma tabela e todas as   
-- chaves forem números inteiros consecutivos come?ando em 1.
--------------------------------------------------------------------------------
function p.isArray(v)
	if type(v) ~= 'table' then
		return false
	end
	local i = 0
	for _ in pairs(v) do
		i = i + 1
		if v[i] == nil then
			return false
		end
	end
	return true
end

--------------------------------------------------------------------------------
-- isArrayLike
--
-- Essa fun??o retorna "true" se o valor fornecido for iterável e todas as  
-- chaves forem números inteiros consecutivos come?ando em 1.
--------------------------------------------------------------------------------
function p.isArrayLike(v)
	if not pcall(pairs, v) then
		return false
	end
	local i = 0
	for _ in pairs(v) do
		i = i + 1
		if v[i] == nil then
			return false
		end
	end
	return true
end

--------------------------------------------------------------------------------
-- invert
--
-- Essa fun??o transp?e as chaves e valores em um arranjo. Por exemplo, 
-- {"a", "b", "c"} -> {a = 1, b = 2, c = 3}. As duplicatas n?o s?o suportadas 
-- (os valores dos resultados referem-se ao índice da última duplicata) e os  
-- valores "NaN" s?o ignorados.
--------------------------------------------------------------------------------
function p.invert(arr)
	checkType("invert", 1, arr, "table")
	local isNan = p.isNan
	local map = {}
	for i, v in ipairs(arr) do
		if not isNan(v) then
			map[v] = i
		end
	end

	return map
end

--------------------------------------------------------------------------------
-- listToSet
--
-- Essa fun??o cria um conjunto a partir da parte do arranjo da tabela. 
-- A indexa??o do conjunto por qualquer um dos valores do arranjo retorna
-- "true". Por exemplo, {"a", "b", "c"} -> {a = true, b = true, c = true}. Os
-- valores "NaN" s?o ignorados, pois Lua os considera como nunca sendo iguais 
-- a qualquer valor (incluindo outros "NaN"s ou até eles mesmos).
--------------------------------------------------------------------------------
function p.listToSet(arr)
	checkType("listToSet", 1, arr, "table")
	local isNan = p.isNan
	local set = {}
	for _, v in ipairs(arr) do
		if not isNan(v) then
			set[v] = true
		end
	end

	return set
end

--------------------------------------------------------------------------------
-- deepCopy
--
-- Fun??o de cópia profunda recursiva. Preserva as identidades das subtabelas.
--------------------------------------------------------------------------------
local function _deepCopy(orig, includeMetatable, already_seen)
	if type(orig) ~= "table" then
		return orig
	end
	
	-- already_seen armazena as cópias das tabelas indexadas pela tabela 
	-- original.
	local copy = already_seen[orig]
	if copy ~= nil then
		return copy
	end
	
	copy = {}
	already_seen[orig] = copy -- memoriza antes de qualquer recurs?o, para 
							  -- evitar loops infinitos
	
	for orig_key, orig_value in pairs(orig) do
		copy[_deepCopy(orig_key, includeMetatable, already_seen)] = _deepCopy(orig_value, includeMetatable, already_seen)
	end
	
	if includeMetatable then
		local mt = getmetatable(orig)
		if mt ~= nil then
			setmetatable(copy, _deepCopy(mt, true, already_seen))
		end
	end
	
	return copy
end

function p.deepCopy(orig, noMetatable, already_seen)
	checkType("deepCopy", 3, already_seen, "table", true)
	return _deepCopy(orig, not noMetatable, already_seen or {})
end

--------------------------------------------------------------------------------
-- sparseConcat
--
-- Essa fun??o concatena todos os valores na tabela que s?o indexados por 
-- um número, em ordem.
-- "sparseConcat{a, nil, c, d}"  =>  "acd"
-- "sparseConcat{nil, b, c, d}"  =>  "bcd"
--------------------------------------------------------------------------------
function p.sparseConcat(t, sep, i, j)
	local arr = {}

	local arr_i = 0
	for _, v in p.sparseIpairs(t) do
		arr_i = arr_i + 1
		arr[arr_i] = v
	end

	return table.concat(arr, sep, i, j)
end

--------------------------------------------------------------------------------
-- length
--
-- Essa fun??o localiza o comprimento de um arranjo ou de um 
-- quase-arranjo com chaves como "data1", "data2" etc., usando um
-- algoritmo de pesquisa exponencial. Ela é semelhante ao operador #, mas pode 
-- retornar um valor diferente quando houver lacunas na parte do arranjo
-- da tabela. Destina-se a ser usada em dados carregados com "mw.loadData".  
-- Para outras tabelas, use #.
-- Observa??o: "#frame.args" no objeto "frame" sempre será definido como 0, 
-- independentemente do número de parametros de predefini??o sem nome, 
-- portanto, use esta fun??o para "frame.args".
--------------------------------------------------------------------------------
function p.length(t, prefix)
	-- Exige módulo embutido, de modo que 
	-- [[Módulo:Exponential search]] que é necessário 
	-- somente para esta fun??o, n?o obtenha milh?es de transclus?es.
	local expSearch = require("Módulo:Exponential search")
	checkType('length', 1, t, 'table')
	checkType('length', 2, prefix, 'string', true)
	return expSearch(function (i)
		local key
		if prefix then
			key = prefix .. tostring(i)
		else
			key = i
		end
		return t[key] ~= nil
	end) or 0
end

--------------------------------------------------------------------------------
-- inArray
--
-- Essa fun??o Retorna "true" se "searchElement" for um membro do arranjo
-- e "false" se n?o. Equivalente a "array.includes(searchElement)" ou
-- "array.includes(searchElement, fromIndex)", exceto que "fromIndex" é 1 
-- indexado
--------------------------------------------------------------------------------
function p.inArray(array, searchElement, fromIndex)
	checkType("inArray", 1, array, "table")
	-- se "searchElement" for nulo, erro?

	fromIndex = tonumber(fromIndex)
	if fromIndex then
		if (fromIndex < 0) then
			fromIndex = #array + fromIndex + 1
		end
		if fromIndex < 1 then fromIndex = 1 end
		for _, v in ipairs({unpack(array, fromIndex)}) do
			if v == searchElement then
				return true
			end
		end
	else
		for _, v in pairs(array) do
			if v == searchElement then
				return true
			end
		end
	end
	return false
end

--------------------------------------------------------------------------------
-- merge
--
-- Dados os arranjos, retorna um arranjo contendo os elementos de cada arranjo 
-- de entrada em sequência.
--------------------------------------------------------------------------------
function p.merge(...)
	local arrays = {...}
	local ret = {}
	for i, arr in ipairs(arrays) do
		checkType('merge', i, arr, 'table')
		for _, v in ipairs(arr) do
			ret[#ret + 1] = v
		end
	end
	return ret
end

--------------------------------------------------------------------------------
-- extend
--
-- Estende o primeiro arranjo no lugar anexando todos os elementos do segundo
-- arranjo.
--------------------------------------------------------------------------------
function p.extend(arr1, arr2)
	checkType('extend', 1, arr1, 'table')
	checkType('extend', 2, arr2, 'table')

	for _, v in ipairs(arr2) do
		arr1[#arr1 + 1] = v
	end
end

return p
上火了吃什么	opo是奶粉里的什么成分	北京晚上有什么好玩的景点	狗发烧吃什么药	昙花一现什么意思
仓鼠爱吃什么东西	冠状沟是什么	断档是什么意思	颈椎病看什么科	情绪波动大是什么原因
生姜和红枣煮水喝有什么作用	农历6月21日是什么星座	什么姿势最爽	水丸是什么意思	皮肤病是什么原因造成的
承德有什么大学	眼睛不能见光是什么病	宫腔镜是什么检查	重庆东站什么时候通车	三点水卖读什么
总胆固醇偏低是什么意思hcv8jop6ns1r.cn	圆是什么生肖hcv9jop3ns2r.cn	花都有什么花hcv8jop2ns5r.cn	淋巴细胞百分比偏高是什么意思hcv9jop0ns5r.cn	rv是什么品牌hcv9jop1ns1r.cn
生蒜头吃了有什么好处和坏处hcv9jop5ns2r.cn	胰腺炎吃什么水果hcv9jop1ns6r.cn	什么叫动脉硬化hcv9jop5ns5r.cn	急性肠胃炎吃什么药效果好xjhesheng.com	熟地是什么hcv7jop6ns0r.cn
脑炎是什么症状hcv7jop7ns2r.cn	智齿有什么作用hcv9jop2ns6r.cn	腹部ct平扫能检查出什么hcv9jop1ns0r.cn	脸小适合什么发型hcv7jop9ns0r.cn	神经衰弱吃什么药好hcv8jop3ns1r.cn
健身rm是什么意思hcv8jop5ns9r.cn	乌龟白眼病用什么药hcv8jop3ns3r.cn	现在买什么股票好hcv8jop8ns7r.cn	婆婆过生日送什么礼物好wzqsfys.com	猫咪冠状病毒什么症状hcv8jop5ns7r.cn
《战场兄弟》游侠LMAO 3.5汉化补丁下载发布！

Carregando o módulo

isPositiveInteger

isNan

shallowClone

removeDuplicates

numKeys

affixNums

numData

compressSparseArray

sparseIpairs

size

keysToList

sortedPairs

isArray

isArrayLike

invert

listToSet

deepCopy

sparseConcat

length

inArray

fromIndex

merge

extend
