points de connaissance lua

Introduction

Dans un développement normal, C# est beaucoup utilisé et Lua n'a pas été beaucoup utilisé. Ici, enregistrez principalement les points de connaissance de lua pour votre propre examen

2. Points de connaissance

2.1 Types de données

• nil : Indique une valeur invalide ou aucune valeur, c'est un mot clé de Lua (assigner nil à une variable équivaut à la supprimer)
• booléen : indique le type booléen, qui peut être vrai ou faux
• nombre : Représente des types numériques, y compris des nombres entiers et des nombres à virgule flottante
• chaîne : indique le type de chaîne, qui peut être du texte entouré de guillemets simples ou de guillemets doubles
• table : représente la structure de données la plus importante en Lua, composée de paires clé-valeur
• fonction : indique le type de fonction, qui peut être une fonction intégrée ou une fonction personnalisée
• userdata : indique le type étendu pris en charge par Lua, généralement utilisé pour représenter la structure de données du langage C
• thread : Indique le type de coroutine de Lua, qui peut être compris comme un processus d'exécution indépendant.

En lua, booléen, nombre et chaîne sont équivalents aux types valeur en C# (en C#, chaîne est un type référence) et table est équivalent à un type référence

2.2 tableau tableau

2.2.1 Structure du tableau

-- 初始化表
tab = {}

-- 指定值
tab[1]= "Lua"

-- 移除引用
tab = nil

2.2.2 structure du tableau

La table peut être divisée en deux parties : table de hachage et tableau. La table de hachage représente la partie avec des paires clé-valeur (similaire au dictionnaire C#), et le tableau est la partie sans paires clé-valeur. Regardons l'analyse de code suivante

tab1 = { "apple","pear",  [1] = 1, [2] = 2, nil, "watermelon"}

--1.结构如下:
-- 哈希表部分：[1] = 1, [2] = 2
-- 数组部分："apple","pear","nil","watermelon"

--2.接着tab会把数组部分,从左到右，从1开始自增附上key转为哈希表
--数组部分转化后为：[1] = apple, [2] = "pear",[3] = nil, [4] = "watermelon"

--3.我们可以看到数组部分和哈希表部分的key会冲突，table会以后面的数组部分为准。
--则转化为table结构如下：
--tab1 = {[1] = apple, [2] = "pear",[3] = nil, [4] = "watermelon"} 

2.3 Similitudes et différences entre paires IP et paires

2.3.1 Similitudes

• Les paires IP et les paires peuvent être utilisées pour traverser la table

2.3.2 Différences

• ipairs : ipairs est un parcours ordonné, en partant de la clé [1] et en remontant, lorsqu'il rencontre nil ou que la valeur de la clé est dans le désordre, il s'arrête de traverser
• paires : l'ordre de parcours des paires est incertain, mais toutes les clés seront parcourues, et nil sera ignoré, et la clé suivante sera traversée.

OK, regardons le code et imprimons

tab1 = { "apple", "pear", [1] = 1, [2] = 2, nil, "watermelon" }

print("---ipairs---")
for k, v in ipairs(tab1) do
    print(k, v)
end

print("---pairs---")

for k, v in pairs(tab1) do
    print(k, v)
end

La sortie est la suivante :

根据2.2.2的分析，我们知道tab1最终结构为：
tab1 = {[1] = apple, [2] = "pear",[3] = nil, [4] = "watermelon"} 

---ipairs---
1	apple
2	pear
---pairs---
1	apple
2	pear
4	watermelon

Les résultats de sortie sont conformes aux règles de traversée des paires IP et des paires

2.3 Métatable

Une métatable est aussi une table, nous pouvons définir une métatable pour une table

• définir la métatable

local tab = {}
local metaTab = {1,2}
-- 把表metaTab设置为表tab的元表
setmetatable(tab,metaTab);

• devenir métatable

-- 获取tab的元表
local targetMeta = getmetatable(tab)

2.4 Métaméthodes

2.4.1 Définition

En Lua, les métaméthodes sont des fonctions spéciales utilisées pour définir le comportement des tables, et les métaméthodes sont stockées dans une métatable indépendante. Par exemple, lors de l'utilisation de l'opérateur + dans une table, Lua vérifiera s'il existe une métaméthode __add dans sa métatable, et si c'est le cas, utilisera cette métaméthode pour implémenter l'opération d'ajout de la table.

2.4.2 Métaméthodes courantes

• __index : utilisé pour interroger des clés qui n'existent pas dans la table. Lorsque la clé spécifiée n'existe pas dans la table, Lua appellera automatiquement la métaméthode __index pour renvoyer une valeur par défaut ou une nouvelle valeur.

• __newindex : utilisé pour ajouter une nouvelle paire clé-valeur, lorsque vous essayez d'ajouter une clé inexistante à la table, Lua appellera automatiquement la métaméthode __newindex pour ajouter une nouvelle paire clé-valeur ou modifier une paire clé-valeur existante

• __add, __sub, __mul, __div, __mod, __pow, __unm : utilisé pour surcharger les opérateurs, lors de l'utilisation de tables pour participer à des opérations mathématiques, Lua appellera automatiquement la méta-méthode correspondante pour réaliser l'opération.

• __tostring : utilisé pour convertir un tableau en chaîne, lorsque la fonction tostring est utilisée pour convertir un tableau en chaîne, Lua appellera automatiquement la métaméthode __tostring pour réaliser la conversion.

En utilisant correctement les métaméthodes, nous pouvons définir divers comportements pour la table, afin de réaliser des structures de données et des algorithmes plus flexibles, efficaces et faciles à utiliser.

2.5 Application de la métatable et de la métaméthode

2.5.1 Application __index

Nous pouvons utiliser la métaméthode __index pour ajouter des paires clé-valeur à une table, telles que

local tab = {}
local metaTab = {1,2}
-- 把表metaTab设置为表tab的元表
setmetatable(tab,metaTab);
metaTab.__index = metaTab;

print(tab[1])

--输出
1

• Règles de recherche de clé de table
  Nous pouvons voir que la table d'onglets n'a pas la clé [1], mais 1 est la sortie, ce qui est lié aux règles de recherche de clé de table. Les règles de recherche sont les suivantes :

1. Par exemple, tab[1], vérifiez d'abord s'il y a une touche [1] dans l'onglet, affichez s'il y en a une et passez à l'étape suivante s'il n'y en a pas
2. Vérifier si la table a une métatable et une métaméthode __index, sinon, retourner nil, si oui, si la métaméthode __index pointe vers une méthode, puis retourner la valeur selon la méthode, si elle pointe vers une table, passer à l'étape suivante
3. Vérifiez si la table a la clé [1], sortie s'il y en a une, et vérifiez si la table a sa propre métatable et __index métaméthode (équivalent à revenir à l'étape 1 jusqu'à ce qu'elle soit trouvée ou non trouvée)

