Types de données Lua


Lua est un langage typé dynamiquement. Les variables n'ont pas besoin d'être saisies, seules les variables doivent se voir attribuer des valeurs. Les valeurs peuvent être stockées dans des variables, transmises comme arguments ou renvoyées comme résultats.

Il existe 8 types de base dans Lua : nul, booléen, nombre, chaîne, données utilisateur, fonction, thread et table.

数据类型描述
nil这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。
boolean包含两个值：false和true。
number表示双精度类型的实浮点数
string字符串由一对双引号或单引号来表示
function由 C 或 Lua 编写的函数
userdata表示任意存储在变量中的C数据结构
thread表示执行的独立线路，用于执行协同程序
tableLua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。

Nous pouvons utiliser la fonction type pour tester le type d'une variable ou d'une valeur donnée : 

print(type("Hello world"))      --> string
print(type(10.4*3))             --> number
print(type(print))              --> function
print(type(type))               --> function
print(type(true))               --> boolean
print(type(nil))                --> nil
print(type(type(X)))            --> string

nil (null)

le type nil représente un type qui n'en a pas valeurs valides, il n'a qu'une seule valeur -- nil, par exemple, imprimer une variable sans valeur assignée produira une valeur nulle : 

> print(type(a))
nil
>

Pour les variables globales et les tables, nil a également une fonction "supprimer", qui sert à supprimer des variables globales ou des tables. Attribuer une valeur nulle aux variables équivaut à les supprimer. Vous le saurez en exécutant le code suivant : 

tab1 = { key1 = "val1", key2 = "val2", "val3" }
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end
 
tab1.key1 = nil
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end

boolean (Boolean)

<🎜. >Le type booléen n'a que deux valeurs facultatives : true ( true) et false (false), Lua considère false et nil comme "false", et tout le reste est "true":

print(type(true))
print(type(false))
print(type(nil))
 
if false or nil then
    print("至少有一个是 true")
else
    print("false 和 nil 都为 false!")
end

Le résultat de l'exécution de ce qui précède le code est le suivant :

$ lua test.lua 
boolean
boolean
nil
false 和 nil 都为 false!

number (number)

Lua n'a qu'un seul type de nombre par défaut - le type double (double précision) (le type par défaut peut être modifié dans luaconf. h), les méthodes d'écriture suivantes sont considérées comme des types de nombres :

Instance

print(type(2))
print(type(2.2))
print(type(0.2))
print(type(2e+1))
print(type(0.2e-1))
print(type(7.8263692594256e-06))

Exécuter l'instance»Cliquez sur le bouton Bouton "Exécuter l'instance" pour afficher l'instance en ligne

<🎜 >

Le résultat de l'exécution du code ci-dessus : 

number
number
number
number
number
number

string (string)

Une chaîne est représentée par une paire de guillemets doubles ou simples. 

string1 = "this is string1"
string2 = 'this is string2'

Vous pouvez également utiliser 2 crochets "[[]]" pour représenter un "bloc" de chaînes. 

html = [[
<html>
<head></head>
<body>
    <a href="http://www.w3cschool.cc/">w3cschoolphp中文网</a>
</body>
</html>
]]
print(html)

Le résultat de l'exécution du code suivant est :

<html>
<head></head>
<body>
    <a href="http://www.w3cschool.cc/">w3cschoolphp中文网</a>
</body>
</html>

Lors de l'exécution d'opérations arithmétiques sur une chaîne numérique, Lua essaiera de convertir la chaîne numérique en nombre :

> print("2" + 6)
8.0
> print("2" + "6")
8.0
> print("2 + 6")
2 + 6
> print("-2e2" * "6")
-1200.0
> print("error" + 1)
stdin:1: attempt to perform arithmetic on a string value
stack traceback:
	stdin:1: in main chunk
	[C]: in ?
>

Dans le code ci-dessus, "error" + 1 est exécuté et une erreur est signalée. La connexion par chaîne utilise .., telle que : 

> print("a" .. 'b')
ab
> print(157 .. 428)
157428
>

Utilisez # pour calculer la longueur de la chaîne et placez-la devant. de la chaîne, comme le montre l'exemple suivant : 

> len = "www.w3cschool.cc"
> print(#len)
16
> print(#"www.w3cschool.cc")
16
>

table (table)

En Lua, la création d'une table est complétée par "l'expression de construction". est {}, qui est utilisé pour créer une table vide. Vous pouvez également ajouter des données à la table et initialiser la table directement : 

-- 创建一个空的 table
local tbl1 = {}
 
-- 直接初始表
local tbl2 = {"apple", "pear", "orange", "grape"}

Une table en Lua est en fait un "tableau associatif", et l'index du tableau peut être un nombre ou une chaîne. 

-- table_test.lua 脚本文件
a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
    print(k .. " : " .. v)
end

Le résultat de l'exécution du script est : 

$ lua table_test.lua 
key : value
10 : 33

Contrairement aux tableaux dans d'autres langages, qui utilisent 0 comme index initial du tableau, l'index initial par défaut de la table dans Lua commence généralement par 1 . 

-- table_test2.lua 脚本文件
local tbl = {"apple", "pear", "orange", "grape"}
for key, val in pairs(tbl) do
    print("Key", key)
end

Le résultat de l'exécution du script est : 

$ lua table_test2.lua 
Key	1
Key	2
Key	3
Key	4

la table n'aura pas de longueur fixe Lorsque de nouvelles données sont ajoutées, la longueur de la table augmentera automatiquement. Les tables qui ne sont pas initialisées sont toutes. néant. 

-- table_test3.lua 脚本文件
a3 = {}
for i = 1, 10 do
    a3[i] = i
end
a3["key"] = "val"
print(a3["key"])
print(a3["none"])

Le résultat de l'exécution du script est :

$ lua table_test3.lua 
val
nil

fonction (fonction)

Dans Lua, les fonctions sont considérées comme des "valeurs de première classe (Première- Class Value)", la fonction peut être stockée dans la variable : 

-- function_test.lua 脚本文件
function factorial1(n)
    if n == 0 then
        return 1
    else
        return n * factorial1(n - 1)
    end
end
print(factorial1(5))
factorial2 = factorial1
print(factorial2(5))

Le résultat de l'exécution du script est : 

$ lua function_test.lua 
120
120

la fonction peut être transmise comme fonction anonyme via les paramètres : 

-- function_test2.lua 脚本文件
function anonymous(tab, fun)
    for k, v in pairs(tab) do
        print(fun(k, v))
    end
end
tab = { key1 = "val1", key2 = "val2" }
anonymous(tab, function(key, val)
    return key .. " = " .. val
end)

Le résultat de l'exécution du script est : 

$ lua function_test2.lua 
key1 = val1
key2 = val2

thread (thread)

Dans Lua, le thread le plus important est la coroutine. Il est similaire à un thread et possède sa propre pile indépendante, ses variables locales et son pointeur d'instruction. Il peut partager des variables globales et la plupart des autres éléments avec d'autres coroutines.

La différence entre les threads et les coroutines : les threads peuvent s'exécuter plusieurs fois en même temps, mais les coroutines ne peuvent en exécuter qu'une à la fois, et une coroutine en cours d'exécution ne sera suspendue que lorsqu'elle est suspendue.

userdata (type personnalisé)

userdata est un type de données définies par l'utilisateur utilisé pour représenter un type créé par une application ou une bibliothèque de langage C/C++. Type de données C/C++ (généralement une structure et un pointeur) dans une variable Lua et appelez-la.

←
→