Lua élément de table (MetaTable)
Dans le tableau Lua, nous pouvons accéder à la valeur de clé correspondante pour obtenir la valeur, mais il ne peut pas fonctionner sur deux tables.
Par conséquent, Lua fournit un élément de table (MetaTable), table nous permet de changer le comportement de chaque action associée à la méthode des éléments correspondant.
Par exemple, en utilisant la table de méta, nous pouvons définir la façon dont la table Lua pour calculer la somme des deux opérations a + b.
Lorsque tentative Lua ajoutant deux tables, d'abord vérifier s'il y a une des deux tables de yuans, après avoir vérifié que il y a un endroit appelé "__add champ", se trouve, puis d'appeler la valeur correspondante. "__add" Et un autre domaine instantanée, la valeur correspondante (souvent une fonction ou une table) est la «méthode Element."
Il y a deux fonctions très importantes pour gérer la table de yuans:
- SetMetaTable (table, métatable): mettre la table pour l'élément de table spécifié (métatable), si __metatable table élément clé (métatable) dans, SetMetaTable échouer.
- getmetatable (tableau): Retourne la table objet de métadonnées (de métatable).
L'exemple suivant montre comment définir la table pour l'élément de table spécifié:
mytable = {} -- 普通表
mymetatable = {} -- 元表
setmetatable(mytable,mymetatable) -- 把 mymetatable 设为 mytable 的元表
Le code ci-dessus peut être écrit directement à la ligne:
mytable = setmetatable({},{})
Suite à la table sont retour objet de métadonnées:
getmetatable(mytable) -- 这回返回mymetatable
__index Element Method
Ceci est la clé métatable le plus couramment utilisé.
Lorsque vous passez la clé pour accéder à la table, et si la clé n'a pas de valeur, alors Lua trouverez la table des métatable (en supposant métatable) dans la clé de __index. Si __index contient une table, Lua trouvera la clé correspondante dans la table.Nous pouvons utiliser la commande lua pour entrer en mode interactif Vues:
$ lua
Lua 5.3.0 Copyright (C) 1994-2015 Lua.org, PUC-Rio
> other = { foo = 3 }
> t = setmetatable({}, { __index = other })
> t.foo
3
> t.bar
nil
Si __index contient une fonction, puis, Lua appeler cette fonction, une table et des touches sera passé en paramètre à la fonction.
méthode des éléments __index pour afficher l'élément de table existe, sinon, renvoie le résultat est nul, si elle existe par __index résultats de retour.
mytable = setmetatable({key1 = "value1"}, {
__index = function(mytable, key)
if key == "key2" then
return "metatablevalue"
else
return nil
end
end
})
print(mytable.key1,mytable.key2)
Des exemples de sortie est:
value1 metatablevalue
Des exemples d'analyse:
Tableau mytable attribué{key1 = "valeur1"}.
mytable ensemble méta tableau méthode des éléments __index.
Trouver key1 dans la table mytable, si elle est trouvée, le retour de cet élément ne peut être trouvé, continuer.
Trouver key2 dans la table mytable, si elle est trouvée, retourner metatablevalue, retrouvez continué.
L'analyse de méta tableau n'a pas de méthode de __index, si __index méthode est une fonction, appelez la fonction.
- méthode Element pour vérifier si entrant "key2" touche de paramètre (mytable.key2 set), si le "key2" retours de paramètres "metatablevalue" entrant, touche correspondante autrement mytable.
Nous pouvons écrire le code ci-dessus est simple:
mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } })
print(mytable.key1,mytable.key2)
résumé
Lua recherche des règles d'un élément de table quand, en fait, les trois étapes suivantes:
- 1. Trouver dans le tableau, si elle est trouvée, retourner cet élément, non trouvé, continuer
- 2. déterminer si la table a une table de RMB, s'il n'y a pas de table table d'éléments, le rendement nul, il est poursuivi dollar.
- 3. Analyse méta tableau n'a pas de méthode de __index, si __index méthode est nul, le retour nul; si __index méthode est une table, répétez 1,2,3, si __index méthode est une fonction, la fonction retourne la valeur de retour.
__newindex Element Method
méthode des éléments __newindex est utilisé pour mettre à jour la table, __ index est utilisé pour accéder à la table.
Quand vous donnez une affectation de table d'index manquant, l'interprète se penchera __newindex Element Method: Si vous appelez cette fonction sans affectation.
L'exemple suivant illustre l'application de la méthode des éléments:
mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })
print(mytable.key1)
mytable.newkey = "新值2"
print(mytable.newkey,mymetatable.newkey)
mytable.key1 = "新值1"
print(mytable.key1,mymetatable.key1)
Des exemples de mise en oeuvre du résultat ci-dessus est la suivante:
value1 nil 新值2 新值1 nil
Des exemples des tableaux ci-dessus fixées méthode des éléments __newindex, lorsque la nouvelle clé d'index (newkey) affectation (mytable.newkey = "nouvelle valeur 2"), va appeler la méthode des éléments sans affectation. Et si une clé d'index existant (key1), sera chargée de la mission, sans faire appel à la méthode des éléments __newindex.
L'exemple suivant utilise la fonction rawset pour mettre à jour la table:
mytable = setmetatable({key1 = "value1"}, {
__newindex = function(mytable, key, value)
rawset(mytable, key, "\""..value.."\"")
end
})
mytable.key1 = "new value"
mytable.key2 = 4
print(mytable.key1,mytable.key2)
Des exemples de mise en oeuvre du résultat ci-dessus est la suivante:
new value "4"
Ajouter opérateur pour la table
L'exemple suivant montre deux tables ajoutent le fonctionnement:
-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用
-- 自定义计算表中最大值函数 table_maxn
function table_maxn(t)
local mn = 0
for k, v in pairs(t) do
if mn < k then
mn = k
end
end
return mn
end
-- 两表相加操作
mytable = setmetatable({ 1, 2, 3 }, {
__add = function(mytable, newtable)
for i = 1, table_maxn(newtable) do
table.insert(mytable, table_maxn(mytable)+1,newtable[i])
end
return mytable
end
})
secondtable = {4,5,6}
mytable = mytable + secondtable
for k,v in ipairs(mytable) do
print(k,v)
end
Des exemples de mise en oeuvre du résultat ci-dessus est la suivante:
1 1 2 2 3 3 4 4 5 5 6 6
__add élément clé contenue dans le tableau, et ajoutez l'opération. Une liste d'actions correspondant au tableau suivant:
| mode | description |
|---|---|
| __add | opérateur correspondant '+'. |
| __sub | opérateur correspondant '-'. |
| __mul | opérateur correspondant '*'. |
| __div | opérateur correspondant '/'. |
| __mod | opérateur correspondant 'de%'. |
| __unm | opérateur correspondant '-'. |
| __concat | opérateur correspondant '..'. |
| __eq | opérateur correspondant '=='. |
| __lt | opérateur correspondant '<'. |
| __le | opérateur correspondant '<='. |
__call Element Method
méthode des éléments __call est appelée lorsque Lua appelle une valeur. L'exemple suivant illustre le tableau de calcul des éléments, et:
-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用
-- 自定义计算表中最大值函数 table_maxn
function table_maxn(t)
local mn = 0
for k, v in pairs(t) do
if mn < k then
mn = k
end
end
return mn
end
-- 定义元方法__call
mytable = setmetatable({10}, {
__call = function(mytable, newtable)
sum = 0
for i = 1, table_maxn(mytable) do
sum = sum + mytable[i]
end
for i = 1, table_maxn(newtable) do
sum = sum + newtable[i]
end
return sum
end
})
newtable = {10,20,30}
print(mytable(newtable))
Des exemples de mise en oeuvre du résultat ci-dessus est la suivante:
70
__toString Element Method
Méthode élément __toString est utilisé pour modifier le comportement de la table de sortie. Les exemples suivants de notre table de sortie personnalisé du contenu:
mytable = setmetatable({ 10, 20, 30 }, {
__tostring = function(mytable)
sum = 0
for k, v in pairs(mytable) do
sum = sum + v
end
return "表所有元素的和为 " .. sum
end
})
print(mytable)
Des exemples de mise en oeuvre du résultat ci-dessus est la suivante:
表所有元素的和为 60
De cet article, nous pouvons savoir Table Element peut être une bonne simplifier notre fonction de code, de sorte que la compréhension Lua méta tableau nous permet d'écrire plus simple code excellent Lua.