Parce que tab n'a pas la clé [1], mais il a la métatable metaTab et la métaméthode __index, la métaméthode __index pointe vers la métatable metaTab elle-même, metaTab[1] = 1, donc 1 est renvoyé

2.5.2 Implémentation de l'orientation objet

Nous pouvons utiliser des métatables et des métaméthodes __index pour réaliser l'utilisation de classes et d'objets en C #

-- 定义一个ClassA类
ClassA = {x = 1, y = 2}
ClassA.__index = ClassA

--定义一个New构造方法，返回对象实例
function ClassA.New(x,y)
    --创建新对象
    local o = {}
    --设置元表位ClassA
    setmetatable(o,ClassA);
    --为变量赋值
    o.x = x;
    o.y = y;
    return o;
end

--创建对象实例inst1
local inst1 = ClassA.New(3,4)
--创建对象实例inst2
local inst2 = ClassA.New(5)

--打印inst1
print("inst1.x:"..inst1.x)
print("inst1.y:"..inst1.y)

--打印inst2
print("inst2.x:"..inst2.x)
print("inst2.y:"..inst2.y)

La sortie est la suivante

inst1.x:3
inst1.y:4
inst2.x:5
inst2.y:2

Vous pouvez voir que l'effet de la création d'objets similaires à C # est atteint

2.5.3 Application __newindex

__newIndex Lorsque vous essayez d'ajouter une clé inexistante à la table, Lua appellera automatiquement la métaméthode __newindex pour ajouter une nouvelle paire clé-valeur ou modifier une paire clé-valeur existante

Nous pouvons utiliser l'exemple ci-dessus pour ajouter la méthode __newindex pour voir sa sortie

ClassA = {x = 1, y = 2}
ClassA.__index = ClassA
ClassA.__newindex = ClassA

function ClassA.New(x,y)
    local o = {}
    setmetatable(o,ClassA);
    o.x = x;
    o.y = y;
    return o;
end
--创建2个实例，并赋值
local inst1 = ClassA.New(3,4)
local inst2 = ClassA.New(5,6)

--继续赋值
inst1.z = 7;
inst2.z = 8;

--打印inst1
print("inst1.x:"..inst1.x)
print("inst1.y:"..inst1.y)
print("inst1.z:"..inst1.z)

--打印inst2
print("inst2.x:"..inst2.x)
print("inst2.y:"..inst2.y)
print("inst2.z:"..inst2.z)

sortir

inst1.x:5
inst1.y:6
inst1.z:8
inst2.x:5
inst2.y:6
inst2.z:8

On peut voir que la sortie de inst1 et inst2 sont les mêmes, en raison de la métaméthode __newindex, lors de l'attribution d'une valeur à une clé que la table elle-même n'a pas, elle sera attribuée à la table correspondant à la métaméthode __newindex. Étant donné que la même table est modifiée, la sortie de inst1 et inst2 est la même.

2.6 Lors de la modification des méthodes, la différence entre . et :

. et **:** peuvent tous deux être utilisés pour modifier la méthode, utilisez : pour passer automatiquement la variable self de classe lors de la réparation de la méthode, telle que

  --下面这2个方法等价
  function  class.func1(self)  end
  function  class:func1( )  end

Vous pouvez voir l'exemple suivant

ClassA = { x = 1, y = 2 }
ClassA.__index = ClassA
ClassA.__newindex = ClassA

function ClassA:func1(a)
    print("ClassA:func1:"..a)
    print("ClassA:func1+:"..(a + self.x))
end

function ClassA.func2(a)
    print("ClassA.func1:"..a)
    print("ClassA.func1+:"..(a + ClassA.x))
end

ClassA:func1(3)
ClassA.func2(3)

sortir

ClassA:func1:3
ClassA:func1+:4
ClassA.func1:3
ClassA.func1+:4