Présentation des types de données Lua
Explorez les types nil, booléen, nombre, chaîne, table, fonction et userdata.
Présentation des types de données Lua est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.
Bienvenue dans Lua
Lua est un langage de script léger, rapide et intégrable, utilisé dans les moteurs de jeu, les serveurs web et les systèmes embarqués. Avant d’écrire de vrais programmes, vous devez comprendre comment Lua représente les données.
Lua possède 8 types de base : nil, boolean, number, string, table, function, userdata et thread. Chaque valeur en Lua appartient exactement à l’un de ces types.
-- Check the type of any value with type()
print(type(42)) -- number
print(type("hello")) -- string
print(type(true)) -- boolean
print(type(nil)) -- nilnil : l’absence de valeur
nil est la manière dont Lua représente rien ou aucune valeur. C’est l’unique valeur de son type. Les variables auxquelles aucune valeur n’a encore été attribuée contiennent automatiquement nil.
Attribuer nil à une variable globale la supprime effectivement. Dans les tables, définir une clé sur nil supprime entièrement cette entrée.
-- Unassigned variables are nil
print(x) -- nil
x = 10
print(x) -- 10
x = nil
print(x) -- nil (variable is gone)boolean : true et false
Le type boolean possède exactement deux valeurs : true et false. Les règles de vérité de Lua sont simples, mais importantes : seuls nil et false sont considérés comme faux. Toutes les autres valeurs — y compris le nombre 0 et la chaîne vide "" — sont considérées comme vraies.
Cela diffère de nombreux langages dans lesquels 0 ou "" sont considérés comme faux.
-- Lua truthiness examples
if 0 then print("0 is truthy!") end -- prints!
if "" then print("empty str is truthy!") end -- prints!
if nil then print("nil") else print("nil is falsy") end
if false then print("false") else print("false is falsy") endnumber : entiers et nombres flottants
Lua 5.3 et les versions ultérieures possèdent deux sous-types de number : integer et float. Les entiers sont des valeurs exactes sur 64 bits ; les nombres flottants sont des valeurs IEEE 754 en double précision. Dans Lua 5.1 et 5.2, tous les nombres sont des nombres doubles.
La fonction math.type() distingue les deux sous-types. La division avec / renvoie toujours un nombre flottant ; // (division entière par défaut) renvoie un entier lorsque les deux opérandes sont des entiers.
print(type(10)) -- number
print(type(10.5)) -- number
print(math.type(10)) -- integer
print(math.type(10.5))-- float
print(10 / 3) -- 3.3333...
print(10 // 3) -- 3 (floor division)string : le texte en Lua
Les chaînes de caractères en Lua sont des séquences immuables d’octets. Vous pouvez les délimiter avec des apostrophes, des guillemets doubles ou des crochets longs [[...]] pour les chaînes multilignes. Les chaînes entre crochets longs ignorent le premier saut de ligne et préservent littéralement tout le reste.
Les chaînes Lua sont internées, de sorte que les chaînes identiques partagent la mémoire. L’opérateur de longueur # renvoie le nombre d’octets.
local s1 = 'single quotes'
local s2 = "double quotes"
local s3 = [[multi-line
long string]]
print(#s1) -- 13
print(type(s1)) -- string
print(s1 .. " works") -- concatenation with ..table : le conteneur universel
Le type table est l’unique structure de données composée de Lua, mais il est suffisamment puissant pour implémenter des tableaux, des dictionnaires, des objets, des ensembles et bien plus encore. Les tables sont des tableaux associatifs : elles associent des clés à des valeurs, les clés pouvant être n’importe quelle valeur autre que nil ou NaN.
Les tables sont créées avec des accolades {}. Les tables de type tableau utilisent des clés entières commençant à 1.
-- Array style
local fruits = {"apple", "banana", "cherry"}
print(fruits[1]) -- apple (1-indexed!)
-- Dictionary style
local person = {name = "Alice", age = 30}
print(person.name) -- Alice
print(person["age"]) -- 30function : des valeurs de première classe
Les fonctions en Lua sont des valeurs de première classe du type function. Elles peuvent être stockées dans des variables, passées comme arguments et renvoyées par d’autres fonctions. Lua se prête ainsi naturellement aux modèles de programmation fonctionnelle.
Vous pouvez définir des fonctions avec le mot-clé function ou attribuer des fonctions anonymes à des variables. Les deux formes sont équivalentes.
-- Two equivalent ways to define a function
function greet(name)
return "Hello, " .. name
end
local greet2 = function(name)
return "Hello, " .. name
end
print(type(greet)) -- function
print(greet("Lua")) -- Hello, Luauserdata et thread
userdata représente des données C arbitraires gérées par l’application hôte. Vous ne pouvez pas créer de userdata en Lua pur : ces données proviennent d’extensions C ou d’environnements intégrés tels que les moteurs de jeu. Cela permet au code C d’exposer des objets aux scripts Lua.
thread représente des coroutines — des fils d’exécution indépendants possédant leurs propres piles. Nous étudierons les coroutines dans une leçon dédiée. Pour le moment, retenez que coroutine.create() renvoie une valeur du type thread.
-- thread type via coroutine
local co = coroutine.create(function()
print("coroutine body")
end)
print(type(co)) -- thread
-- userdata comes from C, not creatable in pure Lua
-- type(io.stdin) == "file" is a userdata variantUtiliser type() pour examiner les valeurs
La fonction intégrée type() renvoie toujours une chaîne de caractères indiquant le type de son argument. C’est utile pour la programmation défensive et le débogage. Vous pouvez comparer directement le résultat aux chaînes contenant les noms des types.
Notez que type(nil) renvoie la chaîne "nil", et non la valeur nil elle-même. Vous pouvez ainsi vérifier sans risque qu’une variable contient nil, sans provoquer d’erreur.
local values = {42, "hi", true, nil, {}, function() end}
-- Note: nil in table stops ipairs early
for i = 1, 3 do
print(i, type(values[i]))
end
-- 1 number
-- 2 string
-- 3 booleanDifférences de types avec d’autres langages
Si vous venez de JavaScript, Python ou Java, certaines règles de typage de Lua peuvent vous surprendre. Il n’existe pas de type entier distinct visible par type() : les entiers comme les nombres flottants renvoient "number". Les tableaux n’ont pas leur propre type : ce sont simplement des tables. Les classes n’existent pas : les objets sont des tables dotées de métatables.
Comprendre ces différences permet d’éviter les bogues courants lors du passage d’un langage à un autre.
-- No separate array type
local arr = {1, 2, 3}
print(type(arr)) -- table (not array!)
-- No separate integer type visible
print(type(1)) -- number
print(type(1.0)) -- number
-- math.type distinguishes
print(math.type(1)) -- integer
print(math.type(1.0)) -- floatVérification rapide
Que renvoie type(0) en Lua ?
Récapitulatif : vue d’ensemble des types de données Lua
Vous avez découvert les 8 types Lua :
- nil — absence de valeur ; considéré comme faux
- boolean — true/false ; seuls nil et false sont considérés comme faux
- number — entier ou nombre flottant ; utilisez math.type() pour les distinguer
- string — séquences d’octets immuables ; utilisez .. pour les concaténer
- table — conteneur universel pour les tableaux et les dictionnaires
- function — valeurs de première classe pouvant être stockées dans des variables
- userdata — données C exposées à Lua
- thread — références vers des coroutines
Ensuite : déclarer des variables — portée globale et portée locale.
Questions Fréquemment Posées
La leçon « Présentation des types de données Lua » est-elle gratuite ?
Oui — le texte complet de « Présentation des types de données Lua » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Présentation des types de données Lua » ?
Explorez les types nil, booléen, nombre, chaîne, table, fonction et userdata. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Lua Academy ?
Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Présentation des types de données Lua » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?
Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Présentation des types de données Lua
- Déclarer des variables en Lua
- Opérateurs arithmétiques et relationnels
- Coercition et conversion de types